2 * Copyright (c) 2017 Netflix, Inc
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
41 #include <sys/linker.h>
42 #include <sys/module.h>
44 #include <sys/sysctl.h>
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 { "unbound", no_argument, NULL, 'u' },
53 { "verbose", no_argument, NULL, 'v' },
57 #define DEVMATCH_MAX_HITS 256
61 static char *linker_hints;
62 static char *nomatch_str;
63 static int unbound_flag;
64 static int verbose_flag;
67 static void *hints_end;
68 static struct devinfo_dev *root;
71 read_hints(const char *fn, size_t *len)
77 fd = open(fn, O_RDONLY);
81 err(1, "Can't open %s for reading", fn);
83 if (fstat(fd, &sb) != 0)
84 err(1, "Can't fstat %s\n", fn);
85 h = malloc(sb.st_size);
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);
96 read_linker_hints(void)
99 char *modpath, *p, *q;
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);
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.");
111 while ((q = strsep(&p, ";")) != NULL) {
112 snprintf(fn, sizeof(fn), "%s/linker.hints", q);
113 hints = read_hints(fn, &len);
119 errx(1, "Can't read linker hints file.");
121 hints = read_hints(linker_hints, &len);
123 err(1, "Can't open %s for reading", fn);
126 if (*(int *)(intptr_t)hints != LINKER_HINTS_VERSION) {
127 warnx("Linker hints version %d doesn't match expected %d.",
128 *(int *)(intptr_t)hints, LINKER_HINTS_VERSION);
133 hints_end = (void *)((intptr_t)hints + (intptr_t)len);
142 p = (int *)roundup2((intptr_t)p, sizeof(int));
149 getstr(void **ptr, char *val)
153 int len = *(uint8_t *)c;
155 memcpy(val, c + 1, len);
162 pnpval_as_int(const char *val, const char *pnpinfo)
171 cp = strchr(val, ';');
174 strlcpy(key + 1, val, sizeof(key) - 1);
176 memcpy(key + 1, val, cp - val);
177 key[cp - val + 1] = '\0';
179 strlcat(key, "=", sizeof(key));
180 if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0)
181 rv = strtol(pnpinfo + strlen(key + 1), NULL, 0);
183 cp = strstr(pnpinfo, key);
187 rv = strtol(cp + strlen(key), NULL, 0);
193 quoted_strcpy(char *dst, const char *src)
197 if (*src == '\'' || *src == '"')
199 while (*src && *src != q)
200 *dst++ = *src++; // XXX backtick quoting
206 pnpval_as_str(const char *val, const char *pnpinfo)
208 static char retval[256];
212 if (pnpinfo == NULL) {
217 cp = strchr(val, ';');
220 strlcpy(key + 1, val, sizeof(key) - 1);
222 memcpy(key + 1, val, cp - val);
223 key[cp - val + 1] = '\0';
225 strlcat(key, "=", sizeof(key));
226 if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0)
227 quoted_strcpy(retval, pnpinfo + strlen(key + 1));
229 cp = strstr(pnpinfo, key);
231 strcpy(retval, "MISSING");
233 quoted_strcpy(retval, cp + strlen(key));
239 search_hints(const char *bus, const char *dev, const char *pnpinfo)
241 char val1[256], val2[256];
242 int ival, len, ents, i, notme, mask, bit, v, found;
244 char *lastmod = NULL, *cp, *s;
250 printf("Searching bus %s dev %s for pnpinfo %s\n",
252 while (walker < hints_end) {
253 len = getint(&walker);
254 ival = getint(&walker);
261 if (dump_flag || verbose_flag)
262 printf("Version: if %s.%d kmod %s\n", val1, ival, val2);
269 lastmod = strdup(val2);
270 if (dump_flag || verbose_flag)
271 printf("Module %s in %s\n", val1, val2);
274 if (!dump_flag && !unbound_flag && lastmod && strcmp(lastmod, "kernel") == 0)
279 if (dump_flag || verbose_flag)
280 printf("PNP info for bus %s format %s %d entries (%s)\n",
281 val1, val2, ents, lastmod);
282 if (strcmp(val1, "usb") == 0) {
284 printf("Treating usb as uhub -- bug in source table still?\n");
285 strcpy(val1, "uhub");
287 if (bus && strcmp(val1, bus) != 0) {
289 printf("Skipped because table for bus %s, looking for %s\n",
293 for (i = 0; i < ents; i++) {
295 printf("---------- Entry %d ----------\n", i);
304 /* All integer fields */
312 printf("%#x:", ival);
315 if (bit >= 0 && ((1 << bit) & mask) == 0)
317 v = pnpval_as_int(cp + 2, pnpinfo);
319 printf("Matching %s (%c) table=%#x tomatch=%#x\n",
320 cp + 2, *cp, v, ival);
348 printf("'%s':", val1);
353 s = pnpval_as_str(cp + 2, pnpinfo);
354 if (strcmp(s, val1) != 0)
357 /* Key override fields, required to be last in the string */
360 * This is imperfect and only does one key and will be redone
361 * to be more general for multiple keys. Currently, nothing
364 if (dump_flag) /* No per-row data stored */
366 if (cp[strlen(cp) - 1] == ';') /* Skip required ; at end */
367 cp[strlen(cp) - 1] = '\0'; /* in case it's not there */
368 if ((s = strstr(pnpinfo, cp + 2)) == NULL)
370 else if (s > pnpinfo && s[-1] != ' ')
374 fprintf(stderr, "Unknown field type %c\n:", *cp);
378 cp = strchr(cp, ';');
387 printf("%s: %s", *dev ? dev : "unattached", lastmod);
389 printf("%s\n", lastmod);
391 printf("Matches --- %s ---\n", lastmod);
399 printf("Unknown Type %d len %d\n", ival, len);
402 walker = (void *)(len - sizeof(int) + (intptr_t)walker);
404 if (unbound_flag && found == 0 && *pnpinfo) {
406 printf("------------------------- ");
407 printf("%s on %s pnpinfo %s", *dev ? dev : "unattached", bus, pnpinfo);
409 printf(" -------------------------");
416 find_unmatched(struct devinfo_dev *dev, void *arg)
418 struct devinfo_dev *parent;
422 if (!all_flag && dev->dd_name[0] != '\0')
424 if (!(dev->dd_flags & DF_ENABLED))
426 if (dev->dd_flags & DF_ATTACHED_ONCE)
428 parent = devinfo_handle_to_device(dev->dd_parent);
429 bus = strdup(parent->dd_name);
430 p = bus + strlen(bus) - 1;
431 while (p >= bus && isdigit(*p))
435 printf("Searching %s %s bus at %s for pnpinfo %s\n",
436 dev->dd_name, bus, dev->dd_location, dev->dd_pnpinfo);
437 search_hints(bus, dev->dd_name, dev->dd_pnpinfo);
441 return (devinfo_foreach_device_child(dev, find_unmatched, arg));
448 struct devinfo_dev *dev;
452 * Look for the exact location specified by the nomatch event. The
453 * loc and pnpinfo run together to get the string we're looking for,
454 * so we have to synthesize the same thing that subr_bus.c is
455 * generating in devnomatch/devaddq to do the string comparison.
458 find_exact_dev(struct devinfo_dev *dev, void *arg)
460 struct devinfo_dev *parent;
462 struct exact_info *info;
466 if (info->dev != NULL)
468 if (!(dev->dd_flags & DF_ENABLED))
470 parent = devinfo_handle_to_device(dev->dd_parent);
471 if (strcmp(info->bus, parent->dd_name) != 0)
473 asprintf(&loc, "%s %s", parent->dd_pnpinfo,
474 parent->dd_location);
475 if (strcmp(loc, info->loc) == 0)
480 return (devinfo_foreach_device_child(dev, find_exact_dev, arg));
484 find_nomatch(char *nomatch)
486 char *bus, *pnpinfo, *tmp, *busnameunit;
487 struct exact_info info;
490 * Find our bus name. It will include the unit number. We have to search
491 * backwards to avoid false positive for any PNP string that has ' on '
492 * in them, which would come earlier in the string. Like if there were
493 * an 'Old Bard' ethernet card made by 'Stratford on Avon Hardware' or
494 * something silly like that.
496 tmp = nomatch + strlen(nomatch) - 4;
497 while (tmp > nomatch && strncmp(tmp, " on ", 4) != 0)
500 errx(1, "No bus found in nomatch string: '%s'", nomatch);
503 busnameunit = strdup(bus);
504 if (busnameunit == NULL)
505 errx(1, "Can't allocate memory for strings");
506 tmp = bus + strlen(bus) - 1;
507 while (tmp > bus && isdigit(*tmp))
512 * Note: the NOMATCH events place both the bus location as well as the
513 * pnp info after the 'at' and we don't know where one stops and the
514 * other begins, so we pass the whole thing to our search routine.
518 if (strncmp(nomatch, " at ", 4) != 0)
519 errx(1, "Malformed NOMATCH string: '%s'", nomatch);
520 pnpinfo = nomatch + 4;
523 * See if we can find the devinfo_dev for this device. If we
524 * can, and it's been attached before, we should filter it out
525 * so that a kldunload foo doesn't cause an immediate reload.
528 info.bus = busnameunit;
530 devinfo_foreach_device_child(root, find_exact_dev, (void *)&info);
531 if (info.dev != NULL && info.dev->dd_flags & DF_ATTACHED_ONCE)
533 search_hints(bus, "", pnpinfo);
542 errx(1, "devmatch [-adv] [-p nomatch] [-h linker-hints]");
546 main(int argc, char **argv)
550 while ((ch = getopt_long(argc, argv, "adh:p:uv",
551 longopts, NULL)) != -1) {
560 linker_hints = optarg;
563 nomatch_str = optarg;
583 search_hints(NULL, NULL, NULL);
588 err(1, "devinfo_init");
589 if ((root = devinfo_handle_to_device(DEVINFO_ROOT_DEVICE)) == NULL)
590 errx(1, "can't find root device");
591 if (nomatch_str != NULL)
592 find_nomatch(nomatch_str);
594 devinfo_foreach_device_child(root, find_unmatched, (void *)0);