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