sys/kern/kern_linker.c

   1 /*-
   2  * Copyright (c) 1997 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  * $FreeBSD: src/sys/kern/kern_linker.c,v 1.41.2.3 2001/11/21 17:50:35 luigi Exp $
  27  * $DragonFly: src/sys/kern/kern_linker.c,v 1.13 2003/11/10 06:12:13 dillon Exp $
  28  */
  29
  30 #include "opt_ddb.h"
  31
  32 #include <sys/param.h>
  33 #include <sys/kernel.h>
  34 #include <sys/systm.h>
  35 #include <sys/malloc.h>
  36 #include <sys/sysproto.h>
  37 #include <sys/sysent.h>
  38 #include <sys/proc.h>
  39 #include <sys/lock.h>
  40 #include <sys/module.h>
  41 #include <sys/linker.h>
  42 #include <sys/fcntl.h>
  43 #include <sys/libkern.h>
  44 #include <sys/namei.h>
  45 #include <sys/vnode.h>
  46 #include <sys/sysctl.h>
  47
  48 #include <vm/vm_zone.h>
  49
  50 #ifdef KLD_DEBUG
  51 int kld_debug = 0;
  52 #endif
  53
  54 MALLOC_DEFINE(M_LINKER, "kld", "kernel linker");
  55 linker_file_t linker_current_file;
  56 linker_file_t linker_kernel_file;
  57
  58 static struct lock lock;        /* lock for the file list */
  59 static linker_class_list_t classes;
  60 static linker_file_list_t linker_files;
  61 static int next_file_id = 1;
  62
  63 static void
  64 linker_init(void* arg)
  65 {
  66     lockinit(&lock, 0, "klink", 0, 0);
  67     TAILQ_INIT(&classes);
  68     TAILQ_INIT(&linker_files);
  69 }
  70
  71 SYSINIT(linker, SI_SUB_KLD, SI_ORDER_FIRST, linker_init, 0);
  72
  73 int
  74 linker_add_class(const char* desc, void* priv,
  75                  struct linker_class_ops* ops)
  76 {
  77     linker_class_t lc;
  78
  79     lc = malloc(sizeof(struct linker_class), M_LINKER, M_NOWAIT);
  80     if (!lc)
  81         return ENOMEM;
  82     bzero(lc, sizeof(*lc));
  83
  84     lc->desc = desc;
  85     lc->priv = priv;
  86     lc->ops = ops;
  87     TAILQ_INSERT_HEAD(&classes, lc, link);
  88
  89     return 0;
  90 }
  91
  92 static int
  93 linker_file_sysinit(linker_file_t lf)
  94 {
  95     struct sysinit** start, ** stop;
  96     struct sysinit** sipp;
  97     struct sysinit** xipp;
  98     struct sysinit* save;
  99     const moduledata_t *moddata;
 100     int error;
 101
 102     KLD_DPF(FILE, ("linker_file_sysinit: calling SYSINITs for %s\n",
 103                    lf->filename));
 104
 105     if (linker_file_lookup_set(lf, "sysinit_set", &start, &stop, NULL) != 0)
 106         return 0; /* XXX is this correct ? No sysinit ? */
 107
 108     /* HACK ALERT! */
 109     for (sipp = start; sipp < stop; sipp++) {
 110         if ((*sipp)->func == module_register_init) {
 111             moddata = (*sipp)->udata;
 112             error = module_register(moddata, lf);
 113             if (error) {
 114                 printf("linker_file_sysinit \"%s\" failed to register! %d\n",
 115                     lf->filename, error);
 116                 return error;
 117             }
 118         }
 119     }
 120
 121     /*
 122      * Perform a bubble sort of the system initialization objects by
 123      * their subsystem (primary key) and order (secondary key).
 124      *
 125      * Since some things care about execution order, this is the
 126      * operation which ensures continued function.
 127      */
 128     for (sipp = start; sipp < stop; sipp++) {
 129         for (xipp = sipp + 1; xipp < stop; xipp++) {
 130             if ((*sipp)->subsystem < (*xipp)->subsystem ||
 131                  ((*sipp)->subsystem == (*xipp)->subsystem &&
 132                   (*sipp)->order <= (*xipp)->order))
 133                 continue;       /* skip*/
 134             save = *sipp;
 135             *sipp = *xipp;
 136             *xipp = save;
 137         }
 138     }
 139
 140
 141     /*
 142      * Traverse the (now) ordered list of system initialization tasks.
 143      * Perform each task, and continue on to the next task.
 144      */
 145     for (sipp = start; sipp < stop; sipp++) {
 146         if ((*sipp)->subsystem == SI_SUB_DUMMY)
 147             continue;   /* skip dummy task(s)*/
 148
 149         /* Call function */
 150         (*((*sipp)->func))((*sipp)->udata);
 151     }
 152     return 0; /* no errors */
 153 }
 154
 155 static void
 156 linker_file_sysuninit(linker_file_t lf)
 157 {
 158     struct sysinit** start, ** stop;
 159     struct sysinit** sipp;
 160     struct sysinit** xipp;
 161     struct sysinit* save;
 162
 163     KLD_DPF(FILE, ("linker_file_sysuninit: calling SYSUNINITs for %s\n",
 164                    lf->filename));
 165
 166     if (linker_file_lookup_set(lf, "sysuninit_set", &start, &stop, NULL) != 0)
 167         return;
 168
 169     /*
 170      * Perform a reverse bubble sort of the system initialization objects
 171      * by their subsystem (primary key) and order (secondary key).
 172      *
 173      * Since some things care about execution order, this is the
 174      * operation which ensures continued function.
 175      */
 176     for (sipp = start; sipp < stop; sipp++) {
 177         for (xipp = sipp + 1; xipp < stop; xipp++) {
 178             if ((*sipp)->subsystem > (*xipp)->subsystem ||
 179                  ((*sipp)->subsystem == (*xipp)->subsystem &&
 180                   (*sipp)->order >= (*xipp)->order))
 181                 continue;       /* skip*/
 182             save = *sipp;
 183             *sipp = *xipp;
 184             *xipp = save;
 185         }
 186     }
 187
 188
 189     /*
 190      * Traverse the (now) ordered list of system initialization tasks.
 191      * Perform each task, and continue on to the next task.
 192      */
 193     for (sipp = start; sipp < stop; sipp++) {
 194         if ((*sipp)->subsystem == SI_SUB_DUMMY)
 195             continue;   /* skip dummy task(s)*/
 196
 197         /* Call function */
 198         (*((*sipp)->func))((*sipp)->udata);
 199     }
 200 }
 201
 202 static void
 203 linker_file_register_sysctls(linker_file_t lf)
 204 {
 205     struct sysctl_oid **start, **stop, **oidp;
 206
 207     KLD_DPF(FILE, ("linker_file_register_sysctls: registering SYSCTLs for %s\n",
 208                    lf->filename));
 209
 210     if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
 211         return;
 212     for (oidp = start; oidp < stop; oidp++)
 213         sysctl_register_oid(*oidp);
 214 }
 215
 216 static void
 217 linker_file_unregister_sysctls(linker_file_t lf)
 218 {
 219     struct sysctl_oid **start, **stop, **oidp;
 220
 221     KLD_DPF(FILE, ("linker_file_unregister_sysctls: registering SYSCTLs for %s\n",
 222                    lf->filename));
 223
 224     if (linker_file_lookup_set(lf, "sysctl_set", &start, &stop, NULL) != 0)
 225         return;
 226     for (oidp = start; oidp < stop; oidp++)
 227         sysctl_unregister_oid(*oidp);
 228 }
 229
 230 int
 231 linker_load_file(const char* filename, linker_file_t* result)
 232 {
 233     linker_class_t lc;
 234     linker_file_t lf;
 235     int foundfile, error = 0;
 236     char *koname = NULL;
 237
 238     /* Refuse to load modules if securelevel raised */
 239     if (securelevel > 0)
 240         return EPERM;
 241
 242     lf = linker_find_file_by_name(filename);
 243     if (lf) {
 244         KLD_DPF(FILE, ("linker_load_file: file %s is already loaded, incrementing refs\n", filename));
 245         *result = lf;
 246         lf->refs++;
 247         goto out;
 248     }
 249
 250     koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
 251     if (koname == NULL) {
 252         error = ENOMEM;
 253         goto out;
 254     }
 255     sprintf(koname, "%s.ko", filename);
 256     lf = NULL;
 257     foundfile = 0;
 258     for (lc = TAILQ_FIRST(&classes); lc; lc = TAILQ_NEXT(lc, link)) {
 259         KLD_DPF(FILE, ("linker_load_file: trying to load %s as %s\n",
 260                        filename, lc->desc));
 261
 262         error = lc->ops->load_file(koname, &lf);        /* First with .ko */
 263         if (lf == NULL && error == ENOENT)
 264             error = lc->ops->load_file(filename, &lf);  /* Then try without */
 265         /*
 266          * If we got something other than ENOENT, then it exists but we cannot
 267          * load it for some other reason.
 268          */
 269         if (error != ENOENT)
 270             foundfile = 1;
 271         if (lf) {
 272             linker_file_register_sysctls(lf);
 273             error = linker_file_sysinit(lf);
 274
 275             *result = lf;
 276             goto out;
 277         }
 278     }
 279     /*
 280      * Less than ideal, but tells the user whether it failed to load or
 281      * the module was not found.
 282      */
 283     if (foundfile) {
 284             /*
 285              * Format not recognized or otherwise unloadable.
 286              * When loading a module that is statically built into
 287              * the kernel EEXIST percolates back up as the return
 288              * value.  Preserve this so that apps like sysinstall
 289              * can recognize this special case and not post bogus
 290              * dialog messages.
 291              */
 292             if (error != EEXIST)
 293                     error = ENOEXEC;
 294     } else
 295         error = ENOENT;         /* Nothing found */
 296
 297 out:
 298     if (koname)
 299         free(koname, M_LINKER);
 300     return error;
 301 }
 302
 303 linker_file_t
 304 linker_find_file_by_name(const char* filename)
 305 {
 306     linker_file_t lf = 0;
 307     char *koname;
 308
 309     koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
 310     if (koname == NULL)
 311         goto out;
 312     sprintf(koname, "%s.ko", filename);
 313
 314     lockmgr(&lock, LK_SHARED, 0, curthread);
 315     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
 316         if (!strcmp(lf->filename, koname))
 317             break;
 318         if (!strcmp(lf->filename, filename))
 319             break;
 320     }
 321     lockmgr(&lock, LK_RELEASE, 0, curthread);
 322
 323 out:
 324     if (koname)
 325         free(koname, M_LINKER);
 326     return lf;
 327 }
 328
 329 linker_file_t
 330 linker_find_file_by_id(int fileid)
 331 {
 332     linker_file_t lf = 0;
 333
 334     lockmgr(&lock, LK_SHARED, 0, curthread);
 335     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link))
 336         if (lf->id == fileid)
 337             break;
 338     lockmgr(&lock, LK_RELEASE, 0, curthread);
 339
 340     return lf;
 341 }
 342
 343 linker_file_t
 344 linker_make_file(const char* pathname, void* priv, struct linker_file_ops* ops)
 345 {
 346     linker_file_t lf = 0;
 347     int namelen;
 348     const char *filename;
 349
 350     filename = rindex(pathname, '/');
 351     if (filename && filename[1])
 352         filename++;
 353     else
 354         filename = pathname;
 355
 356     KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
 357     lockmgr(&lock, LK_EXCLUSIVE, 0, curthread);
 358     namelen = strlen(filename) + 1;
 359     lf = malloc(sizeof(struct linker_file) + namelen, M_LINKER, M_WAITOK);
 360     if (!lf)
 361         goto out;
 362     bzero(lf, sizeof(*lf));
 363
 364     lf->refs = 1;
 365     lf->userrefs = 0;
 366     lf->flags = 0;
 367     lf->filename = (char*) (lf + 1);
 368     strcpy(lf->filename, filename);
 369     lf->id = next_file_id++;
 370     lf->ndeps = 0;
 371     lf->deps = NULL;
 372     STAILQ_INIT(&lf->common);
 373     TAILQ_INIT(&lf->modules);
 374
 375     lf->priv = priv;
 376     lf->ops = ops;
 377     TAILQ_INSERT_TAIL(&linker_files, lf, link);
 378
 379 out:
 380     lockmgr(&lock, LK_RELEASE, 0, curthread);
 381     return lf;
 382 }
 383
 384 int
 385 linker_file_unload(linker_file_t file)
 386 {
 387     module_t mod, next;
 388     struct common_symbol* cp;
 389     int error = 0;
 390     int i;
 391
 392     /* Refuse to unload modules if securelevel raised */
 393     if (securelevel > 0)
 394         return EPERM;
 395
 396     KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
 397     lockmgr(&lock, LK_EXCLUSIVE, 0, curthread);
 398     if (file->refs == 1) {
 399         KLD_DPF(FILE, ("linker_file_unload: file is unloading, informing modules\n"));
 400         /*
 401          * Inform any modules associated with this file.
 402          */
 403         for (mod = TAILQ_FIRST(&file->modules); mod; mod = next) {
 404             next = module_getfnext(mod);
 405
 406             /*
 407              * Give the module a chance to veto the unload.
 408              */
 409             if ((error = module_unload(mod)) != 0) {
 410                 KLD_DPF(FILE, ("linker_file_unload: module %x vetoes unload\n",
 411                                mod));
 412                 lockmgr(&lock, LK_RELEASE, 0, curthread);
 413                 goto out;
 414             }
 415
 416             module_release(mod);
 417         }
 418     }
 419
 420     file->refs--;
 421     if (file->refs > 0) {
 422         lockmgr(&lock, LK_RELEASE, 0, curthread);
 423         goto out;
 424     }
 425
 426     /* Don't try to run SYSUNINITs if we are unloaded due to a link error */
 427     if (file->flags & LINKER_FILE_LINKED) {
 428         linker_file_sysuninit(file);
 429         linker_file_unregister_sysctls(file);
 430     }
 431
 432     TAILQ_REMOVE(&linker_files, file, link);
 433     lockmgr(&lock, LK_RELEASE, 0, curthread);
 434
 435     for (i = 0; i < file->ndeps; i++)
 436         linker_file_unload(file->deps[i]);
 437     free(file->deps, M_LINKER);
 438
 439     for (cp = STAILQ_FIRST(&file->common); cp;
 440          cp = STAILQ_FIRST(&file->common)) {
 441         STAILQ_REMOVE(&file->common, cp, common_symbol, link);
 442         free(cp, M_LINKER);
 443     }
 444
 445     file->ops->unload(file);
 446     free(file, M_LINKER);
 447
 448 out:
 449     return error;
 450 }
 451
 452 int
 453 linker_file_add_dependancy(linker_file_t file, linker_file_t dep)
 454 {
 455     linker_file_t* newdeps;
 456
 457     newdeps = malloc((file->ndeps + 1) * sizeof(linker_file_t*),
 458                      M_LINKER, M_WAITOK);
 459     if (newdeps == NULL)
 460         return ENOMEM;
 461     bzero(newdeps, (file->ndeps + 1) * sizeof(linker_file_t*));
 462
 463     if (file->deps) {
 464         bcopy(file->deps, newdeps, file->ndeps * sizeof(linker_file_t*));
 465         free(file->deps, M_LINKER);
 466     }
 467     file->deps = newdeps;
 468     file->deps[file->ndeps] = dep;
 469     file->ndeps++;
 470
 471     return 0;
 472 }
 473
 474 /*
 475  * Locate a linker set and its contents.
 476  * This is a helper function to avoid linker_if.h exposure elsewhere.
 477  * Note: firstp and lastp are really void ***
 478  */
 479 int
 480 linker_file_lookup_set(linker_file_t file, const char *name,
 481                       void *firstp, void *lastp, int *countp)
 482 {
 483     return file->ops->lookup_set(file, name, firstp, lastp, countp);
 484 }
 485
 486 int
 487 linker_file_lookup_symbol(linker_file_t file, const char* name, int deps, caddr_t *raddr)
 488 {
 489     c_linker_sym_t sym;
 490     linker_symval_t symval;
 491     linker_file_t lf;
 492     size_t common_size = 0;
 493     int i;
 494
 495     KLD_DPF(SYM, ("linker_file_lookup_symbol: file=%x, name=%s, deps=%d\n",
 496                   file, name, deps));
 497
 498     if (file->ops->lookup_symbol(file, name, &sym) == 0) {
 499         file->ops->symbol_values(file, sym, &symval);
 500
 501         /*
 502          * XXX Assume a common symbol if its value is 0 and it has a non-zero
 503          * size, otherwise it could be an absolute symbol with a value of 0.
 504          */
 505         if (symval.value == 0 && symval.size != 0) {
 506             /*
 507              * For commons, first look them up in the dependancies and
 508              * only allocate space if not found there.
 509              */
 510             common_size = symval.size;
 511         } else {
 512             KLD_DPF(SYM, ("linker_file_lookup_symbol: symbol.value=%x\n", symval.value));
 513             *raddr = symval.value;
 514             return 0;
 515         }
 516     }
 517     if (deps) {
 518         for (i = 0; i < file->ndeps; i++) {
 519             if (linker_file_lookup_symbol(file->deps[i], name, 0, raddr) == 0) {
 520                 KLD_DPF(SYM, ("linker_file_lookup_symbol: deps value=%x\n", *raddr));
 521                 return 0;
 522             }
 523         }
 524
 525         /* If we have not found it in the dependencies, search globally */
 526         for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
 527             /* But skip the current file if it's on the list */
 528             if (lf == file)
 529                 continue;
 530             /* And skip the files we searched above */
 531             for (i = 0; i < file->ndeps; i++)
 532                 if (lf == file->deps[i])
 533                     break;
 534             if (i < file->ndeps)
 535                 continue;
 536             if (linker_file_lookup_symbol(lf, name, 0, raddr) == 0) {
 537                 KLD_DPF(SYM, ("linker_file_lookup_symbol: global value=%x\n", *raddr));
 538                 return 0;
 539             }
 540         }
 541     }
 542
 543     if (common_size > 0) {
 544         /*
 545          * This is a common symbol which was not found in the
 546          * dependancies.  We maintain a simple common symbol table in
 547          * the file object.
 548          */
 549         struct common_symbol* cp;
 550
 551         for (cp = STAILQ_FIRST(&file->common); cp;
 552              cp = STAILQ_NEXT(cp, link))
 553             if (!strcmp(cp->name, name)) {
 554                 KLD_DPF(SYM, ("linker_file_lookup_symbol: old common value=%x\n", cp->address));
 555                 *raddr = cp->address;
 556                 return 0;
 557             }
 558
 559         /*
 560          * Round the symbol size up to align.
 561          */
 562         common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
 563         cp = malloc(sizeof(struct common_symbol)
 564                     + common_size
 565                     + strlen(name) + 1,
 566                     M_LINKER, M_WAITOK);
 567         if (!cp) {
 568             KLD_DPF(SYM, ("linker_file_lookup_symbol: nomem\n"));
 569             return ENOMEM;
 570         }
 571         bzero(cp, sizeof(struct common_symbol) + common_size + strlen(name)+ 1);
 572
 573         cp->address = (caddr_t) (cp + 1);
 574         cp->name = cp->address + common_size;
 575         strcpy(cp->name, name);
 576         bzero(cp->address, common_size);
 577         STAILQ_INSERT_TAIL(&file->common, cp, link);
 578
 579         KLD_DPF(SYM, ("linker_file_lookup_symbol: new common value=%x\n", cp->address));
 580         *raddr = cp->address;
 581         return 0;
 582     }
 583
 584     KLD_DPF(SYM, ("linker_file_lookup_symbol: fail\n"));
 585     return ENOENT;
 586 }
 587
 588 #ifdef DDB
 589 /*
 590  * DDB Helpers.  DDB has to look across multiple files with their own
 591  * symbol tables and string tables.
 592  *
 593  * Note that we do not obey list locking protocols here.  We really don't
 594  * need DDB to hang because somebody's got the lock held.  We'll take the
 595  * chance that the files list is inconsistant instead.
 596  */
 597
 598 int
 599 linker_ddb_lookup(const char *symstr, c_linker_sym_t *sym)
 600 {
 601     linker_file_t lf;
 602
 603     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
 604         if (lf->ops->lookup_symbol(lf, symstr, sym) == 0)
 605             return 0;
 606     }
 607     return ENOENT;
 608 }
 609
 610 int
 611 linker_ddb_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
 612 {
 613     linker_file_t lf;
 614     u_long off = (uintptr_t)value;
 615     u_long diff, bestdiff;
 616     c_linker_sym_t best;
 617     c_linker_sym_t es;
 618
 619     best = 0;
 620     bestdiff = off;
 621     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
 622         if (lf->ops->search_symbol(lf, value, &es, &diff) != 0)
 623             continue;
 624         if (es != 0 && diff < bestdiff) {
 625             best = es;
 626             bestdiff = diff;
 627         }
 628         if (bestdiff == 0)
 629             break;
 630     }
 631     if (best) {
 632         *sym = best;
 633         *diffp = bestdiff;
 634         return 0;
 635     } else {
 636         *sym = 0;
 637         *diffp = off;
 638         return ENOENT;
 639     }
 640 }
 641
 642 int
 643 linker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
 644 {
 645     linker_file_t lf;
 646
 647     for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
 648         if (lf->ops->symbol_values(lf, sym, symval) == 0)
 649             return 0;
 650     }
 651     return ENOENT;
 652 }
 653
 654 #endif
 655
 656 /*
 657  * Syscalls.
 658  */
 659
 660 int
 661 kldload(struct kldload_args *uap)
 662 {
 663     struct thread *td = curthread;
 664     char* filename = NULL, *modulename;
 665     linker_file_t lf;
 666     int error = 0;
 667
 668     uap->sysmsg_result = -1;
 669
 670     if (securelevel > 0)        /* redundant, but that's OK */
 671         return EPERM;
 672
 673     if ((error = suser(td)) != 0)
 674         return error;
 675
 676     filename = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 677     if ((error = copyinstr(SCARG(uap, file), filename, MAXPATHLEN, NULL)) != 0)
 678         goto out;
 679
 680     /* Can't load more than one module with the same name */
 681     modulename = rindex(filename, '/');
 682     if (modulename == NULL)
 683         modulename = filename;
 684     else
 685         modulename++;
 686     if (linker_find_file_by_name(modulename)) {
 687         error = EEXIST;
 688         goto out;
 689     }
 690
 691     if ((error = linker_load_file(filename, &lf)) != 0)
 692         goto out;
 693
 694     lf->userrefs++;
 695     uap->sysmsg_result = lf->id;
 696
 697 out:
 698     if (filename)
 699         free(filename, M_TEMP);
 700     return error;
 701 }
 702
 703 int
 704 kldunload(struct kldunload_args *uap)
 705 {
 706     struct thread *td = curthread;
 707     linker_file_t lf;
 708     int error = 0;
 709
 710     if (securelevel > 0)        /* redundant, but that's OK */
 711         return EPERM;
 712
 713     if ((error = suser(td)) != 0)
 714         return error;
 715
 716     lf = linker_find_file_by_id(SCARG(uap, fileid));
 717     if (lf) {
 718         KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
 719         if (lf->userrefs == 0) {
 720             printf("linkerunload: attempt to unload file that was loaded by the kernel\n");
 721             error = EBUSY;
 722             goto out;
 723         }
 724         lf->userrefs--;
 725         error = linker_file_unload(lf);
 726         if (error)
 727             lf->userrefs++;
 728     } else
 729         error = ENOENT;
 730
 731 out:
 732     return error;
 733 }
 734
 735 int
 736 kldfind(struct kldfind_args *uap)
 737 {
 738     char *filename = NULL, *modulename;
 739     linker_file_t lf;
 740     int error = 0;
 741
 742     uap->sysmsg_result = -1;
 743
 744     filename = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 745     if ((error = copyinstr(SCARG(uap, file), filename, MAXPATHLEN, NULL)) != 0)
 746         goto out;
 747
 748     modulename = rindex(filename, '/');
 749     if (modulename == NULL)
 750         modulename = filename;
 751
 752     lf = linker_find_file_by_name(modulename);
 753     if (lf)
 754         uap->sysmsg_result = lf->id;
 755     else
 756         error = ENOENT;
 757
 758 out:
 759     if (filename)
 760         free(filename, M_TEMP);
 761     return error;
 762 }
 763
 764 int
 765 kldnext(struct kldnext_args *uap)
 766 {
 767     linker_file_t lf;
 768     int error = 0;
 769
 770     if (SCARG(uap, fileid) == 0) {
 771         if (TAILQ_FIRST(&linker_files))
 772             uap->sysmsg_result = TAILQ_FIRST(&linker_files)->id;
 773         else
 774             uap->sysmsg_result = 0;
 775         return 0;
 776     }
 777
 778     lf = linker_find_file_by_id(SCARG(uap, fileid));
 779     if (lf) {
 780         if (TAILQ_NEXT(lf, link))
 781             uap->sysmsg_result = TAILQ_NEXT(lf, link)->id;
 782         else
 783             uap->sysmsg_result = 0;
 784     } else
 785         error = ENOENT;
 786
 787     return error;
 788 }
 789
 790 int
 791 kldstat(struct kldstat_args *uap)
 792 {
 793     linker_file_t lf;
 794     int error = 0;
 795     int version;
 796     struct kld_file_stat* stat;
 797     int namelen;
 798
 799     lf = linker_find_file_by_id(SCARG(uap, fileid));
 800     if (!lf) {
 801         error = ENOENT;
 802         goto out;
 803     }
 804
 805     stat = SCARG(uap, stat);
 806
 807     /*
 808      * Check the version of the user's structure.
 809      */
 810     if ((error = copyin(&stat->version, &version, sizeof(version))) != 0)
 811         goto out;
 812     if (version != sizeof(struct kld_file_stat)) {
 813         error = EINVAL;
 814         goto out;
 815     }
 816
 817     namelen = strlen(lf->filename) + 1;
 818     if (namelen > MAXPATHLEN)
 819         namelen = MAXPATHLEN;
 820     if ((error = copyout(lf->filename, &stat->name[0], namelen)) != 0)
 821         goto out;
 822     if ((error = copyout(&lf->refs, &stat->refs, sizeof(int))) != 0)
 823         goto out;
 824     if ((error = copyout(&lf->id, &stat->id, sizeof(int))) != 0)
 825         goto out;
 826     if ((error = copyout(&lf->address, &stat->address, sizeof(caddr_t))) != 0)
 827         goto out;
 828     if ((error = copyout(&lf->size, &stat->size, sizeof(size_t))) != 0)
 829         goto out;
 830
 831     uap->sysmsg_result = 0;
 832
 833 out:
 834     return error;
 835 }
 836
 837 int
 838 kldfirstmod(struct kldfirstmod_args *uap)
 839 {
 840     linker_file_t lf;
 841     int error = 0;
 842
 843     lf = linker_find_file_by_id(SCARG(uap, fileid));
 844     if (lf) {
 845         if (TAILQ_FIRST(&lf->modules))
 846             uap->sysmsg_result = module_getid(TAILQ_FIRST(&lf->modules));
 847         else
 848             uap->sysmsg_result = 0;
 849     } else
 850         error = ENOENT;
 851
 852     return error;
 853 }
 854
 855 int
 856 kldsym(struct kldsym_args *uap)
 857 {
 858     char *symstr = NULL;
 859     c_linker_sym_t sym;
 860     linker_symval_t symval;
 861     linker_file_t lf;
 862     struct kld_sym_lookup lookup;
 863     int error = 0;
 864
 865     if ((error = copyin(SCARG(uap, data), &lookup, sizeof(lookup))) != 0)
 866         goto out;
 867     if (lookup.version != sizeof(lookup) || SCARG(uap, cmd) != KLDSYM_LOOKUP) {
 868         error = EINVAL;
 869         goto out;
 870     }
 871
 872     symstr = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 873     if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
 874         goto out;
 875
 876     if (SCARG(uap, fileid) != 0) {
 877         lf = linker_find_file_by_id(SCARG(uap, fileid));
 878         if (lf == NULL) {
 879             error = ENOENT;
 880             goto out;
 881         }
 882         if (lf->ops->lookup_symbol(lf, symstr, &sym) == 0 &&
 883             lf->ops->symbol_values(lf, sym, &symval) == 0) {
 884             lookup.symvalue = (uintptr_t)symval.value;
 885             lookup.symsize = symval.size;
 886             error = copyout(&lookup, SCARG(uap, data), sizeof(lookup));
 887         } else
 888             error = ENOENT;
 889     } else {
 890         for (lf = TAILQ_FIRST(&linker_files); lf; lf = TAILQ_NEXT(lf, link)) {
 891             if (lf->ops->lookup_symbol(lf, symstr, &sym) == 0 &&
 892                 lf->ops->symbol_values(lf, sym, &symval) == 0) {
 893                 lookup.symvalue = (uintptr_t)symval.value;
 894                 lookup.symsize = symval.size;
 895                 error = copyout(&lookup, SCARG(uap, data), sizeof(lookup));
 896                 break;
 897             }
 898         }
 899         if (!lf)
 900             error = ENOENT;
 901     }
 902 out:
 903     if (symstr)
 904         free(symstr, M_TEMP);
 905     return error;
 906 }
 907
 908 /*
 909  * Preloaded module support
 910  */
 911
 912 static void
 913 linker_preload(void* arg)
 914 {
 915     caddr_t             modptr;
 916     char                *modname;
 917     char                *modtype;
 918     linker_file_t       lf;
 919     linker_class_t      lc;
 920     int                 error;
 921     struct sysinit      **sipp;
 922     const moduledata_t  *moddata;
 923     struct sysinit      **si_start, **si_stop;
 924
 925     modptr = NULL;
 926     while ((modptr = preload_search_next_name(modptr)) != NULL) {
 927         modname = (char *)preload_search_info(modptr, MODINFO_NAME);
 928         modtype = (char *)preload_search_info(modptr, MODINFO_TYPE);
 929         if (modname == NULL) {
 930             printf("Preloaded module at %p does not have a name!\n", modptr);
 931             continue;
 932         }
 933         if (modtype == NULL) {
 934             printf("Preloaded module at %p does not have a type!\n", modptr);
 935             continue;
 936         }
 937         printf("Preloaded %s \"%s\" at %p.\n", modtype, modname, modptr);
 938         lf = linker_find_file_by_name(modname);
 939         if (lf) {
 940             lf->userrefs++;
 941             continue;
 942         }
 943         lf = NULL;
 944         for (lc = TAILQ_FIRST(&classes); lc; lc = TAILQ_NEXT(lc, link)) {
 945             error = lc->ops->load_file(modname, &lf);
 946             if (error) {
 947                 lf = NULL;
 948                 break;
 949             }
 950         }
 951         if (lf) {
 952             lf->userrefs++;
 953
 954             if (linker_file_lookup_set(lf, "sysinit_set", &si_start, &si_stop, NULL) == 0) {
 955                 /* HACK ALERT!
 956                  * This is to set the sysinit moduledata so that the module
 957                  * can attach itself to the correct containing file.
 958                  * The sysinit could be run at *any* time.
 959                  */
 960                 for (sipp = si_start; sipp < si_stop; sipp++) {
 961                     if ((*sipp)->func == module_register_init) {
 962                         moddata = (*sipp)->udata;
 963                         error = module_register(moddata, lf);
 964                         if (error)
 965                             printf("Preloaded %s \"%s\" failed to register: %d\n",
 966                                 modtype, modname, error);
 967                     }
 968                 }
 969                 sysinit_add(si_start, si_stop);
 970             }
 971             linker_file_register_sysctls(lf);
 972         }
 973     }
 974 }
 975
 976 SYSINIT(preload, SI_SUB_KLD, SI_ORDER_MIDDLE, linker_preload, 0);
 977
 978 /*
 979  * Search for a not-loaded module by name.
 980  *
 981  * Modules may be found in the following locations:
 982  *
 983  * - preloaded (result is just the module name)
 984  * - on disk (result is full path to module)
 985  *
 986  * If the module name is qualified in any way (contains path, etc.)
 987  * the we simply return a copy of it.
 988  *
 989  * The search path can be manipulated via sysctl.  Note that we use the ';'
 990  * character as a separator to be consistent with the bootloader.
 991  */
 992
 993 static char linker_path[MAXPATHLEN] = "/;/boot/;/modules/";
 994
 995 SYSCTL_STRING(_kern, OID_AUTO, module_path, CTLFLAG_RW, linker_path,
 996               sizeof(linker_path), "module load search path");
 997
 998 static char *
 999 linker_strdup(const char *str)
