The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_linker.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 1997-2000 Doug Rabson
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: head/sys/kern/kern_linker.c 339463 2018-10-20 18:08:43Z cem $");
   31 
   32 #include "opt_ddb.h"
   33 #include "opt_kld.h"
   34 #include "opt_hwpmc_hooks.h"
   35 
   36 #include <sys/param.h>
   37 #include <sys/kernel.h>
   38 #include <sys/systm.h>
   39 #include <sys/malloc.h>
   40 #include <sys/sysproto.h>
   41 #include <sys/sysent.h>
   42 #include <sys/priv.h>
   43 #include <sys/proc.h>
   44 #include <sys/lock.h>
   45 #include <sys/mutex.h>
   46 #include <sys/sx.h>
   47 #include <sys/module.h>
   48 #include <sys/mount.h>
   49 #include <sys/linker.h>
   50 #include <sys/eventhandler.h>
   51 #include <sys/fcntl.h>
   52 #include <sys/jail.h>
   53 #include <sys/libkern.h>
   54 #include <sys/namei.h>
   55 #include <sys/vnode.h>
   56 #include <sys/syscallsubr.h>
   57 #include <sys/sysctl.h>
   58 
   59 #ifdef DDB
   60 #include <ddb/ddb.h>
   61 #endif
   62 
   63 #include <net/vnet.h>
   64 
   65 #include <security/mac/mac_framework.h>
   66 
   67 #include "linker_if.h"
   68 
   69 #ifdef HWPMC_HOOKS
   70 #include <sys/pmckern.h>
   71 #endif
   72 
   73 #ifdef KLD_DEBUG
   74 int kld_debug = 0;
   75 SYSCTL_INT(_debug, OID_AUTO, kld_debug, CTLFLAG_RWTUN,
   76     &kld_debug, 0, "Set various levels of KLD debug");
   77 #endif
   78 
   79 /* These variables are used by kernel debuggers to enumerate loaded files. */
   80 const int kld_off_address = offsetof(struct linker_file, address);
   81 const int kld_off_filename = offsetof(struct linker_file, filename);
   82 const int kld_off_pathname = offsetof(struct linker_file, pathname);
   83 const int kld_off_next = offsetof(struct linker_file, link.tqe_next);
   84 
   85 /*
   86  * static char *linker_search_path(const char *name, struct mod_depend
   87  * *verinfo);
   88  */
   89 static const char       *linker_basename(const char *path);
   90 
   91 /*
   92  * Find a currently loaded file given its filename.
   93  */
   94 static linker_file_t linker_find_file_by_name(const char* _filename);
   95 
   96 /*
   97  * Find a currently loaded file given its file id.
   98  */
   99 static linker_file_t linker_find_file_by_id(int _fileid);
  100 
  101 /* Metadata from the static kernel */
  102 SET_DECLARE(modmetadata_set, struct mod_metadata);
  103 
  104 MALLOC_DEFINE(M_LINKER, "linker", "kernel linker");
  105 
  106 linker_file_t linker_kernel_file;
  107 
  108 static struct sx kld_sx;        /* kernel linker lock */
  109 
  110 /*
  111  * Load counter used by clients to determine if a linker file has been
  112  * re-loaded. This counter is incremented for each file load.
  113  */
  114 static int loadcnt;
  115 
  116 static linker_class_list_t classes;
  117 static linker_file_list_t linker_files;
  118 static int next_file_id = 1;
  119 static int linker_no_more_classes = 0;
  120 
  121 #define LINKER_GET_NEXT_FILE_ID(a) do {                                 \
  122         linker_file_t lftmp;                                            \
  123                                                                         \
  124         if (!cold)                                                      \
  125                 sx_assert(&kld_sx, SA_XLOCKED);                         \
  126 retry:                                                                  \
  127         TAILQ_FOREACH(lftmp, &linker_files, link) {                     \
  128                 if (next_file_id == lftmp->id) {                        \
  129                         next_file_id++;                                 \
  130                         goto retry;                                     \
  131                 }                                                       \
  132         }                                                               \
  133         (a) = next_file_id;                                             \
  134 } while(0)
  135 
  136 
  137 /* XXX wrong name; we're looking at version provision tags here, not modules */
  138 typedef TAILQ_HEAD(, modlist) modlisthead_t;
  139 struct modlist {
  140         TAILQ_ENTRY(modlist) link;      /* chain together all modules */
  141         linker_file_t   container;
  142         const char      *name;
  143         int             version;
  144 };
  145 typedef struct modlist *modlist_t;
  146 static modlisthead_t found_modules;
  147 
  148 static int      linker_file_add_dependency(linker_file_t file,
  149                     linker_file_t dep);
  150 static caddr_t  linker_file_lookup_symbol_internal(linker_file_t file,
  151                     const char* name, int deps);
  152 static int      linker_load_module(const char *kldname,
  153                     const char *modname, struct linker_file *parent,
  154                     const struct mod_depend *verinfo, struct linker_file **lfpp);
  155 static modlist_t modlist_lookup2(const char *name, const struct mod_depend *verinfo);
  156 
  157 static void
  158 linker_init(void *arg)
  159 {
  160 
  161         sx_init(&kld_sx, "kernel linker");
  162         TAILQ_INIT(&classes);
  163         TAILQ_INIT(&linker_files);
  164 }
  165 
  166 SYSINIT(linker, SI_SUB_KLD, SI_ORDER_FIRST, linker_init, NULL);
  167 
  168 static void
  169 linker_stop_class_add(void *arg)
  170 {
  171 
  172         linker_no_more_classes = 1;
  173 }
  174 
  175 SYSINIT(linker_class, SI_SUB_KLD, SI_ORDER_ANY, linker_stop_class_add, NULL);
  176 
  177 int
  178 linker_add_class(linker_class_t lc)
  179 {
  180 
  181         /*
  182          * We disallow any class registration past SI_ORDER_ANY
  183          * of SI_SUB_KLD.  We bump the reference count to keep the
  184          * ops from being freed.
  185          */
  186         if (linker_no_more_classes == 1)
  187                 return (EPERM);
  188         kobj_class_compile((kobj_class_t) lc);
  189         ((kobj_class_t)lc)->refs++;     /* XXX: kobj_mtx */
  190         TAILQ_INSERT_TAIL(&classes, lc, link);
  191         return (0);
  192 }
  193 
  194 static void
  195 linker_file_sysinit(linker_file_t lf)
  196 {
  197         struct sysinit **start, **stop, **sipp, **xipp, *save;
  198 
  199         KLD_DPF(FILE, ("linker_file_sysinit: calling SYSINITs for %s\n",
  200             lf->filename));
  201 
  202         sx_assert(&kld_sx, SA_XLOCKED);
  203 
  204         if (linker_file_lookup_set(lf, "sysinit_set", &start, &stop, NULL) != 0)
  205                 return;
  206         /*
  207          * Perform a bubble sort of the system initialization objects by
  208          * their subsystem (primary key) and order (secondary key).
  209          *
  210          * Since some things care about execution order, this is the operation
  211          * which ensures continued function.
  212          */
  213         for (sipp = start; sipp < stop; sipp++) {
  214                 for (xipp = sipp + 1; xipp < stop; xipp++) {
  215                         if ((*sipp)->subsystem < (*xipp)->subsystem ||
  216                             ((*sipp)->subsystem == (*xipp)->subsystem &&
  217                             (*sipp)->order <= (*xipp)->order))
  218                                 continue;       /* skip */
  219                         save = *sipp;
  220                         *sipp = *xipp;
  221                         *xipp = save;
  222                 }
  223         }
  224 
  225         /*
  226          * Traverse the (now) ordered list of system initialization tasks.
  227          * Perform each task, and continue on to the next task.
  228          */
  229         sx_xunlock(&kld_sx);
  230         mtx_lock(&Giant);
  231         for (sipp = start; sipp < stop; sipp++) {
  232                 if ((*sipp)->subsystem == SI_SUB_DUMMY)
  233                         continue;       /* skip dummy task(s) */
  234 
  235                 /* Call function */
  236                 (*((*sipp)->func)) ((*sipp)->udata);
  237         }
  238         mtx_unlock(&Giant);
  239         sx_xlock(&kld_sx);
  240 }
  241 
  242 static void
  243 linker_file_sysuninit(linker_file_t lf)
  244 {
  245         struct sysinit **start, **stop, **sipp, **xipp, *save;
  246 
  247         KLD_DPF(FILE, ("linker_file_sysuninit: calling SYSUNINITs for %s\n",
  248             lf->filename));
  249 
  250         sx_assert(&kld_sx, SA_XLOCKED);
  251 
  252         if (linker_file_lookup_set(lf, "sysuninit_set", &start, &stop,
  253             NULL) != 0)
  254                 return;
  255 
  256         /*
  257          * Perform a reverse bubble sort of the system initialization objects
  258          * by their subsystem (primary key) and order (secondary key).
  259          *
  260          * Since some things care about execution order, this is the operation
  261          * which ensures continued function.
  262          */
  263         for (sipp = start; sipp < stop; sipp++) {
  264                 for (xipp = sipp + 1; xipp < stop; xipp++) {
  265                         if ((*sipp)->subsystem > (*xipp)->subsystem ||
  266                             ((*sipp)->subsystem == (*xipp)->subsystem &&
  267                             (*sipp)->order >= (*xipp)->order))
  268                                 continue;       /* skip */
  269                         save = *sipp;
  270                         *sipp = *xipp;
  271                         *xipp = save;
  272                 }
  273         }
  274 
  275         /*
  276          * Traverse the (now) ordered list of system initialization tasks.
  277          * Perform each task, and continue on to the next task.
  278          */
  279         sx_xunlock(&kld_sx);
  280         mtx_lock(&Giant);
  281         for (sipp = start; sipp < stop; sipp++) {
  282                 if ((*sipp)->subsystem == SI_SUB_DUMMY)
  283                         continue;       /* skip dummy task(s) */
  284 
  285                 /* Call function */
  286                 (*((*sipp)->func)) ((*sipp)->udata);
  287         }
  288         mtx_unlock(&Giant);
  289         sx_xlock(&kld_sx);
  290 }
  291 
  292 static void
  293 linker_file_register_sysctls(linker_file_t lf, bool enable)
  294 {
  295         struct sysctl_oid **start, **stop, **oidp;
  296 
  297         KLD_DPF(FILE,
  298             ("linker_file_register_sysctls: registering SYSCTLs for %s\n",
  299             lf->filename));
  300 
  301         sx_assert(&kld_sx, SA_XLOCKED);
  302 
  303         if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
  304                 return;
  305 
  306         sx_xunlock(&kld_sx);
  307         sysctl_wlock();
  308         for (oidp = start; oidp < stop; oidp++) {
  309                 if (enable)
  310                         sysctl_register_oid(*oidp);
  311                 else
  312                         sysctl_register_disabled_oid(*oidp);
  313         }
  314         sysctl_wunlock();
  315         sx_xlock(&kld_sx);
  316 }
  317 
  318 static void
  319 linker_file_enable_sysctls(linker_file_t lf)
  320 {
  321         struct sysctl_oid **start, **stop, **oidp;
  322 
  323         KLD_DPF(FILE,
  324             ("linker_file_enable_sysctls: enable SYSCTLs for %s\n",
  325             lf->filename));
  326 
  327         sx_assert(&kld_sx, SA_XLOCKED);
  328 
  329         if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
  330                 return;
  331 
  332         sx_xunlock(&kld_sx);
  333         sysctl_wlock();
  334         for (oidp = start; oidp < stop; oidp++)
  335                 sysctl_enable_oid(*oidp);
  336         sysctl_wunlock();
  337         sx_xlock(&kld_sx);
  338 }
  339 
  340 static void
  341 linker_file_unregister_sysctls(linker_file_t lf)
  342 {
  343         struct sysctl_oid **start, **stop, **oidp;
  344 
  345         KLD_DPF(FILE, ("linker_file_unregister_sysctls: unregistering SYSCTLs"
  346             " for %s\n", lf->filename));
  347 
  348         sx_assert(&kld_sx, SA_XLOCKED);
  349 
  350         if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
  351                 return;
  352 
  353         sx_xunlock(&kld_sx);
  354         sysctl_wlock();
  355         for (oidp = start; oidp < stop; oidp++)
  356                 sysctl_unregister_oid(*oidp);
  357         sysctl_wunlock();
  358         sx_xlock(&kld_sx);
  359 }
  360 
  361 static int
  362 linker_file_register_modules(linker_file_t lf)
  363 {
  364         struct mod_metadata **start, **stop, **mdp;
  365         const moduledata_t *moddata;
  366         int first_error, error;
  367 
  368         KLD_DPF(FILE, ("linker_file_register_modules: registering modules"
  369             " in %s\n", lf->filename));
  370 
  371         sx_assert(&kld_sx, SA_XLOCKED);
  372 
  373         if (linker_file_lookup_set(lf, "modmetadata_set", &start,
  374             &stop, NULL) != 0) {
  375                 /*
  376                  * This fallback should be unnecessary, but if we get booted
  377                  * from boot2 instead of loader and we are missing our
  378                  * metadata then we have to try the best we can.
  379                  */
  380                 if (lf == linker_kernel_file) {
  381                         start = SET_BEGIN(modmetadata_set);
  382                         stop = SET_LIMIT(modmetadata_set);
  383                 } else
  384                         return (0);
  385         }
  386         first_error = 0;
  387         for (mdp = start; mdp < stop; mdp++) {
  388                 if ((*mdp)->md_type != MDT_MODULE)
  389                         continue;
  390                 moddata = (*mdp)->md_data;
  391                 KLD_DPF(FILE, ("Registering module %s in %s\n",
  392                     moddata->name, lf->filename));
  393                 error = module_register(moddata, lf);
  394                 if (error) {
  395                         printf("Module %s failed to register: %d\n",
  396                             moddata->name, error);
  397                         if (first_error == 0)
  398                                 first_error = error;
  399                 }
  400         }
  401         return (first_error);
  402 }
  403 
  404 static void
  405 linker_init_kernel_modules(void)
  406 {
  407 
  408         sx_xlock(&kld_sx);
  409         linker_file_register_modules(linker_kernel_file);
  410         sx_xunlock(&kld_sx);
  411 }
  412 
  413 SYSINIT(linker_kernel, SI_SUB_KLD, SI_ORDER_ANY, linker_init_kernel_modules,
  414     NULL);
  415 
  416 static int
  417 linker_load_file(const char *filename, linker_file_t *result)
  418 {
  419         linker_class_t lc;
  420         linker_file_t lf;
  421         int foundfile, error, modules;
  422 
  423         /* Refuse to load modules if securelevel raised */
  424         if (prison0.pr_securelevel > 0)
  425                 return (EPERM);
  426 
  427         sx_assert(&kld_sx, SA_XLOCKED);
  428         lf = linker_find_file_by_name(filename);
  429         if (lf) {
  430                 KLD_DPF(FILE, ("linker_load_file: file %s is already loaded,"
  431                     " incrementing refs\n", filename));
  432                 *result = lf;
  433                 lf->refs++;
  434                 return (0);
  435         }
  436         foundfile = 0;
  437         error = 0;
  438 
  439         /*
  440          * We do not need to protect (lock) classes here because there is
  441          * no class registration past startup (SI_SUB_KLD, SI_ORDER_ANY)
  442          * and there is no class deregistration mechanism at this time.
  443          */
  444         TAILQ_FOREACH(lc, &classes, link) {
  445                 KLD_DPF(FILE, ("linker_load_file: trying to load %s\n",
  446                     filename));
  447                 error = LINKER_LOAD_FILE(lc, filename, &lf);
  448                 /*
  449                  * If we got something other than ENOENT, then it exists but
  450                  * we cannot load it for some other reason.
  451                  */
  452                 if (error != ENOENT)
  453                         foundfile = 1;
  454                 if (lf) {
  455                         error = linker_file_register_modules(lf);
  456                         if (error == EEXIST) {
  457                                 linker_file_unload(lf, LINKER_UNLOAD_FORCE);
  458                                 return (error);
  459                         }
  460                         modules = !TAILQ_EMPTY(&lf->modules);
  461                         linker_file_register_sysctls(lf, false);
  462                         linker_file_sysinit(lf);
  463                         lf->flags |= LINKER_FILE_LINKED;
  464 
  465                         /*
  466                          * If all of the modules in this file failed
  467                          * to load, unload the file and return an
  468                          * error of ENOEXEC.
  469                          */
  470                         if (modules && TAILQ_EMPTY(&lf->modules)) {
  471                                 linker_file_unload(lf, LINKER_UNLOAD_FORCE);
  472                                 return (ENOEXEC);
  473                         }
  474                         linker_file_enable_sysctls(lf);
  475                         EVENTHANDLER_INVOKE(kld_load, lf);
  476                         *result = lf;
  477                         return (0);
  478                 }
  479         }
  480         /*
  481          * Less than ideal, but tells the user whether it failed to load or
  482          * the module was not found.
  483          */
  484         if (foundfile) {
  485 
  486                 /*
  487                  * If the file type has not been recognized by the last try
  488                  * printout a message before to fail.
  489                  */
  490                 if (error == ENOSYS)
  491                         printf("%s: %s - unsupported file type\n",
  492                             __func__, filename);
  493 
  494                 /*
  495                  * Format not recognized or otherwise unloadable.
  496                  * When loading a module that is statically built into
  497                  * the kernel EEXIST percolates back up as the return
  498                  * value.  Preserve this so that apps like sysinstall
  499                  * can recognize this special case and not post bogus
  500                  * dialog boxes.
  501                  */
  502                 if (error != EEXIST)
  503                         error = ENOEXEC;
  504         } else
  505                 error = ENOENT;         /* Nothing found */
  506         return (error);
  507 }
  508 
  509 int
  510 linker_reference_module(const char *modname, struct mod_depend *verinfo,
  511     linker_file_t *result)
  512 {
  513         modlist_t mod;
  514         int error;
  515 
  516         sx_xlock(&kld_sx);
  517         if ((mod = modlist_lookup2(modname, verinfo)) != NULL) {
  518                 *result = mod->container;
  519                 (*result)->refs++;
  520                 sx_xunlock(&kld_sx);
  521                 return (0);
  522         }
  523 
  524         error = linker_load_module(NULL, modname, NULL, verinfo, result);
  525         sx_xunlock(&kld_sx);
  526         return (error);
  527 }
  528 
  529 int
  530 linker_release_module(const char *modname, struct mod_depend *verinfo,
  531     linker_file_t lf)
  532 {
  533         modlist_t mod;
  534         int error;
  535 
  536         sx_xlock(&kld_sx);
  537         if (lf == NULL) {
  538                 KASSERT(modname != NULL,
  539                     ("linker_release_module: no file or name"));
  540                 mod = modlist_lookup2(modname, verinfo);
  541                 if (mod == NULL) {
  542                         sx_xunlock(&kld_sx);
  543                         return (ESRCH);
  544                 }
  545                 lf = mod->container;
  546         } else
  547                 KASSERT(modname == NULL && verinfo == NULL,
  548                     ("linker_release_module: both file and name"));
  549         error = linker_file_unload(lf, LINKER_UNLOAD_NORMAL);
  550         sx_xunlock(&kld_sx);
  551         return (error);
  552 }
  553 
  554 static linker_file_t
  555 linker_find_file_by_name(const char *filename)
  556 {
  557         linker_file_t lf;
  558         char *koname;
  559 
  560         koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
  561         sprintf(koname, "%s.ko", filename);
  562 
  563         sx_assert(&kld_sx, SA_XLOCKED);
  564         TAILQ_FOREACH(lf, &linker_files, link) {
  565                 if (strcmp(lf->filename, koname) == 0)
  566                         break;
  567                 if (strcmp(lf->filename, filename) == 0)
  568                         break;
  569         }
  570         free(koname, M_LINKER);
  571         return (lf);
  572 }
  573 
  574 static linker_file_t
  575 linker_find_file_by_id(int fileid)
  576 {
  577         linker_file_t lf;
  578 
  579         sx_assert(&kld_sx, SA_XLOCKED);
  580         TAILQ_FOREACH(lf, &linker_files, link)
  581                 if (lf->id == fileid && lf->flags & LINKER_FILE_LINKED)
  582                         break;
  583         return (lf);
  584 }
  585 
  586 int
  587 linker_file_foreach(linker_predicate_t *predicate, void *context)
  588 {
  589         linker_file_t lf;
  590         int retval = 0;
  591 
  592         sx_xlock(&kld_sx);
  593         TAILQ_FOREACH(lf, &linker_files, link) {
  594                 retval = predicate(lf, context);
  595                 if (retval != 0)
  596                         break;
  597         }
  598         sx_xunlock(&kld_sx);
  599         return (retval);
  600 }
  601 
  602 linker_file_t
  603 linker_make_file(const char *pathname, linker_class_t lc)
  604 {
  605         linker_file_t lf;
  606         const char *filename;
  607 
  608         if (!cold)
  609                 sx_assert(&kld_sx, SA_XLOCKED);
  610         filename = linker_basename(pathname);
  611 
  612         KLD_DPF(FILE, ("linker_make_file: new file, filename='%s' for pathname='%s'\n", filename, pathname));
  613         lf = (linker_file_t)kobj_create((kobj_class_t)lc, M_LINKER, M_WAITOK);
  614         if (lf == NULL)
  615                 return (NULL);
  616         lf->ctors_addr = 0;
  617         lf->ctors_size = 0;
  618         lf->refs = 1;
  619         lf->userrefs = 0;
  620         lf->flags = 0;
  621         lf->filename = strdup(filename, M_LINKER);
  622         lf->pathname = strdup(pathname, M_LINKER);
  623         LINKER_GET_NEXT_FILE_ID(lf->id);
  624         lf->ndeps = 0;
  625         lf->deps = NULL;
  626         lf->loadcnt = ++loadcnt;
  627         STAILQ_INIT(&lf->common);
  628         TAILQ_INIT(&lf->modules);
  629         TAILQ_INSERT_TAIL(&linker_files, lf, link);
  630         return (lf);
  631 }
  632 
  633 int
  634 linker_file_unload(linker_file_t file, int flags)
  635 {
  636         module_t mod, next;
  637         modlist_t ml, nextml;
  638         struct common_symbol *cp;
  639         int error, i;
  640 
  641         /* Refuse to unload modules if securelevel raised. */
  642         if (prison0.pr_securelevel > 0)
  643                 return (EPERM);
  644 
  645         sx_assert(&kld_sx, SA_XLOCKED);
  646         KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
  647 
  648         /* Easy case of just dropping a reference. */
  649         if (file->refs > 1) {
  650                 file->refs--;
  651                 return (0);
  652         }
  653 
  654         /* Give eventhandlers a chance to prevent the unload. */
  655         error = 0;
  656         EVENTHANDLER_INVOKE(kld_unload_try, file, &error);
  657         if (error != 0)
  658                 return (EBUSY);
  659 
  660         KLD_DPF(FILE, ("linker_file_unload: file is unloading,"
  661             " informing modules\n"));
  662 
  663         /*
  664          * Quiesce all the modules to give them a chance to veto the unload.
  665          */
  666         MOD_SLOCK;
  667         for (mod = TAILQ_FIRST(&file->modules); mod;
  668              mod = module_getfnext(mod)) {
  669 
  670                 error = module_quiesce(mod);
  671                 if (error != 0 && flags != LINKER_UNLOAD_FORCE) {
  672                         KLD_DPF(FILE, ("linker_file_unload: module %s"
  673                             " vetoed unload\n", module_getname(mod)));
  674                         /*
  675                          * XXX: Do we need to tell all the quiesced modules
  676                          * that they can resume work now via a new module
  677                          * event?
  678                          */
  679                         MOD_SUNLOCK;
  680                         return (error);
  681                 }
  682         }
  683         MOD_SUNLOCK;
  684 
  685         /*
  686          * Inform any modules associated with this file that they are
  687          * being unloaded.
  688          */
  689         MOD_XLOCK;
  690         for (mod = TAILQ_FIRST(&file->modules); mod; mod = next) {
  691                 next = module_getfnext(mod);
  692                 MOD_XUNLOCK;
  693 
  694                 /*
  695                  * Give the module a chance to veto the unload.
  696                  */
  697                 if ((error = module_unload(mod)) != 0) {
  698 #ifdef KLD_DEBUG
  699                         MOD_SLOCK;
  700                         KLD_DPF(FILE, ("linker_file_unload: module %s"
  701                             " failed unload\n", module_getname(mod)));
  702                         MOD_SUNLOCK;
  703 #endif
  704                         return (error);
  705                 }
  706                 MOD_XLOCK;
  707                 module_release(mod);
  708         }
  709         MOD_XUNLOCK;
  710 
  711         TAILQ_FOREACH_SAFE(ml, &found_modules, link, nextml) {
  712                 if (ml->container == file) {
  713                         TAILQ_REMOVE(&found_modules, ml, link);
  714                         free(ml, M_LINKER);
  715                 }
  716         }
  717 
  718         /*
  719          * Don't try to run SYSUNINITs if we are unloaded due to a
  720          * link error.
  721          */
  722         if (file->flags & LINKER_FILE_LINKED) {
  723                 file->flags &= ~LINKER_FILE_LINKED;
  724                 linker_file_unregister_sysctls(file);
  725                 linker_file_sysuninit(file);
  726         }
  727         TAILQ_REMOVE(&linker_files, file, link);
  728 
  729         if (file->deps) {
  730                 for (i = 0; i < file->ndeps; i++)
  731                         linker_file_unload(file->deps[i], flags);
  732                 free(file->deps, M_LINKER);
  733                 file->deps = NULL;
  734         }
  735         while ((cp = STAILQ_FIRST(&file->common)) != NULL) {
  736                 STAILQ_REMOVE_HEAD(&file->common, link);
  737                 free(cp, M_LINKER);
  738         }
  739 
  740         LINKER_UNLOAD(file);
  741 
  742         EVENTHANDLER_INVOKE(kld_unload, file->filename, file->address,
  743             file->size);
  744 
  745         if (file->filename) {
  746                 free(file->filename, M_LINKER);
  747                 file->filename = NULL;
  748         }
  749         if (file->pathname) {
  750                 free(file->pathname, M_LINKER);
  751                 file->pathname = NULL;
  752         }
  753         kobj_delete((kobj_t) file, M_LINKER);
  754         return (0);
  755 }
  756 
  757 int
  758 linker_ctf_get(linker_file_t file, linker_ctf_t *lc)
  759 {
  760         return (LINKER_CTF_GET(file, lc));
  761 }
  762 
  763 static int
  764 linker_file_add_dependency(linker_file_t file, linker_file_t dep)
  765 {
  766         linker_file_t *newdeps;
  767 
  768         sx_assert(&kld_sx, SA_XLOCKED);
  769         file->deps = realloc(file->deps, (file->ndeps + 1) * sizeof(*newdeps),
  770             M_LINKER, M_WAITOK | M_ZERO);
  771         file->deps[file->ndeps] = dep;
  772         file->ndeps++;
  773         KLD_DPF(FILE, ("linker_file_add_dependency:"
  774             " adding %s as dependency for %s\n", 
  775             dep->filename, file->filename));
  776         return (0);
  777 }
  778 
  779 /*
  780  * Locate a linker set and its contents.  This is a helper function to avoid
  781  * linker_if.h exposure elsewhere.  Note: firstp and lastp are really void **.
  782  * This function is used in this file so we can avoid having lots of (void **)
  783  * casts.
  784  */
  785 int
  786 linker_file_lookup_set(linker_file_t file, const char *name,
  787     void *firstp, void *lastp, int *countp)
  788 {
  789 
  790         sx_assert(&kld_sx, SA_LOCKED);
  791         return (LINKER_LOOKUP_SET(file, name, firstp, lastp, countp));
  792 }
  793 
  794 /*
  795  * List all functions in a file.
  796  */
  797 int
  798 linker_file_function_listall(linker_file_t lf,
  799     linker_function_nameval_callback_t callback_func, void *arg)
  800 {
  801         return (LINKER_EACH_FUNCTION_NAMEVAL(lf, callback_func, arg));
  802 }
  803 
  804 caddr_t
  805 linker_file_lookup_symbol(linker_file_t file, const char *name, int deps)
  806 {
  807         caddr_t sym;
  808         int locked;
  809 
  810         locked = sx_xlocked(&kld_sx);
  811         if (!locked)
  812                 sx_xlock(&kld_sx);
  813         sym = linker_file_lookup_symbol_internal(file, name, deps);
  814         if (!locked)
  815                 sx_xunlock(&kld_sx);
  816         return (sym);
  817 }
  818 
  819 static caddr_t
  820 linker_file_lookup_symbol_internal(linker_file_t file, const char *name,
  821     int deps)
  822 {
  823         c_linker_sym_t sym;
  824         linker_symval_t symval;
  825         caddr_t address;
  826         size_t common_size = 0;
  827         int i;
  828 
  829         sx_assert(&kld_sx, SA_XLOCKED);
  830         KLD_DPF(SYM, ("linker_file_lookup_symbol: file=%p, name=%s, deps=%d\n",
  831             file, name, deps));
  832 
  833         if (LINKER_LOOKUP_SYMBOL(file, name, &sym) == 0) {
  834                 LINKER_SYMBOL_VALUES(file, sym, &symval);
  835                 if (symval.value == 0)
  836                         /*
  837                          * For commons, first look them up in the
  838                          * dependencies and only allocate space if not found
  839                          * there.
  840                          */
  841                         common_size = symval.size;
  842                 else {
  843                         KLD_DPF(SYM, ("linker_file_lookup_symbol: symbol"
  844                             ".value=%p\n", symval.value));
  845                         return (symval.value);
  846                 }
  847         }
  848         if (deps) {
  849                 for (i = 0; i < file->ndeps; i++) {
  850                         address = linker_file_lookup_symbol_internal(
  851                             file->deps[i], name, 0);
  852                         if (address) {
  853                                 KLD_DPF(SYM, ("linker_file_lookup_symbol:"
  854                                     " deps value=%p\n", address));
  855                                 return (address);
  856                         }
  857                 }
  858         }
  859         if (common_size > 0) {
  860                 /*
  861                  * This is a common symbol which was not found in the
  862                  * dependencies.  We maintain a simple common symbol table in
  863                  * the file object.
  864                  */
  865                 struct common_symbol *cp;
  866 
  867                 STAILQ_FOREACH(cp, &file->common, link) {
  868                         if (strcmp(cp->name, name) == 0) {
  869                                 KLD_DPF(SYM, ("linker_file_lookup_symbol:"
  870                                     " old common value=%p\n", cp->address));
  871                                 return (cp->address);
  872                         }
  873                 }
  874                 /*
  875                  * Round the symbol size up to align.
  876                  */
  877                 common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
  878                 cp = malloc(sizeof(struct common_symbol)
  879                     + common_size + strlen(name) + 1, M_LINKER,
  880                     M_WAITOK | M_ZERO);
  881                 cp->address = (caddr_t)(cp + 1);
  882                 cp->name = cp->address + common_size;
  883                 strcpy(cp->name, name);
  884                 bzero(cp->address, common_size);
  885                 STAILQ_INSERT_TAIL(&file->common, cp, link);
  886 
  887                 KLD_DPF(SYM, ("linker_file_lookup_symbol: new common"
  888                     " value=%p\n", cp->address));
  889                 return (cp->address);
  890         }
  891         KLD_DPF(SYM, ("linker_file_lookup_symbol: fail\n"));
  892         return (0);
  893 }
  894 
  895 /*
  896  * Both DDB and stack(9) rely on the kernel linker to provide forward and
  897  * backward lookup of symbols.  However, DDB and sometimes stack(9) need to
  898  * do this in a lockfree manner.  We provide a set of internal helper
  899  * routines to perform these operations without locks, and then wrappers that
  900  * optionally lock.
  901  *
  902  * linker_debug_lookup() is ifdef DDB as currently it's only used by DDB.
  903  */
  904 #ifdef DDB
  905 static int
  906 linker_debug_lookup(const char *symstr, c_linker_sym_t *sym)
  907 {
  908         linker_file_t lf;
  909 
  910         TAILQ_FOREACH(lf, &linker_files, link) {
  911                 if (LINKER_LOOKUP_SYMBOL(lf, symstr, sym) == 0)
  912                         return (0);
  913         }
  914         return (ENOENT);
  915 }
  916 #endif
  917 
  918 static int
  919 linker_debug_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
  920 {
  921         linker_file_t lf;
  922         c_linker_sym_t best, es;
  923         u_long diff, bestdiff, off;
  924 
  925         best = 0;
  926         off = (uintptr_t)value;
  927         bestdiff = off;
  928         TAILQ_FOREACH(lf, &linker_files, link) {
  929                 if (LINKER_SEARCH_SYMBOL(lf, value, &es, &diff) != 0)
  930                         continue;
  931                 if (es != 0 && diff < bestdiff) {
  932                         best = es;
  933                         bestdiff = diff;
  934                 }
  935                 if (bestdiff == 0)
  936                         break;
  937         }
  938         if (best) {
  939                 *sym = best;
  940                 *diffp = bestdiff;
  941                 return (0);
  942         } else {
  943                 *sym = 0;
  944                 *diffp = off;
  945                 return (ENOENT);
  946         }
  947 }
  948 
  949 static int
  950 linker_debug_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
  951 {
  952         linker_file_t lf;
  953 
  954         TAILQ_FOREACH(lf, &linker_files, link) {
  955                 if (LINKER_SYMBOL_VALUES(lf, sym, symval) == 0)
  956                         return (0);
  957         }
  958         return (ENOENT);
  959 }
  960 
  961 static int
  962 linker_debug_search_symbol_name(caddr_t value, char *buf, u_int buflen,
  963     long *offset)
  964 {
  965         linker_symval_t symval;
  966         c_linker_sym_t sym;
  967         int error;
  968 
  969         *offset = 0;
  970         error = linker_debug_search_symbol(value, &sym, offset);
  971         if (error)
  972                 return (error);
  973         error = linker_debug_symbol_values(sym, &symval);
  974         if (error)
  975                 return (error);
  976         strlcpy(buf, symval.name, buflen);
  977         return (0);
  978 }
  979 
  980 /*
  981  * DDB Helpers.  DDB has to look across multiple files with their own symbol
  982  * tables and string tables.
  983  *
  984  * Note that we do not obey list locking protocols here.  We really don't need
  985  * DDB to hang because somebody's got the lock held.  We'll take the chance
  986  * that the files list is inconsistent instead.
  987  */
  988 #ifdef DDB
  989 int
  990 linker_ddb_lookup(const char *symstr, c_linker_sym_t *sym)
  991 {
  992 
  993         return (linker_debug_lookup(symstr, sym));
  994 }
  995 #endif
  996 
  997 int
  998 linker_ddb_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
  999 {
 1000 
 1001         return (linker_debug_search_symbol(value, sym, diffp));
 1002 }
 1003 
 1004 int
 1005 linker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
 1006 {
 1007 
 1008         return (linker_debug_symbol_values(sym, symval));
 1009 }
 1010 
 1011 int
 1012 linker_ddb_search_symbol_name(caddr_t value, char *buf, u_int buflen,
 1013     long *offset)
 1014 {
 1015 
 1016         return (linker_debug_search_symbol_name(value, buf, buflen, offset));
 1017 }
 1018 
 1019 /*
 1020  * stack(9) helper for non-debugging environemnts.  Unlike DDB helpers, we do
 1021  * obey locking protocols, and offer a significantly less complex interface.
 1022  */
 1023 int
 1024 linker_search_symbol_name_flags(caddr_t value, char *buf, u_int buflen,
 1025     long *offset, int flags)
 1026 {
 1027         int error;
 1028 
 1029         KASSERT((flags & (M_NOWAIT | M_WAITOK)) != 0 &&
 1030             (flags & (M_NOWAIT | M_WAITOK)) != (M_NOWAIT | M_WAITOK),
 1031             ("%s: bad flags: 0x%x", __func__, flags));
 1032 
 1033         if (flags & M_NOWAIT) {
 1034                 if (!sx_try_slock(&kld_sx))
 1035                         return (EWOULDBLOCK);
 1036         } else
 1037                 sx_slock(&kld_sx);
 1038 
 1039         error = linker_debug_search_symbol_name(value, buf, buflen, offset);
 1040         sx_sunlock(&kld_sx);
 1041         return (error);
 1042 }
 1043 
 1044 int
 1045 linker_search_symbol_name(caddr_t value, char *buf, u_int buflen,
 1046     long *offset)
 1047 {
 1048 
 1049         return (linker_search_symbol_name_flags(value, buf, buflen, offset,
 1050             M_WAITOK));
 1051 }
 1052 
 1053 /*
 1054  * Syscalls.
 1055  */
 1056 int
 1057 kern_kldload(struct thread *td, const char *file, int *fileid)
 1058 {
 1059         const char *kldname, *modname;
 1060         linker_file_t lf;
 1061         int error;
 1062 
 1063         if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
 1064                 return (error);
 1065 
 1066         if ((error = priv_check(td, PRIV_KLD_LOAD)) != 0)
 1067                 return (error);
 1068 
 1069         /*
 1070          * It is possible that kldloaded module will attach a new ifnet,
 1071          * so vnet context must be set when this ocurs.
 1072          */
 1073         CURVNET_SET(TD_TO_VNET(td));
 1074 
 1075         /*
 1076          * If file does not contain a qualified name or any dot in it
 1077          * (kldname.ko, or kldname.ver.ko) treat it as an interface
 1078          * name.
 1079          */
 1080         if (strchr(file, '/') || strchr(file, '.')) {
 1081                 kldname = file;
 1082                 modname = NULL;
 1083         } else {
 1084                 kldname = NULL;
 1085                 modname = file;
 1086         }
 1087 
 1088         sx_xlock(&kld_sx);
 1089         error = linker_load_module(kldname, modname, NULL, NULL, &lf);
 1090         if (error) {
 1091                 sx_xunlock(&kld_sx);
 1092                 goto done;
 1093         }
 1094         lf->userrefs++;
 1095         if (fileid != NULL)
 1096                 *fileid = lf->id;
 1097         sx_xunlock(&kld_sx);
 1098 
 1099 done:
 1100         CURVNET_RESTORE();
 1101         return (error);
 1102 }
 1103 
 1104 int
 1105 sys_kldload(struct thread *td, struct kldload_args *uap)
 1106 {
 1107         char *pathname = NULL;
 1108         int error, fileid;
 1109 
 1110         td->td_retval[0] = -1;
 1111 
 1112         pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 1113         error = copyinstr(uap->file, pathname, MAXPATHLEN, NULL);
 1114         if (error == 0) {
 1115                 error = kern_kldload(td, pathname, &fileid);
 1116                 if (error == 0)
 1117                         td->td_retval[0] = fileid;
 1118         }
 1119         free(pathname, M_TEMP);
 1120         return (error);
 1121 }
 1122 
 1123 int
 1124 kern_kldunload(struct thread *td, int fileid, int flags)
 1125 {
 1126         linker_file_t lf;
 1127         int error = 0;
 1128 
 1129         if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
 1130                 return (error);
 1131 
 1132         if ((error = priv_check(td, PRIV_KLD_UNLOAD)) != 0)
 1133                 return (error);
 1134 
 1135         CURVNET_SET(TD_TO_VNET(td));
 1136         sx_xlock(&kld_sx);
 1137         lf = linker_find_file_by_id(fileid);
 1138         if (lf) {
 1139                 KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
 1140 
 1141                 if (lf->userrefs == 0) {
 1142                         /*
 1143                          * XXX: maybe LINKER_UNLOAD_FORCE should override ?
 1144                          */
 1145                         printf("kldunload: attempt to unload file that was"
 1146                             " loaded by the kernel\n");
 1147                         error = EBUSY;
 1148                 } else {
 1149                         lf->userrefs--;
 1150                         error = linker_file_unload(lf, flags);
 1151                         if (error)
 1152                                 lf->userrefs++;
 1153                 }
 1154         } else
 1155                 error = ENOENT;
 1156         sx_xunlock(&kld_sx);
 1157 
 1158         CURVNET_RESTORE();
 1159         return (error);
 1160 }
 1161 
 1162 int
 1163 sys_kldunload(struct thread *td, struct kldunload_args *uap)
 1164 {
 1165 
 1166         return (kern_kldunload(td, uap->fileid, LINKER_UNLOAD_NORMAL));
 1167 }
 1168 
 1169 int
 1170 sys_kldunloadf(struct thread *td, struct kldunloadf_args *uap)
 1171 {
 1172 
 1173         if (uap->flags != LINKER_UNLOAD_NORMAL &&
 1174             uap->flags != LINKER_UNLOAD_FORCE)
 1175                 return (EINVAL);
 1176         return (kern_kldunload(td, uap->fileid, uap->flags));
 1177 }
 1178 
 1179 int
 1180 sys_kldfind(struct thread *td, struct kldfind_args *uap)
 1181 {
 1182         char *pathname;
 1183         const char *filename;
 1184         linker_file_t lf;
 1185         int error;
 1186 
 1187 #ifdef MAC
 1188         error = mac_kld_check_stat(td->td_ucred);
 1189         if (error)
 1190                 return (error);
 1191 #endif
 1192 
 1193         td->td_retval[0] = -1;
 1194 
 1195         pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 1196         if ((error = copyinstr(uap->file, pathname, MAXPATHLEN, NULL)) != 0)
 1197                 goto out;
 1198 
 1199         filename = linker_basename(pathname);
 1200         sx_xlock(&kld_sx);
 1201         lf = linker_find_file_by_name(filename);
 1202         if (lf)
 1203                 td->td_retval[0] = lf->id;
 1204         else
 1205                 error = ENOENT;
 1206         sx_xunlock(&kld_sx);
 1207 out:
 1208         free(pathname, M_TEMP);
 1209         return (error);
 1210 }
 1211 
 1212 int
 1213 sys_kldnext(struct thread *td, struct kldnext_args *uap)
 1214 {
 1215         linker_file_t lf;
 1216         int error = 0;
 1217 
 1218 #ifdef MAC
 1219         error = mac_kld_check_stat(td->td_ucred);
 1220         if (error)
 1221                 return (error);
 1222 #endif
 1223 
 1224         sx_xlock(&kld_sx);
 1225         if (uap->fileid == 0)
 1226                 lf = TAILQ_FIRST(&linker_files);
 1227         else {
 1228                 lf = linker_find_file_by_id(uap->fileid);
 1229                 if (lf == NULL) {
 1230                         error = ENOENT;
 1231                         goto out;
 1232                 }
 1233                 lf = TAILQ_NEXT(lf, link);
 1234         }
 1235 
 1236         /* Skip partially loaded files. */
 1237         while (lf != NULL && !(lf->flags & LINKER_FILE_LINKED))
 1238                 lf = TAILQ_NEXT(lf, link);
 1239 
 1240         if (lf)
 1241                 td->td_retval[0] = lf->id;
 1242         else
 1243                 td->td_retval[0] = 0;
 1244 out:
 1245         sx_xunlock(&kld_sx);
 1246         return (error);
 1247 }
 1248 
 1249 int
 1250 sys_kldstat(struct thread *td, struct kldstat_args *uap)
 1251 {
 1252         struct kld_file_stat *stat;
 1253         int error, version;
 1254 
 1255         /*
 1256          * Check the version of the user's structure.
 1257          */
 1258         if ((error = copyin(&uap->stat->version, &version, sizeof(version)))
 1259             != 0)
 1260                 return (error);
 1261         if (version != sizeof(struct kld_file_stat_1) &&
 1262             version != sizeof(struct kld_file_stat))
 1263                 return (EINVAL);
 1264 
 1265         stat = malloc(sizeof(*stat), M_TEMP, M_WAITOK | M_ZERO);
 1266         error = kern_kldstat(td, uap->fileid, stat);
 1267         if (error == 0)
 1268                 error = copyout(stat, uap->stat, version);
 1269         free(stat, M_TEMP);
 1270         return (error);
 1271 }
 1272 
 1273 int
 1274 kern_kldstat(struct thread *td, int fileid, struct kld_file_stat *stat)
 1275 {
 1276         linker_file_t lf;
 1277         int namelen;
 1278 #ifdef MAC
 1279         int error;
 1280 
 1281         error = mac_kld_check_stat(td->td_ucred);
 1282         if (error)
 1283                 return (error);
 1284 #endif
 1285 
 1286         sx_xlock(&kld_sx);
 1287         lf = linker_find_file_by_id(fileid);
 1288         if (lf == NULL) {
 1289                 sx_xunlock(&kld_sx);
 1290                 return (ENOENT);
 1291         }
 1292 
 1293         /* Version 1 fields: */
 1294         namelen = strlen(lf->filename) + 1;
 1295         if (namelen > sizeof(stat->name))
 1296                 namelen = sizeof(stat->name);
 1297         bcopy(lf->filename, &stat->name[0], namelen);
 1298         stat->refs = lf->refs;
 1299         stat->id = lf->id;
 1300         stat->address = lf->address;
 1301         stat->size = lf->size;
 1302         /* Version 2 fields: */
 1303         namelen = strlen(lf->pathname) + 1;
 1304         if (namelen > sizeof(stat->pathname))
 1305                 namelen = sizeof(stat->pathname);
 1306         bcopy(lf->pathname, &stat->pathname[0], namelen);
 1307         sx_xunlock(&kld_sx);
 1308 
 1309         td->td_retval[0] = 0;
 1310         return (0);
 1311 }
 1312 
 1313 #ifdef DDB
 1314 DB_COMMAND(kldstat, db_kldstat)
 1315 {
 1316         linker_file_t lf;
 1317 
 1318 #define POINTER_WIDTH   ((int)(sizeof(void *) * 2 + 2))
 1319         db_printf("Id Refs Address%*c Size     Name\n", POINTER_WIDTH - 7, ' ');
 1320 #undef  POINTER_WIDTH
 1321         TAILQ_FOREACH(lf, &linker_files, link) {
 1322                 if (db_pager_quit)
 1323                         return;
 1324                 db_printf("%2d %4d %p %-8zx %s\n", lf->id, lf->refs,
 1325                     lf->address, lf->size, lf->filename);
 1326         }
 1327 }
 1328 #endif /* DDB */
 1329 
 1330 int
 1331 sys_kldfirstmod(struct thread *td, struct kldfirstmod_args *uap)
 1332 {
 1333         linker_file_t lf;
 1334         module_t mp;
 1335         int error = 0;
 1336 
 1337 #ifdef MAC
 1338         error = mac_kld_check_stat(td->td_ucred);
 1339         if (error)
 1340                 return (error);
 1341 #endif
 1342 
 1343         sx_xlock(&kld_sx);
 1344         lf = linker_find_file_by_id(uap->fileid);
 1345         if (lf) {
 1346                 MOD_SLOCK;
 1347                 mp = TAILQ_FIRST(&lf->modules);
 1348                 if (mp != NULL)
 1349                         td->td_retval[0] = module_getid(mp);
 1350                 else
 1351                         td->td_retval[0] = 0;
 1352                 MOD_SUNLOCK;
 1353         } else
 1354                 error = ENOENT;
 1355         sx_xunlock(&kld_sx);
 1356         return (error);
 1357 }
 1358 
 1359 int
 1360 sys_kldsym(struct thread *td, struct kldsym_args *uap)
 1361 {
 1362         char *symstr = NULL;
 1363         c_linker_sym_t sym;
 1364         linker_symval_t symval;
 1365         linker_file_t lf;
 1366         struct kld_sym_lookup lookup;
 1367         int error = 0;
 1368 
 1369 #ifdef MAC
 1370         error = mac_kld_check_stat(td->td_ucred);
 1371         if (error)
 1372                 return (error);
 1373 #endif
 1374 
 1375         if ((error = copyin(uap->data, &lookup, sizeof(lookup))) != 0)
 1376                 return (error);
 1377         if (lookup.version != sizeof(lookup) ||
 1378             uap->cmd != KLDSYM_LOOKUP)
 1379                 return (EINVAL);
 1380         symstr = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 1381         if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
 1382                 goto out;
 1383         sx_xlock(&kld_sx);
 1384         if (uap->fileid != 0) {
 1385                 lf = linker_find_file_by_id(uap->fileid);
 1386                 if (lf == NULL)
 1387                         error = ENOENT;
 1388                 else if (LINKER_LOOKUP_SYMBOL(lf, symstr, &sym) == 0 &&
 1389                     LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
 1390                         lookup.symvalue = (uintptr_t) symval.value;
 1391                         lookup.symsize = symval.size;
 1392                         error = copyout(&lookup, uap->data, sizeof(lookup));
 1393                 } else
 1394                         error = ENOENT;
 1395         } else {
 1396                 TAILQ_FOREACH(lf, &linker_files, link) {
 1397                         if (LINKER_LOOKUP_SYMBOL(lf, symstr, &sym) == 0 &&
 1398                             LINKER_SYMBOL_VALUES(lf, sym, &symval) == 0) {
 1399                                 lookup.symvalue = (uintptr_t)symval.value;
 1400                                 lookup.symsize = symval.size;
 1401                                 error = copyout(&lookup, uap->data,
 1402                                     sizeof(lookup));
 1403                                 break;
 1404                         }
 1405                 }
 1406                 if (lf == NULL)
 1407                         error = ENOENT;
 1408         }
 1409         sx_xunlock(&kld_sx);
 1410 out:
 1411         free(symstr, M_TEMP);
 1412         return (error);
 1413 }
 1414 
 1415 /*
 1416  * Preloaded module support
 1417  */
 1418 
 1419 static modlist_t
 1420 modlist_lookup(const char *name, int ver)
 1421 {
 1422         modlist_t mod;
 1423 
 1424         TAILQ_FOREACH(mod, &found_modules, link) {
 1425                 if (strcmp(mod->name, name) == 0 &&
 1426                     (ver == 0 || mod->version == ver))
 1427                         return (mod);
 1428         }
 1429         return (NULL);
 1430 }
 1431 
 1432 static modlist_t
 1433 modlist_lookup2(const char *name, const struct mod_depend *verinfo)
 1434 {
 1435         modlist_t mod, bestmod;
 1436         int ver;
 1437 
 1438         if (verinfo == NULL)
 1439                 return (modlist_lookup(name, 0));
 1440         bestmod = NULL;
 1441         TAILQ_FOREACH(mod, &found_modules, link) {
 1442                 if (strcmp(mod->name, name) != 0)
 1443                         continue;
 1444                 ver = mod->version;
 1445                 if (ver == verinfo->md_ver_preferred)
 1446                         return (mod);
 1447                 if (ver >= verinfo->md_ver_minimum &&
 1448                     ver <= verinfo->md_ver_maximum &&
 1449                     (bestmod == NULL || ver > bestmod->version))
 1450                         bestmod = mod;
 1451         }
 1452         return (bestmod);
 1453 }
 1454 
 1455 static modlist_t
 1456 modlist_newmodule(const char *modname, int version, linker_file_t container)
 1457 {
 1458         modlist_t mod;
 1459 
 1460         mod = malloc(sizeof(struct modlist), M_LINKER, M_NOWAIT | M_ZERO);
 1461         if (mod == NULL)
 1462                 panic("no memory for module list");
 1463         mod->container = container;
 1464         mod->name = modname;
 1465         mod->version = version;
 1466         TAILQ_INSERT_TAIL(&found_modules, mod, link);
 1467         return (mod);
 1468 }
 1469 
 1470 static void
 1471 linker_addmodules(linker_file_t lf, struct mod_metadata **start,
 1472     struct mod_metadata **stop, int preload)
 1473 {
 1474         struct mod_metadata *mp, **mdp;
 1475         const char *modname;
 1476         int ver;
 1477 
 1478         for (mdp = start; mdp < stop; mdp++) {
 1479                 mp = *mdp;
 1480                 if (mp->md_type != MDT_VERSION)
 1481                         continue;
 1482                 modname = mp->md_cval;
 1483                 ver = ((const struct mod_version *)mp->md_data)->mv_version;
 1484                 if (modlist_lookup(modname, ver) != NULL) {
 1485                         printf("module %s already present!\n", modname);
 1486                         /* XXX what can we do? this is a build error. :-( */
 1487                         continue;
 1488                 }
 1489                 modlist_newmodule(modname, ver, lf);
 1490         }
 1491 }
 1492 
 1493 static void
 1494 linker_preload(void *arg)
 1495 {
 1496         caddr_t modptr;
 1497         const char *modname, *nmodname;
 1498         char *modtype;
 1499         linker_file_t lf, nlf;
 1500         linker_class_t lc;
 1501         int error;
 1502         linker_file_list_t loaded_files;
 1503         linker_file_list_t depended_files;
 1504         struct mod_metadata *mp, *nmp;
 1505         struct mod_metadata **start, **stop, **mdp, **nmdp;
 1506         const struct mod_depend *verinfo;
 1507         int nver;
 1508         int resolves;
 1509         modlist_t mod;
 1510         struct sysinit **si_start, **si_stop;
 1511 
 1512         TAILQ_INIT(&loaded_files);
 1513         TAILQ_INIT(&depended_files);
 1514         TAILQ_INIT(&found_modules);
 1515         error = 0;
 1516 
 1517         modptr = NULL;
 1518         sx_xlock(&kld_sx);
 1519         while ((modptr = preload_search_next_name(modptr)) != NULL) {
 1520                 modname = (char *)preload_search_info(modptr, MODINFO_NAME);
 1521                 modtype = (char *)preload_search_info(modptr, MODINFO_TYPE);
 1522                 if (modname == NULL) {
 1523                         printf("Preloaded module at %p does not have a"
 1524                             " name!\n", modptr);
 1525                         continue;
 1526                 }
 1527                 if (modtype == NULL) {
 1528                         printf("Preloaded module at %p does not have a type!\n",
 1529                             modptr);
 1530                         continue;
 1531                 }
 1532                 if (bootverbose)
 1533                         printf("Preloaded %s \"%s\" at %p.\n", modtype, modname,
 1534                             modptr);
 1535                 lf = NULL;
 1536                 TAILQ_FOREACH(lc, &classes, link) {
 1537                         error = LINKER_LINK_PRELOAD(lc, modname, &lf);
 1538                         if (!error)
 1539                                 break;
 1540                         lf = NULL;
 1541                 }
 1542                 if (lf)
 1543                         TAILQ_INSERT_TAIL(&loaded_files, lf, loaded);
 1544         }
 1545 
 1546         /*
 1547          * First get a list of stuff in the kernel.
 1548          */
 1549         if (linker_file_lookup_set(linker_kernel_file, MDT_SETNAME, &start,
 1550             &stop, NULL) == 0)
 1551                 linker_addmodules(linker_kernel_file, start, stop, 1);
 1552 
 1553         /*
 1554          * This is a once-off kinky bubble sort to resolve relocation
 1555          * dependency requirements.
 1556          */
 1557 restart:
 1558         TAILQ_FOREACH(lf, &loaded_files, loaded) {
 1559                 error = linker_file_lookup_set(lf, MDT_SETNAME, &start,
 1560                     &stop, NULL);
 1561                 /*
 1562                  * First, look to see if we would successfully link with this
 1563                  * stuff.
 1564                  */
 1565                 resolves = 1;   /* unless we know otherwise */
 1566                 if (!error) {
 1567                         for (mdp = start; mdp < stop; mdp++) {
 1568                                 mp = *mdp;
 1569                                 if (mp->md_type != MDT_DEPEND)
 1570                                         continue;
 1571                                 modname = mp->md_cval;
 1572                                 verinfo = mp->md_data;
 1573                                 for (nmdp = start; nmdp < stop; nmdp++) {
 1574                                         nmp = *nmdp;
 1575                                         if (nmp->md_type != MDT_VERSION)
 1576                                                 continue;
 1577                                         nmodname = nmp->md_cval;
 1578                                         if (strcmp(modname, nmodname) == 0)
 1579                                                 break;
 1580                                 }
 1581                                 if (nmdp < stop)   /* it's a self reference */
 1582                                         continue;
 1583 
 1584                                 /*
 1585                                  * ok, the module isn't here yet, we
 1586                                  * are not finished
 1587                                  */
 1588                                 if (modlist_lookup2(modname, verinfo) == NULL)
 1589                                         resolves = 0;
 1590                         }
 1591                 }
 1592                 /*
 1593                  * OK, if we found our modules, we can link.  So, "provide"
 1594                  * the modules inside and add it to the end of the link order
 1595                  * list.
 1596                  */
 1597                 if (resolves) {
 1598                         if (!error) {
 1599                                 for (mdp = start; mdp < stop; mdp++) {
 1600                                         mp = *mdp;
 1601                                         if (mp->md_type != MDT_VERSION)
 1602                                                 continue;
 1603                                         modname = mp->md_cval;
 1604                                         nver = ((const struct mod_version *)
 1605                                             mp->md_data)->mv_version;
 1606                                         if (modlist_lookup(modname,
 1607                                             nver) != NULL) {
 1608                                                 printf("module %s already"
 1609                                                     " present!\n", modname);
 1610                                                 TAILQ_REMOVE(&loaded_files,
 1611                                                     lf, loaded);
 1612                                                 linker_file_unload(lf,
 1613                                                     LINKER_UNLOAD_FORCE);
 1614                                                 /* we changed tailq next ptr */
 1615                                                 goto restart;
 1616                                         }
 1617                                         modlist_newmodule(modname, nver, lf);
 1618                                 }
 1619                         }
 1620                         TAILQ_REMOVE(&loaded_files, lf, loaded);
 1621                         TAILQ_INSERT_TAIL(&depended_files, lf, loaded);
 1622                         /*
 1623                          * Since we provided modules, we need to restart the
 1624                          * sort so that the previous files that depend on us
 1625                          * have a chance. Also, we've busted the tailq next
 1626                          * pointer with the REMOVE.
 1627                          */
 1628                         goto restart;
 1629                 }
 1630         }
 1631 
 1632         /*
 1633          * At this point, we check to see what could not be resolved..
 1634          */
 1635         while ((lf = TAILQ_FIRST(&loaded_files)) != NULL) {
 1636                 TAILQ_REMOVE(&loaded_files, lf, loaded);
 1637                 printf("KLD file %s is missing dependencies\n", lf->filename);
 1638                 linker_file_unload(lf, LINKER_UNLOAD_FORCE);
 1639         }
 1640 
 1641         /*
 1642          * We made it. Finish off the linking in the order we determined.
 1643          */
 1644         TAILQ_FOREACH_SAFE(lf, &depended_files, loaded, nlf) {
 1645                 if (linker_kernel_file) {
 1646                         linker_kernel_file->refs++;
 1647                         error = linker_file_add_dependency(lf,
 1648                             linker_kernel_file);
 1649                         if (error)
 1650                                 panic("cannot add dependency");
 1651                 }
 1652                 error = linker_file_lookup_set(lf, MDT_SETNAME, &start,
 1653                     &stop, NULL);
 1654                 if (!error) {
 1655                         for (mdp = start; mdp < stop; mdp++) {
 1656                                 mp = *mdp;
 1657                                 if (mp->md_type != MDT_DEPEND)
 1658                                         continue;
 1659                                 modname = mp->md_cval;
 1660                                 verinfo = mp->md_data;
 1661                                 mod = modlist_lookup2(modname, verinfo);
 1662                                 if (mod == NULL) {
 1663                                         printf("KLD file %s - cannot find "
 1664                                             "dependency \"%s\"\n",
 1665                                             lf->filename, modname);
 1666                                         goto fail;
 1667                                 }
 1668                                 /* Don't count self-dependencies */
 1669                                 if (lf == mod->container)
 1670                                         continue;
 1671                                 mod->container->refs++;
 1672                                 error = linker_file_add_dependency(lf,
 1673                                     mod->container);
 1674                                 if (error)
 1675                                         panic("cannot add dependency");
 1676                         }
 1677                 }
 1678                 /*
 1679                  * Now do relocation etc using the symbol search paths
 1680                  * established by the dependencies
 1681                  */
 1682                 error = LINKER_LINK_PRELOAD_FINISH(lf);
 1683                 if (error) {
 1684                         printf("KLD file %s - could not finalize loading\n",
 1685                             lf->filename);
 1686                         goto fail;
 1687                 }
 1688                 linker_file_register_modules(lf);
 1689                 if (!TAILQ_EMPTY(&lf->modules))
 1690                         lf->flags |= LINKER_FILE_MODULES;
 1691                 if (linker_file_lookup_set(lf, "sysinit_set", &si_start,
 1692                     &si_stop, NULL) == 0)
 1693                         sysinit_add(si_start, si_stop);
 1694                 linker_file_register_sysctls(lf, true);
 1695                 lf->flags |= LINKER_FILE_LINKED;
 1696                 continue;
 1697 fail:
 1698                 TAILQ_REMOVE(&depended_files, lf, loaded);
 1699                 linker_file_unload(lf, LINKER_UNLOAD_FORCE);
 1700         }
 1701         sx_xunlock(&kld_sx);
 1702         /* woohoo! we made it! */
 1703 }
 1704 
 1705 SYSINIT(preload, SI_SUB_KLD, SI_ORDER_MIDDLE, linker_preload, NULL);
 1706 
 1707 /*
 1708  * Handle preload files that failed to load any modules.
 1709  */
 1710 static void
 1711 linker_preload_finish(void *arg)
 1712 {
 1713         linker_file_t lf, nlf;
 1714 
 1715         sx_xlock(&kld_sx);
 1716         TAILQ_FOREACH_SAFE(lf, &linker_files, link, nlf) {
 1717                 /*
 1718                  * If all of the modules in this file failed to load, unload
 1719                  * the file and return an error of ENOEXEC.  (Parity with
 1720                  * linker_load_file.)
 1721                  */
 1722                 if ((lf->flags & LINKER_FILE_MODULES) != 0 &&
 1723                     TAILQ_EMPTY(&lf->modules)) {
 1724                         linker_file_unload(lf, LINKER_UNLOAD_FORCE);
 1725                         continue;
 1726                 }
 1727 
 1728                 lf->flags &= ~LINKER_FILE_MODULES;
 1729                 lf->userrefs++; /* so we can (try to) kldunload it */
 1730         }
 1731         sx_xunlock(&kld_sx);
 1732 }
 1733 
 1734 /*
 1735  * Attempt to run after all DECLARE_MODULE SYSINITs.  Unfortunately they can be
 1736  * scheduled at any subsystem and order, so run this as late as possible.  init
 1737  * becomes runnable in SI_SUB_KTHREAD_INIT, so go slightly before that.
 1738  */
 1739 SYSINIT(preload_finish, SI_SUB_KTHREAD_INIT - 100, SI_ORDER_MIDDLE,
 1740     linker_preload_finish, NULL);
 1741 
 1742 /*
 1743  * Search for a not-loaded module by name.
 1744  *
 1745  * Modules may be found in the following locations:
 1746  *
 1747  * - preloaded (result is just the module name) - on disk (result is full path
 1748  * to module)
 1749  *
 1750  * If the module name is qualified in any way (contains path, etc.) the we
 1751  * simply return a copy of it.
 1752  *
 1753  * The search path can be manipulated via sysctl.  Note that we use the ';'
 1754  * character as a separator to be consistent with the bootloader.
 1755  */
 1756 
 1757 static char linker_hintfile[] = "linker.hints";
 1758 static char linker_path[MAXPATHLEN] = "/boot/kernel;/boot/modules";
 1759 
 1760 SYSCTL_STRING(_kern, OID_AUTO, module_path, CTLFLAG_RWTUN, linker_path,
 1761     sizeof(linker_path), "module load search path");
 1762 
 1763 TUNABLE_STR("module_path", linker_path, sizeof(linker_path));
 1764 
 1765 static char *linker_ext_list[] = {
 1766         "",
 1767         ".ko",
 1768         NULL
 1769 };
 1770 
 1771 /*
 1772  * Check if file actually exists either with or without extension listed in
 1773  * the linker_ext_list. (probably should be generic for the rest of the
 1774  * kernel)
 1775  */
 1776 static char *
 1777 linker_lookup_file(const char *path, int pathlen, const char *name,
 1778     int namelen, struct vattr *vap)
 1779 {
 1780         struct nameidata nd;
 1781         struct thread *td = curthread;  /* XXX */
 1782         char *result, **cpp, *sep;
 1783         int error, len, extlen, reclen, flags;
 1784         enum vtype type;
 1785 
 1786         extlen = 0;
 1787         for (cpp = linker_ext_list; *cpp; cpp++) {
 1788                 len = strlen(*cpp);
 1789                 if (len > extlen)
 1790                         extlen = len;
 1791         }
 1792         extlen++;               /* trailing '\0' */
 1793         sep = (path[pathlen - 1] != '/') ? "/" : "";
 1794 
 1795         reclen = pathlen + strlen(sep) + namelen + extlen + 1;
 1796         result = malloc(reclen, M_LINKER, M_WAITOK);
 1797         for (cpp = linker_ext_list; *cpp; cpp++) {
 1798                 snprintf(result, reclen, "%.*s%s%.*s%s", pathlen, path, sep,
 1799                     namelen, name, *cpp);
 1800                 /*
 1801                  * Attempt to open the file, and return the path if
 1802                  * we succeed and it's a regular file.
 1803                  */
 1804                 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, result, td);
 1805                 flags = FREAD;
 1806                 error = vn_open(&nd, &flags, 0, NULL);
 1807                 if (error == 0) {
 1808                         NDFREE(&nd, NDF_ONLY_PNBUF);
 1809                         type = nd.ni_vp->v_type;
 1810                         if (vap)
 1811                                 VOP_GETATTR(nd.ni_vp, vap, td->td_ucred);
 1812                         VOP_UNLOCK(nd.ni_vp, 0);
 1813                         vn_close(nd.ni_vp, FREAD, td->td_ucred, td);
 1814                         if (type == VREG)
 1815                                 return (result);
 1816                 }
 1817         }
 1818         free(result, M_LINKER);
 1819         return (NULL);
 1820 }
 1821 
 1822 #define INT_ALIGN(base, ptr)    ptr =                                   \
 1823         (base) + roundup2((ptr) - (base), sizeof(int))
 1824 
 1825 /*
 1826  * Lookup KLD which contains requested module in the "linker.hints" file. If
 1827  * version specification is available, then try to find the best KLD.
 1828  * Otherwise just find the latest one.
 1829  */
 1830 static char *
 1831 linker_hints_lookup(const char *path, int pathlen, const char *modname,
 1832     int modnamelen, const struct mod_depend *verinfo)
 1833 {
 1834         struct thread *td = curthread;  /* XXX */
 1835         struct ucred *cred = td ? td->td_ucred : NULL;
 1836         struct nameidata nd;
 1837         struct vattr vattr, mattr;
 1838         u_char *hints = NULL;
 1839         u_char *cp, *recptr, *bufend, *result, *best, *pathbuf, *sep;
 1840         int error, ival, bestver, *intp, found, flags, clen, blen;
 1841         ssize_t reclen;
 1842 
 1843         result = NULL;
 1844         bestver = found = 0;
 1845 
 1846         sep = (path[pathlen - 1] != '/') ? "/" : "";
 1847         reclen = imax(modnamelen, strlen(linker_hintfile)) + pathlen +
 1848             strlen(sep) + 1;
 1849         pathbuf = malloc(reclen, M_LINKER, M_WAITOK);
 1850         snprintf(pathbuf, reclen, "%.*s%s%s", pathlen, path, sep,
 1851             linker_hintfile);
 1852 
 1853         NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, pathbuf, td);
 1854         flags = FREAD;
 1855         error = vn_open(&nd, &flags, 0, NULL);
 1856         if (error)
 1857                 goto bad;
 1858         NDFREE(&nd, NDF_ONLY_PNBUF);
 1859         if (nd.ni_vp->v_type != VREG)
 1860                 goto bad;
 1861         best = cp = NULL;
 1862         error = VOP_GETATTR(nd.ni_vp, &vattr, cred);
 1863         if (error)
 1864                 goto bad;
 1865         /*
 1866          * XXX: we need to limit this number to some reasonable value
 1867          */
 1868         if (vattr.va_size > LINKER_HINTS_MAX) {
 1869                 printf("hints file too large %ld\n", (long)vattr.va_size);
 1870                 goto bad;
 1871         }
 1872         hints = malloc(vattr.va_size, M_TEMP, M_WAITOK);
 1873         error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)hints, vattr.va_size, 0,
 1874             UIO_SYSSPACE, IO_NODELOCKED, cred, NOCRED, &reclen, td);
 1875         if (error)
 1876                 goto bad;
 1877         VOP_UNLOCK(nd.ni_vp, 0);
 1878         vn_close(nd.ni_vp, FREAD, cred, td);
 1879         nd.ni_vp = NULL;
 1880         if (reclen != 0) {
 1881                 printf("can't read %zd\n", reclen);
 1882                 goto bad;
 1883         }
 1884         intp = (int *)hints;
 1885         ival = *intp++;
 1886         if (ival != LINKER_HINTS_VERSION) {
 1887                 printf("hints file version mismatch %d\n", ival);
 1888                 goto bad;
 1889         }
 1890         bufend = hints + vattr.va_size;
 1891         recptr = (u_char *)intp;
 1892         clen = blen = 0;
 1893         while (recptr < bufend && !found) {
 1894                 intp = (int *)recptr;
 1895                 reclen = *intp++;
 1896                 ival = *intp++;
 1897                 cp = (char *)intp;
 1898                 switch (ival) {
 1899                 case MDT_VERSION:
 1900                         clen = *cp++;
 1901                         if (clen != modnamelen || bcmp(cp, modname, clen) != 0)
 1902                                 break;
 1903                         cp += clen;
 1904                         INT_ALIGN(hints, cp);
 1905                         ival = *(int *)cp;
 1906                         cp += sizeof(int);
 1907                         clen = *cp++;
 1908                         if (verinfo == NULL ||
 1909                             ival == verinfo->md_ver_preferred) {
 1910                                 found = 1;
 1911                                 break;
 1912                         }
 1913                         if (ival >= verinfo->md_ver_minimum &&
 1914                             ival <= verinfo->md_ver_maximum &&
 1915                             ival > bestver) {
 1916                                 bestver = ival;
 1917                                 best = cp;
 1918                                 blen = clen;
 1919                         }
 1920                         break;
 1921                 default:
 1922                         break;
 1923                 }
 1924                 recptr += reclen + sizeof(int);
 1925         }
 1926         /*
 1927          * Finally check if KLD is in the place
 1928          */
 1929         if (found)
 1930                 result = linker_lookup_file(path, pathlen, cp, clen, &mattr);
 1931         else if (best)
 1932                 result = linker_lookup_file(path, pathlen, best, blen, &mattr);
 1933 
 1934         /*
 1935          * KLD is newer than hints file. What we should do now?
 1936          */
 1937         if (result && timespeccmp(&mattr.va_mtime, &vattr.va_mtime, >))
 1938                 printf("warning: KLD '%s' is newer than the linker.hints"
 1939                     " file\n", result);
 1940 bad:
 1941         free(pathbuf, M_LINKER);
 1942         if (hints)
 1943                 free(hints, M_TEMP);
 1944         if (nd.ni_vp != NULL) {
 1945                 VOP_UNLOCK(nd.ni_vp, 0);
 1946                 vn_close(nd.ni_vp, FREAD, cred, td);
 1947         }
 1948         /*
 1949          * If nothing found or hints is absent - fallback to the old
 1950          * way by using "kldname[.ko]" as module name.
 1951          */
 1952         if (!found && !bestver && result == NULL)
 1953                 result = linker_lookup_file(path, pathlen, modname,
 1954                     modnamelen, NULL);
 1955         return (result);
 1956 }
 1957 
 1958 /*
 1959  * Lookup KLD which contains requested module in the all directories.
 1960  */
 1961 static char *
 1962 linker_search_module(const char *modname, int modnamelen,
 1963     const struct mod_depend *verinfo)
 1964 {
 1965         char *cp, *ep, *result;
 1966 
 1967         /*
 1968          * traverse the linker path
 1969          */
 1970         for (cp = linker_path; *cp; cp = ep + 1) {
 1971                 /* find the end of this component */
 1972                 for (ep = cp; (*ep != 0) && (*ep != ';'); ep++);
 1973                 result = linker_hints_lookup(cp, ep - cp, modname,
 1974                     modnamelen, verinfo);
 1975                 if (result != NULL)
 1976                         return (result);
 1977                 if (*ep == 0)
 1978                         break;
 1979         }
 1980         return (NULL);
 1981 }
 1982 
 1983 /*
 1984  * Search for module in all directories listed in the linker_path.
 1985  */
 1986 static char *
 1987 linker_search_kld(const char *name)
 1988 {
 1989         char *cp, *ep, *result;
 1990         int len;
 1991 
 1992         /* qualified at all? */
 1993         if (strchr(name, '/'))
 1994                 return (strdup(name, M_LINKER));
 1995 
 1996         /* traverse the linker path */
 1997         len = strlen(name);
 1998         for (ep = linker_path; *ep; ep++) {
 1999                 cp = ep;
 2000                 /* find the end of this component */
 2001                 for (; *ep != 0 && *ep != ';'; ep++);
 2002                 result = linker_lookup_file(cp, ep - cp, name, len, NULL);
 2003                 if (result != NULL)
 2004                         return (result);
 2005         }
 2006         return (NULL);
 2007 }
 2008 
 2009 static const char *
 2010 linker_basename(const char *path)
 2011 {
 2012         const char *filename;
 2013 
 2014         filename = strrchr(path, '/');
 2015         if (filename == NULL)
 2016                 return path;
 2017         if (filename[1])
 2018                 filename++;
 2019         return (filename);
 2020 }
 2021 
 2022 #ifdef HWPMC_HOOKS
 2023 /*
 2024  * Inform hwpmc about the set of kernel modules currently loaded.
 2025  */
 2026 void *
 2027 linker_hwpmc_list_objects(void)
 2028 {
 2029         linker_file_t lf;
 2030         struct pmckern_map_in *kobase;
 2031         int i, nmappings;
 2032 
 2033         nmappings = 0;
 2034         sx_slock(&kld_sx);
 2035         TAILQ_FOREACH(lf, &linker_files, link)
 2036                 nmappings++;
 2037 
 2038         /* Allocate nmappings + 1 entries. */
 2039         kobase = malloc((nmappings + 1) * sizeof(struct pmckern_map_in),
 2040             M_LINKER, M_WAITOK | M_ZERO);
 2041         i = 0;
 2042         TAILQ_FOREACH(lf, &linker_files, link) {
 2043 
 2044                 /* Save the info for this linker file. */
 2045                 kobase[i].pm_file = lf->filename;
 2046                 kobase[i].pm_address = (uintptr_t)lf->address;
 2047                 i++;
 2048         }
 2049         sx_sunlock(&kld_sx);
 2050 
 2051         KASSERT(i > 0, ("linker_hpwmc_list_objects: no kernel objects?"));
 2052 
 2053         /* The last entry of the malloced area comprises of all zeros. */
 2054         KASSERT(kobase[i].pm_file == NULL,
 2055             ("linker_hwpmc_list_objects: last object not NULL"));
 2056 
 2057         return ((void *)kobase);
 2058 }
 2059 #endif
 2060 
 2061 /*
 2062  * Find a file which contains given module and load it, if "parent" is not
 2063  * NULL, register a reference to it.
 2064  */
 2065 static int
 2066 linker_load_module(const char *kldname, const char *modname,
 2067     struct linker_file *parent, const struct mod_depend *verinfo,
 2068     struct linker_file **lfpp)
 2069 {
 2070         linker_file_t lfdep;
 2071         const char *filename;
 2072         char *pathname;
 2073         int error;
 2074 
 2075         sx_assert(&kld_sx, SA_XLOCKED);
 2076         if (modname == NULL) {
 2077                 /*
 2078                  * We have to load KLD
 2079                  */
 2080                 KASSERT(verinfo == NULL, ("linker_load_module: verinfo"
 2081                     " is not NULL"));
 2082                 pathname = linker_search_kld(kldname);
 2083         } else {
 2084                 if (modlist_lookup2(modname, verinfo) != NULL)
 2085                         return (EEXIST);
 2086                 if (kldname != NULL)
 2087                         pathname = strdup(kldname, M_LINKER);
 2088                 else if (rootvnode == NULL)
 2089                         pathname = NULL;
 2090                 else
 2091                         /*
 2092                          * Need to find a KLD with required module
 2093                          */
 2094                         pathname = linker_search_module(modname,
 2095                             strlen(modname), verinfo);
 2096         }
 2097         if (pathname == NULL)
 2098                 return (ENOENT);
 2099 
 2100         /*
 2101          * Can't load more than one file with the same basename XXX:
 2102          * Actually it should be possible to have multiple KLDs with
 2103          * the same basename but different path because they can
 2104          * provide different versions of the same modules.
 2105          */
 2106         filename = linker_basename(pathname);
 2107         if (linker_find_file_by_name(filename))
 2108                 error = EEXIST;
 2109         else do {
 2110                 error = linker_load_file(pathname, &lfdep);
 2111                 if (error)
 2112                         break;
 2113                 if (modname && verinfo &&
 2114                     modlist_lookup2(modname, verinfo) == NULL) {
 2115                         linker_file_unload(lfdep, LINKER_UNLOAD_FORCE);
 2116                         error = ENOENT;
 2117                         break;
 2118                 }
 2119                 if (parent) {
 2120                         error = linker_file_add_dependency(parent, lfdep);
 2121                         if (error)
 2122                                 break;
 2123                 }
 2124                 if (lfpp)
 2125                         *lfpp = lfdep;
 2126         } while (0);
 2127         free(pathname, M_LINKER);
 2128         return (error);
 2129 }
 2130 
 2131 /*
 2132  * This routine is responsible for finding dependencies of userland initiated
 2133  * kldload(2)'s of files.
 2134  */
 2135 int
 2136 linker_load_dependencies(linker_file_t lf)
 2137 {
 2138         linker_file_t lfdep;
 2139         struct mod_metadata **start, **stop, **mdp, **nmdp;
 2140         struct mod_metadata *mp, *nmp;
 2141         const struct mod_depend *verinfo;
 2142         modlist_t mod;
 2143         const char *modname, *nmodname;
 2144         int ver, error = 0;
 2145 
 2146         /*
 2147          * All files are dependent on /kernel.
 2148          */
 2149         sx_assert(&kld_sx, SA_XLOCKED);
 2150         if (linker_kernel_file) {
 2151                 linker_kernel_file->refs++;
 2152                 error = linker_file_add_dependency(lf, linker_kernel_file);
 2153                 if (error)
 2154                         return (error);
 2155         }
 2156         if (linker_file_lookup_set(lf, MDT_SETNAME, &start, &stop,
 2157             NULL) != 0)
 2158                 return (0);
 2159         for (mdp = start; mdp < stop; mdp++) {
 2160                 mp = *mdp;
 2161                 if (mp->md_type != MDT_VERSION)
 2162                         continue;
 2163                 modname = mp->md_cval;
 2164                 ver = ((const struct mod_version *)mp->md_data)->mv_version;
 2165                 mod = modlist_lookup(modname, ver);
 2166                 if (mod != NULL) {
 2167                         printf("interface %s.%d already present in the KLD"
 2168                             " '%s'!\n", modname, ver,
 2169                             mod->container->filename);
 2170                         return (EEXIST);
 2171                 }
 2172         }
 2173 
 2174         for (mdp = start; mdp < stop; mdp++) {
 2175                 mp = *mdp;
 2176                 if (mp->md_type != MDT_DEPEND)
 2177                         continue;
 2178                 modname = mp->md_cval;
 2179                 verinfo = mp->md_data;
 2180                 nmodname = NULL;
 2181                 for (nmdp = start; nmdp < stop; nmdp++) {
 2182                         nmp = *nmdp;
 2183                         if (nmp->md_type != MDT_VERSION)
 2184                                 continue;
 2185                         nmodname = nmp->md_cval;
 2186                         if (strcmp(modname, nmodname) == 0)
 2187                                 break;
 2188                 }
 2189                 if (nmdp < stop)/* early exit, it's a self reference */
 2190                         continue;
 2191                 mod = modlist_lookup2(modname, verinfo);
 2192                 if (mod) {      /* woohoo, it's loaded already */
 2193                         lfdep = mod->container;
 2194                         lfdep->refs++;
 2195                         error = linker_file_add_dependency(lf, lfdep);
 2196                         if (error)
 2197                                 break;
 2198                         continue;
 2199                 }
 2200                 error = linker_load_module(NULL, modname, lf, verinfo, NULL);
 2201                 if (error) {
 2202                         printf("KLD %s: depends on %s - not available or"
 2203                             " version mismatch\n", lf->filename, modname);
 2204                         break;
 2205                 }
 2206         }
 2207 
 2208         if (error)
 2209                 return (error);
 2210         linker_addmodules(lf, start, stop, 0);
 2211         return (error);
 2212 }
 2213 
 2214 static int
 2215 sysctl_kern_function_list_iterate(const char *name, void *opaque)
 2216 {
 2217         struct sysctl_req *req;
 2218 
 2219         req = opaque;
 2220         return (SYSCTL_OUT(req, name, strlen(name) + 1));
 2221 }
 2222 
 2223 /*
 2224  * Export a nul-separated, double-nul-terminated list of all function names
 2225  * in the kernel.
 2226  */
 2227 static int
 2228 sysctl_kern_function_list(SYSCTL_HANDLER_ARGS)
 2229 {
 2230         linker_file_t lf;
 2231         int error;
 2232 
 2233 #ifdef MAC
 2234         error = mac_kld_check_stat(req->td->td_ucred);
 2235         if (error)
 2236                 return (error);
 2237 #endif
 2238         error = sysctl_wire_old_buffer(req, 0);
 2239         if (error != 0)
 2240                 return (error);
 2241         sx_xlock(&kld_sx);
 2242         TAILQ_FOREACH(lf, &linker_files, link) {
 2243                 error = LINKER_EACH_FUNCTION_NAME(lf,
 2244                     sysctl_kern_function_list_iterate, req);
 2245                 if (error) {
 2246                         sx_xunlock(&kld_sx);
 2247                         return (error);
 2248                 }
 2249         }
 2250         sx_xunlock(&kld_sx);
 2251         return (SYSCTL_OUT(req, "", 1));
 2252 }
 2253 
 2254 SYSCTL_PROC(_kern, OID_AUTO, function_list, CTLTYPE_OPAQUE | CTLFLAG_RD,
 2255     NULL, 0, sysctl_kern_function_list, "", "kernel function list");

Cache object: ba6d27694c037177957d34e1a07fb393


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.