stand/common/module.c

   1 /*-
   2  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
   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 /*
  31  * file/module function dispatcher, support, etc.
  32  */
  33
  34 #include <stand.h>
  35 #include <string.h>
  36 #include <sys/param.h>
  37 #include <sys/linker.h>
  38 #include <sys/module.h>
  39 #include <sys/queue.h>
  40 #include <sys/stdint.h>
  41
  42 #if defined(LOADER_FDT_SUPPORT)
  43 #include <fdt_platform.h>
  44 #endif
  45
  46 #include "bootstrap.h"
  47
  48 #define MDIR_REMOVED    0x0001
  49 #define MDIR_NOHINTS    0x0002
  50
  51 struct moduledir {
  52         char    *d_path;        /* path of modules directory */
  53         u_char  *d_hints;       /* content of linker.hints file */
  54         int     d_hintsz;       /* size of hints data */
  55         int     d_flags;
  56         STAILQ_ENTRY(moduledir) d_link;
  57 };
  58
  59 static int                      file_load(char *filename, vm_offset_t dest, struct preloaded_file **result);
  60 static int                      file_load_dependencies(struct preloaded_file *base_mod);
  61 static char *                   file_search(const char *name, char **extlist);
  62 static struct kernel_module *   file_findmodule(struct preloaded_file *fp, char *modname, struct mod_depend *verinfo);
  63 static int                      file_havepath(const char *name);
  64 static char                     *mod_searchmodule(char *name, struct mod_depend *verinfo);
  65 static char *                   mod_searchmodule_pnpinfo(const char *bus, const char *pnpinfo);
  66 static void                     file_insert_tail(struct preloaded_file *mp);
  67 static void                     file_remove(struct preloaded_file *fp);
  68 struct file_metadata*           metadata_next(struct file_metadata *base_mp, int type);
  69 static void                     moduledir_readhints(struct moduledir *mdp);
  70 static void                     moduledir_rebuild(void);
  71
  72 /* load address should be tweaked by first module loaded (kernel) */
  73 static vm_offset_t      loadaddr = 0;
  74
  75 #if defined(LOADER_FDT_SUPPORT)
  76 static const char       *default_searchpath =
  77     "/boot/kernel;/boot/modules;/boot/dtb";
  78 #else
  79 static const char       *default_searchpath = "/boot/kernel;/boot/modules";
  80 #endif
  81
  82 static STAILQ_HEAD(, moduledir) moduledir_list =
  83     STAILQ_HEAD_INITIALIZER(moduledir_list);
  84
  85 struct preloaded_file *preloaded_files = NULL;
  86
  87 static char *kld_ext_list[] = {
  88     ".ko",
  89     "",
  90     ".debug",
  91     NULL
  92 };
  93
  94
  95 /*
  96  * load an object, either a disk file or code module.
  97  *
  98  * To load a file, the syntax is:
  99  *
 100  * load -t <type> <path>
 101  *
 102  * code modules are loaded as:
 103  *
 104  * load <path> <options>
 105  */
 106
 107 COMMAND_SET(load, "load", "load a kernel or module", command_load);
 108
 109 static int
 110 command_load(int argc, char *argv[])
 111 {
 112         struct preloaded_file *fp;
 113         char    *typestr;
 114         char    *prefix;
 115         char    *skip;
 116         int             dflag, dofile, dokld, ch, error;
 117
 118         dflag = dokld = dofile = 0;
 119         optind = 1;
 120         optreset = 1;
 121         typestr = NULL;
 122         if (argc == 1) {
 123                 command_errmsg = "no filename specified";
 124                 return (CMD_CRIT);
 125         }
 126         prefix = skip = NULL;
 127         while ((ch = getopt(argc, argv, "dkp:s:t:")) != -1) {
 128                 switch(ch) {
 129                 case 'd':
 130                         dflag++;
 131                         break;
 132                 case 'k':
 133                         dokld = 1;
 134                         break;
 135                 case 'p':
 136                         prefix = optarg;
 137                         break;
 138                 case 's':
 139                         skip = optarg;
 140                         break;
 141                 case 't':
 142                         typestr = optarg;
 143                         dofile = 1;
 144                         break;
 145                 case '?':
 146                 default:
 147                         /* getopt has already reported an error */
 148                         return (CMD_OK);
 149                 }
 150         }
 151         argv += (optind - 1);
 152         argc -= (optind - 1);
 153
 154         /*
 155          * Request to load a raw file?
 156          */
 157         if (dofile) {
 158                 if ((argc != 2) || (typestr == NULL) || (*typestr == 0)) {
 159                         command_errmsg = "invalid load type";
 160                         return (CMD_CRIT);
 161                 }
 162
 163 #ifdef LOADER_VERIEXEC
 164                 if (strncmp(typestr, "manifest", 8) == 0) {
 165                         if (dflag > 0)
 166                                 ve_debug_set(dflag);
 167                         return (load_manifest(argv[1], prefix, skip, NULL));
 168                 }
 169 #ifdef LOADER_VERIEXEC_PASS_MANIFEST
 170                 if (strncmp(typestr, "pass_manifest", 13) == 0) {
 171                         if (dflag > 0)
 172                                 ve_debug_set(dflag);
 173                     return (pass_manifest(argv[1], prefix));
 174                 }
 175 #endif
 176 #endif
 177
 178                 fp = file_findfile(argv[1], typestr);
 179                 if (fp) {
 180                         snprintf(command_errbuf, sizeof(command_errbuf),
 181                           "warning: file '%s' already loaded", argv[1]);
 182                         return (CMD_WARN);
 183                 }
 184
 185                 if (file_loadraw(argv[1], typestr, 1) != NULL)
 186                         return (CMD_OK);
 187
 188                 /* Failing to load mfs_root is never going to end well! */
 189                 if (strcmp("mfs_root", typestr) == 0)
 190                         return (CMD_FATAL);
 191
 192                 return (CMD_ERROR);
 193         }
 194         /*
 195          * Do we have explicit KLD load ?
 196          */
 197         if (dokld || file_havepath(argv[1])) {
 198                 error = mod_loadkld(argv[1], argc - 2, argv + 2);
 199                 if (error == EEXIST) {
 200                         snprintf(command_errbuf, sizeof(command_errbuf),
 201                           "warning: KLD '%s' already loaded", argv[1]);
 202                         return (CMD_WARN);
 203                 }
 204
 205                 return (error == 0 ? CMD_OK : CMD_CRIT);
 206         }
 207         /*
 208          * Looks like a request for a module.
 209          */
 210         error = mod_load(argv[1], NULL, argc - 2, argv + 2);
 211         if (error == EEXIST) {
 212                 snprintf(command_errbuf, sizeof(command_errbuf),
 213                   "warning: module '%s' already loaded", argv[1]);
 214                 return (CMD_WARN);
 215         }
 216
 217         return (error == 0 ? CMD_OK : CMD_CRIT);
 218 }
 219
 220 #ifdef LOADER_GELI_SUPPORT
 221 COMMAND_SET(load_geli, "load_geli", "load a geli key", command_load_geli);
 222
 223 static int
 224 command_load_geli(int argc, char *argv[])
 225 {
 226         char    typestr[80];
 227         char    *cp;
 228         int             ch, num;
 229
 230         if (argc < 3) {
 231                 command_errmsg = "usage is [-n key#] <prov> <file>";
 232                 return(CMD_ERROR);
 233         }
 234
 235         num = 0;
 236         optind = 1;
 237         optreset = 1;
 238         while ((ch = getopt(argc, argv, "n:")) != -1) {
 239                 switch(ch) {
 240                 case 'n':
 241                         num = strtol(optarg, &cp, 0);
 242                         if (cp == optarg) {
 243                                 snprintf(command_errbuf, sizeof(command_errbuf),
 244                                   "bad key index '%s'", optarg);
 245                                 return(CMD_ERROR);
 246                         }
 247                         break;
 248                 case '?':
 249                 default:
 250                         /* getopt has already reported an error */
 251                         return(CMD_OK);
 252                 }
 253         }
 254         argv += (optind - 1);
 255         argc -= (optind - 1);
 256         sprintf(typestr, "%s:geli_keyfile%d", argv[1], num);
 257         return (file_loadraw(argv[2], typestr, 1) ? CMD_OK : CMD_ERROR);
 258 }
 259 #endif
 260
 261 void
 262 unload(void)
 263 {
 264         struct preloaded_file *fp;
 265
 266         while (preloaded_files != NULL) {
 267                 fp = preloaded_files;
 268                 preloaded_files = preloaded_files->f_next;
 269                 file_discard(fp);
 270         }
 271         loadaddr = 0;
 272         unsetenv("kernelname");
 273 }
 274
 275 COMMAND_SET(unload, "unload", "unload all modules", command_unload);
 276
 277 static int
 278 command_unload(int argc, char *argv[])
 279 {
 280         unload();
 281         return(CMD_OK);
 282 }
 283
 284 COMMAND_SET(lsmod, "lsmod", "list loaded modules", command_lsmod);
 285
 286 static int
 287 command_lsmod(int argc, char *argv[])
 288 {
 289         struct preloaded_file   *fp;
 290         struct kernel_module    *mp;
 291         struct file_metadata    *md;
 292         char                    lbuf[80];
 293         int                             ch, verbose, ret = 0;
 294
 295         verbose = 0;
 296         optind = 1;
 297         optreset = 1;
 298         while ((ch = getopt(argc, argv, "v")) != -1) {
 299                 switch(ch) {
 300                 case 'v':
 301                         verbose = 1;
 302                         break;
 303                 case '?':
 304                 default:
 305                         /* getopt has already reported an error */
 306                         return(CMD_OK);
 307                 }
 308         }
 309
 310         pager_open();
 311         for (fp = preloaded_files; fp; fp = fp->f_next) {
 312                 snprintf(lbuf, sizeof(lbuf), " %p: ", (void *) fp->f_addr);
 313                 pager_output(lbuf);
 314                 pager_output(fp->f_name);
 315                 snprintf(lbuf, sizeof(lbuf), " (%s, 0x%lx)\n", fp->f_type,
 316                   (long)fp->f_size);
 317                 if (pager_output(lbuf))
 318                         break;
 319                 if (fp->f_args != NULL) {
 320                         pager_output("    args: ");
 321                         pager_output(fp->f_args);
 322                         if (pager_output("\n"))
 323                                 break;
 324                 }
 325                 if (fp->f_modules) {
 326                         pager_output("  modules: ");
 327                         for (mp = fp->f_modules; mp; mp = mp->m_next) {
 328                                 snprintf(lbuf, sizeof(lbuf), "%s.%d ", mp->m_name,
 329                                   mp->m_version);
 330                                 pager_output(lbuf);
 331                         }
 332                         if (pager_output("\n"))
 333                                 break;
 334                 }
 335                 if (verbose) {
 336                         /* XXX could add some formatting smarts here to display some better */
 337                         for (md = fp->f_metadata; md != NULL; md = md->md_next) {
 338                                 snprintf(lbuf, sizeof(lbuf), "      0x%04x, 0x%lx\n",
 339                                   md->md_type, (long) md->md_size);
 340                                 if (pager_output(lbuf))
 341                                         break;
 342                         }
 343                 }
 344                 if (ret)
 345                         break;
 346         }
 347         pager_close();
 348         return(CMD_OK);
 349 }
 350
 351 COMMAND_SET(pnpmatch, "pnpmatch", "list matched modules based on pnpinfo", command_pnpmatch);
 352
 353 static int pnp_dump_flag = 0;
 354 static int pnp_unbound_flag = 0;
 355 static int pnp_verbose_flag = 0;
 356
 357 static int
 358 command_pnpmatch(int argc, char *argv[])
 359 {
 360         char *module;
 361         int ch;
 362
 363         pnp_verbose_flag = 0;
 364         pnp_dump_flag = 0;
 365         optind = 1;
 366         optreset = 1;
 367         while ((ch = getopt(argc, argv, "vd")) != -1) {
 368                 switch(ch) {
 369                 case 'v':
 370                         pnp_verbose_flag = 1;
 371                         break;
 372                 case 'd':
 373                         pnp_dump_flag = 1;
 374                         break;
 375                 case '?':
 376                 default:
 377                         /* getopt has already reported an error */
 378                         return(CMD_OK);
 379                 }
 380         }
 381         argv += (optind - 1);
 382         argc -= (optind - 1);
 383
 384         module = mod_searchmodule_pnpinfo(argv[1], argv[2]);
 385         if (module)
 386                 printf("Matched module: %s\n", module);
 387         else if(argv[1])
 388                 printf("No module matches %s\n", argv[1]);
 389
 390         return (CMD_OK);
 391 }
 392
 393 COMMAND_SET(pnpload, "pnpload", "load matched modules based on pnpinfo", command_pnpload);
 394
 395 static int
 396 command_pnpload(int argc, char *argv[])
 397 {
 398         char *module;
 399         int ch, error;
 400
 401         pnp_verbose_flag = 0;
 402         pnp_dump_flag = 0;
 403         optind = 1;
 404         optreset = 1;
 405         while ((ch = getopt(argc, argv, "vd")) != -1) {
 406                 switch(ch) {
 407                 case 'v':
 408                         pnp_verbose_flag = 1;
 409                         break;
 410                 case 'd':
 411                         pnp_dump_flag = 1;
 412                         break;
 413                 case '?':
 414                 default:
 415                         /* getopt has already reported an error */
 416                         return(CMD_OK);
 417                 }
 418         }
 419         argv += (optind - 1);
 420         argc -= (optind - 1);
 421
 422         if (argc != 2)
 423                 return (CMD_ERROR);
 424
 425         module = mod_searchmodule_pnpinfo(argv[1], argv[2]);
 426
 427         error = mod_load(module, NULL, 0, NULL);
 428         if (error == EEXIST) {
 429                 snprintf(command_errbuf, sizeof(command_errbuf),
 430                   "warning: module '%s' already loaded", argv[1]);
 431                 return (CMD_WARN);
 432         }
 433
 434         return (error == 0 ? CMD_OK : CMD_CRIT);
 435 }
 436
 437 #if defined(LOADER_FDT_SUPPORT)
 438 static void
 439 pnpautoload_simplebus(void) {
 440         const char *pnpstring;
 441         const char *compatstr;
 442         char *pnpinfo = NULL;
 443         char *module = NULL;
 444         int tag = 0, len, pnplen;
 445         int error;
 446
 447         while (1) {
 448                 pnpstring = fdt_devmatch_next(&tag, &len);
 449                 if (pnpstring == NULL)
 450                         return;
 451
 452                 compatstr = pnpstring;
 453                 for (pnplen = 0; pnplen != len; compatstr = pnpstring + pnplen) {
 454                         pnplen += strlen(compatstr) + 1;
 455                         asprintf(&pnpinfo, "compat=%s", compatstr);
 456
 457                         module = mod_searchmodule_pnpinfo("simplebus", pnpinfo);
 458                         if (module) {
 459                                 error = mod_loadkld(module, 0, NULL);
 460                                 if (error)
 461                                         printf("Cannot load module %s\n", module);
 462                                 break;
 463                         }
 464                 }
 465                 free(pnpinfo);
 466                 free(module);
 467         }
 468 }
 469 #endif
 470
 471 struct pnp_bus {
 472         const char *name;
 473         void (*load)(void);
 474 };
 475
 476 struct pnp_bus pnp_buses[] = {
 477 #if defined(LOADER_FDT_SUPPORT)
 478         {"simplebus", pnpautoload_simplebus},
 479 #endif
 480 };
 481
 482 COMMAND_SET(pnpautoload, "pnpautoload", "auto load modules based on pnpinfo", command_pnpautoload);
 483
 484 static int
 485 command_pnpautoload(int argc, char *argv[])
 486 {
 487         int i;
 488         int verbose;
 489         int ch, match;
 490
 491         pnp_verbose_flag = 0;
 492         pnp_dump_flag = 0;
 493         verbose = 0;
 494         optind = 1;
 495         optreset = 1;
 496         match = 0;
 497         while ((ch = getopt(argc, argv, "v")) != -1) {
 498                 switch(ch) {
 499                 case 'v':
 500                         verbose = 1;
 501                         break;
 502                 case '?':
 503                 default:
 504                         /* getopt has already reported an error */
 505                         return(CMD_OK);
 506                 }
 507         }
 508         argv += (optind - 1);
 509         argc -= (optind - 1);
 510
 511         if (argc > 2)
 512                 return (CMD_ERROR);
 513
 514         for (i = 0; i < nitems(pnp_buses); i++) {
 515                 if (argc == 2 && strcmp(argv[1], pnp_buses[i].name) != 0) {
 516                         if (verbose)
 517                                 printf("Skipping bus %s\n", pnp_buses[i].name);
 518                         continue;
 519                 }
 520                 if (verbose)
 521                         printf("Autoloading modules for simplebus\n");
 522                 pnp_buses[i].load();
 523                 match = 1;
 524         }
 525         if (match == 0)
 526                 printf("Unsupported bus %s\n", argv[1]);
 527
 528         return (CMD_OK);
 529 }
 530
 531 /*
 532  * File level interface, functions file_*
 533  */
 534 int
 535 file_load(char *filename, vm_offset_t dest, struct preloaded_file **result)
 536 {
 537         static int last_file_format = 0;
 538         struct preloaded_file *fp;
 539         int error;
 540         int i;
 541
 542         if (archsw.arch_loadaddr != NULL)
 543                 dest = archsw.arch_loadaddr(LOAD_RAW, filename, dest);
 544
 545         error = EFTYPE;
 546         for (i = last_file_format, fp = NULL;
 547              file_formats[i] && fp == NULL; i++) {
 548                 error = (file_formats[i]->l_load)(filename, dest, &fp);
 549                 if (error == 0) {
 550                         fp->f_loader = last_file_format = i; /* remember the loader */
 551                         *result = fp;
 552                         break;
 553                 } else if (last_file_format == i && i != 0) {
 554                         /* Restart from the beginning */
 555                         i = -1;
 556                         last_file_format = 0;
 557                         fp = NULL;
 558                         continue;
 559                 }
 560                 if (error == EFTYPE)
 561                         continue;               /* Unknown to this handler? */
 562                 if (error) {
 563                         snprintf(command_errbuf, sizeof(command_errbuf),
 564                           "can't load file '%s': %s", filename, strerror(error));
 565                         break;
 566                 }
 567         }
 568         return (error);
 569 }
 570
 571 static int
 572 file_load_dependencies(struct preloaded_file *base_file)
 573 {
 574         struct file_metadata *md;
 575         struct preloaded_file *fp;
 576         struct mod_depend *verinfo;
 577         struct kernel_module *mp;
 578         char *dmodname;
 579         int error;
 580
 581         md = file_findmetadata(base_file, MODINFOMD_DEPLIST);
 582         if (md == NULL)
 583                 return (0);
 584         error = 0;
 585         do {
 586                 verinfo = (struct mod_depend*)md->md_data;
 587                 dmodname = (char *)(verinfo + 1);
 588                 if (file_findmodule(NULL, dmodname, verinfo) == NULL) {
 589                         printf("loading required module '%s'\n", dmodname);
 590                         error = mod_load(dmodname, verinfo, 0, NULL);
 591                         if (error)
 592                                 break;
 593                         /*
 594                          * If module loaded via kld name which isn't listed
 595                          * in the linker.hints file, we should check if it have
 596                          * required version.
 597                          */
 598                         mp = file_findmodule(NULL, dmodname, verinfo);
 599                         if (mp == NULL) {
 600                                 snprintf(command_errbuf, sizeof(command_errbuf),
 601                                   "module '%s' exists but with wrong version", dmodname);
 602                                 error = ENOENT;
 603                                 break;
 604                         }
 605                 }
 606                 md = metadata_next(md, MODINFOMD_DEPLIST);
 607         } while (md);
 608         if (!error)
 609                 return (0);
 610         /* Load failed; discard everything */
 611         while (base_file != NULL) {
 612                 fp = base_file;
 613                 base_file = base_file->f_next;
 614                 file_discard(fp);
 615         }
 616         return (error);
 617 }
 618
 619
 620 #ifdef LOADER_VERIEXEC_VECTX
 621 #define VECTX_HANDLE(fd) vctx
 622 #else
 623 #define VECTX_HANDLE(fd) fd
 624 #endif
 625
 626
 627 /*
 628  * We've been asked to load (fname) as (type), so just suck it in,
 629  * no arguments or anything.
 630  */
 631 struct preloaded_file *
 632 file_loadraw(const char *fname, char *type, int insert)
 633 {
 634         struct preloaded_file   *fp;
 635         char                    *name;
 636         int                             fd, got;
 637         vm_offset_t                     laddr;
 638 #ifdef LOADER_VERIEXEC_VECTX
 639         struct vectx            *vctx;
 640         int                     verror;
 641 #endif
 642
 643         /* We can't load first */
 644         if ((file_findfile(NULL, NULL)) == NULL) {
 645                 command_errmsg = "can't load file before kernel";
 646                 return(NULL);
 647         }
 648
 649         /* locate the file on the load path */
 650         name = file_search(fname, NULL);
 651         if (name == NULL) {
 652                 snprintf(command_errbuf, sizeof(command_errbuf),
 653                   "can't find '%s'", fname);
 654                 return(NULL);
 655         }
 656
 657         if ((fd = open(name, O_RDONLY)) < 0) {
 658                 snprintf(command_errbuf, sizeof(command_errbuf),
 659                   "can't open '%s': %s", name, strerror(errno));
 660                 free(name);
 661                 return(NULL);
 662         }
 663
 664 #ifdef LOADER_VERIEXEC_VECTX
 665         vctx = vectx_open(fd, name, 0L, NULL, &verror, __func__);
 666         if (verror) {
 667                 sprintf(command_errbuf, "can't verify '%s': %s",
 668                     name, ve_error_get());
 669                 free(name);
 670                 free(vctx);
 671                 close(fd);
 672                 return(NULL);
 673         }
 674 #else
 675 #ifdef LOADER_VERIEXEC
 676         if (verify_file(fd, name, 0, VE_MUST, __func__) < 0) {
 677                 sprintf(command_errbuf, "can't verify '%s': %s",
 678                     name, ve_error_get());
 679                 free(name);
 680                 close(fd);
 681                 return(NULL);
 682         }
 683 #endif
 684 #endif
 685
 686         if (archsw.arch_loadaddr != NULL)
 687                 loadaddr = archsw.arch_loadaddr(LOAD_RAW, name, loadaddr);
 688
 689         printf("%s ", name);
 690
 691         laddr = loadaddr;
 692         for (;;) {
 693                 /* read in 4k chunks; size is not really important */
 694                 got = archsw.arch_readin(VECTX_HANDLE(fd), laddr, 4096);
 695                 if (got == 0)                           /* end of file */
 696                         break;
 697                 if (got < 0) {                          /* error */
 698                         snprintf(command_errbuf, sizeof(command_errbuf),
 699                           "error reading '%s': %s", name, strerror(errno));
 700                         free(name);
 701                         close(fd);
 702 #ifdef LOADER_VERIEXEC_VECTX
 703                         free(vctx);
 704 #endif
 705                         return(NULL);
 706                 }
 707                 laddr += got;
 708         }
 709
 710         printf("size=%#jx\n", (uintmax_t)(laddr - loadaddr));
 711 #ifdef LOADER_VERIEXEC_VECTX
 712         verror = vectx_close(vctx, VE_MUST, __func__);
 713         if (verror) {
 714                 free(name);
 715                 close(fd);
 716                 free(vctx);
 717                 return(NULL);
 718         }
 719 #endif
 720
 721         /* Looks OK so far; create & populate control structure */
 722         fp = file_alloc();
 723         if (fp == NULL) {
 724                 snprintf(command_errbuf, sizeof (command_errbuf),
 725                     "no memory to load %s", name);
 726                 free(name);
 727                 close(fd);
 728                 return (NULL);
 729         }
 730         fp->f_name = name;
 731         fp->f_type = strdup(type);
 732         fp->f_args = NULL;
 733         fp->f_metadata = NULL;
 734         fp->f_loader = -1;
 735         fp->f_addr = loadaddr;
 736         fp->f_size = laddr - loadaddr;
 737
 738         if (fp->f_type == NULL) {
 739                 snprintf(command_errbuf, sizeof (command_errbuf),
 740                     "no memory to load %s", name);
 741                 free(name);
 742                 close(fd);
 743                 return (NULL);
 744         }
 745         /* recognise space consumption */
 746         loadaddr = laddr;
 747
 748         /* Add to the list of loaded files */
 749         if (insert != 0)
 750                 file_insert_tail(fp);
 751         close(fd);
 752         return(fp);
 753 }
 754
 755 /*
 756  * Load the module (name), pass it (argc),(argv), add container file
 757  * to the list of loaded files.
 758  * If module is already loaded just assign new argc/argv.
 759  */
 760 int
 761 mod_load(char *modname, struct mod_depend *verinfo, int argc, char *argv[])
 762 {
 763         struct kernel_module    *mp;
 764         int                             err;
 765         char                    *filename;
 766
 767         if (file_havepath(modname)) {
 768                 printf("Warning: mod_load() called instead of mod_loadkld() for module '%s'\n", modname);
 769                 return (mod_loadkld(modname, argc, argv));
 770         }
 771         /* see if module is already loaded */
 772         mp = file_findmodule(NULL, modname, verinfo);
 773         if (mp) {
 774 #ifdef moduleargs
 775                 free(mp->m_args);
 776                 mp->m_args = unargv(argc, argv);
 777 #endif
 778                 snprintf(command_errbuf, sizeof(command_errbuf),
 779                   "warning: module '%s' already loaded", mp->m_name);
 780                 return (0);
 781         }
 782         /* locate file with the module on the search path */
 783         filename = mod_searchmodule(modname, verinfo);
 784         if (filename == NULL) {
 785                 snprintf(command_errbuf, sizeof(command_errbuf),
 786                   "can't find '%s'", modname);
 787                 return (ENOENT);
 788         }
 789         err = mod_loadkld(filename, argc, argv);
 790         free(filename);
 791         return (err);
 792 }
 793
 794 /*
 795  * Load specified KLD. If path is omitted, then try to locate it via
 796  * search path.
 797  */
 798 int
 799 mod_loadkld(const char *kldname, int argc, char *argv[])
 800 {
 801         struct preloaded_file   *fp;
 802         int                     err;
 803         char                    *filename;
 804         vm_offset_t             loadaddr_saved;
 805
 806         /*
 807          * Get fully qualified KLD name
 808          */
 809         filename = file_search(kldname, kld_ext_list);
 810         if (filename == NULL) {
 811                 snprintf(command_errbuf, sizeof(command_errbuf),
 812                   "can't find '%s'", kldname);
 813                 return (ENOENT);
 814         }
 815         /*
 816          * Check if KLD already loaded
 817          */
 818         fp = file_findfile(filename, NULL);
 819         if (fp) {
 820                 snprintf(command_errbuf, sizeof(command_errbuf),
 821                   "warning: KLD '%s' already loaded", filename);
 822                 free(filename);
 823                 return (0);
 824         }
 825
 826         do {
 827                 err = file_load(filename, loadaddr, &fp);
 828                 if (err)
 829                         break;
 830                 fp->f_args = unargv(argc, argv);
 831                 loadaddr_saved = loadaddr;
 832                 loadaddr = fp->f_addr + fp->f_size;
 833                 file_insert_tail(fp);   /* Add to the list of loaded files */
 834                 if (file_load_dependencies(fp) != 0) {
 835                         err = ENOENT;
 836                         file_remove(fp);
 837                         loadaddr = loadaddr_saved;
 838                         fp = NULL;
 839                         break;
 840                 }
 841         } while(0);
 842         if (err == EFTYPE) {
 843                 snprintf(command_errbuf, sizeof(command_errbuf),
 844                   "don't know how to load module '%s'", filename);
 845         }
 846         if (err)
 847                 file_discard(fp);
 848         free(filename);
 849         return (err);
 850 }
 851
 852 /*
 853  * Find a file matching (name) and (type).
 854  * NULL may be passed as a wildcard to either.
 855  */
 856 struct preloaded_file *
 857 file_findfile(const char *name, const char *type)
 858 {
 859         struct preloaded_file *fp;
 860
 861         for (fp = preloaded_files; fp != NULL; fp = fp->f_next) {
 862                 if (((name == NULL) || !strcmp(name, fp->f_name)) &&
 863                   ((type == NULL) || !strcmp(type, fp->f_type)))
 864                         break;
 865         }
 866         return (fp);
 867 }
 868
 869 /*
 870  * Find a module matching (name) inside of given file.
 871  * NULL may be passed as a wildcard.
 872  */
 873 struct kernel_module *
 874 file_findmodule(struct preloaded_file *fp, char *modname,
 875         struct mod_depend *verinfo)
 876 {
 877         struct kernel_module *mp, *best;
 878         int bestver, mver;
 879
 880         if (fp == NULL) {
 881                 for (fp = preloaded_files; fp; fp = fp->f_next) {
 882                         mp = file_findmodule(fp, modname, verinfo);
 883                         if (mp)
 884                                 return (mp);
 885                 }
 886                 return (NULL);
 887         }
 888         best = NULL;
 889         bestver = 0;
 890         for (mp = fp->f_modules; mp; mp = mp->m_next) {
 891                 if (strcmp(modname, mp->m_name) == 0) {
 892                         if (verinfo == NULL)
 893                                 return (mp);
 894                         mver = mp->m_version;
 895                         if (mver == verinfo->md_ver_preferred)
 896                                 return (mp);
 897                         if (mver >= verinfo->md_ver_minimum &&
 898                           mver <= verinfo->md_ver_maximum &&
 899                           mver > bestver) {
 900                                 best = mp;
 901                                 bestver = mver;
 902                         }
 903                 }
 904         }
 905         return (best);
 906 }
 907 /*
 908  * Make a copy of (size) bytes of data from (p), and associate them as
 909  * metadata of (type) to the module (mp).
 910  */
 911 void
 912 file_addmetadata(struct preloaded_file *fp, int type, size_t size, void *p)
 913 {
 914         struct file_metadata    *md;
 915
 916         md = malloc(sizeof(struct file_metadata) - sizeof(md->md_data) + size);
 917         if (md != NULL) {
 918                 md->md_size = size;
 919                 md->md_type = type;
 920                 bcopy(p, md->md_data, size);
 921                 md->md_next = fp->f_metadata;
 922         }
 923         fp->f_metadata = md;
 924 }
 925
 926 /*
 927  * Find a metadata object of (type) associated with the file (fp)
 928  */
 929 struct file_metadata *
 930 file_findmetadata(struct preloaded_file *fp, int type)
 931 {
 932         struct file_metadata *md;
 933
 934         for (md = fp->f_metadata; md != NULL; md = md->md_next)
 935                 if (md->md_type == type)
 936                         break;
 937         return(md);
 938 }
 939
 940 /*
 941  * Remove all metadata from the file.
 942  */
 943 void
 944 file_removemetadata(struct preloaded_file *fp)
 945 {
 946         struct file_metadata *md, *next;
 947
 948         for (md = fp->f_metadata; md != NULL; md = next)
 949         {
 950                 next = md->md_next;
 951                 free(md);
 952         }
 953         fp->f_metadata = NULL;
 954 }
 955
 956 struct file_metadata *
 957 metadata_next(struct file_metadata *md, int type)
 958 {
 959
 960         if (md == NULL)
 961                 return (NULL);
 962         while((md = md->md_next) != NULL)
 963                 if (md->md_type == type)
 964                         break;
 965         return (md);
 966 }
 967
 968 static char *emptyextlist[] = { "", NULL };
 969
 970 /*
 971  * Check if the given file is in place and return full path to it.
 972  */
 973 static char *
 974 file_lookup(const char *path, const char *name, int namelen, char **extlist)
 975 {
 976         struct stat     st;
 977         char    *result, *cp, **cpp;
 978         int             pathlen, extlen, len;
 979
 980         pathlen = strlen(path);
 981         extlen = 0;
 982         if (extlist == NULL)
 983                 extlist = emptyextlist;
 984         for (cpp = extlist; *cpp; cpp++) {
 985                 len = strlen(*cpp);
 986                 if (len > extlen)
 987                         extlen = len;
 988         }
 989         result = malloc(pathlen + namelen + extlen + 2);
 990         if (result == NULL)
 991                 return (NULL);
 992         bcopy(path, result, pathlen);
 993         if (pathlen > 0 && result[pathlen - 1] != '/')
 994                 result[pathlen++] = '/';
 995         cp = result + pathlen;
 996         bcopy(name, cp, namelen);
 997         cp += namelen;
 998         for (cpp = extlist; *cpp; cpp++) {
 999                 strcpy(cp, *cpp);
1000                 if (stat(result, &st) == 0 && S_ISREG(st.st_mode))
1001                         return result;
1002         }
1003         free(result);
1004         return NULL;
1005 }
1006
1007 /*
1008  * Check if file name have any qualifiers
1009  */
1010 static int
1011 file_havepath(const char *name)
1012 {
1013         const char              *cp;
1014
1015         archsw.arch_getdev(NULL, name, &cp);
1016         return (cp != name || strchr(name, '/') != NULL);
1017 }
1018
1019 /*
1020  * Attempt to find the file (name) on the module searchpath.
1021  * If (name) is qualified in any way, we simply check it and
1022  * return it or NULL.  If it is not qualified, then we attempt
1023  * to construct a path using entries in the environment variable
1024  * module_path.
1025  *
1026  * The path we return a pointer to need never be freed, as we manage
1027  * it internally.
1028  */
1029 static char *
1030 file_search(const char *name, char **extlist)
1031 {
1032         struct moduledir        *mdp;
1033         struct stat             sb;
1034         char            *result;
1035         int                     namelen;
1036
1037         /* Don't look for nothing */
1038         if (name == NULL)
1039                 return(NULL);
1040
1041         if (*name == 0)
1042                 return(strdup(name));
1043
1044         if (file_havepath(name)) {
1045                 /* Qualified, so just see if it exists */
1046                 if (stat(name, &sb) == 0)
1047                         return(strdup(name));
1048                 return(NULL);
1049         }
1050         moduledir_rebuild();
1051         result = NULL;
1052         namelen = strlen(name);
1053         STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
1054                 result = file_lookup(mdp->d_path, name, namelen, extlist);
1055                 if (result)
1056                         break;
1057         }
1058         return(result);
1059 }
1060
1061 #define INT_ALIGN(base, ptr)    ptr = \
1062         (base) + roundup2((ptr) - (base), sizeof(int))
1063
1064 static char *
1065 mod_search_hints(struct moduledir *mdp, const char *modname,
1066         struct mod_depend *verinfo)
1067 {
1068         u_char  *cp, *recptr, *bufend, *best;
1069         char    *result;
1070         int             *intp, bestver, blen, clen, found, ival, modnamelen, reclen;
1071
1072         moduledir_readhints(mdp);
1073         modnamelen = strlen(modname);
1074         found = 0;
1075         result = NULL;
1076         bestver = 0;
1077         if (mdp->d_hints == NULL)
1078                 goto bad;
1079         recptr = mdp->d_hints;
1080         bufend = recptr + mdp->d_hintsz;
1081         clen = blen = 0;
1082         best = cp = NULL;
1083         while (recptr < bufend && !found) {
1084                 intp = (int*)recptr;
1085                 reclen = *intp++;
1086                 ival = *intp++;
1087                 cp = (u_char*)intp;
1088                 switch (ival) {
1089                 case MDT_VERSION:
1090                         clen = *cp++;
1091                         if (clen != modnamelen || bcmp(cp, modname, clen) != 0)
1092                                 break;
1093                         cp += clen;
1094                         INT_ALIGN(mdp->d_hints, cp);
1095                         ival = *(int*)cp;
1096                         cp += sizeof(int);
1097                         clen = *cp++;
1098                         if (verinfo == NULL || ival == verinfo->md_ver_preferred) {
1099                                 found = 1;
1100                                 break;
1101                         }
1102                         if (ival >= verinfo->md_ver_minimum &&
1103                           ival <= verinfo->md_ver_maximum &&
1104                           ival > bestver) {
1105                                 bestver = ival;
1106                                 best = cp;
1107                                 blen = clen;
1108                         }
1109                         break;
1110                 default:
1111                         break;
1112                 }
1113                 recptr += reclen + sizeof(int);
1114         }
1115         /*
1116          * Finally check if KLD is in the place
1117          */
1118         if (found)
1119                 result = file_lookup(mdp->d_path, (const char *)cp, clen, NULL);
1120         else if (best)
1121                 result = file_lookup(mdp->d_path, (const char *)best, blen, NULL);
1122 bad:
1123         /*
1124          * If nothing found or hints is absent - fallback to the old way
1125          * by using "kldname[.ko]" as module name.
1126          */
1127         if (!found && !bestver && result == NULL)
1128                 result = file_lookup(mdp->d_path, modname, modnamelen, kld_ext_list);
1129         return result;
1130 }
1131
1132 static int
1133 getint(void **ptr)
1134 {
1135         int *p = *ptr;
1136         int rv;
1137
1138         p = (int *)roundup2((intptr_t)p, sizeof(int));
1139         rv = *p++;
1140         *ptr = p;
1141         return rv;
1142 }
1143
1144 static void
1145 getstr(void **ptr, char *val)
1146 {
1147         int *p = *ptr;
1148         char *c = (char *)p;
1149         int len = *(uint8_t *)c;
1150
1151         memcpy(val, c + 1, len);
1152         val[len] = 0;
1153         c += len + 1;
1154         *ptr = (void *)c;
1155 }
1156
1157 static int
1158 pnpval_as_int(const char *val, const char *pnpinfo)
1159 {
1160         int rv;
1161         char key[256];
1162         char *cp;
1163
1164         if (pnpinfo == NULL)
1165                 return -1;
1166
1167         cp = strchr(val, ';');
1168         key[0] = ' ';
1169         if (cp == NULL)
1170                 strlcpy(key + 1, val, sizeof(key) - 1);
1171         else {
1172                 memcpy(key + 1, val, cp - val);
1173                 key[cp - val + 1] = '\0';
1174         }
1175         strlcat(key, "=", sizeof(key));
1176         if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0)
1177                 rv = strtol(pnpinfo + strlen(key + 1), NULL, 0);
1178         else {
1179                 cp = strstr(pnpinfo, key);
1180                 if (cp == NULL)
1181                         rv = -1;
1182                 else
1183                         rv = strtol(cp + strlen(key), NULL, 0);
1184         }
1185         return rv;
1186 }
1187
1188 static void
1189 quoted_strcpy(char *dst, const char *src)
1190 {
1191         char q = ' ';
1192
1193         if (*src == '\'' || *src == '"')
1194                 q = *src++;
1195         while (*src && *src != q)
1196                 *dst++ = *src++; // XXX backtick quoting
1197         *dst++ = '\0';
1198         // XXX overflow
1199 }
1200
1201 static char *
1202 pnpval_as_str(const char *val, const char *pnpinfo)
1203 {
1204         static char retval[256];
1205         char key[256];
1206         char *cp;
1207
1208         if (pnpinfo == NULL) {
1209                 *retval = '\0';
1210                 return retval;
1211         }
1212
1213         cp = strchr(val, ';');
1214         key[0] = ' ';
1215         if (cp == NULL)
1216                 strlcpy(key + 1, val, sizeof(key) - 1);
1217         else {
1218                 memcpy(key + 1, val, cp - val);
1219                 key[cp - val + 1] = '\0';
1220         }
1221         strlcat(key, "=", sizeof(key));
1222         if (strncmp(key + 1, pnpinfo, strlen(key + 1)) == 0)
1223                 quoted_strcpy(retval, pnpinfo + strlen(key + 1));
1224         else {
1225                 cp = strstr(pnpinfo, key);
1226                 if (cp == NULL)
1227                         strcpy(retval, "MISSING");
1228                 else
1229                         quoted_strcpy(retval, cp + strlen(key));
1230         }
1231         return retval;
1232 }
1233
1234 static char *
1235 devmatch_search_hints(struct moduledir *mdp, const char *bus, const char *dev, const char *pnpinfo)
1236 {
1237         char val1[256], val2[256];
1238         int ival, len, ents, i, notme, mask, bit, v, found;
1239         void *ptr, *walker, *hints_end;
1240         char *lastmod = NULL, *cp, *s;
1241
1242         moduledir_readhints(mdp);
1243         found = 0;
1244         if (mdp->d_hints == NULL)
1245                 goto bad;
1246         walker = mdp->d_hints;
1247         hints_end = walker + mdp->d_hintsz;
1248         while (walker < hints_end && !found) {
1249                 len = getint(&walker);
1250                 ival = getint(&walker);
1251                 ptr = walker;
1252                 switch (ival) {
1253                 case MDT_VERSION:
1254                         getstr(&ptr, val1);
1255                         ival = getint(&ptr);
1256                         getstr(&ptr, val2);
1257                         if (pnp_dump_flag || pnp_verbose_flag)
1258                                 printf("Version: if %s.%d kmod %s\n", val1, ival, val2);
1259                         break;
1260                 case MDT_MODULE:
1261                         getstr(&ptr, val1);
1262                         getstr(&ptr, val2);
1263                         if (lastmod)
1264                                 free(lastmod);
1265                         lastmod = strdup(val2);
1266                         if (pnp_dump_flag || pnp_verbose_flag)
1267                                 printf("module %s in %s\n", val1, val1);
1268                         break;
1269                 case MDT_PNP_INFO:
1270                         if (!pnp_dump_flag && !pnp_unbound_flag && lastmod && strcmp(lastmod, "kernel") == 0)
1271                                 break;
1272                         getstr(&ptr, val1);
1273                         getstr(&ptr, val2);
1274                         ents = getint(&ptr);
1275                         if (pnp_dump_flag || pnp_verbose_flag)
1276                                 printf("PNP info for bus %s format %s %d entries (%s)\n",
1277                                     val1, val2, ents, lastmod);
1278                         if (strcmp(val1, "usb") == 0) {
1279                                 if (pnp_verbose_flag)
1280                                         printf("Treating usb as uhub -- bug in source table still?\n");
1281                                 strcpy(val1, "uhub");
1282                         }
1283                         if (bus && strcmp(val1, bus) != 0) {
1284                                 if (pnp_verbose_flag)
1285                                         printf("Skipped because table for bus %s, looking for %s\n",
1286                                             val1, bus);
1287                                 break;
1288                         }
1289                         for (i = 0; i < ents; i++) {
1290                                 if (pnp_verbose_flag)
1291                                         printf("---------- Entry %d ----------\n", i);
1292                                 if (pnp_dump_flag)
1293                                         printf("   ");
1294                                 cp = val2;
1295                                 notme = 0;
1296                                 mask = -1;
1297                                 bit = -1;
1298                                 do {
1299                                         switch (*cp) {
1300                                                 /* All integer fields */
1301                                         case 'I':
1302                                         case 'J':
1303                                         case 'G':
1304                                         case 'L':
1305                                         case 'M':
1306                                                 ival = getint(&ptr);
1307                                                 if (pnp_dump_flag) {
1308                                                         printf("%#x:", ival);
1309                                                         break;
1310                                                 }
1311                                                 if (bit >= 0 && ((1 << bit) & mask) == 0)
1312                                                         break;
1313                                                 v = pnpval_as_int(cp + 2, pnpinfo);
1314                                                 if (pnp_verbose_flag)
1315                                                         printf("Matching %s (%c) table=%#x tomatch=%#x\n",
1316                                                             cp + 2, *cp, v, ival);
1317                                                 switch (*cp) {
1318                                                 case 'J':
1319                                                         if (ival == -1)
1320                                                                 break;
1321                                                         /*FALLTHROUGH*/
1322                                                 case 'I':
1323                                                         if (v != ival)
1324                                                                 notme++;
1325                                                         break;
1326                                                 case 'G':
1327                                                         if (v < ival)
1328                                                                 notme++;
1329                                                         break;
1330                                                 case 'L':
1331                                                         if (v > ival)
1332                                                                 notme++;
1333                                                         break;
1334                                                 case 'M':
1335                                                         mask = ival;
1336                                                         break;
1337                                                 }
1338                                                 break;
1339                                                 /* String fields */
1340                                         case 'D':
1341                                         case 'Z':
1342                                                 getstr(&ptr, val1);
1343                                                 if (pnp_dump_flag) {
1344                                                         printf("'%s':", val1);
1345                                                         break;
1346                                                 }
1347                                                 if (*cp == 'D')
1348                                                         break;
1349                                                 s = pnpval_as_str(cp + 2, pnpinfo);
1350                                                 if (strcmp(s, val1) != 0)
1351                                                         notme++;
1352                                                 break;
1353                                                 /* Key override fields, required to be last in the string */
1354                                         case 'T':
1355                                                 /*
1356                                                  * This is imperfect and only does one key and will be redone
1357                                                  * to be more general for multiple keys. Currently, nothing
1358                                                  * does that.
1359                                                  */
1360                                                 if (pnp_dump_flag)                              /* No per-row data stored */
1361                                                         break;
1362                                                 if (cp[strlen(cp) - 1] == ';')          /* Skip required ; at end */
1363                                                         cp[strlen(cp) - 1] = '\0';      /* in case it's not there */
1364                                                 if ((s = strstr(pnpinfo, cp + 2)) == NULL)
1365                                                         notme++;
1366                                                 else if (s > pnpinfo && s[-1] != ' ')
1367                                                         notme++;
1368                                                 break;
1369                                         default:
1370                                                 printf("Unknown field type %c\n:", *cp);
1371                                                 break;
1372                                         }
1373                                         bit++;
1374                                         cp = strchr(cp, ';');
1375                                         if (cp)
1376                                                 cp++;
1377                                 } while (cp && *cp);
1378                                 if (pnp_dump_flag)
1379                                         printf("\n");
1380                                 else if (!notme) {
1381                                         if (!pnp_unbound_flag) {
1382                                                 if (pnp_verbose_flag)
1383                                                         printf("Matches --- %s ---\n", lastmod);
1384                                         }
1385                                         found++;
1386                                 }
1387                         }
1388                         break;
1389                 default:
1390                         break;
1391                 }
1392                 walker = (void *)(len - sizeof(int) + (intptr_t)walker);
1393         }
1394         if (pnp_unbound_flag && found == 0 && *pnpinfo) {
1395                 if (pnp_verbose_flag)
1396                         printf("------------------------- ");
1397                 printf("%s on %s pnpinfo %s", *dev ? dev : "unattached", bus, pnpinfo);
1398                 if (pnp_verbose_flag)
1399                         printf(" -------------------------");
1400                 printf("\n");
1401         }
1402         if (found != 0)
1403                 return (lastmod);
1404         free(lastmod);
1405
1406 bad:
1407         return (NULL);
1408 }
1409
1410 /*
1411  * Attempt to locate the file containing the module (name)
1412  */
1413 static char *
1414 mod_searchmodule(char *name, struct mod_depend *verinfo)
1415 {
1416         struct  moduledir *mdp;
1417         char    *result;
1418
1419         moduledir_rebuild();
1420         /*
1421          * Now we ready to lookup module in the given directories
1422          */
1423         result = NULL;
1424         STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
1425                 result = mod_search_hints(mdp, name, verinfo);
1426                 if (result)
1427                         break;
1428         }
1429
1430         return(result);
1431 }
1432
1433 static char *
1434 mod_searchmodule_pnpinfo(const char *bus, const char *pnpinfo)
1435 {
1436         struct  moduledir *mdp;
1437         char    *result;
1438
1439         moduledir_rebuild();
1440         /*
1441          * Now we ready to lookup module in the given directories
1442          */
1443         result = NULL;
1444         STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
1445                 result = devmatch_search_hints(mdp, bus, NULL, pnpinfo);
1446                 if (result)
1447                         break;
1448         }
1449
1450         return(result);
1451 }
1452
1453 int
1454 file_addmodule(struct preloaded_file *fp, char *modname, int version,
1455         struct kernel_module **newmp)
1456 {
1457         struct kernel_module *mp;
1458         struct mod_depend mdepend;
1459
1460         bzero(&mdepend, sizeof(mdepend));
1461         mdepend.md_ver_preferred = version;
1462         mp = file_findmodule(fp, modname, &mdepend);
1463         if (mp)
1464                 return (EEXIST);
1465         mp = calloc(1, sizeof(struct kernel_module));
1466         if (mp == NULL)
1467                 return (ENOMEM);
1468         mp->m_name = strdup(modname);
1469         if (mp->m_name == NULL) {
1470                 free(mp);
1471                 return (ENOMEM);
1472         }
1473         mp->m_version = version;
1474         mp->m_fp = fp;
1475         mp->m_next = fp->f_modules;
1476         fp->f_modules = mp;
1477         if (newmp)
1478                 *newmp = mp;
1479         return (0);
1480 }
1481
1482 /*
1483  * Throw a file away
1484  */
1485 void
1486 file_discard(struct preloaded_file *fp)
1487 {
1488         struct file_metadata    *md, *md1;
1489         struct kernel_module    *mp, *mp1;
1490         if (fp == NULL)
1491                 return;
1492         md = fp->f_metadata;
1493         while (md) {
1494                 md1 = md;
1495                 md = md->md_next;
1496                 free(md1);
1497         }
1498         mp = fp->f_modules;
1499         while (mp) {
1500                 free(mp->m_name);
1501                 mp1 = mp;
1502                 mp = mp->m_next;
1503                 free(mp1);
1504         }
1505         free(fp->f_name);
1506         free(fp->f_type);
1507         free(fp->f_args);
1508         free(fp);
1509 }
1510
1511 /*
1512  * Allocate a new file; must be used instead of malloc()
1513  * to ensure safe initialisation.
1514  */
1515 struct preloaded_file *
1516 file_alloc(void)
1517 {
1518
1519         return (calloc(1, sizeof(struct preloaded_file)));
1520 }
1521
1522 /*
1523  * Add a module to the chain
1524  */
1525 static void
1526 file_insert_tail(struct preloaded_file *fp)
1527 {
1528         struct preloaded_file   *cm;
1529
1530         /* Append to list of loaded file */
1531         fp->f_next = NULL;
1532         if (preloaded_files == NULL) {
1533                 preloaded_files = fp;
1534         } else {
1535                 for (cm = preloaded_files; cm->f_next != NULL; cm = cm->f_next)
1536                         ;
1537                 cm->f_next = fp;
1538         }
1539 }
1540
1541 /*
1542  * Remove module from the chain
1543  */
1544 static void
1545 file_remove(struct preloaded_file *fp)
1546 {
1547         struct preloaded_file   *cm;
1548
1549         if (preloaded_files == NULL)
1550                 return;
1551
1552         if (preloaded_files == fp) {
1553                 preloaded_files = fp->f_next;
1554                 return;
1555         }
1556         for (cm = preloaded_files; cm->f_next != NULL; cm = cm->f_next) {
1557                 if (cm->f_next == fp) {
1558                         cm->f_next = fp->f_next;
1559                         return;
1560                 }
1561         }
1562 }
1563
1564 static char *
1565 moduledir_fullpath(struct moduledir *mdp, const char *fname)
1566 {
1567         char *cp;
1568
1569         cp = malloc(strlen(mdp->d_path) + strlen(fname) + 2);
1570         if (cp == NULL)
1571                 return NULL;
1572         strcpy(cp, mdp->d_path);
1573         strcat(cp, "/");
1574         strcat(cp, fname);
1575         return (cp);
1576 }
1577
1578 /*
1579  * Read linker.hints file into memory performing some sanity checks.
1580  */
1581 static void
1582 moduledir_readhints(struct moduledir *mdp)
1583 {
1584         struct stat     st;
1585         char    *path;
1586         int             fd, size, version;
1587
1588         if (mdp->d_hints != NULL || (mdp->d_flags & MDIR_NOHINTS))
1589                 return;
1590         path = moduledir_fullpath(mdp, "linker.hints");
1591         if (stat(path, &st) != 0 ||
1592           st.st_size < (ssize_t)(sizeof(version) + sizeof(int)) ||
1593           st.st_size > LINKER_HINTS_MAX || (fd = open(path, O_RDONLY)) < 0) {
1594                 free(path);
1595                 mdp->d_flags |= MDIR_NOHINTS;
1596                 return;
1597         }
1598         free(path);
1599         size = read(fd, &version, sizeof(version));
1600         if (size != sizeof(version) || version != LINKER_HINTS_VERSION)
1601                 goto bad;
1602         size = st.st_size - size;
1603         mdp->d_hints = malloc(size);
1604         if (mdp->d_hints == NULL)
1605                 goto bad;
1606         if (read(fd, mdp->d_hints, size) != size)
1607                 goto bad;
1608         mdp->d_hintsz = size;
1609         close(fd);
1610         return;
1611 bad:
1612         close(fd);
1613         free(mdp->d_hints);
1614         mdp->d_hints = NULL;
1615         mdp->d_flags |= MDIR_NOHINTS;
1616         return;
1617 }
1618
1619 /*
1620  * Extract directories from the ';' separated list, remove duplicates.
1621  */
1622 static void
1623 moduledir_rebuild(void)
1624 {
1625         struct  moduledir *mdp, *mtmp;
1626         const char      *path, *cp, *ep;
1627         size_t  cplen;
1628
1629         path = getenv("module_path");
1630         if (path == NULL)
1631                 path = default_searchpath;
1632         /*
1633          * Rebuild list of module directories if it changed
1634          */
1635         STAILQ_FOREACH(mdp, &moduledir_list, d_link)
1636                 mdp->d_flags |= MDIR_REMOVED;
1637
1638         for (ep = path; *ep != 0;  ep++) {
1639                 cp = ep;
1640                 for (; *ep != 0 && *ep != ';'; ep++)
1641                         ;
1642                 /*
1643                  * Ignore trailing slashes
1644                  */
1645                 for (cplen = ep - cp; cplen > 1 && cp[cplen - 1] == '/'; cplen--)
1646                         ;
1647                 STAILQ_FOREACH(mdp, &moduledir_list, d_link) {
1648                         if (strlen(mdp->d_path) != cplen ||     bcmp(cp, mdp->d_path, cplen) != 0)
1649                                 continue;
1650                         mdp->d_flags &= ~MDIR_REMOVED;
1651                         break;
1652                 }
1653                 if (mdp == NULL) {
1654                         mdp = malloc(sizeof(*mdp) + cplen + 1);
1655                         if (mdp == NULL)
1656                                 return;
1657                         mdp->d_path = (char*)(mdp + 1);
1658                         bcopy(cp, mdp->d_path, cplen);
1659                         mdp->d_path[cplen] = 0;
1660                         mdp->d_hints = NULL;
1661                         mdp->d_flags = 0;
1662                         STAILQ_INSERT_TAIL(&moduledir_list, mdp, d_link);
1663                 }
1664                 if (*ep == 0)
1665                         break;
1666         }
1667         /*
1668          * Delete unused directories if any
1669          */
1670         mdp = STAILQ_FIRST(&moduledir_list);
1671         while (mdp) {
1672                 if ((mdp->d_flags & MDIR_REMOVED) == 0) {
1673                         mdp = STAILQ_NEXT(mdp, d_link);
1674                 } else {
1675                         free(mdp->d_hints);
1676                         mtmp = mdp;
1677                         mdp = STAILQ_NEXT(mdp, d_link);
1678                         STAILQ_REMOVE(&moduledir_list, mtmp, moduledir, d_link);
1679                         free(mtmp);
1680                 }
1681         }
1682         return;
1683 }