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