1 /*- 2 * Copyright (c) 2017 Netflix, Inc 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 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. 13 * 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 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <ctype.h> 32 #include <devinfo.h> 33 #include <err.h> 34 #include <errno.h> 35 #include <fcntl.h> 36 #include <getopt.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <string.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 { "unbound", no_argument, NULL, 'u' }, 53 { "verbose", no_argument, NULL, 'v' }, 54 { NULL, 0, NULL, 0 } 55 }; 56 57 #define DEVMATCH_MAX_HITS 256 58 59 static int all_flag; 60 static int dump_flag; 61 static char *linker_hints; 62 static char *nomatch_str; 63 static int unbound_flag; 64 static int verbose_flag; 65 66 static void *hints; 67 static void *hints_end; 68 static struct devinfo_dev *root; 69 70 static void * 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 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 errx(1, "Can't read linker hints file."); 120 } else { 121 hints = read_hints(linker_hints, &len); 122 if (hints == NULL) 123 err(1, "Can't open %s for reading", fn); 124 } 125 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); 129 free(hints); 130 hints = NULL; 131 } 132 if (hints != NULL) 133 hints_end = (void *)((intptr_t)hints + (intptr_t)len); 134 } 135 136 static int 137 getint(void **ptr) 138 { 139 int *p = *ptr; 140 int rv; 141 142 p = (int *)roundup2((intptr_t)p, sizeof(int)); 143 rv = *p++; 144 *ptr = p; 145 return rv; 146 } 147 148 static void 149 getstr(void **ptr, char *val) 150 { 151 int *p = *ptr; 152 char *c = (char *)p; 153 int len = *(uint8_t *)c; 154 155 memcpy(val, c + 1, len); 156 val[len] = 0; 157 c += len + 1; 158 *ptr = (void *)c; 159 } 160 161 static int 162 pnpval_as_int(const char *val, const char *pnpinfo) 163 { 164 int rv; 165 char key[256]; 166 char *cp; 167 168 if (pnpinfo == NULL) 169 return -1; 170 171 cp = strchr(val, ';'); 172 key[0] = ' '; 173 if (cp == NULL) 174 strlcpy(key + 1, val, sizeof(key) - 1); 175 else { 176 memcpy(key + 1, val, cp - val); 177 key[cp - val + 1] = '\0'; 178 } 179 strlcat(key, "=", sizeof(key)); 180 if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0) 181 rv = strtol(pnpinfo + strlen(key + 1), NULL, 0); 182 else { 183 cp = strstr(pnpinfo, key); 184 if (cp == NULL) 185 rv = -1; 186 else 187 rv = strtol(cp + strlen(key), NULL, 0); 188 } 189 return rv; 190 } 191 192 static void 193 quoted_strcpy(char *dst, const char *src) 194 { 195 char q = ' '; 196 197 if (*src == '\'' || *src == '"') 198 q = *src++; 199 while (*src && *src != q) 200 *dst++ = *src++; // XXX backtick quoting 201 *dst++ = '\0'; 202 // XXX overflow 203 } 204 205 static char * 206 pnpval_as_str(const char *val, const char *pnpinfo) 207 { 208 static char retval[256]; 209 char key[256]; 210 char *cp; 211 212 if (pnpinfo == NULL) { 213 *retval = '\0'; 214 return retval; 215 } 216 217 cp = strchr(val, ';'); 218 key[0] = ' '; 219 if (cp == NULL) 220 strlcpy(key + 1, val, sizeof(key) - 1); 221 else { 222 memcpy(key + 1, val, cp - val); 223 key[cp - val + 1] = '\0'; 224 } 225 strlcat(key, "=", sizeof(key)); 226 if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0) 227 quoted_strcpy(retval, pnpinfo + strlen(key + 1)); 228 else { 229 cp = strstr(pnpinfo, key); 230 if (cp == NULL) 231 strcpy(retval, "MISSING"); 232 else 233 quoted_strcpy(retval, cp + strlen(key)); 234 } 235 return retval; 236 } 237 238 static void 239 search_hints(const char *bus, const char *dev, const char *pnpinfo) 240 { 241 char val1[256], val2[256]; 242 int ival, len, ents, i, notme, mask, bit, v, found; 243 void *ptr, *walker; 244 char *lastmod = NULL, *cp, *s; 245 246 walker = hints; 247 getint(&walker); 248 found = 0; 249 if (verbose_flag) 250 printf("Searching bus %s dev %s for pnpinfo %s\n", 251 bus, dev, pnpinfo); 252 while (walker < hints_end) { 253 len = getint(&walker); 254 ival = getint(&walker); 255 ptr = walker; 256 switch (ival) { 257 case MDT_VERSION: 258 getstr(&ptr, val1); 259 ival = getint(&ptr); 260 getstr(&ptr, val2); 261 if (dump_flag || verbose_flag) 262 printf("Version: if %s.%d kmod %s\n", val1, ival, val2); 263 break; 264 case MDT_MODULE: 265 getstr(&ptr, val1); 266 getstr(&ptr, val2); 267 if (lastmod) 268 free(lastmod); 269 lastmod = strdup(val2); 270 if (dump_flag || verbose_flag) 271 printf("Module %s in %s\n", val1, val2); 272 break; 273 case MDT_PNP_INFO: 274 if (!dump_flag && !unbound_flag && lastmod && strcmp(lastmod, "kernel") == 0) 275 break; 276 getstr(&ptr, val1); 277 getstr(&ptr, val2); 278 ents = getint(&ptr); 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) { 283 if (verbose_flag) 284 printf("Treating usb as uhub -- bug in source table still?\n"); 285 strcpy(val1, "uhub"); 286 } 287 if (bus && strcmp(val1, bus) != 0) { 288 if (verbose_flag) 289 printf("Skipped because table for bus %s, looking for %s\n", 290 val1, bus); 291 break; 292 } 293 for (i = 0; i < ents; i++) { 294 if (verbose_flag) 295 printf("---------- Entry %d ----------\n", i); 296 if (dump_flag) 297 printf(" "); 298 cp = val2; 299 notme = 0; 300 mask = -1; 301 bit = -1; 302 do { 303 switch (*cp) { 304 /* All integer fields */ 305 case 'I': 306 case 'J': 307 case 'G': 308 case 'L': 309 case 'M': 310 ival = getint(&ptr); 311 if (dump_flag) { 312 printf("%#x:", ival); 313 break; 314 } 315 if (bit >= 0 && ((1 << bit) & mask) == 0) 316 break; 317 v = pnpval_as_int(cp + 2, pnpinfo); 318 if (verbose_flag) 319 printf("Matching %s (%c) table=%#x tomatch=%#x\n", 320 cp + 2, *cp, v, ival); 321 switch (*cp) { 322 case 'J': 323 if (ival == -1) 324 break; 325 /*FALLTHROUGH*/ 326 case 'I': 327 if (v != ival) 328 notme++; 329 break; 330 case 'G': 331 if (v < ival) 332 notme++; 333 break; 334 case 'L': 335 if (v > ival) 336 notme++; 337 break; 338 case 'M': 339 mask = ival; 340 break; 341 } 342 break; 343 /* String fields */ 344 case 'D': 345 case 'Z': 346 getstr(&ptr, val1); 347 if (dump_flag) { 348 printf("'%s':", val1); 349 break; 350 } 351 if (*cp == 'D') 352 break; 353 s = pnpval_as_str(cp + 2, pnpinfo); 354 if (strcmp(s, val1) != 0) 355 notme++; 356 break; 357 /* Key override fields, required to be last in the string */ 358 case 'T': 359 /* 360 * This is imperfect and only does one key and will be redone 361 * to be more general for multiple keys. Currently, nothing 362 * does that. 363 */ 364 if (dump_flag) /* No per-row data stored */ 365 break; 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) 369 notme++; 370 else if (s > pnpinfo && s[-1] != ' ') 371 notme++; 372 break; 373 default: 374 fprintf(stderr, "Unknown field type %c\n:", *cp); 375 break; 376 } 377 bit++; 378 cp = strchr(cp, ';'); 379 if (cp) 380 cp++; 381 } while (cp && *cp); 382 if (dump_flag) 383 printf("\n"); 384 else if (!notme) { 385 if (!unbound_flag) { 386 if (all_flag) 387 printf("%s: %s", *dev ? dev : "unattached", lastmod); 388 else 389 printf("%s\n", lastmod); 390 if (verbose_flag) 391 printf("Matches --- %s ---\n", lastmod); 392 } 393 found++; 394 } 395 } 396 break; 397 default: 398 if (dump_flag) 399 printf("Unknown Type %d len %d\n", ival, len); 400 break; 401 } 402 walker = (void *)(len - sizeof(int) + (intptr_t)walker); 403 } 404 if (unbound_flag && found == 0 && *pnpinfo) { 405 if (verbose_flag) 406 printf("------------------------- "); 407 printf("%s on %s pnpinfo %s", *dev ? dev : "unattached", bus, pnpinfo); 408 if (verbose_flag) 409 printf(" -------------------------"); 410 printf("\n"); 411 } 412 free(lastmod); 413 } 414 415 static int 416 find_unmatched(struct devinfo_dev *dev, void *arg) 417 { 418 struct devinfo_dev *parent; 419 char *bus, *p; 420 421 do { 422 if (!all_flag && dev->dd_name[0] != '\0') 423 break; 424 if (!(dev->dd_flags & DF_ENABLED)) 425 break; 426 if (dev->dd_flags & DF_ATTACHED_ONCE) 427 break; 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)) 432 p--; 433 *++p = '\0'; 434 if (verbose_flag) 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); 438 free(bus); 439 } while (0); 440 441 return (devinfo_foreach_device_child(dev, find_unmatched, arg)); 442 } 443 444 struct exact_info 445 { 446 const char *bus; 447 const char *loc; 448 struct devinfo_dev *dev; 449 }; 450 451 /* 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. 456 */ 457 static int 458 find_exact_dev(struct devinfo_dev *dev, void *arg) 459 { 460 struct devinfo_dev *parent; 461 char *loc; 462 struct exact_info *info; 463 464 info = arg; 465 do { 466 if (info->dev != NULL) 467 break; 468 if (!(dev->dd_flags & DF_ENABLED)) 469 break; 470 parent = devinfo_handle_to_device(dev->dd_parent); 471 if (strcmp(info->bus, parent->dd_name) != 0) 472 break; 473 asprintf(&loc, "%s %s", parent->dd_pnpinfo, 474 parent->dd_location); 475 if (strcmp(loc, info->loc) == 0) 476 info->dev = dev; 477 free(loc); 478 } while (0); 479 480 return (devinfo_foreach_device_child(dev, find_exact_dev, arg)); 481 } 482 483 static void 484 find_nomatch(char *nomatch) 485 { 486 char *bus, *pnpinfo, *tmp, *busnameunit; 487 struct exact_info info; 488 489 /* 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. 495 */ 496 tmp = nomatch + strlen(nomatch) - 4; 497 while (tmp > nomatch && strncmp(tmp, " on ", 4) != 0) 498 tmp--; 499 if (tmp == nomatch) 500 errx(1, "No bus found in nomatch string: '%s'", nomatch); 501 bus = tmp + 4; 502 *tmp = '\0'; 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)) 508 tmp--; 509 *++tmp = '\0'; 510 511 /* 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. 515 */ 516 if (*nomatch == '?') 517 nomatch++; 518 if (strncmp(nomatch, " at ", 4) != 0) 519 errx(1, "Malformed NOMATCH string: '%s'", nomatch); 520 pnpinfo = nomatch + 4; 521 522 /* 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. 526 */ 527 info.loc = pnpinfo; 528 info.bus = busnameunit; 529 info.dev = NULL; 530 devinfo_foreach_device_child(root, find_exact_dev, (void *)&info); 531 if (info.dev != NULL && info.dev->dd_flags & DF_ATTACHED_ONCE) 532 exit(0); 533 search_hints(bus, "", pnpinfo); 534 535 exit(0); 536 } 537 538 static void 539 usage(void) 540 { 541 542 errx(1, "devmatch [-adv] [-p nomatch] [-h linker-hints]"); 543 } 544 545 int 546 main(int argc, char **argv) 547 { 548 int ch; 549 550 while ((ch = getopt_long(argc, argv, "adh:p:uv", 551 longopts, NULL)) != -1) { 552 switch (ch) { 553 case 'a': 554 all_flag++; 555 break; 556 case 'd': 557 dump_flag++; 558 break; 559 case 'h': 560 linker_hints = optarg; 561 break; 562 case 'p': 563 nomatch_str = optarg; 564 break; 565 case 'u': 566 unbound_flag++; 567 break; 568 case 'v': 569 verbose_flag++; 570 break; 571 default: 572 usage(); 573 } 574 } 575 argc -= optind; 576 argv += optind; 577 578 if (argc >= 1) 579 usage(); 580 581 read_linker_hints(); 582 if (dump_flag) { 583 search_hints(NULL, NULL, NULL); 584 exit(0); 585 } 586 587 if (devinfo_init()) 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); 593 else 594 devinfo_foreach_device_child(root, find_unmatched, (void *)0); 595 devinfo_free(); 596 } 597