1000 {
1001     char        *result;
1002
1003     if ((result = malloc((strlen(str) + 1), M_LINKER, M_WAITOK)) != NULL)
1004         strcpy(result, str);
1005     return(result);
1006 }
1007
1008 char *
1009 linker_search_path(const char *name)
1010 {
1011     struct nameidata    nd;
1012     struct thread       *td = curthread;
1013     char                *cp, *ep, *result;
1014     int                 error;
1015     enum vtype          type;
1016
1017     /* qualified at all? */
1018     if (index(name, '/'))
1019         return(linker_strdup(name));
1020
1021     /* traverse the linker path */
1022     cp = linker_path;
1023     for (;;) {
1024
1025         /* find the end of this component */
1026         for (ep = cp; (*ep != 0) && (*ep != ';'); ep++)
1027             ;
1028         result = malloc((strlen(name) + (ep - cp) + 1), M_LINKER, M_WAITOK);
1029         if (result == NULL)     /* actually ENOMEM */
1030             return(NULL);
1031
1032         strncpy(result, cp, ep - cp);
1033         strcpy(result + (ep - cp), name);
1034
1035         /*
1036          * Attempt to open the file, and return the path if we succeed and it's
1037          * a regular file.
1038          */
1039         NDINIT(&nd, NAMEI_LOOKUP, CNP_FOLLOW, UIO_SYSSPACE, result, td);
1040         error = vn_open(&nd, FREAD, 0);
1041         if (error == 0) {
1042             NDFREE(&nd, NDF_ONLY_PNBUF);
1043             type = nd.ni_vp->v_type;
1044             VOP_UNLOCK(nd.ni_vp, 0, td);
1045             vn_close(nd.ni_vp, FREAD, td);
1046             if (type == VREG)
1047                 return(result);
1048         }
1049         free(result, M_LINKER);
1050
1051         if (*ep == 0)
1052             break;
1053         cp = ep + 1;
1054     }
1055     return(NULL);
1056 }