sys/kern/kern_linker.c

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