1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2017 Netflix, Inc.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/param.h>
29 #include <ctype.h>
30 #include <devinfo.h>
31 #include <err.h>
32 #include <errno.h>
33 #include <fcntl.h>
34 #include <getopt.h>
35 #include <stdbool.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <sysexits.h>
40 #include <unistd.h>
41 #include <sys/linker.h>
42 #include <sys/module.h>
43 #include <sys/stat.h>
44 #include <sys/sysctl.h>
45
46 /* options descriptor */
47 static struct option longopts[] = {
48 { "all", no_argument, NULL, 'a' },
49 { "dump", no_argument, NULL, 'd' },
50 { "hints", required_argument, NULL, 'h' },
51 { "nomatch", required_argument, NULL, 'p' },
52 { "quiet", no_argument, NULL, 'q' },
53 { "unbound", no_argument, NULL, 'u' },
54 { "verbose", no_argument, NULL, 'v' },
55 { NULL, 0, NULL, 0 }
56 };
57
58 #define DEVMATCH_MAX_HITS 256
59
60 static bool all_flag;
61 static bool dump_flag;
62 static char *linker_hints;
63 static char *nomatch_str;
64 static bool quiet_flag;
65 static bool unbound_flag;
66 static bool verbose_flag;
67
68 static void *hints;
69 static void *hints_end;
70 static struct devinfo_dev *root;
71
72 static void *
read_hints(const char * fn,size_t * len)73 read_hints(const char *fn, size_t *len)
74 {
75 void *h;
76 int fd;
77 struct stat sb;
78
79 fd = open(fn, O_RDONLY);
80 if (fd < 0) {
81 if (errno == ENOENT)
82 return NULL;
83 err(1, "Can't open %s for reading", fn);
84 }
85 if (fstat(fd, &sb) != 0)
86 err(1, "Can't fstat %s\n", fn);
87 h = malloc(sb.st_size);
88 if (h == NULL)
89 err(1, "not enough space to read hints file of %ju bytes", (uintmax_t)sb.st_size);
90 if (read(fd, h, sb.st_size) != sb.st_size)
91 err(1, "Can't read in %ju bytes from %s", (uintmax_t)sb.st_size, fn);
92 close(fd);
93 *len = sb.st_size;
94 return h;
95 }
96
97 static void
read_linker_hints(void)98 read_linker_hints(void)
99 {
100 char fn[MAXPATHLEN];
101 char *modpath, *p, *q;
102 size_t buflen, len;
103
104 if (linker_hints == NULL) {
105 if (sysctlbyname("kern.module_path", NULL, &buflen, NULL, 0) < 0)
106 errx(1, "Can't find kernel module path.");
107 modpath = malloc(buflen);
108 if (modpath == NULL)
109 err(1, "Can't get memory for modpath.");
110 if (sysctlbyname("kern.module_path", modpath, &buflen, NULL, 0) < 0)
111 errx(1, "Can't find kernel module path.");
112 p = modpath;
113 while ((q = strsep(&p, ";")) != NULL) {
114 snprintf(fn, sizeof(fn), "%s/linker.hints", q);
115 hints = read_hints(fn, &len);
116 if (hints == NULL)
117 continue;
118 break;
119 }
120 if (q == NULL) {
121 if (quiet_flag)
122 exit(EX_UNAVAILABLE);
123 else
124 errx(EX_UNAVAILABLE, "Can't read linker hints file.");
125 }
126 } else {
127 hints = read_hints(linker_hints, &len);
128 if (hints == NULL)
129 err(1, "Can't open %s for reading", fn);
130 }
131
132 if (len < sizeof(int)) {
133 warnx("Linker hints file too short.");
134 free(hints);
135 hints = NULL;
136 return;
137 }
138 if (*(int *)(intptr_t)hints != LINKER_HINTS_VERSION) {
139 warnx("Linker hints version %d doesn't match expected %d.",
140 *(int *)(intptr_t)hints, LINKER_HINTS_VERSION);
141 free(hints);
142 hints = NULL;
143 }
144 if (hints != NULL)
145 hints_end = (void *)((intptr_t)hints + (intptr_t)len);
146 }
147
148 static int
getint(void ** ptr)149 getint(void **ptr)
150 {
151 int *p = *ptr;
152 int rv;
153
154 p = (int *)roundup2((intptr_t)p, sizeof(int));
155 rv = *p++;
156 *ptr = p;
157 return rv;
158 }
159
160 static void
getstr(void ** ptr,char * val)161 getstr(void **ptr, char *val)
162 {
163 int *p = *ptr;
164 char *c = (char *)p;
165 int len = *(uint8_t *)c;
166
167 memcpy(val, c + 1, len);
168 val[len] = 0;
169 c += len + 1;
170 *ptr = (void *)c;
171 }
172
173 static int
pnpval_as_int(const char * val,const char * pnpinfo)174 pnpval_as_int(const char *val, const char *pnpinfo)
175 {
176 int rv;
177 char key[256];
178 char *cp;
179
180 if (pnpinfo == NULL)
181 return -1;
182
183 cp = strchr(val, ';');
184 key[0] = ' ';
185 if (cp == NULL)
186 strlcpy(key + 1, val, sizeof(key) - 1);
187 else {
188 memcpy(key + 1, val, cp - val);
189 key[cp - val + 1] = '\0';
190 }
191 strlcat(key, "=", sizeof(key));
192 if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0)
193 rv = strtol(pnpinfo + strlen(key + 1), NULL, 0);
194 else {
195 cp = strstr(pnpinfo, key);
196 if (cp == NULL)
197 rv = -1;
198 else
199 rv = strtol(cp + strlen(key), NULL, 0);
200 }
201 return rv;
202 }
203
204 static void
quoted_strcpy(char * dst,const char * src)205 quoted_strcpy(char *dst, const char *src)
206 {
207 char q = ' ';
208
209 if (*src == '\'' || *src == '"')
210 q = *src++;
211 while (*src && *src != q)
212 *dst++ = *src++; // XXX backtick quoting
213 *dst++ = '\0';
214 // XXX overflow
215 }
216
217 static char *
pnpval_as_str(const char * val,const char * pnpinfo)218 pnpval_as_str(const char *val, const char *pnpinfo)
219 {
220 static char retval[256];
221 char key[256];
222 char *cp;
223
224 if (pnpinfo == NULL) {
225 *retval = '\0';
226 return retval;
227 }
228
229 cp = strchr(val, ';');
230 key[0] = ' ';
231 if (cp == NULL)
232 strlcpy(key + 1, val, sizeof(key) - 1);
233 else {
234 memcpy(key + 1, val, cp - val);
235 key[cp - val + 1] = '\0';
236 }
237 strlcat(key, "=", sizeof(key));
238 if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0)
239 quoted_strcpy(retval, pnpinfo + strlen(key + 1));
240 else {
241 cp = strstr(pnpinfo, key);
242 if (cp == NULL)
243 strcpy(retval, "MISSING");
244 else
245 quoted_strcpy(retval, cp + strlen(key));
246 }
247 return retval;
248 }
249
250 static void
search_hints(const char * bus,const char * dev,const char * pnpinfo)251 search_hints(const char *bus, const char *dev, const char *pnpinfo)
252 {
253 char val1[256], val2[256];
254 int ival, len, ents, i, notme, mask, bit, v, found;
255 void *ptr, *walker;
256 char *lastmod = NULL, *cp, *s;
257
258 walker = hints;
259 getint(&walker);
260 found = 0;
261 if (verbose_flag)
262 printf("Searching bus %s dev %s for pnpinfo %s\n",
263 bus, dev, pnpinfo);
264 while (walker < hints_end) {
265 len = getint(&walker);
266 ival = getint(&walker);
267 ptr = walker;
268 switch (ival) {
269 case MDT_VERSION:
270 getstr(&ptr, val1);
271 ival = getint(&ptr);
272 getstr(&ptr, val2);
273 if (dump_flag || verbose_flag)
274 printf("Version: if %s.%d kmod %s\n", val1, ival, val2);
275 break;
276 case MDT_MODULE:
277 getstr(&ptr, val1);
278 getstr(&ptr, val2);
279 if (lastmod)
280 free(lastmod);
281 lastmod = strdup(val2);
282 if (dump_flag || verbose_flag)
283 printf("Module %s in %s\n", val1, val2);
284 break;
285 case MDT_PNP_INFO:
286 if (!dump_flag && !unbound_flag && lastmod && strcmp(lastmod, "kernel") == 0)
287 break;
288 getstr(&ptr, val1);
289 getstr(&ptr, val2);
290 ents = getint(&ptr);
291 if (dump_flag || verbose_flag)
292 printf("PNP info for bus %s format %s %d entries (%s)\n",
293 val1, val2, ents, lastmod);
294 if (strcmp(val1, "usb") == 0) {
295 if (verbose_flag)
296 printf("Treating usb as uhub -- bug in source table still?\n");
297 strcpy(val1, "uhub");
298 }
299 if (bus && strcmp(val1, bus) != 0) {
300 if (verbose_flag)
301 printf("Skipped because table for bus %s, looking for %s\n",
302 val1, bus);
303 break;
304 }
305 for (i = 0; i < ents; i++) {
306 if (verbose_flag)
307 printf("---------- Entry %d ----------\n", i);
308 if (dump_flag)
309 printf(" ");
310 cp = val2;
311 notme = 0;
312 mask = -1;
313 bit = -1;
314 do {
315 switch (*cp) {
316 /* All integer fields */
317 case 'I':
318 case 'J':
319 case 'G':
320 case 'L':
321 case 'M':
322 ival = getint(&ptr);
323 if (dump_flag) {
324 printf("%#x:", ival);
325 break;
326 }
327 if (bit >= 0 && ((1 << bit) & mask) == 0)
328 break;
329 if (cp[2] == '#') {
330 if (verbose_flag) {
331 printf("Ignoring %s (%c) table=%#x tomatch=%#x\n",
332 cp + 2, *cp, v, ival);
333 }
334 break;
335 }
336 v = pnpval_as_int(cp + 2, pnpinfo);
337 if (verbose_flag)
338 printf("Matching %s (%c) table=%#x tomatch=%#x\n",
339 cp + 2, *cp, v, ival);
340 switch (*cp) {
341 case 'J':
342 if (ival == -1)
343 break;
344 /*FALLTHROUGH*/
345 case 'I':
346 if (v != ival)
347 notme++;
348 break;
349 case 'G':
350 if (v < ival)
351 notme++;
352 break;
353 case 'L':
354 if (v > ival)
355 notme++;
356 break;
357 case 'M':
358 mask = ival;
359 break;
360 }
361 break;
362 /* String fields */
363 case 'D':
364 case 'Z':
365 getstr(&ptr, val1);
366 if (dump_flag) {
367 printf("'%s':", val1);
368 break;
369 }
370 if (*cp == 'D')
371 break;
372 if (bit >= 0 && ((1 << bit) & mask) == 0)
373 break;
374 if (cp[2] == '#') {
375 if (verbose_flag) {
376 printf("Ignoring %s (%c) table=%#x tomatch=%#x\n",
377 cp + 2, *cp, v, ival);
378 }
379 break;
380 }
381 s = pnpval_as_str(cp + 2, pnpinfo);
382 if (verbose_flag)
383 printf("Matching %s (%c) table=%s tomatch=%s\n",
384 cp + 2, *cp, s, val1);
385 if (strcmp(s, val1) != 0)
386 notme++;
387 break;
388 /* Key override fields, required to be last in the string */
389 case 'T':
390 /*
391 * This is imperfect and only does one key and will be redone
392 * to be more general for multiple keys. Currently, nothing
393 * does that.
394 */
395 if (dump_flag) /* No per-row data stored */
396 break;
397 if (cp[strlen(cp) - 1] == ';') /* Skip required ; at end */
398 cp[strlen(cp) - 1] = '\0'; /* in case it's not there */
399 if ((s = strstr(pnpinfo, cp + 2)) == NULL)
400 notme++;
401 else if (s > pnpinfo && s[-1] != ' ')
402 notme++;
403 break;
404 default:
405 fprintf(stderr, "Unknown field type %c\n:", *cp);
406 break;
407 }
408 bit++;
409 cp = strchr(cp, ';');
410 if (cp)
411 cp++;
412 } while (cp && *cp);
413 if (dump_flag)
414 printf("\n");
415 else if (!notme) {
416 if (!unbound_flag) {
417 if (all_flag)
418 printf("%s: %s\n", *dev ? dev : "unattached", lastmod);
419 else
420 printf("%s\n", lastmod);
421 if (verbose_flag)
422 printf("Matches --- %s ---\n", lastmod);
423 }
424 found++;
425 }
426 }
427 break;
428 default:
429 if (dump_flag)
430 printf("Unknown Type %d len %d\n", ival, len);
431 break;
432 }
433 walker = (void *)(len - sizeof(int) + (intptr_t)walker);
434 }
435 if (unbound_flag && found == 0 && *pnpinfo) {
436 if (verbose_flag)
437 printf("------------------------- ");
438 printf("%s on %s pnpinfo %s", *dev ? dev : "unattached", bus, pnpinfo);
439 if (verbose_flag)
440 printf(" -------------------------");
441 printf("\n");
442 }
443 free(lastmod);
444 }
445
446 static int
find_unmatched(struct devinfo_dev * dev,void * arg)447 find_unmatched(struct devinfo_dev *dev, void *arg)
448 {
449 struct devinfo_dev *parent;
450 char *bus, *p;
451
452 do {
453 if (!all_flag && dev->dd_name[0] != '\0')
454 break;
455 if (!(dev->dd_flags & DF_ENABLED))
456 break;
457 if (!all_flag && dev->dd_flags & DF_ATTACHED_ONCE)
458 break;
459 parent = devinfo_handle_to_device(dev->dd_parent);
460 bus = strdup(parent->dd_name);
461 p = bus + strlen(bus) - 1;
462 while (p >= bus && isdigit(*p))
463 p--;
464 *++p = '\0';
465 if (verbose_flag)
466 printf("Searching %s %s bus at %s for pnpinfo %s\n",
467 dev->dd_name, bus, dev->dd_location, dev->dd_pnpinfo);
468 search_hints(bus, dev->dd_name, dev->dd_pnpinfo);
469 free(bus);
470 } while (0);
471
472 return (devinfo_foreach_device_child(dev, find_unmatched, arg));
473 }
474
475 struct exact_info
476 {
477 const char *bus;
478 const char *loc;
479 struct devinfo_dev *dev;
480 };
481
482 /*
483 * Look for the exact location specified by the nomatch event. The
484 * loc and pnpinfo run together to get the string we're looking for,
485 * so we have to synthesize the same thing that subr_bus.c is
486 * generating in devnomatch/devaddq to do the string comparison.
487 */
488 static int
find_exact_dev(struct devinfo_dev * dev,void * arg)489 find_exact_dev(struct devinfo_dev *dev, void *arg)
490 {
491 struct devinfo_dev *parent;
492 char *loc;
493 struct exact_info *info;
494
495 info = arg;
496 do {
497 if (info->dev != NULL)
498 break;
499 if (!(dev->dd_flags & DF_ENABLED))
500 break;
501 parent = devinfo_handle_to_device(dev->dd_parent);
502 if (strcmp(info->bus, parent->dd_name) != 0)
503 break;
504 asprintf(&loc, "%s %s", parent->dd_pnpinfo,
505 parent->dd_location);
506 if (strcmp(loc, info->loc) == 0)
507 info->dev = dev;
508 free(loc);
509 } while (0);
510
511 return (devinfo_foreach_device_child(dev, find_exact_dev, arg));
512 }
513
514 static void
find_nomatch(char * nomatch)515 find_nomatch(char *nomatch)
516 {
517 char *bus, *pnpinfo, *tmp, *busnameunit;
518 struct exact_info info;
519
520 /*
521 * Find our bus name. It will include the unit number. We have to search
522 * backwards to avoid false positive for any PNP string that has ' on '
523 * in them, which would come earlier in the string. Like if there were
524 * an 'Old Bard' ethernet card made by 'Stratford on Avon Hardware' or
525 * something silly like that.
526 */
527 tmp = nomatch + strlen(nomatch) - 4;
528 while (tmp > nomatch && strncmp(tmp, " on ", 4) != 0)
529 tmp--;
530 if (tmp == nomatch)
531 errx(1, "No bus found in nomatch string: '%s'", nomatch);
532 bus = tmp + 4;
533 *tmp = '\0';
534 busnameunit = strdup(bus);
535 if (busnameunit == NULL)
536 errx(1, "Can't allocate memory for strings");
537 tmp = bus + strlen(bus) - 1;
538 while (tmp > bus && isdigit(*tmp))
539 tmp--;
540 *++tmp = '\0';
541
542 /*
543 * Note: the NOMATCH events place both the bus location as well as the
544 * pnp info after the 'at' and we don't know where one stops and the
545 * other begins, so we pass the whole thing to our search routine.
546 */
547 if (*nomatch == '?')
548 nomatch++;
549 if (strncmp(nomatch, " at ", 4) != 0)
550 errx(1, "Malformed NOMATCH string: '%s'", nomatch);
551 pnpinfo = nomatch + 4;
552
553 /*
554 * See if we can find the devinfo_dev for this device. If we
555 * can, and it's been attached before, we should filter it out
556 * so that a kldunload foo doesn't cause an immediate reload.
557 */
558 info.loc = pnpinfo;
559 info.bus = busnameunit;
560 info.dev = NULL;
561 devinfo_foreach_device_child(root, find_exact_dev, (void *)&info);
562 if (info.dev != NULL && info.dev->dd_flags & DF_ATTACHED_ONCE)
563 exit(0);
564 search_hints(bus, "", pnpinfo);
565
566 exit(0);
567 }
568
569 static void
usage(void)570 usage(void)
571 {
572
573 errx(1, "devmatch [-adv] [-p nomatch] [-h linker-hints]");
574 }
575
576 int
main(int argc,char ** argv)577 main(int argc, char **argv)
578 {
579 int ch;
580
581 while ((ch = getopt_long(argc, argv, "adh:p:quv",
582 longopts, NULL)) != -1) {
583 switch (ch) {
584 case 'a':
585 all_flag = true;
586 break;
587 case 'd':
588 dump_flag = true;
589 break;
590 case 'h':
591 linker_hints = optarg;
592 break;
593 case 'p':
594 nomatch_str = optarg;
595 break;
596 case 'q':
597 quiet_flag = true;
598 break;
599 case 'u':
600 unbound_flag = true;
601 break;
602 case 'v':
603 verbose_flag = true;
604 break;
605 default:
606 usage();
607 }
608 }
609 argc -= optind;
610 argv += optind;
611
612 if (argc >= 1)
613 usage();
614
615 read_linker_hints();
616 if (dump_flag) {
617 search_hints(NULL, NULL, NULL);
618 exit(0);
619 }
620
621 if (devinfo_init())
622 err(1, "devinfo_init");
623 if ((root = devinfo_handle_to_device(DEVINFO_ROOT_DEVICE)) == NULL)
624 errx(1, "can't find root device");
625 if (nomatch_str != NULL)
626 find_nomatch(nomatch_str);
627 else
628 devinfo_foreach_device_child(root, find_unmatched, (void *)0);
629 devinfo_free();
630 }
631