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