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


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

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

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: subr_kobj.c,v 1.24.4.2 2009/06/17 20:20:54 bouyer Exp $        */
    2 
    3 /*-
    4  * Copyright (c) 2008 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   26  * POSSIBILITY OF SUCH DAMAGE.
   27  */
   28 
   29 /*-
   30  * Copyright (c) 1998-2000 Doug Rabson
   31  * Copyright (c) 2004 Peter Wemm
   32  * All rights reserved.
   33  *
   34  * Redistribution and use in source and binary forms, with or without
   35  * modification, are permitted provided that the following conditions
   36  * are met:
   37  * 1. Redistributions of source code must retain the above copyright
   38  *    notice, this list of conditions and the following disclaimer.
   39  * 2. Redistributions in binary form must reproduce the above copyright
   40  *    notice, this list of conditions and the following disclaimer in the
   41  *    documentation and/or other materials provided with the distribution.
   42  *
   43  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   53  * SUCH DAMAGE.
   54  */
   55 
   56 /*
   57  * Kernel loader for ELF objects.
   58  *
   59  * TODO: adjust kmem_alloc() calls to avoid needless fragmentation.
   60  */
   61 
   62 #include "opt_modular.h"
   63 
   64 #include <sys/cdefs.h>
   65 __KERNEL_RCSID(0, "$NetBSD: subr_kobj.c,v 1.24.4.2 2009/06/17 20:20:54 bouyer Exp $");
   66 
   67 #define ELFSIZE         ARCH_ELFSIZE
   68 
   69 #include <sys/systm.h>
   70 #include <sys/kobj.h>
   71 #include <sys/errno.h>
   72 
   73 #ifdef MODULAR
   74 
   75 #include <sys/param.h>
   76 #include <sys/kernel.h>
   77 #include <sys/kmem.h>
   78 #include <sys/proc.h>
   79 #include <sys/namei.h>
   80 #include <sys/vnode.h>
   81 #include <sys/fcntl.h>
   82 #include <sys/ksyms.h>
   83 #include <sys/lkm.h>
   84 #include <sys/exec.h>
   85 #include <sys/exec_elf.h>
   86 
   87 #include <machine/stdarg.h>
   88 
   89 #include <uvm/uvm_extern.h>
   90 
   91 
   92 typedef struct {
   93         void            *addr;
   94         Elf_Off         size;
   95         int             flags;
   96         int             sec;            /* Original section */
   97         const char      *name;
   98 } progent_t;
   99 
  100 typedef struct {
  101         Elf_Rel         *rel;
  102         int             nrel;
  103         int             sec;
  104         size_t          size;
  105 } relent_t;
  106 
  107 typedef struct {
  108         Elf_Rela        *rela;
  109         int             nrela;
  110         int             sec;
  111         size_t          size;
  112 } relaent_t;
  113 
  114 typedef enum kobjtype {
  115         KT_UNSET,
  116         KT_VNODE,
  117         KT_MEMORY
  118 } kobjtype_t;
  119 
  120 struct kobj {
  121         char            ko_name[MAXLKMNAME];
  122         kobjtype_t      ko_type;
  123         void            *ko_source;
  124         ssize_t         ko_memsize;
  125         vaddr_t         ko_address;     /* Relocation address */
  126         Elf_Shdr        *ko_shdr;
  127         progent_t       *ko_progtab;
  128         relaent_t       *ko_relatab;
  129         relent_t        *ko_reltab;
  130         Elf_Sym         *ko_symtab;     /* Symbol table */
  131         char            *ko_strtab;     /* String table */
  132         char            *ko_shstrtab;   /* Section name string table */
  133         size_t          ko_size;        /* Size of text/data/bss */
  134         size_t          ko_symcnt;      /* Number of symbols */
  135         size_t          ko_strtabsz;    /* Number of bytes in string table */
  136         size_t          ko_shstrtabsz;  /* Number of bytes in scn str table */
  137         size_t          ko_shdrsz;
  138         int             ko_nrel;
  139         int             ko_nrela;
  140         int             ko_nprogtab;
  141         bool            ko_ksyms;
  142         bool            ko_loaded;
  143 };
  144 
  145 static int      kobj_relocate(kobj_t, bool);
  146 static int      kobj_checkdup(kobj_t);
  147 static void     kobj_error(const char *, ...);
  148 static int      kobj_read(kobj_t, void **, size_t, off_t);
  149 static int      kobj_read_bits(kobj_t, void *, size_t, off_t);
  150 static void     kobj_jettison(kobj_t);
  151 static void     kobj_free(kobj_t, void *, size_t);
  152 static void     kobj_close(kobj_t);
  153 static int      kobj_load(kobj_t);
  154 
  155 extern struct vm_map *lkm_map;
  156 
  157 /*
  158  * kobj_load_file:
  159  *
  160  *      Load an object located in the file system.
  161  */
  162 int
  163 kobj_load_file(kobj_t *kop, const char *filename, const char *base,
  164                bool autoload)
  165 {
  166         struct nameidata nd;
  167         kauth_cred_t cred;
  168         char *path;
  169         int error;
  170         kobj_t ko;
  171 
  172         cred = kauth_cred_get();
  173 
  174         ko = kmem_zalloc(sizeof(*ko), KM_SLEEP);
  175         if (ko == NULL) {
  176                 return ENOMEM;
  177         }
  178 
  179         if (autoload) {
  180                 error = ENOENT;
  181         } else {
  182                 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename);
  183                 error = vn_open(&nd, FREAD, 0);
  184         }
  185         if (error != 0) {
  186                 if (error != ENOENT) {
  187                         goto out;
  188                 }
  189                 path = PNBUF_GET();
  190                 snprintf(path, MAXPATHLEN - 1, "%s/%s/%s.kmod", base,
  191                     filename, filename);
  192                 NDINIT(&nd, LOOKUP, FOLLOW | NOCHROOT, UIO_SYSSPACE, path);
  193                 error = vn_open(&nd, FREAD, 0);
  194                 if (error != 0) {
  195                         strlcat(path, ".o", MAXPATHLEN);
  196                         NDINIT(&nd, LOOKUP, FOLLOW | NOCHROOT, UIO_SYSSPACE,
  197                             path);
  198                         error = vn_open(&nd, FREAD, 0);
  199                 }
  200                 PNBUF_PUT(path);
  201                 if (error != 0) {
  202                         goto out;
  203                 }
  204         }
  205 
  206  out:
  207         if (error != 0) {
  208                 kmem_free(ko, sizeof(*ko));
  209                 return error;
  210         }
  211 
  212         ko->ko_type = KT_VNODE;
  213         ko->ko_source = nd.ni_vp;
  214         *kop = ko;
  215         return kobj_load(ko);
  216 }
  217 
  218 /*
  219  * kobj_load_mem:
  220  *
  221  *      Load an object already resident in memory.  If size is not -1,
  222  *      the complete size of the object is known.
  223  */
  224 int
  225 kobj_load_mem(kobj_t *kop, void *base, ssize_t size)
  226 {
  227         kobj_t ko;
  228 
  229         ko = kmem_zalloc(sizeof(*ko), KM_SLEEP);
  230         if (ko == NULL) {
  231                 return ENOMEM;
  232         }
  233 
  234         ko->ko_type = KT_MEMORY;
  235         ko->ko_source = base;
  236         ko->ko_memsize = size;
  237         *kop = ko;
  238         return kobj_load(ko);
  239 }
  240 
  241 /*
  242  * kobj_close:
  243  *
  244  *      Close an open ELF object.
  245  */
  246 static void
  247 kobj_close(kobj_t ko)
  248 {
  249 
  250         if (ko->ko_source == NULL) {
  251                 return;
  252         }
  253 
  254         switch (ko->ko_type) {
  255         case KT_VNODE:
  256                 VOP_UNLOCK(ko->ko_source, 0);
  257                 vn_close(ko->ko_source, FREAD, kauth_cred_get());
  258                 break;
  259         case KT_MEMORY:
  260                 /* nothing */
  261                 break;
  262         default:
  263                 panic("kobj_close: unknown type");
  264                 break;
  265         }
  266 
  267         ko->ko_source = NULL;
  268 }
  269 
  270 /*
  271  * kobj_load:
  272  *
  273  *      Load an ELF object and prepare to link into the running kernel
  274  *      image.
  275  */
  276 static int
  277 kobj_load(kobj_t ko)
  278 {
  279         Elf_Ehdr *hdr;
  280         Elf_Shdr *shdr;
  281         Elf_Sym *es;
  282         vaddr_t mapbase;
  283         size_t mapsize;
  284         int error;
  285         int symtabindex;
  286         int symstrindex;
  287         int nsym;
  288         int pb, rl, ra;
  289         int alignmask;
  290         int i, j;
  291         void *addr;
  292 
  293         KASSERT(ko->ko_type != KT_UNSET);
  294         KASSERT(ko->ko_source != NULL);
  295 
  296         shdr = NULL;
  297         mapsize = 0;
  298         error = 0;
  299         hdr = NULL;
  300 
  301         /*
  302          * Read the elf header from the file.
  303          */
  304         error = kobj_read(ko, (void **)&hdr, sizeof(*hdr), 0);
  305         if (error != 0)
  306                 goto out;
  307         if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0) {
  308                 kobj_error("not an ELF object");
  309                 error = ENOEXEC;
  310                 goto out;
  311         }
  312 
  313         if (hdr->e_ident[EI_VERSION] != EV_CURRENT ||
  314             hdr->e_version != EV_CURRENT) {
  315                 kobj_error("unsupported file version");
  316                 error = ENOEXEC;
  317                 goto out;
  318         }
  319         if (hdr->e_type != ET_REL) {
  320                 kobj_error("unsupported file type");
  321                 error = ENOEXEC;
  322                 goto out;
  323         }
  324         switch (hdr->e_machine) {
  325 #if ELFSIZE == 32
  326         ELF32_MACHDEP_ID_CASES
  327 #else
  328         ELF64_MACHDEP_ID_CASES
  329 #endif
  330         default:
  331                 kobj_error("unsupported machine");
  332                 error = ENOEXEC;
  333                 goto out;
  334         }
  335 
  336         ko->ko_nprogtab = 0;
  337         ko->ko_shdr = 0;
  338         ko->ko_nrel = 0;
  339         ko->ko_nrela = 0;
  340 
  341         /*
  342          * Allocate and read in the section header.
  343          */
  344         ko->ko_shdrsz = hdr->e_shnum * hdr->e_shentsize;
  345         if (ko->ko_shdrsz == 0 || hdr->e_shoff == 0 ||
  346             hdr->e_shentsize != sizeof(Elf_Shdr)) {
  347                 error = ENOEXEC;
  348                 goto out;
  349         }
  350         error = kobj_read(ko, (void **)&shdr, ko->ko_shdrsz, hdr->e_shoff);
  351         if (error != 0) {
  352                 goto out;
  353         }
  354         ko->ko_shdr = shdr;
  355 
  356         /*
  357          * Scan the section header for information and table sizing.
  358          */
  359         nsym = 0;
  360         symtabindex = -1;
  361         symstrindex = -1;
  362         for (i = 0; i < hdr->e_shnum; i++) {
  363                 switch (shdr[i].sh_type) {
  364                 case SHT_PROGBITS:
  365                 case SHT_NOBITS:
  366                         ko->ko_nprogtab++;
  367                         break;
  368                 case SHT_SYMTAB:
  369                         nsym++;
  370                         symtabindex = i;
  371                         symstrindex = shdr[i].sh_link;
  372                         break;
  373                 case SHT_REL:
  374                         ko->ko_nrel++;
  375                         break;
  376                 case SHT_RELA:
  377                         ko->ko_nrela++;
  378                         break;
  379                 case SHT_STRTAB:
  380                         break;
  381                 }
  382         }
  383         if (ko->ko_nprogtab == 0) {
  384                 kobj_error("file has no contents");
  385                 error = ENOEXEC;
  386                 goto out;
  387         }
  388         if (nsym != 1) {
  389                 /* Only allow one symbol table for now */
  390                 kobj_error("file has no valid symbol table");
  391                 error = ENOEXEC;
  392                 goto out;
  393         }
  394         if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
  395             shdr[symstrindex].sh_type != SHT_STRTAB) {
  396                 kobj_error("file has invalid symbol strings");
  397                 error = ENOEXEC;
  398                 goto out;
  399         }
  400 
  401         /*
  402          * Allocate space for tracking the load chunks.
  403          */
  404         if (ko->ko_nprogtab != 0) {
  405                 ko->ko_progtab = kmem_zalloc(ko->ko_nprogtab *
  406                     sizeof(*ko->ko_progtab), KM_SLEEP);
  407                 if (ko->ko_progtab == NULL) {
  408                         error = ENOMEM;
  409                         goto out;
  410                 }
  411         }
  412         if (ko->ko_nrel != 0) {
  413                 ko->ko_reltab = kmem_zalloc(ko->ko_nrel *
  414                     sizeof(*ko->ko_reltab), KM_SLEEP);
  415                 if (ko->ko_reltab == NULL) {
  416                         error = ENOMEM;
  417                         goto out;
  418                 }
  419         }
  420         if (ko->ko_nrela != 0) {
  421                 ko->ko_relatab = kmem_zalloc(ko->ko_nrela *
  422                     sizeof(*ko->ko_relatab), KM_SLEEP);
  423                 if (ko->ko_relatab == NULL) {
  424                         error = ENOMEM;
  425                         goto out;
  426                 }
  427         }
  428         if (symtabindex == -1) {
  429                 kobj_error("lost symbol table index");
  430                 goto out;
  431         }
  432 
  433         /*
  434          * Allocate space for and load the symbol table.
  435          */
  436         ko->ko_symcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
  437         if (ko->ko_symcnt == 0) {
  438                 kobj_error("no symbol table");
  439                 goto out;
  440         }
  441         error = kobj_read(ko, (void **)&ko->ko_symtab,
  442             ko->ko_symcnt * sizeof(Elf_Sym),
  443             shdr[symtabindex].sh_offset);
  444         if (error != 0) {
  445                 goto out;
  446         }
  447 
  448         /*
  449          * Allocate space for and load the symbol strings.
  450          */
  451         ko->ko_strtabsz = shdr[symstrindex].sh_size;
  452         if (ko->ko_strtabsz == 0) {
  453                 kobj_error("no symbol strings");
  454                 goto out;
  455         }
  456         error = kobj_read(ko, (void *)&ko->ko_strtab, ko->ko_strtabsz,
  457             shdr[symstrindex].sh_offset);
  458         if (error != 0) {
  459                 goto out;
  460         }
  461 
  462         /*
  463          * Do we have a string table for the section names?
  464          */
  465         if (hdr->e_shstrndx != 0 && shdr[hdr->e_shstrndx].sh_size != 0 &&
  466             shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
  467                 ko->ko_shstrtabsz = shdr[hdr->e_shstrndx].sh_size;
  468                 error = kobj_read(ko, (void *)&ko->ko_shstrtab,
  469                     shdr[hdr->e_shstrndx].sh_size,
  470                     shdr[hdr->e_shstrndx].sh_offset);
  471                 if (error != 0) {
  472                         goto out;
  473                 }
  474         }
  475 
  476         /*
  477          * Size up code/data(progbits) and bss(nobits).
  478          */
  479         alignmask = 0;
  480         mapbase = 0;
  481         for (i = 0; i < hdr->e_shnum; i++) {
  482                 switch (shdr[i].sh_type) {
  483                 case SHT_PROGBITS:
  484                 case SHT_NOBITS:
  485                         if (mapbase == 0)
  486                                 mapbase = shdr[i].sh_offset;
  487                         alignmask = shdr[i].sh_addralign - 1;
  488                         mapsize += alignmask;
  489                         mapsize &= ~alignmask;
  490                         mapsize += shdr[i].sh_size;
  491                         break;
  492                 }
  493         }
  494 
  495         /*
  496          * We know how much space we need for the text/data/bss/etc.
  497          * This stuff needs to be in a single chunk so that profiling etc
  498          * can get the bounds and gdb can associate offsets with modules.
  499          */
  500         if (mapsize == 0) {
  501                 kobj_error("no text/data/bss");
  502                 goto out;
  503         }
  504         if (ko->ko_type == KT_MEMORY) {
  505                 mapbase += (vaddr_t)ko->ko_source;
  506         } else {
  507                 mapbase = uvm_km_alloc(lkm_map, round_page(mapsize),
  508                     0, UVM_KMF_WIRED | UVM_KMF_EXEC);
  509                 if (mapbase == 0) {
  510                         error = ENOMEM;
  511                         goto out;
  512                 }
  513         }
  514         ko->ko_address = mapbase;
  515         ko->ko_size = mapsize;
  516 
  517         /*
  518          * Now load code/data(progbits), zero bss(nobits), allocate space
  519          * for and load relocs
  520          */
  521         pb = 0;
  522         rl = 0;
  523         ra = 0;
  524         alignmask = 0;
  525         for (i = 0; i < hdr->e_shnum; i++) {
  526                 switch (shdr[i].sh_type) {
  527                 case SHT_PROGBITS:
  528                 case SHT_NOBITS:
  529                         alignmask = shdr[i].sh_addralign - 1;
  530                         if (ko->ko_type == KT_MEMORY) {
  531                                 addr = (void *)(shdr[i].sh_offset +
  532                                     (vaddr_t)ko->ko_source);
  533                                 if (((vaddr_t)addr & alignmask) != 0) {
  534                                         kobj_error("section %d not aligned\n",
  535                                             i);
  536                                         goto out;
  537                                 }
  538                         } else {
  539                                 mapbase += alignmask;
  540                                 mapbase &= ~alignmask;
  541                                 addr = (void *)mapbase;
  542                                 mapbase += shdr[i].sh_size;
  543                         }
  544                         ko->ko_progtab[pb].addr = addr;
  545                         if (shdr[i].sh_type == SHT_PROGBITS) {
  546                                 ko->ko_progtab[pb].name = "<<PROGBITS>>";
  547                                 error = kobj_read_bits(ko, addr,
  548                                     shdr[i].sh_size, shdr[i].sh_offset);
  549                                 if (error != 0) {
  550                                         goto out;
  551                                 }
  552                         } else if (ko->ko_type == KT_MEMORY &&
  553                             shdr[i].sh_size != 0) {
  554                                 kobj_error("non-loadable BSS section in "
  555                                     "pre-loaded module");
  556                                 error = EINVAL;
  557                                 goto out;
  558                         } else {
  559                                 ko->ko_progtab[pb].name = "<<NOBITS>>";
  560                                 memset(addr, 0, shdr[i].sh_size);
  561                         }
  562                         ko->ko_progtab[pb].size = shdr[i].sh_size;
  563                         ko->ko_progtab[pb].sec = i;
  564                         if (ko->ko_shstrtab != NULL && shdr[i].sh_name != 0) {
  565                                 ko->ko_progtab[pb].name =
  566                                     ko->ko_shstrtab + shdr[i].sh_name;
  567                         }
  568 
  569                         /* Update all symbol values with the offset. */
  570                         for (j = 0; j < ko->ko_symcnt; j++) {
  571                                 es = &ko->ko_symtab[j];
  572                                 if (es->st_shndx != i) {
  573                                         continue;
  574                                 }
  575                                 es->st_value += (Elf_Addr)addr;
  576                         }
  577                         pb++;
  578                         break;
  579                 case SHT_REL:
  580                         ko->ko_reltab[rl].size = shdr[i].sh_size;
  581                         ko->ko_reltab[rl].size -=
  582                             shdr[i].sh_size % sizeof(Elf_Rel);
  583                         if (ko->ko_reltab[rl].size != 0) {
  584                                 ko->ko_reltab[rl].nrel =
  585                                     shdr[i].sh_size / sizeof(Elf_Rel);
  586                                 ko->ko_reltab[rl].sec = shdr[i].sh_info;
  587                                 error = kobj_read(ko,
  588                                     (void **)&ko->ko_reltab[rl].rel,
  589                                     ko->ko_reltab[rl].size,
  590                                     shdr[i].sh_offset);
  591                                 if (error != 0) {
  592                                         goto out;
  593                                 }
  594                         }
  595                         rl++;
  596                         break;
  597                 case SHT_RELA:
  598                         ko->ko_relatab[ra].size = shdr[i].sh_size;
  599                         ko->ko_relatab[ra].size -=
  600                             shdr[i].sh_size % sizeof(Elf_Rela);
  601                         if (ko->ko_relatab[ra].size != 0) {
  602                                 ko->ko_relatab[ra].nrela =
  603                                     shdr[i].sh_size / sizeof(Elf_Rela);
  604                                 ko->ko_relatab[ra].sec = shdr[i].sh_info;
  605                                 error = kobj_read(ko,
  606                                     (void **)&ko->ko_relatab[ra].rela,
  607                                     shdr[i].sh_size,
  608                                     shdr[i].sh_offset);
  609                                 if (error != 0) {
  610                                         goto out;
  611                                 }
  612                         }
  613                         ra++;
  614                         break;
  615                 default:
  616                         break;
  617                 }
  618         }
  619         if (pb != ko->ko_nprogtab) {
  620                 panic("lost progbits");
  621         }
  622         if (rl != ko->ko_nrel) {
  623                 panic("lost rel");
  624         }
  625         if (ra != ko->ko_nrela) {
  626                 panic("lost rela");
  627         }
  628         if (ko->ko_type != KT_MEMORY && mapbase != ko->ko_address + mapsize) {
  629                 panic("mapbase 0x%lx != address %lx + mapsize %ld (0x%lx)\n",
  630                     (long)mapbase, (long)ko->ko_address, (long)mapsize,
  631                     (long)ko->ko_address + mapsize);
  632         }
  633 
  634         /*
  635          * Perform local relocations only.  Relocations relating to global
  636          * symbols will be done by kobj_affix().
  637          */
  638         error = kobj_checkdup(ko);
  639         if (error == 0) {
  640                 error = kobj_relocate(ko, true);
  641         }
  642  out:
  643         if (hdr != NULL) {
  644                 kobj_free(ko, hdr, sizeof(*hdr));
  645         }
  646         kobj_close(ko);
  647         if (error != 0) {
  648                 kobj_unload(ko);
  649         }
  650 
  651         return error;
  652 }
  653 
  654 /*
  655  * kobj_unload:
  656  *
  657  *      Unload an object previously loaded by kobj_load().
  658  */
  659 void
  660 kobj_unload(kobj_t ko)
  661 {
  662         int error;
  663 
  664         kobj_close(ko);
  665         kobj_jettison(ko);
  666 
  667         /*
  668          * Notify MD code that a module has been unloaded.
  669          */
  670         if (ko->ko_loaded) {
  671                 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
  672                     false);
  673                 if (error != 0) {
  674                         kobj_error("machine dependent deinit failed");
  675                 }
  676         }
  677         if (ko->ko_address != 0 && ko->ko_type != KT_MEMORY) {
  678                 uvm_km_free(lkm_map, ko->ko_address, round_page(ko->ko_size),
  679                     UVM_KMF_WIRED);
  680         }
  681         if (ko->ko_ksyms == true) {
  682                 ksyms_modunload(ko->ko_name);
  683         }
  684         if (ko->ko_symtab != NULL) {
  685                 kobj_free(ko, ko->ko_symtab, ko->ko_symcnt * sizeof(Elf_Sym));
  686         }
  687         if (ko->ko_strtab != NULL) {
  688                 kobj_free(ko, ko->ko_strtab, ko->ko_strtabsz);
  689         }
  690         if (ko->ko_progtab != NULL) {
  691                 kobj_free(ko, ko->ko_progtab, ko->ko_nprogtab *
  692                     sizeof(*ko->ko_progtab));
  693                 ko->ko_progtab = NULL;
  694         }
  695         if (ko->ko_shstrtab) {
  696                 kobj_free(ko, ko->ko_shstrtab, ko->ko_shstrtabsz);
  697                 ko->ko_shstrtab = NULL;
  698         }
  699 
  700         kmem_free(ko, sizeof(*ko));
  701 }
  702 
  703 /*
  704  * kobj_stat:
  705  *
  706  *      Return size and load address of an object.
  707  */
  708 void
  709 kobj_stat(kobj_t ko, vaddr_t *address, size_t *size)
  710 {
  711 
  712         if (address != NULL) {
  713                 *address = ko->ko_address;
  714         }
  715         if (size != NULL) {
  716                 *size = ko->ko_size;
  717         }
  718 }
  719 
  720 /*
  721  * kobj_affix:
  722  *
  723  *      Set an object's name and perform global relocs.  May only be
  724  *      called after the module and any requisite modules are loaded.
  725  */
  726 int
  727 kobj_affix(kobj_t ko, const char *name)
  728 {
  729         int error;
  730 
  731         KASSERT(ko->ko_ksyms == false);
  732         KASSERT(ko->ko_loaded == false);
  733 
  734         strlcpy(ko->ko_name, name, sizeof(ko->ko_name));
  735 
  736         /* Now do global relocations. */
  737         error = kobj_relocate(ko, false);
  738 
  739         /*
  740          * Now that we know the name, register the symbol table.
  741          * Do after global relocations because ksyms will pack it.
  742          */
  743         ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt *
  744             sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz);
  745         ko->ko_ksyms = true;
  746 
  747         /* Jettison unneeded memory post-link. */
  748         kobj_jettison(ko);
  749 
  750         /* Notify MD code that a module has been loaded. */
  751         if (error == 0) {
  752                 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
  753                     true);
  754                 if (error != 0) {
  755                         kobj_error("machine dependent init failed");
  756                 }
  757                 ko->ko_loaded = true;
  758         }
  759 
  760         /* If there was an error, destroy the whole object. */
  761         if (error != 0) {
  762                 kobj_unload(ko);
  763         }
  764 
  765         return error;
  766 }
  767 
  768 /*
  769  * kobj_find_section:
  770  *
  771  *      Given a section name, search the loaded object and return
  772  *      virtual address if present and loaded.
  773  */
  774 int
  775 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size)
  776 {
  777         int i;
  778 
  779         KASSERT(ko->ko_progtab != NULL);
  780 
  781         for (i = 0; i < ko->ko_nprogtab; i++) {
  782                 if (strcmp(ko->ko_progtab[i].name, name) == 0) { 
  783                         if (addr != NULL) {
  784                                 *addr = ko->ko_progtab[i].addr;
  785                         }
  786                         if (size != NULL) {
  787                                 *size = ko->ko_progtab[i].size;
  788                         }
  789                         return 0;
  790                 }
  791         }
  792 
  793         return ENOENT;
  794 }
  795 
  796 /*
  797  * kobj_jettison: 
  798  *
  799  *      Release object data not needed after performing relocations.
  800  */
  801 static void
  802 kobj_jettison(kobj_t ko)
  803 {
  804         int i;
  805 
  806         if (ko->ko_reltab != NULL) {
  807                 for (i = 0; i < ko->ko_nrel; i++) {
  808                         if (ko->ko_reltab[i].rel) {
  809                                 kobj_free(ko, ko->ko_reltab[i].rel,
  810                                     ko->ko_reltab[i].size);
  811                         }
  812                 }
  813                 kobj_free(ko, ko->ko_reltab, ko->ko_nrel *
  814                     sizeof(*ko->ko_reltab));
  815                 ko->ko_reltab = NULL;
  816                 ko->ko_nrel = 0;
  817         }
  818         if (ko->ko_relatab != NULL) {
  819                 for (i = 0; i < ko->ko_nrela; i++) {
  820                         if (ko->ko_relatab[i].rela) {
  821                                 kobj_free(ko, ko->ko_relatab[i].rela,
  822                                     ko->ko_relatab[i].size);
  823                         }
  824                 }
  825                 kobj_free(ko, ko->ko_relatab, ko->ko_nrela *
  826                     sizeof(*ko->ko_relatab));
  827                 ko->ko_relatab = NULL;
  828                 ko->ko_nrela = 0;
  829         }
  830         if (ko->ko_shdr != NULL) {
  831                 kobj_free(ko, ko->ko_shdr, ko->ko_shdrsz);
  832                 ko->ko_shdr = NULL;
  833         }
  834 }
  835 
  836 /*
  837  * kobj_sym_lookup:
  838  *
  839  *      Symbol lookup function to be used when the symbol index
  840  *      is known (ie during relocation).
  841  */
  842 uintptr_t
  843 kobj_sym_lookup(kobj_t ko, uintptr_t symidx)
  844 {
  845         const Elf_Sym *sym;
  846         const char *symbol;
  847         int error;
  848         u_long addr;
  849 
  850         /* Don't even try to lookup the symbol if the index is bogus. */
  851         if (symidx >= ko->ko_symcnt)
  852                 return 0;
  853 
  854         sym = ko->ko_symtab + symidx;
  855 
  856         /* Quick answer if there is a definition included. */
  857         if (sym->st_shndx != SHN_UNDEF) {
  858                 return sym->st_value;
  859         }
  860 
  861         /* If we get here, then it is undefined and needs a lookup. */
  862         switch (ELF_ST_BIND(sym->st_info)) {
  863         case STB_LOCAL:
  864                 /* Local, but undefined? huh? */
  865                 kobj_error("local symbol undefined");
  866                 return 0;
  867 
  868         case STB_GLOBAL:
  869                 /* Relative to Data or Function name */
  870                 symbol = ko->ko_strtab + sym->st_name;
  871 
  872                 /* Force a lookup failure if the symbol name is bogus. */
  873                 if (*symbol == 0) {
  874                         kobj_error("bad symbol name");
  875                         return 0;
  876                 }
  877 
  878                 /*
  879                  * Don't need to lock, as it is known that the symbol
  880                  * tables aren't going to change (we hold module_lock).
  881                  */
  882                 error = ksyms_getval(NULL, symbol, &addr, KSYMS_ANY);
  883                 if (error != 0) {
  884                         kobj_error("symbol `%s' not found", symbol);
  885                         return (uintptr_t)0;
  886                 }
  887                 return (uintptr_t)addr;
  888 
  889         case STB_WEAK:
  890                 kobj_error("weak symbols not supported\n");
  891                 return 0;
  892 
  893         default:
  894                 return 0;
  895         }
  896 }
  897 
  898 /*
  899  * kobj_findbase:
  900  *
  901  *      Return base address of the given section.
  902  */
  903 static uintptr_t
  904 kobj_findbase(kobj_t ko, int sec)
  905 {
  906         int i;
  907 
  908         for (i = 0; i < ko->ko_nprogtab; i++) {
  909                 if (sec == ko->ko_progtab[i].sec) {
  910                         return (uintptr_t)ko->ko_progtab[i].addr;
  911                 }
  912         }
  913         return 0;
  914 }
  915 
  916 /*
  917  * kobj_checkdup:
  918  *
  919  *      Scan symbol table for duplicates.
  920  */
  921 static int
  922 kobj_checkdup(kobj_t ko)
  923 {
  924         unsigned long rval;
  925         Elf_Sym *sym, *ms;
  926         const char *name;
  927         bool dup;
  928 
  929         dup = false;
  930         for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) {
  931                 /* Check validity of the symbol. */
  932                 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL ||
  933                     sym->st_name == 0)
  934                         continue;
  935 
  936                 /* Check if the symbol already exists */
  937                 name = ko->ko_strtab + sym->st_name;
  938                 if (ksyms_getval(NULL, name, &rval, KSYMS_EXTERN) != 0) {
  939                         continue;
  940                 }
  941 
  942                 /* Check (and complain) about differing values */
  943                 if (sym->st_value == rval || sym->st_shndx == SHN_UNDEF) {
  944                         continue;
  945                 }
  946                 if (strcmp(name, "_bss_start") == 0 ||
  947                     strcmp(name, "__bss_start") == 0 ||
  948                     strcmp(name, "_bss_end__") == 0 ||
  949                     strcmp(name, "__bss_end__") == 0 ||
  950                     strcmp(name, "_edata") == 0 ||
  951                     strcmp(name, "_end") == 0 ||
  952                     strcmp(name, "__end") == 0 ||
  953                     strcmp(name, "__end__") == 0 ||
  954                     strncmp(name, "__start_link_set_", 17) == 0 ||
  955                     strncmp(name, "__stop_link_set_", 16)) {
  956                         continue;
  957                 }
  958                 kobj_error("global symbol `%s' redefined\n", name);
  959                 dup = true;
  960         }
  961 
  962         return dup ? EEXIST : 0;
  963 }
  964 
  965 /*
  966  * kobj_relocate:
  967  *
  968  *      Resolve relocations for the loaded object.
  969  */
  970 static int
  971 kobj_relocate(kobj_t ko, bool local)
  972 {
  973         const Elf_Rel *rellim;
  974         const Elf_Rel *rel;
  975         const Elf_Rela *relalim;
  976         const Elf_Rela *rela;
  977         const Elf_Sym *sym;
  978         uintptr_t base;
  979         int i, error;
  980         uintptr_t symidx;
  981 
  982         /*
  983          * Perform relocations without addend if there are any.
  984          */
  985         for (i = 0; i < ko->ko_nrel; i++) {
  986                 rel = ko->ko_reltab[i].rel;
  987                 if (rel == NULL) {
  988                         continue;
  989                 }
  990                 rellim = rel + ko->ko_reltab[i].nrel;
  991                 base = kobj_findbase(ko, ko->ko_reltab[i].sec);
  992                 if (base == 0) {
  993                         panic("lost base for e_reltab");
  994                 }
  995                 for (; rel < rellim; rel++) {
  996                         symidx = ELF_R_SYM(rel->r_info);
  997                         if (symidx >= ko->ko_symcnt) {
  998                                 continue;
  999                         }
 1000                         sym = ko->ko_symtab + symidx;
 1001                         if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) {
 1002                                 continue;
 1003                         }
 1004                         error = kobj_reloc(ko, base, rel, false, local);
 1005                         if (error != 0) {
 1006                                 return ENOENT;
 1007                         }
 1008                 }
 1009         }
 1010 
 1011         /*
 1012          * Perform relocations with addend if there are any.
 1013          */
 1014         for (i = 0; i < ko->ko_nrela; i++) {
 1015                 rela = ko->ko_relatab[i].rela;
 1016                 if (rela == NULL) {
 1017                         continue;
 1018                 }
 1019                 relalim = rela + ko->ko_relatab[i].nrela;
 1020                 base = kobj_findbase(ko, ko->ko_relatab[i].sec);
 1021                 if (base == 0) {
 1022                         panic("lost base for e_relatab");
 1023                 }
 1024                 for (; rela < relalim; rela++) {
 1025                         symidx = ELF_R_SYM(rela->r_info);
 1026                         if (symidx >= ko->ko_symcnt) {
 1027                                 continue;
 1028                         }
 1029                         sym = ko->ko_symtab + symidx;
 1030                         if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) {
 1031                                 continue;
 1032                         }
 1033                         error = kobj_reloc(ko, base, rela, true, local);
 1034                         if (error != 0) {
 1035                                 return ENOENT;
 1036                         }
 1037                 }
 1038         }
 1039 
 1040         return 0;
 1041 }
 1042 
 1043 /*
 1044  * kobj_error:
 1045  *
 1046  *      Utility function: log an error.
 1047  */
 1048 static void
 1049 kobj_error(const char *fmt, ...)
 1050 {
 1051         va_list ap;
 1052 
 1053         va_start(ap, fmt);
 1054         printf("WARNING: linker error: ");
 1055         vprintf(fmt, ap);
 1056         printf("\n");
 1057         va_end(ap);
 1058 }
 1059 
 1060 /*
 1061  * kobj_read:
 1062  *
 1063  *      Utility function: read from the object.
 1064  */
 1065 static int
 1066 kobj_read(kobj_t ko, void **basep, size_t size, off_t off)
 1067 {
 1068         size_t resid;
 1069         void *base;
 1070         int error;
 1071 
 1072         KASSERT(ko->ko_source != NULL);
 1073 
 1074         switch (ko->ko_type) {
 1075         case KT_VNODE:
 1076                 base = kmem_alloc(size, KM_SLEEP);
 1077                 if (base == NULL) {
 1078                         error = ENOMEM;
 1079                         break;
 1080                 }
 1081                 error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off,
 1082                     UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid,
 1083                     curlwp);
 1084                 if (error == 0 && resid != 0) {
 1085                         error = EINVAL;
 1086                 }
 1087                 if (error != 0) {
 1088                         kmem_free(base, size);
 1089                         base = NULL;
 1090                 }
 1091                 break;
 1092         case KT_MEMORY:
 1093                 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
 1094                         kobj_error("kobj_read: preloaded object short");
 1095                         error = EINVAL;
 1096                         base = NULL;
 1097                 } else {
 1098                         base = (uint8_t *)ko->ko_source + off;
 1099                         error = 0;
 1100                 }
 1101                 break;
 1102         default:
 1103                 panic("kobj_read: invalid type");
 1104         }
 1105 
 1106         *basep = base;
 1107         return error;
 1108 }
 1109 
 1110 /*
 1111  * kobj_read_bits:
 1112  *
 1113  *      Utility function: load a section from the object.
 1114  */
 1115 static int
 1116 kobj_read_bits(kobj_t ko, void *base, size_t size, off_t off)
 1117 {
 1118         size_t resid;
 1119         int error;
 1120 
 1121         KASSERT(ko->ko_source != NULL);
 1122 
 1123         switch (ko->ko_type) {
 1124         case KT_VNODE:
 1125                 KASSERT((uintptr_t)base >= (uintptr_t)ko->ko_address);
 1126                 KASSERT((uintptr_t)base + size <=
 1127                     (uintptr_t)ko->ko_address + ko->ko_size);
 1128                 error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off,
 1129                     UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid,
 1130                     curlwp);
 1131                 if (error == 0 && resid != 0) {
 1132                         error = EINVAL;
 1133                 }
 1134                 break;
 1135         case KT_MEMORY:
 1136                 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
 1137                         kobj_error("kobj_read_bits: preloaded object short");
 1138                         error = EINVAL;
 1139                 } else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) {
 1140                         kobj_error("kobj_read_bits: object not aligned");
 1141                         kobj_error("source=%p base=%p off=%d size=%zd",
 1142                             ko->ko_source, base, (int)off, size);
 1143                         error = EINVAL;
 1144                 } else {
 1145                         /* Nothing to do.  Loading in-situ. */
 1146                         error = 0;
 1147                 }
 1148                 break;
 1149         default:
 1150                 panic("kobj_read: invalid type");
 1151         }
 1152 
 1153         return error;
 1154 }
 1155 
 1156 /*
 1157  * kobj_free:
 1158  *
 1159  *      Utility function: free memory if it was allocated from the heap.
 1160  */
 1161 static void
 1162 kobj_free(kobj_t ko, void *base, size_t size)
 1163 {
 1164 
 1165         if (ko->ko_type != KT_MEMORY)
 1166                 kmem_free(base, size);
 1167 }
 1168 
 1169 #else   /* MODULAR */
 1170 
 1171 int
 1172 kobj_load_file(kobj_t *kop, const char *name, const char *base, bool autoload)
 1173 {
 1174 
 1175         return ENOSYS;
 1176 }
 1177 
 1178 int
 1179 kobj_load_mem(kobj_t *kop, void *base, ssize_t size)
 1180 {
 1181 
 1182         return ENOSYS;
 1183 }
 1184 
 1185 void
 1186 kobj_unload(kobj_t ko)
 1187 {
 1188 
 1189         panic("not modular");
 1190 }
 1191 
 1192 void
 1193 kobj_stat(kobj_t ko, vaddr_t *base, size_t *size)
 1194 {
 1195 
 1196         panic("not modular");
 1197 }
 1198 
 1199 int
 1200 kobj_affix(kobj_t ko, const char *name)
 1201 {
 1202 
 1203         panic("not modular");
 1204 }
 1205 
 1206 int
 1207 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size)
 1208 {
 1209 
 1210         panic("not modular");
 1211 }
 1212 
 1213 #endif  /* MODULAR */

Cache object: d176327d99fa9b44773acaae941371dd


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


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