sbin/devmatch/devmatch.c

   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 struct match_data {
  60         char *descr;
  61         int priority;
  62 } match_data[DEVMATCH_MAX_HITS];
  63
  64 static int hit_index;
  65 static int all_flag;
  66 static int dump_flag;
  67 static char *linker_hints;
  68 static char *nomatch_str;
  69 static int unbound_flag;
  70 static int verbose_flag;
  71
  72 static void *hints;
  73 static void *hints_end;
  74
  75 static void *
  76 read_hints(const char *fn, size_t *len)
  77 {
  78         void *h;
  79         int fd;
  80         struct stat sb;
  81
  82         fd = open(fn, O_RDONLY);
  83         if (fd < 0) {
  84                 if (errno == ENOENT)
  85                         return NULL;
  86                 err(1, "Can't open %s for reading", fn);
  87         }
  88         if (fstat(fd, &sb) != 0)
  89                 err(1, "Can't fstat %s\n", fn);
  90         h = malloc(sb.st_size);
  91         if (h == NULL)
  92                 err(1, "not enough space to read hints file of %ju bytes", (uintmax_t)sb.st_size);
  93         if (read(fd, h, sb.st_size) != sb.st_size)
  94                 err(1, "Can't read in %ju bytes from %s", (uintmax_t)sb.st_size, fn);
  95         close(fd);
  96         *len = sb.st_size;
  97         return h;
  98 }
  99
 100 static void
 101 read_linker_hints(void)
 102 {
 103         char fn[MAXPATHLEN];
 104         char *modpath, *p, *q;
 105         size_t buflen, len;
 106
 107         if (linker_hints == NULL) {
 108                 if (sysctlbyname("kern.module_path", NULL, &buflen, NULL, 0) < 0)
 109                         errx(1, "Can't find kernel module path.");
 110                 modpath = malloc(buflen);
 111                 if (modpath == NULL)
 112                         err(1, "Can't get memory for modpath.");
 113                 if (sysctlbyname("kern.module_path", modpath, &buflen, NULL, 0) < 0)
 114                         errx(1, "Can't find kernel module path.");
 115                 p = modpath;
 116                 while ((q = strsep(&p, ";")) != NULL) {
 117                         snprintf(fn, sizeof(fn), "%s/linker.hints", q);
 118                         hints = read_hints(fn, &len);
 119                         if (hints == NULL)
 120                                 continue;
 121                         break;
 122                 }
 123                 if (q == NULL) {
 124                         warnx("Can't read linker hints file.");
 125                         free(hints);
 126                         hints = NULL;
 127                         return;
 128                 }
 129         } else {
 130                 hints = read_hints(linker_hints, &len);
 131                 if (hints == NULL)
 132                         err(1, "Can't open %s for reading", fn);
 133         }
 134
 135         if (*(int *)(intptr_t)hints != LINKER_HINTS_VERSION) {
 136                 warnx("Linker hints version %d doesn't match expected %d.",
 137                     *(int *)(intptr_t)hints, LINKER_HINTS_VERSION);
 138                 free(hints);
 139                 hints = NULL;
 140         }
 141         if (hints != NULL)
 142                 hints_end = (void *)((intptr_t)hints + (intptr_t)len);
 143 }
 144
 145 static int
 146 getint(void **ptr)
 147 {
 148         int *p = *ptr;
 149         int rv;
 150
 151         p = (int *)roundup2((intptr_t)p, sizeof(int));
 152         rv = *p++;
 153         *ptr = p;
 154         return rv;
 155 }
 156
 157 static void
 158 getstr(void **ptr, char *val)
 159 {
 160         int *p = *ptr;
 161         char *c = (char *)p;
 162         int len = *(uint8_t *)c;
 163
 164         memcpy(val, c + 1, len);
 165         val[len] = 0;
 166         c += len + 1;
 167         *ptr = (void *)c;
 168 }
 169
 170 static int
 171 pnpval_as_int(const char *val, const char *pnpinfo)
 172 {
 173         int rv;
 174         char key[256];
 175         char *cp;
 176
 177         if (pnpinfo == NULL)
 178                 return -1;
 179
 180         cp = strchr(val, ';');
 181         key[0] = ' ';
 182         if (cp == NULL)
 183                 strlcpy(key + 1, val, sizeof(key) - 1);
 184         else {
 185                 memcpy(key + 1, val, cp - val);
 186                 key[cp - val + 1] = '\0';
 187         }
 188         strlcat(key, "=", sizeof(key));
 189         if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0)
 190                 rv = strtol(pnpinfo + strlen(key + 1), NULL, 0);
 191         else {
 192                 cp = strstr(pnpinfo, key);
 193                 if (cp == NULL)
 194                         rv = -1;
 195                 else
 196                         rv = strtol(cp + strlen(key), NULL, 0);
 197         }
 198         return rv;
 199 }
 200
 201 static void
 202 quoted_strcpy(char *dst, const char *src)
 203 {
 204         char q = ' ';
 205
 206         if (*src == '\'' || *src == '"')
 207                 q = *src++;
 208         while (*src && *src != q)
 209                 *dst++ = *src++; // XXX backtick quoting
 210         *dst++ = '\0';
 211         // XXX overflow
 212 }
 213
 214 static char *
 215 pnpval_as_str(const char *val, const char *pnpinfo)
 216 {
 217         static char retval[256];
 218         char key[256];
 219         char *cp;
 220
 221         if (pnpinfo == NULL) {
 222                 *retval = '\0';
 223                 return retval;
 224         }
 225
 226         cp = strchr(val, ';');
 227         key[0] = ' ';
 228         if (cp == NULL)
 229                 strlcpy(key + 1, val, sizeof(key) - 1);
 230         else {
 231                 memcpy(key + 1, val, cp - val);
 232                 key[cp - val + 1] = '\0';
 233         }
 234         strlcat(key, "=", sizeof(key));
 235         if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0)
 236                 quoted_strcpy(retval, pnpinfo + strlen(key + 1));
 237         else {
 238                 cp = strstr(pnpinfo, key);
 239                 if (cp == NULL)
 240                         strcpy(retval, "MISSING");
 241                 else
 242                         quoted_strcpy(retval, cp + strlen(key));
 243         }
 244         return retval;
 245 }
 246
 247 static int
 248 match_data_compare(const void *_pa, const void *_pb)
 249 {
 250         const struct match_data *pa = _pa;
 251         const struct match_data *pb = _pb;
 252
 253         /* biggest value first */
 254         if (pa->priority > pb->priority)
 255                 return (-1);
 256         else if (pa->priority < pb->priority)
 257                 return (1);
 258
 259         /* then sort by string */
 260         return (strcmp(pa->descr, pb->descr));
 261 }
 262
 263 static int
 264 bitrev16(int input)
 265 {
 266         int retval = 0;
 267         int x;
 268
 269         for (x = 0; x != 16; x++) {
 270                 if ((input >> x) & 1)
 271                         retval |= (0x8000 >> x);
 272         }
 273         return (retval);
 274 }
 275
 276 static void
 277 search_hints(const char *bus, const char *dev, const char *pnpinfo)
 278 {
 279         char val1[256], val2[256];
 280         int ival, len, ents, i, notme, mask, bit, v, found;
 281         void *ptr, *walker;
 282         char *lastmod = NULL, *cp, *s;
 283
 284         walker = hints;
 285         getint(&walker);
 286         found = 0;
 287         while (walker < hints_end) {
 288                 len = getint(&walker);
 289                 ival = getint(&walker);
 290                 ptr = walker;
 291                 switch (ival) {
 292                 case MDT_VERSION:
 293                         getstr(&ptr, val1);
 294                         ival = getint(&ptr);
 295                         getstr(&ptr, val2);
 296                         if (dump_flag)
 297                                 printf("Version: if %s.%d kmod %s\n", val1, ival, val2);
 298                         break;
 299                 case MDT_MODULE:
 300                         getstr(&ptr, val1);
 301                         getstr(&ptr, val2);
 302                         if (lastmod)
 303                                 free(lastmod);
 304                         lastmod = strdup(val2);
 305                         if (dump_flag)
 306                                 printf("Module %s in %s\n", val1, val2);
 307                         break;
 308                 case MDT_PNP_INFO:
 309                         if (!dump_flag && !unbound_flag && lastmod && strcmp(lastmod, "kernel") == 0)
 310                                 break;
 311                         getstr(&ptr, val1);
 312                         getstr(&ptr, val2);
 313                         ents = getint(&ptr);
 314                         if (bus && strcmp(val1, bus) != 0)
 315                                 break;
 316                         if (dump_flag)
 317                                 printf("PNP info for bus %s format %s %d entries (%s)\n",
 318                                     val1, val2, ents, lastmod);
 319                         for (i = 0; i < ents; i++) {
 320                                 if (dump_flag)
 321                                         printf("   ");
 322                                 cp = val2;
 323                                 notme = 0;
 324                                 mask = -1;
 325                                 bit = -1;
 326                                 do {
 327                                         switch (*cp) {
 328                                                 /* All integer fields */
 329                                         case 'I':
 330                                         case 'J':
 331                                         case 'G':
 332                                         case 'L':
 333                                         case 'M':
 334                                                 ival = getint(&ptr);
 335                                                 if (dump_flag) {
 336                                                         printf("%#x:", ival);
 337                                                         break;
 338                                                 }
 339                                                 if (bit >= 0 && ((1 << bit) & mask) == 0)
 340                                                         break;
 341                                                 v = pnpval_as_int(cp + 2, pnpinfo);
 342                                                 switch (*cp) {
 343                                                 case 'J':
 344                                                         if (ival == -1)
 345                                                                 break;
 346                                                         /*FALLTHROUGH*/
 347                                                 case 'I':
 348                                                         if (v != ival)
 349                                                                 notme++;
 350                                                         break;
 351                                                 case 'G':
 352                                                         if (v < ival)
 353                                                                 notme++;
 354                                                         break;
 355                                                 case 'L':
 356                                                         if (v > ival)
 357                                                                 notme++;
 358                                                         break;
 359                                                 case 'M':
 360                                                         mask = ival;
 361                                                         break;
 362                                                 }
 363                                                 break;
 364                                                 /* String fields */
 365                                         case 'D':
 366                                         case 'Z':
 367                                                 getstr(&ptr, val1);
 368                                                 if (dump_flag) {
 369                                                         printf("'%s':", val1);
 370                                                         break;
 371                                                 }
 372                                                 if (*cp == 'D')
 373                                                         break;
 374                                                 s = pnpval_as_str(cp + 2, pnpinfo);
 375                                                 if (strcmp(s, val1) != 0)
 376                                                         notme++;
 377                                                 break;
 378                                                 /* Key override fields, required to be last in the string */
 379                                         case 'T':
 380                                                 /*
 381                                                  * This is imperfect and only does one key and will be redone
 382                                                  * to be more general for multiple keys. Currently, nothing
 383                                                  * does that.
 384                                                  */
 385                                                 if (dump_flag)                          /* No per-row data stored */
 386                                                         break;
 387                                                 if (cp[strlen(cp) - 1] == ';')          /* Skip required ; at end */
 388                                                         cp[strlen(cp) - 1] = '\0';      /* in case it's not there */
 389                                                 if ((s = strstr(pnpinfo, cp + 2)) == NULL)
 390                                                         notme++;
 391                                                 else if (s > pnpinfo && s[-1] != ' ')
 392                                                         notme++;
 393                                                 break;
 394                                         default:
 395                                                 fprintf(stderr, "Unknown field type %c\n:", *cp);
 396                                                 break;
 397                                         }
 398                                         bit++;
 399                                         cp = strchr(cp, ';');
 400                                         if (cp)
 401                                                 cp++;
 402                                 } while (cp && *cp);
 403                                 if (dump_flag)
 404                                         printf("\n");
 405                                 else if (!notme) {
 406                                         if (!unbound_flag) {
 407                                                 char *descr = NULL;
 408
 409                                                 if (all_flag)
 410                                                         asprintf(&descr, "%s: %s", *dev ? dev : "unattached", lastmod);
 411                                                 else
 412                                                         asprintf(&descr, "%s", lastmod);
 413
 414                                                 if (descr != NULL && hit_index < DEVMATCH_MAX_HITS) {
 415                                                         match_data[hit_index].descr = descr;
 416                                                         match_data[hit_index].priority = bitrev16(mask);
 417                                                         hit_index++;
 418                                                 } else {
 419                                                         free(descr);
 420                                                 }
 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 (hit_index != 0) {
 434                 /* sort hits by priority */
 435                 mergesort(match_data, hit_index, sizeof(match_data[0]), &match_data_compare);
 436
 437                 /* printout */
 438                 for (i = 0; i != hit_index; i++) {
 439                         puts(match_data[i].descr);
 440                         free(match_data[i].descr);
 441                 }
 442
 443                 /* reset hit_index */
 444                 hit_index = 0;
 445         }
 446         if (unbound_flag && found == 0 && *pnpinfo) {
 447                 if (verbose_flag)
 448                         printf("------------------------- ");
 449                 printf("%s on %s pnpinfo %s", *dev ? dev : "unattached", bus, pnpinfo);
 450                 if (verbose_flag)
 451                         printf(" -------------------------");
 452                 printf("\n");
 453         }
 454         free(lastmod);
 455 }
 456
 457 static int
 458 find_unmatched(struct devinfo_dev *dev, void *arg)
 459 {
 460         struct devinfo_dev *parent;
 461         char *bus, *p;
 462
 463         do {
 464                 if (!all_flag && dev->dd_name[0] != '\0')
 465                         break;
 466                 if (!(dev->dd_flags & DF_ENABLED))
 467                         break;
 468                 parent = devinfo_handle_to_device(dev->dd_parent);
 469                 bus = strdup(parent->dd_name);
 470                 p = bus + strlen(bus) - 1;
 471                 while (p >= bus && isdigit(*p))
 472                         p--;
 473                 *++p = '\0';
 474                 if (verbose_flag)
 475                         printf("Searching %s %s bus at %s for pnpinfo %s\n",
 476                             dev->dd_name, bus, dev->dd_location, dev->dd_pnpinfo);
 477                 search_hints(bus, dev->dd_name, dev->dd_pnpinfo);
 478                 free(bus);
 479         } while (0);
 480
 481         return (devinfo_foreach_device_child(dev, find_unmatched, arg));
 482 }
 483
 484 static void
 485 find_nomatch(char *nomatch)
 486 {
 487         char *bus, *pnpinfo, *tmp;
 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         tmp = bus + strlen(bus) - 1;
 504         while (tmp > bus && isdigit(*tmp))
 505                 tmp--;
 506         *++tmp = '\0';
 507
 508         /*
 509          * Note: the NOMATCH events place both the bus location as well as the
 510          * pnp info after the 'at' and we don't know where one stops and the
 511          * other begins, so we pass the whole thing to our search routine.
 512          */
 513         if (*nomatch == '?')
 514                 nomatch++;
 515         if (strncmp(nomatch, " at ", 4) != 0)
 516                 errx(1, "Malformed NOMATCH string: '%s'", nomatch);
 517         pnpinfo = nomatch + 4;
 518
 519         search_hints(bus, "", pnpinfo);
 520
 521         exit(0);
 522 }
 523
 524 static void
 525 usage(void)
 526 {
 527
 528         errx(1, "devmatch [-adv] [-p nomatch] [-h linker-hints]");
 529 }
 530
 531 int
 532 main(int argc, char **argv)
 533 {
 534         struct devinfo_dev *root;
 535         int ch;
 536
 537         while ((ch = getopt_long(argc, argv, "adh:p:uv",
 538                     longopts, NULL)) != -1) {
 539                 switch (ch) {
 540                 case 'a':
 541                         all_flag++;
 542                         break;
 543                 case 'd':
 544                         dump_flag++;
 545                         break;
 546                 case 'h':
 547                         linker_hints = optarg;
 548                         break;
 549                 case 'p':
 550                         nomatch_str = optarg;
 551                         break;
 552                 case 'u':
 553                         unbound_flag++;
 554                         break;
 555                 case 'v':
 556                         verbose_flag++;
 557                         break;
 558                 default:
 559                         usage();
 560                 }
 561         }
 562         argc -= optind;
 563         argv += optind;
 564
 565         if (argc >= 1)
 566                 usage();
 567
 568         read_linker_hints();
 569         if (dump_flag) {
 570                 search_hints(NULL, NULL, NULL);
 571                 exit(0);
 572         }
 573
 574         if (nomatch_str != NULL)
 575                 find_nomatch(nomatch_str);
 576         if (devinfo_init())
 577                 err(1, "devinfo_init");
 578         if ((root = devinfo_handle_to_device(DEVINFO_ROOT_DEVICE)) == NULL)
 579                 errx(1, "can't find root device");
 580         devinfo_foreach_device_child(root, find_unmatched, (void *)0);
 581         devinfo_free();
 582 }