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 #include "bootstrap.h" 43 44 #define MDIR_REMOVED 0x0001 45 #define MDIR_NOHINTS 0x0002 46 47 struct moduledir { 48 char *d_path; /* path of modules directory */ 49 u_char *d_hints; /* content of linker.hints file */ 50 int d_hintsz; /* size of hints data */ 51 int d_flags; 52 STAILQ_ENTRY(moduledir) d_link; 53 }; 54 55 static int file_load(char *, vm_offset_t, struct preloaded_file **); 56 static int file_load_dependencies(struct preloaded_file *); 57 static char * file_search(const char *, char **); 58 static struct kernel_module *file_findmodule(struct preloaded_file *, char *, 59 struct mod_depend *); 60 static int file_havepath(const char *); 61 static char *mod_searchmodule(char *, struct mod_depend *); 62 static void file_insert_tail(struct preloaded_file *); 63 static void file_remove(struct preloaded_file *); 64 struct file_metadata *metadata_next(struct file_metadata *, int); 65 static void moduledir_readhints(struct moduledir *); 66 static void moduledir_rebuild(void); 67 68 /* load address should be tweaked by first module loaded (kernel) */ 69 static vm_offset_t loadaddr = 0; 70 71 #if defined(LOADER_FDT_SUPPORT) 72 static const char *default_searchpath = 73 "/boot/kernel;/boot/modules;/boot/dtb"; 74 #else 75 static const char *default_searchpath = "/boot/kernel;/boot/modules"; 76 #endif 77 78 static STAILQ_HEAD(, moduledir) moduledir_list = 79 STAILQ_HEAD_INITIALIZER(moduledir_list); 80 81 struct preloaded_file *preloaded_files = NULL; 82 83 static char *kld_ext_list[] = { 84 ".ko", 85 "", 86 ".debug", 87 NULL 88 }; 89 90 91 /* 92 * load an object, either a disk file or code module. 93 * 94 * To load a file, the syntax is: 95 * 96 * load -t <type> <path> 97 * 98 * code modules are loaded as: 99 * 100 * load <path> <options> 101 */ 102 103 COMMAND_SET(load, "load", "load a kernel or module", command_load); 104 105 static int 106 command_load(int argc, char *argv[]) 107 { 108 struct preloaded_file *fp; 109 char *typestr; 110 char *prefix; 111 char *skip; 112 int dflag, dofile, dokld, ch, error; 113 114 dflag = dokld = dofile = 0; 115 optind = 1; 116 optreset = 1; 117 typestr = NULL; 118 if (argc == 1) { 119 command_errmsg = "no filename specified"; 120 return (CMD_CRIT); 121 } 122 prefix = skip = NULL; 123 while ((ch = getopt(argc, argv, "dkp:s:t:")) != -1) { 124 switch(ch) { 125 case 'd': 126 dflag++; 127 break; 128 case 'k': 129 dokld = 1; 130 break; 131 case 'p': 132 prefix = optarg; 133 break; 134 case 's': 135 skip = optarg; 136 break; 137 case 't': 138 typestr = optarg; 139 dofile = 1; 140 break; 141 case '?': 142 default: 143 /* getopt has already reported an error */ 144 return (CMD_OK); 145 } 146 } 147 argv += (optind - 1); 148 argc -= (optind - 1); 149 150 /* 151 * Request to load a raw file? 152 */ 153 if (dofile) { 154 if ((argc != 2) || (typestr == NULL) || (*typestr == 0)) { 155 command_errmsg = "invalid load type"; 156 return (CMD_CRIT); 157 } 158 159 #ifdef LOADER_VERIEXEC 160 if (strncmp(typestr, "manifest", 8) == 0) { 161 if (dflag > 0) 162 ve_debug_set(dflag); 163 return (load_manifest(argv[1], prefix, skip, NULL)); 164 } 165 #ifdef LOADER_VERIEXEC_PASS_MANIFEST 166 if (strncmp(typestr, "pass_manifest", 13) == 0) { 167 if (dflag > 0) 168 ve_debug_set(dflag); 169 return (pass_manifest(argv[1], prefix)); 170 } 171 #endif 172 #endif 173 174 fp = file_findfile(argv[1], typestr); 175 if (fp) { 176 snprintf(command_errbuf, sizeof(command_errbuf), 177 "warning: file '%s' already loaded", argv[1]); 178 return (CMD_WARN); 179 } 180 181 if (file_loadraw(argv[1], typestr, 1) != NULL) 182 return (CMD_OK); 183 184 /* Failing to load mfs_root is never going to end well! */ 185 if (strcmp("mfs_root", typestr) == 0) 186 return (CMD_FATAL); 187 188 return (CMD_ERROR); 189 } 190 /* 191 * Do we have explicit KLD load ? 192 */ 193 if (dokld || file_havepath(argv[1])) { 194 error = mod_loadkld(argv[1], argc - 2, argv + 2); 195 if (error == EEXIST) { 196 snprintf(command_errbuf, sizeof(command_errbuf), 197 "warning: KLD '%s' already loaded", argv[1]); 198 return (CMD_WARN); 199 } 200 201 return (error == 0 ? CMD_OK : CMD_CRIT); 202 } 203 /* 204 * Looks like a request for a module. 205 */ 206 error = mod_load(argv[1], NULL, argc - 2, argv + 2); 207 if (error == EEXIST) { 208 snprintf(command_errbuf, sizeof(command_errbuf), 209 "warning: module '%s' already loaded", argv[1]); 210 return (CMD_WARN); 211 } 212 213 return (error == 0 ? CMD_OK : CMD_CRIT); 214 } 215 216 #ifdef LOADER_GELI_SUPPORT 217 COMMAND_SET(load_geli, "load_geli", "load a geli key", command_load_geli); 218 219 static int 220 command_load_geli(int argc, char *argv[]) 221 { 222 char typestr[80]; 223 char *cp; 224 int ch, num; 225 226 if (argc < 3) { 227 command_errmsg = "usage is [-n key#] <prov> <file>"; 228 return(CMD_ERROR); 229 } 230 231 num = 0; 232 optind = 1; 233 optreset = 1; 234 while ((ch = getopt(argc, argv, "n:")) != -1) { 235 switch(ch) { 236 case 'n': 237 num = strtol(optarg, &cp, 0); 238 if (cp == optarg) { 239 snprintf(command_errbuf, sizeof(command_errbuf), 240 "bad key index '%s'", optarg); 241 return(CMD_ERROR); 242 } 243 break; 244 case '?': 245 default: 246 /* getopt has already reported an error */ 247 return(CMD_OK); 248 } 249 } 250 argv += (optind - 1); 251 argc -= (optind - 1); 252 sprintf(typestr, "%s:geli_keyfile%d", argv[1], num); 253 return (file_loadraw(argv[2], typestr, 1) ? CMD_OK : CMD_ERROR); 254 } 255 #endif 256 257 void 258 unload(void) 259 { 260 struct preloaded_file *fp; 261 262 while (preloaded_files != NULL) { 263 fp = preloaded_files; 264 preloaded_files = preloaded_files->f_next; 265 file_discard(fp); 266 } 267 loadaddr = 0; 268 unsetenv("kernelname"); 269 } 270 271 COMMAND_SET(unload, "unload", "unload all modules", command_unload); 272 273 static int 274 command_unload(int argc, char *argv[]) 275 { 276 unload(); 277 return(CMD_OK); 278 } 279 280 COMMAND_SET(lsmod, "lsmod", "list loaded modules", command_lsmod); 281 282 static int 283 command_lsmod(int argc, char *argv[]) 284 { 285 struct preloaded_file *fp; 286 struct kernel_module *mp; 287 struct file_metadata *md; 288 char lbuf[80]; 289 int ch, verbose, ret = 0; 290 291 verbose = 0; 292 optind = 1; 293 optreset = 1; 294 while ((ch = getopt(argc, argv, "v")) != -1) { 295 switch(ch) { 296 case 'v': 297 verbose = 1; 298 break; 299 case '?': 300 default: 301 /* getopt has already reported an error */ 302 return(CMD_OK); 303 } 304 } 305 306 pager_open(); 307 for (fp = preloaded_files; fp; fp = fp->f_next) { 308 snprintf(lbuf, sizeof(lbuf), " %p: ", (void *) fp->f_addr); 309 pager_output(lbuf); 310 pager_output(fp->f_name); 311 snprintf(lbuf, sizeof(lbuf), " (%s, 0x%lx)\n", fp->f_type, 312 (long)fp->f_size); 313 if (pager_output(lbuf)) 314 break; 315 if (fp->f_args != NULL) { 316 pager_output(" args: "); 317 pager_output(fp->f_args); 318 if (pager_output("\n")) 319 break; 320 } 321 if (fp->f_modules) { 322 pager_output(" modules: "); 323 for (mp = fp->f_modules; mp; mp = mp->m_next) { 324 snprintf(lbuf, sizeof(lbuf), "%s.%d ", mp->m_name, 325 mp->m_version); 326 pager_output(lbuf); 327 } 328 if (pager_output("\n")) 329 break; 330 } 331 if (verbose) { 332 /* XXX could add some formatting smarts here to display some better */ 333 for (md = fp->f_metadata; md != NULL; md = md->md_next) { 334 snprintf(lbuf, sizeof(lbuf), " 0x%04x, 0x%lx\n", 335 md->md_type, (long) md->md_size); 336 if (pager_output(lbuf)) 337 break; 338 } 339 } 340 if (ret) 341 break; 342 } 343 pager_close(); 344 return(CMD_OK); 345 } 346 347 /* 348 * File level interface, functions file_* 349 */ 350 int 351 file_load(char *filename, vm_offset_t dest, struct preloaded_file **result) 352 { 353 static int last_file_format = 0; 354 struct preloaded_file *fp; 355 int error; 356 int i; 357 358 if (archsw.arch_loadaddr != NULL) 359 dest = archsw.arch_loadaddr(LOAD_RAW, filename, dest); 360 361 error = EFTYPE; 362 for (i = last_file_format, fp = NULL; 363 file_formats[i] && fp == NULL; i++) { 364 error = (file_formats[i]->l_load)(filename, dest, &fp); 365 if (error == 0) { 366 fp->f_loader = last_file_format = i; /* remember the loader */ 367 *result = fp; 368 break; 369 } else if (last_file_format == i && i != 0) { 370 /* Restart from the beginning */ 371 i = -1; 372 last_file_format = 0; 373 fp = NULL; 374 continue; 375 } 376 if (error == EFTYPE) 377 continue; /* Unknown to this handler? */ 378 if (error) { 379 snprintf(command_errbuf, sizeof(command_errbuf), 380 "can't load file '%s': %s", filename, strerror(error)); 381 break; 382 } 383 } 384 return (error); 385 } 386 387 static int 388 file_load_dependencies(struct preloaded_file *base_file) 389 { 390 struct file_metadata *md; 391 struct preloaded_file *fp; 392 struct mod_depend *verinfo; 393 struct kernel_module *mp; 394 char *dmodname; 395 int error; 396 397 md = file_findmetadata(base_file, MODINFOMD_DEPLIST); 398 if (md == NULL) 399 return (0); 400 error = 0; 401 do { 402 verinfo = (struct mod_depend*)md->md_data; 403 dmodname = (char *)(verinfo + 1); 404 if (file_findmodule(NULL, dmodname, verinfo) == NULL) { 405 printf("loading required module '%s'\n", dmodname); 406 error = mod_load(dmodname, verinfo, 0, NULL); 407 if (error) 408 break; 409 /* 410 * If module loaded via kld name which isn't listed 411 * in the linker.hints file, we should check if it have 412 * required version. 413 */ 414 mp = file_findmodule(NULL, dmodname, verinfo); 415 if (mp == NULL) { 416 snprintf(command_errbuf, sizeof(command_errbuf), 417 "module '%s' exists but with wrong version", dmodname); 418 error = ENOENT; 419 break; 420 } 421 } 422 md = metadata_next(md, MODINFOMD_DEPLIST); 423 } while (md); 424 if (!error) 425 return (0); 426 /* Load failed; discard everything */ 427 while (base_file != NULL) { 428 fp = base_file; 429 base_file = base_file->f_next; 430 file_discard(fp); 431 } 432 return (error); 433 } 434 435 /* 436 * We've been asked to load (fname) as (type), so just suck it in, 437 * no arguments or anything. 438 */ 439 struct preloaded_file * 440 file_loadraw(const char *fname, char *type, int insert) 441 { 442 struct preloaded_file *fp; 443 char *name; 444 int fd, got; 445 vm_offset_t laddr; 446 447 /* We can't load first */ 448 if ((file_findfile(NULL, NULL)) == NULL) { 449 command_errmsg = "can't load file before kernel"; 450 return(NULL); 451 } 452 453 /* locate the file on the load path */ 454 name = file_search(fname, NULL); 455 if (name == NULL) { 456 snprintf(command_errbuf, sizeof(command_errbuf), 457 "can't find '%s'", fname); 458 return(NULL); 459 } 460 461 if ((fd = open(name, O_RDONLY)) < 0) { 462 snprintf(command_errbuf, sizeof(command_errbuf), 463 "can't open '%s': %s", name, strerror(errno)); 464 free(name); 465 return(NULL); 466 } 467 468 #ifdef LOADER_VERIEXEC 469 if (verify_file(fd, name, 0, VE_MUST) < 0) { 470 sprintf(command_errbuf, "can't verify '%s'", name); 471 free(name); 472 close(fd); 473 return(NULL); 474 } 475 #endif 476 477 if (archsw.arch_loadaddr != NULL) 478 loadaddr = archsw.arch_loadaddr(LOAD_RAW, name, loadaddr); 479 480 printf("%s ", name); 481 482 laddr = loadaddr; 483 for (;;) { 484 /* read in 4k chunks; size is not really important */ 485 got = archsw.arch_readin(fd, laddr, 4096); 486 if (got == 0) /* end of file */ 487 break; 488 if (got < 0) { /* error */ 489 snprintf(command_errbuf, sizeof(command_errbuf), 490 "error reading '%s': %s", name, strerror(errno)); 491 free(name); 492 close(fd); 493 return(NULL); 494 } 495 laddr += got; 496 } 497 498 printf("size=%#jx\n", (uintmax_t)(laddr - loadaddr)); 499 500 /* Looks OK so far; create & populate control structure */ 501 fp = file_alloc(); 502 fp->f_name = strdup(name); 503 fp->f_type = strdup(type); 504 fp->f_args = NULL; 505 fp->f_metadata = NULL; 506 fp->f_loader = -1; 507 fp->f_addr = loadaddr; 508 fp->f_size = laddr - loadaddr; 509 510 /* recognise space consumption */ 511 loadaddr = laddr; 512 513 /* Add to the list of loaded files */ 514 if (insert != 0) 515 file_insert_tail(fp); 516 close(fd); 517 return(fp); 518 } 519 520 /* 521 * Load the module (name), pass it (argc),(argv), add container file 522 * to the list of loaded files. 523 * If module is already loaded just assign new argc/argv. 524 */ 525 int 526 mod_load(char *modname, struct mod_depend *verinfo, int argc, char *argv[]) 527 { 528 struct kernel_module *mp; 529 int err; 530 char *filename; 531 532 if (file_havepath(modname)) { 533 printf("Warning: mod_load() called instead of mod_loadkld() for module '%s'\n", modname); 534 return (mod_loadkld(modname, argc, argv)); 535 } 536 /* see if module is already loaded */ 537 mp = file_findmodule(NULL, modname, verinfo); 538 if (mp) { 539 #ifdef moduleargs 540 free(mp->m_args); 541 mp->m_args = unargv(argc, argv); 542 #endif 543 snprintf(command_errbuf, sizeof(command_errbuf), 544 "warning: module '%s' already loaded", mp->m_name); 545 return (0); 546 } 547 /* locate file with the module on the search path */ 548 filename = mod_searchmodule(modname, verinfo); 549 if (filename == NULL) { 550 snprintf(command_errbuf, sizeof(command_errbuf), 551 "can't find '%s'", modname); 552 return (ENOENT); 553 } 554 err = mod_loadkld(filename, argc, argv); 555 return (err); 556 } 557 558 /* 559 * Load specified KLD. If path is omitted, then try to locate it via 560 * search path. 561 */ 562 int 563 mod_loadkld(const char *kldname, int argc, char *argv[]) 564 { 565 struct preloaded_file *fp; 566 int err; 567 char *filename; 568 vm_offset_t loadaddr_saved; 569 570 /* 571 * Get fully qualified KLD name 572 */ 573 filename = file_search(kldname, kld_ext_list); 574 if (filename == NULL) { 575 snprintf(command_errbuf, sizeof(command_errbuf), 576 "can't find '%s'", kldname); 577 return (ENOENT); 578 } 579 /* 580 * Check if KLD already loaded 581 */ 582 fp = file_findfile(filename, NULL); 583 if (fp) { 584 snprintf(command_errbuf, sizeof(command_errbuf), 585 "warning: KLD '%s' already loaded", filename); 586 free(filename); 587 return (0); 588 } 589 590 do { 591 err = file_load(filename, loadaddr, &fp); 592 if (err) 593 break; 594 fp->f_args = unargv(argc, argv); 595 loadaddr_saved = loadaddr; 596 loadaddr = fp->f_addr + fp->f_size; 597 file_insert_tail(fp); /* Add to the list of loaded files */ 598 if (file_load_dependencies(fp) != 0) { 599 err = ENOENT; 600 file_remove(fp); 601 loadaddr = loadaddr_saved; 602 fp = NULL; 603 break; 604 } 605 } while(0); 606 if (err == EFTYPE) { 607 snprintf(command_errbuf, sizeof(command_errbuf), 608 "don't know how to load module '%s'", filename); 609 } 610 if (err && fp) 611 file_discard(fp); 612 free(filename); 613 return (err); 614 } 615 616 /* 617 * Find a file matching (name) and (type). 618 * NULL may be passed as a wildcard to either. 619 */ 620 struct preloaded_file * 621 file_findfile(const char *name, const char *type) 622 { 623 struct preloaded_file *fp; 624 625 for (fp = preloaded_files; fp != NULL; fp = fp->f_next) { 626 if (((name == NULL) || !strcmp(name, fp->f_name)) && 627 ((type == NULL) || !strcmp(type, fp->f_type))) 628 break; 629 } 630 return (fp); 631 } 632 633 /* 634 * Find a module matching (name) inside of given file. 635 * NULL may be passed as a wildcard. 636 */ 637 struct kernel_module * 638 file_findmodule(struct preloaded_file *fp, char *modname, 639 struct mod_depend *verinfo) 640 { 641 struct kernel_module *mp, *best; 642 int bestver, mver; 643 644 if (fp == NULL) { 645 for (fp = preloaded_files; fp; fp = fp->f_next) { 646 mp = file_findmodule(fp, modname, verinfo); 647 if (mp) 648 return (mp); 649 } 650 return (NULL); 651 } 652 best = NULL; 653 bestver = 0; 654 for (mp = fp->f_modules; mp; mp = mp->m_next) { 655 if (strcmp(modname, mp->m_name) == 0) { 656 if (verinfo == NULL) 657 return (mp); 658 mver = mp->m_version; 659 if (mver == verinfo->md_ver_preferred) 660 return (mp); 661 if (mver >= verinfo->md_ver_minimum && 662 mver <= verinfo->md_ver_maximum && 663 mver > bestver) { 664 best = mp; 665 bestver = mver; 666 } 667 } 668 } 669 return (best); 670 } 671 /* 672 * Make a copy of (size) bytes of data from (p), and associate them as 673 * metadata of (type) to the module (mp). 674 */ 675 void 676 file_addmetadata(struct preloaded_file *fp, int type, size_t size, void *p) 677 { 678 struct file_metadata *md; 679 680 md = malloc(sizeof(struct file_metadata) - sizeof(md->md_data) + size); 681 if (md != NULL) { 682 md->md_size = size; 683 md->md_type = type; 684 bcopy(p, md->md_data, size); 685 md->md_next = fp->f_metadata; 686 } 687 fp->f_metadata = md; 688 } 689 690 /* 691 * Find a metadata object of (type) associated with the file (fp) 692 */ 693 struct file_metadata * 694 file_findmetadata(struct preloaded_file *fp, int type) 695 { 696 struct file_metadata *md; 697 698 for (md = fp->f_metadata; md != NULL; md = md->md_next) 699 if (md->md_type == type) 700 break; 701 return(md); 702 } 703 704 /* 705 * Remove all metadata from the file. 706 */ 707 void 708 file_removemetadata(struct preloaded_file *fp) 709 { 710 struct file_metadata *md, *next; 711 712 for (md = fp->f_metadata; md != NULL; md = next) 713 { 714 next = md->md_next; 715 free(md); 716 } 717 fp->f_metadata = NULL; 718 } 719 720 struct file_metadata * 721 metadata_next(struct file_metadata *md, int type) 722 { 723 724 if (md == NULL) 725 return (NULL); 726 while((md = md->md_next) != NULL) 727 if (md->md_type == type) 728 break; 729 return (md); 730 } 731 732 static char *emptyextlist[] = { "", NULL }; 733 734 /* 735 * Check if the given file is in place and return full path to it. 736 */ 737 static char * 738 file_lookup(const char *path, const char *name, int namelen, char **extlist) 739 { 740 struct stat st; 741 char *result, *cp, **cpp; 742 int pathlen, extlen, len; 743 744 pathlen = strlen(path); 745 extlen = 0; 746 if (extlist == NULL) 747 extlist = emptyextlist; 748 for (cpp = extlist; *cpp; cpp++) { 749 len = strlen(*cpp); 750 if (len > extlen) 751 extlen = len; 752 } 753 result = malloc(pathlen + namelen + extlen + 2); 754 if (result == NULL) 755 return (NULL); 756 bcopy(path, result, pathlen); 757 if (pathlen > 0 && result[pathlen - 1] != '/') 758 result[pathlen++] = '/'; 759 cp = result + pathlen; 760 bcopy(name, cp, namelen); 761 cp += namelen; 762 for (cpp = extlist; *cpp; cpp++) { 763 strcpy(cp, *cpp); 764 if (stat(result, &st) == 0 && S_ISREG(st.st_mode)) 765 return result; 766 } 767 free(result); 768 return NULL; 769 } 770 771 /* 772 * Check if file name have any qualifiers 773 */ 774 static int 775 file_havepath(const char *name) 776 { 777 const char *cp; 778 779 archsw.arch_getdev(NULL, name, &cp); 780 return (cp != name || strchr(name, '/') != NULL); 781 } 782 783 /* 784 * Attempt to find the file (name) on the module searchpath. 785 * If (name) is qualified in any way, we simply check it and 786 * return it or NULL. If it is not qualified, then we attempt 787 * to construct a path using entries in the environment variable 788 * module_path. 789 * 790 * The path we return a pointer to need never be freed, as we manage 791 * it internally. 792 */ 793 static char * 794 file_search(const char *name, char **extlist) 795 { 796 struct moduledir *mdp; 797 struct stat sb; 798 char *result; 799 int namelen; 800 801 /* Don't look for nothing */ 802 if (name == NULL) 803 return(NULL); 804 805 if (*name == 0) 806 return(strdup(name)); 807 808 if (file_havepath(name)) { 809 /* Qualified, so just see if it exists */ 810 if (stat(name, &sb) == 0) 811 return(strdup(name)); 812 return(NULL); 813 } 814 moduledir_rebuild(); 815 result = NULL; 816 namelen = strlen(name); 817 STAILQ_FOREACH(mdp, &moduledir_list, d_link) { 818 result = file_lookup(mdp->d_path, name, namelen, extlist); 819 if (result) 820 break; 821 } 822 return(result); 823 } 824 825 #define INT_ALIGN(base, ptr) ptr = \ 826 (base) + roundup2((ptr) - (base), sizeof(int)) 827 828 static char * 829 mod_search_hints(struct moduledir *mdp, const char *modname, 830 struct mod_depend *verinfo) 831 { 832 u_char *cp, *recptr, *bufend, *best; 833 char *result; 834 int *intp, bestver, blen, clen, found, ival, modnamelen, reclen; 835 836 moduledir_readhints(mdp); 837 modnamelen = strlen(modname); 838 found = 0; 839 result = NULL; 840 bestver = 0; 841 if (mdp->d_hints == NULL) 842 goto bad; 843 recptr = mdp->d_hints; 844 bufend = recptr + mdp->d_hintsz; 845 clen = blen = 0; 846 best = cp = NULL; 847 while (recptr < bufend && !found) { 848 intp = (int*)recptr; 849 reclen = *intp++; 850 ival = *intp++; 851 cp = (u_char*)intp; 852 switch (ival) { 853 case MDT_VERSION: 854 clen = *cp++; 855 if (clen != modnamelen || bcmp(cp, modname, clen) != 0) 856 break; 857 cp += clen; 858 INT_ALIGN(mdp->d_hints, cp); 859 ival = *(int*)cp; 860 cp += sizeof(int); 861 clen = *cp++; 862 if (verinfo == NULL || ival == verinfo->md_ver_preferred) { 863 found = 1; 864 break; 865 } 866 if (ival >= verinfo->md_ver_minimum && 867 ival <= verinfo->md_ver_maximum && 868 ival > bestver) { 869 bestver = ival; 870 best = cp; 871 blen = clen; 872 } 873 break; 874 default: 875 break; 876 } 877 recptr += reclen + sizeof(int); 878 } 879 /* 880 * Finally check if KLD is in the place 881 */ 882 if (found) 883 result = file_lookup(mdp->d_path, (const char *)cp, clen, NULL); 884 else if (best) 885 result = file_lookup(mdp->d_path, (const char *)best, blen, NULL); 886 bad: 887 /* 888 * If nothing found or hints is absent - fallback to the old way 889 * by using "kldname[.ko]" as module name. 890 */ 891 if (!found && !bestver && result == NULL) 892 result = file_lookup(mdp->d_path, modname, modnamelen, kld_ext_list); 893 return result; 894 } 895 896 /* 897 * Attempt to locate the file containing the module (name) 898 */ 899 static char * 900 mod_searchmodule(char *name, struct mod_depend *verinfo) 901 { 902 struct moduledir *mdp; 903 char *result; 904 905 moduledir_rebuild(); 906 /* 907 * Now we ready to lookup module in the given directories 908 */ 909 result = NULL; 910 STAILQ_FOREACH(mdp, &moduledir_list, d_link) { 911 result = mod_search_hints(mdp, name, verinfo); 912 if (result) 913 break; 914 } 915 916 return(result); 917 } 918 919 int 920 file_addmodule(struct preloaded_file *fp, char *modname, int version, 921 struct kernel_module **newmp) 922 { 923 struct kernel_module *mp; 924 struct mod_depend mdepend; 925 926 bzero(&mdepend, sizeof(mdepend)); 927 mdepend.md_ver_preferred = version; 928 mp = file_findmodule(fp, modname, &mdepend); 929 if (mp) 930 return (EEXIST); 931 mp = calloc(1, sizeof(struct kernel_module)); 932 if (mp == NULL) 933 return (ENOMEM); 934 mp->m_name = strdup(modname); 935 if (mp->m_name == NULL) { 936 free(mp); 937 return (ENOMEM); 938 } 939 mp->m_version = version; 940 mp->m_fp = fp; 941 mp->m_next = fp->f_modules; 942 fp->f_modules = mp; 943 if (newmp) 944 *newmp = mp; 945 return (0); 946 } 947 948 /* 949 * Throw a file away 950 */ 951 void 952 file_discard(struct preloaded_file *fp) 953 { 954 struct file_metadata *md, *md1; 955 struct kernel_module *mp, *mp1; 956 if (fp == NULL) 957 return; 958 md = fp->f_metadata; 959 while (md) { 960 md1 = md; 961 md = md->md_next; 962 free(md1); 963 } 964 mp = fp->f_modules; 965 while (mp) { 966 free(mp->m_name); 967 mp1 = mp; 968 mp = mp->m_next; 969 free(mp1); 970 } 971 free(fp->f_name); 972 free(fp->f_type); 973 free(fp->f_args); 974 free(fp); 975 } 976 977 /* 978 * Allocate a new file; must be used instead of malloc() 979 * to ensure safe initialisation. 980 */ 981 struct preloaded_file * 982 file_alloc(void) 983 { 984 985 return (calloc(1, sizeof(struct preloaded_file))); 986 } 987 988 /* 989 * Add a module to the chain 990 */ 991 static void 992 file_insert_tail(struct preloaded_file *fp) 993 { 994 struct preloaded_file *cm; 995 996 /* Append to list of loaded file */ 997 fp->f_next = NULL; 998 if (preloaded_files == NULL) { 999 preloaded_files = fp; 1000 } else { 1001 for (cm = preloaded_files; cm->f_next != NULL; cm = cm->f_next) 1002 ; 1003 cm->f_next = fp; 1004 } 1005 } 1006 1007 /* 1008 * Remove module from the chain 1009 */ 1010 static void 1011 file_remove(struct preloaded_file *fp) 1012 { 1013 struct preloaded_file *cm; 1014 1015 if (preloaded_files == NULL) 1016 return; 1017 1018 if (preloaded_files == fp) { 1019 preloaded_files = fp->f_next; 1020 return; 1021 } 1022 for (cm = preloaded_files; cm->f_next != NULL; cm = cm->f_next) { 1023 if (cm->f_next == fp) { 1024 cm->f_next = fp->f_next; 1025 return; 1026 } 1027 } 1028 } 1029 1030 static char * 1031 moduledir_fullpath(struct moduledir *mdp, const char *fname) 1032 { 1033 char *cp; 1034 1035 cp = malloc(strlen(mdp->d_path) + strlen(fname) + 2); 1036 if (cp == NULL) 1037 return NULL; 1038 strcpy(cp, mdp->d_path); 1039 strcat(cp, "/"); 1040 strcat(cp, fname); 1041 return (cp); 1042 } 1043 1044 /* 1045 * Read linker.hints file into memory performing some sanity checks. 1046 */ 1047 static void 1048 moduledir_readhints(struct moduledir *mdp) 1049 { 1050 struct stat st; 1051 char *path; 1052 int fd, size, version; 1053 1054 if (mdp->d_hints != NULL || (mdp->d_flags & MDIR_NOHINTS)) 1055 return; 1056 path = moduledir_fullpath(mdp, "linker.hints"); 1057 if (stat(path, &st) != 0 || 1058 st.st_size < (ssize_t)(sizeof(version) + sizeof(int)) || 1059 st.st_size > LINKER_HINTS_MAX || (fd = open(path, O_RDONLY)) < 0) { 1060 free(path); 1061 mdp->d_flags |= MDIR_NOHINTS; 1062 return; 1063 } 1064 free(path); 1065 size = read(fd, &version, sizeof(version)); 1066 if (size != sizeof(version) || version != LINKER_HINTS_VERSION) 1067 goto bad; 1068 size = st.st_size - size; 1069 mdp->d_hints = malloc(size); 1070 if (mdp->d_hints == NULL) 1071 goto bad; 1072 if (read(fd, mdp->d_hints, size) != size) 1073 goto bad; 1074 mdp->d_hintsz = size; 1075 close(fd); 1076 return; 1077 bad: 1078 close(fd); 1079 free(mdp->d_hints); 1080 mdp->d_hints = NULL; 1081 mdp->d_flags |= MDIR_NOHINTS; 1082 return; 1083 } 1084 1085 /* 1086 * Extract directories from the ';' separated list, remove duplicates. 1087 */ 1088 static void 1089 moduledir_rebuild(void) 1090 { 1091 struct moduledir *mdp, *mtmp; 1092 const char *path, *cp, *ep; 1093 size_t cplen; 1094 1095 path = getenv("module_path"); 1096 if (path == NULL) 1097 path = default_searchpath; 1098 /* 1099 * Rebuild list of module directories if it changed 1100 */ 1101 STAILQ_FOREACH(mdp, &moduledir_list, d_link) 1102 mdp->d_flags |= MDIR_REMOVED; 1103 1104 for (ep = path; *ep != 0; ep++) { 1105 cp = ep; 1106 for (; *ep != 0 && *ep != ';'; ep++) 1107 ; 1108 /* 1109 * Ignore trailing slashes 1110 */ 1111 for (cplen = ep - cp; cplen > 1 && cp[cplen - 1] == '/'; cplen--) 1112 ; 1113 STAILQ_FOREACH(mdp, &moduledir_list, d_link) { 1114 if (strlen(mdp->d_path) != cplen || bcmp(cp, mdp->d_path, cplen) != 0) 1115 continue; 1116 mdp->d_flags &= ~MDIR_REMOVED; 1117 break; 1118 } 1119 if (mdp == NULL) { 1120 mdp = malloc(sizeof(*mdp) + cplen + 1); 1121 if (mdp == NULL) 1122 return; 1123 mdp->d_path = (char*)(mdp + 1); 1124 bcopy(cp, mdp->d_path, cplen); 1125 mdp->d_path[cplen] = 0; 1126 mdp->d_hints = NULL; 1127 mdp->d_flags = 0; 1128 STAILQ_INSERT_TAIL(&moduledir_list, mdp, d_link); 1129 } 1130 if (*ep == 0) 1131 break; 1132 } 1133 /* 1134 * Delete unused directories if any 1135 */ 1136 mdp = STAILQ_FIRST(&moduledir_list); 1137 while (mdp) { 1138 if ((mdp->d_flags & MDIR_REMOVED) == 0) { 1139 mdp = STAILQ_NEXT(mdp, d_link); 1140 } else { 1141 free(mdp->d_hints); 1142 mtmp = mdp; 1143 mdp = STAILQ_NEXT(mdp, d_link); 1144 STAILQ_REMOVE(&moduledir_list, mtmp, moduledir, d_link); 1145 free(mtmp); 1146 } 1147 } 1148 return; 1149 } 1150