ksyms.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 /*-
    2  * Copyright (c) 2008-2009, Stacey Son <sson@freebsd.org>
    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$
   27  */
   28 
   29 #include <sys/param.h>
   30 #include <sys/systm.h>
   31 #include <sys/kernel.h>
   32 
   33 #include <sys/conf.h>
   34 #include <sys/elf.h>
   35 #include <sys/linker.h>
   36 #include <sys/malloc.h>
   37 #include <sys/mman.h>
   38 #include <sys/module.h>
   39 #include <sys/proc.h>
   40 #include <sys/queue.h>
   41 #include <sys/resourcevar.h>
   42 #include <sys/stat.h>
   43 #include <sys/sx.h>
   44 #include <sys/uio.h>
   45 
   46 #include <machine/elf.h>
   47 
   48 #include <vm/pmap.h>
   49 #include <vm/vm.h>
   50 #include <vm/vm_extern.h>
   51 #include <vm/vm_object.h>
   52 
   53 #include "linker_if.h"
   54 
   55 #define SHDR_NULL       0
   56 #define SHDR_SYMTAB     1
   57 #define SHDR_STRTAB     2
   58 #define SHDR_SHSTRTAB   3
   59 
   60 #define SHDR_NUM        4
   61 
   62 #define STR_SYMTAB      ".symtab"
   63 #define STR_STRTAB      ".strtab"
   64 #define STR_SHSTRTAB    ".shstrtab"
   65 
   66 #define KSYMS_DNAME     "ksyms"
   67 
   68 static d_open_t ksyms_open;
   69 static d_read_t ksyms_read;
   70 static d_mmap_single_t ksyms_mmap_single;
   71 
   72 static struct cdevsw ksyms_cdevsw = {
   73         .d_version =    D_VERSION,
   74         .d_flags =      D_TRACKCLOSE,
   75         .d_open =       ksyms_open,
   76         .d_read =       ksyms_read,
   77         .d_mmap_single = ksyms_mmap_single,
   78         .d_name =       KSYMS_DNAME
   79 };
   80 
   81 struct ksyms_softc {
   82         LIST_ENTRY(ksyms_softc) sc_list;
   83         vm_offset_t             sc_uaddr;
   84         size_t                  sc_usize;
   85         vm_object_t             sc_obj;
   86         vm_size_t               sc_objsz;
   87         struct proc            *sc_proc;
   88 };
   89 
   90 static struct sx                 ksyms_mtx;
   91 static struct cdev              *ksyms_dev;
   92 static LIST_HEAD(, ksyms_softc)  ksyms_list = LIST_HEAD_INITIALIZER(ksyms_list);
   93 
   94 static const char       ksyms_shstrtab[] =
   95         "\0" STR_SYMTAB "\0" STR_STRTAB "\0" STR_SHSTRTAB "\0";
   96 
   97 struct ksyms_hdr {
   98         Elf_Ehdr        kh_ehdr;
   99         Elf_Phdr        kh_txtphdr;
  100         Elf_Phdr        kh_datphdr;
  101         Elf_Shdr        kh_shdr[SHDR_NUM];
  102         char            kh_shstrtab[sizeof(ksyms_shstrtab)];
  103 };
  104 
  105 struct tsizes {
  106         size_t          ts_symsz;
  107         size_t          ts_strsz;
  108 };
  109 
  110 struct toffsets {
  111         struct ksyms_softc *to_sc;
  112         vm_offset_t     to_symoff;
  113         vm_offset_t     to_stroff;
  114         unsigned        to_stridx;
  115         size_t          to_resid;
  116 };
  117 
  118 static MALLOC_DEFINE(M_KSYMS, "KSYMS", "Kernel Symbol Table");
  119 
  120 /*
  121  * Get the symbol and string table sizes for a kernel module. Add it to the
  122  * running total.
  123  */
  124 static int
  125 ksyms_size_permod(linker_file_t lf, void *arg)
  126 {
  127         struct tsizes *ts;
  128         const Elf_Sym *symtab;
  129         caddr_t strtab;
  130         long syms;
  131 
  132         ts = arg;
  133 
  134         syms = LINKER_SYMTAB_GET(lf, &symtab);
  135         ts->ts_symsz += syms * sizeof(Elf_Sym);
  136         ts->ts_strsz += LINKER_STRTAB_GET(lf, &strtab);
  137 
  138         return (0);
  139 }
  140 
  141 /*
  142  * For kernel module get the symbol and string table sizes, returning the
  143  * totals in *ts.
  144  */
  145 static void
  146 ksyms_size_calc(struct tsizes *ts)
  147 {
  148 
  149         ts->ts_symsz = 0;
  150         ts->ts_strsz = 0;
  151 
  152         (void)linker_file_foreach(ksyms_size_permod, ts);
  153 }
  154 
  155 static int
  156 ksyms_emit(struct ksyms_softc *sc, void *buf, off_t off, size_t sz)
  157 {
  158         struct iovec iov;
  159         struct uio uio;
  160 
  161         iov.iov_base = buf;
  162         iov.iov_len = sz;
  163         uio.uio_iov = &iov;
  164         uio.uio_iovcnt = 1;
  165         uio.uio_offset = off;
  166         uio.uio_resid = (ssize_t)sz;
  167         uio.uio_segflg = UIO_SYSSPACE;
  168         uio.uio_rw = UIO_WRITE;
  169         uio.uio_td = curthread;
  170 
  171         return (uiomove_object(sc->sc_obj, sc->sc_objsz, &uio));
  172 }
  173 
  174 #define SYMBLKSZ        (256 * sizeof(Elf_Sym))
  175 
  176 /*
  177  * For a kernel module, add the symbol and string tables into the
  178  * snapshot buffer.  Fix up the offsets in the tables.
  179  */
  180 static int
  181 ksyms_add(linker_file_t lf, void *arg)
  182 {
  183         char *buf;
  184         struct ksyms_softc *sc;
  185         struct toffsets *to;
  186         const Elf_Sym *symtab;
  187         Elf_Sym *symp;
  188         caddr_t strtab;
  189         size_t len, numsyms, strsz, symsz;
  190         linker_symval_t symval;
  191         int error, i, nsyms;
  192 
  193         buf = malloc(SYMBLKSZ, M_KSYMS, M_WAITOK);
  194         to = arg;
  195         sc = to->to_sc;
  196 
  197         MOD_SLOCK;
  198         numsyms =  LINKER_SYMTAB_GET(lf, &symtab);
  199         strsz = LINKER_STRTAB_GET(lf, &strtab);
  200         symsz = numsyms * sizeof(Elf_Sym);
  201 
  202         while (symsz > 0) {
  203                 len = min(SYMBLKSZ, symsz);
  204                 bcopy(symtab, buf, len);
  205 
  206                 /*
  207                  * Fix up symbol table for kernel modules:
  208                  *   string offsets need adjusted
  209                  *   symbol values made absolute
  210                  */
  211                 symp = (Elf_Sym *) buf;
  212                 nsyms = len / sizeof(Elf_Sym);
  213                 for (i = 0; i < nsyms; i++) {
  214                         symp[i].st_name += to->to_stridx;
  215                         if (lf->id > 1 && LINKER_SYMBOL_VALUES(lf,
  216                             (c_linker_sym_t)&symtab[i], &symval) == 0) {
  217                                 symp[i].st_value = (uintptr_t)symval.value;
  218                         }
  219                 }
  220 
  221                 if (len > to->to_resid) {
  222                         MOD_SUNLOCK;
  223                         free(buf, M_KSYMS);
  224                         return (ENXIO);
  225                 }
  226                 to->to_resid -= len;
  227                 error = ksyms_emit(sc, buf, to->to_symoff, len);
  228                 to->to_symoff += len;
  229                 if (error != 0) {
  230                         MOD_SUNLOCK;
  231                         free(buf, M_KSYMS);
  232                         return (error);
  233                 }
  234 
  235                 symtab += nsyms;
  236                 symsz -= len;
  237         }
  238         free(buf, M_KSYMS);
  239         MOD_SUNLOCK;
  240 
  241         if (strsz > to->to_resid)
  242                 return (ENXIO);
  243         to->to_resid -= strsz;
  244         error = ksyms_emit(sc, strtab, to->to_stroff, strsz);
  245         to->to_stroff += strsz;
  246         to->to_stridx += strsz;
  247 
  248         return (error);
  249 }
  250 
  251 /*
  252  * Create a single ELF symbol table for the kernel and kernel modules loaded
  253  * at this time. Write this snapshot out in the process address space. Return
  254  * 0 on success, otherwise error.
  255  */
  256 static int
  257 ksyms_snapshot(struct ksyms_softc *sc, struct tsizes *ts)
  258 {
  259         struct toffsets to;
  260         struct ksyms_hdr *hdr;
  261         int error;
  262 
  263         hdr = malloc(sizeof(*hdr), M_KSYMS, M_WAITOK | M_ZERO);
  264 
  265         /*
  266          * Create the ELF header.
  267          */
  268         hdr->kh_ehdr.e_ident[EI_PAD] = 0;
  269         hdr->kh_ehdr.e_ident[EI_MAG0] = ELFMAG0;
  270         hdr->kh_ehdr.e_ident[EI_MAG1] = ELFMAG1;
  271         hdr->kh_ehdr.e_ident[EI_MAG2] = ELFMAG2;
  272         hdr->kh_ehdr.e_ident[EI_MAG3] = ELFMAG3;
  273         hdr->kh_ehdr.e_ident[EI_DATA] = ELF_DATA;
  274         hdr->kh_ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
  275         hdr->kh_ehdr.e_ident[EI_CLASS] = ELF_CLASS;
  276         hdr->kh_ehdr.e_ident[EI_VERSION] = EV_CURRENT;
  277         hdr->kh_ehdr.e_ident[EI_ABIVERSION] = 0;
  278         hdr->kh_ehdr.e_type = ET_EXEC;
  279         hdr->kh_ehdr.e_machine = ELF_ARCH;
  280         hdr->kh_ehdr.e_version = EV_CURRENT;
  281         hdr->kh_ehdr.e_entry = 0;
  282         hdr->kh_ehdr.e_phoff = offsetof(struct ksyms_hdr, kh_txtphdr);
  283         hdr->kh_ehdr.e_shoff = offsetof(struct ksyms_hdr, kh_shdr);
  284         hdr->kh_ehdr.e_flags = 0;
  285         hdr->kh_ehdr.e_ehsize = sizeof(Elf_Ehdr);
  286         hdr->kh_ehdr.e_phentsize = sizeof(Elf_Phdr);
  287         hdr->kh_ehdr.e_phnum = 2;       /* Text and Data */
  288         hdr->kh_ehdr.e_shentsize = sizeof(Elf_Shdr);
  289         hdr->kh_ehdr.e_shnum = SHDR_NUM;
  290         hdr->kh_ehdr.e_shstrndx = SHDR_SHSTRTAB;
  291 
  292         /*
  293          * Add both the text and data program headers.
  294          */
  295         hdr->kh_txtphdr.p_type = PT_LOAD;
  296         /* XXX - is there a way to put the actual .text addr/size here? */
  297         hdr->kh_txtphdr.p_vaddr = 0;
  298         hdr->kh_txtphdr.p_memsz = 0;
  299         hdr->kh_txtphdr.p_flags = PF_R | PF_X;
  300 
  301         hdr->kh_datphdr.p_type = PT_LOAD;
  302         /* XXX - is there a way to put the actual .data addr/size here? */
  303         hdr->kh_datphdr.p_vaddr = 0;
  304         hdr->kh_datphdr.p_memsz = 0;
  305         hdr->kh_datphdr.p_flags = PF_R | PF_W | PF_X;
  306 
  307         /*
  308          * Add the section headers: null, symtab, strtab, shstrtab.
  309          */
  310 
  311         /* First section header - null */
  312 
  313         /* Second section header - symtab */
  314         hdr->kh_shdr[SHDR_SYMTAB].sh_name = 1; /* String offset (skip null) */
  315         hdr->kh_shdr[SHDR_SYMTAB].sh_type = SHT_SYMTAB;
  316         hdr->kh_shdr[SHDR_SYMTAB].sh_flags = 0;
  317         hdr->kh_shdr[SHDR_SYMTAB].sh_addr = 0;
  318         hdr->kh_shdr[SHDR_SYMTAB].sh_offset = sizeof(*hdr);
  319         hdr->kh_shdr[SHDR_SYMTAB].sh_size = ts->ts_symsz;
  320         hdr->kh_shdr[SHDR_SYMTAB].sh_link = SHDR_STRTAB;
  321         hdr->kh_shdr[SHDR_SYMTAB].sh_info = ts->ts_symsz / sizeof(Elf_Sym);
  322         hdr->kh_shdr[SHDR_SYMTAB].sh_addralign = sizeof(long);
  323         hdr->kh_shdr[SHDR_SYMTAB].sh_entsize = sizeof(Elf_Sym);
  324 
  325         /* Third section header - strtab */
  326         hdr->kh_shdr[SHDR_STRTAB].sh_name = 1 + sizeof(STR_SYMTAB);
  327         hdr->kh_shdr[SHDR_STRTAB].sh_type = SHT_STRTAB;
  328         hdr->kh_shdr[SHDR_STRTAB].sh_flags = 0;
  329         hdr->kh_shdr[SHDR_STRTAB].sh_addr = 0;
  330         hdr->kh_shdr[SHDR_STRTAB].sh_offset =
  331             hdr->kh_shdr[SHDR_SYMTAB].sh_offset + ts->ts_symsz;
  332         hdr->kh_shdr[SHDR_STRTAB].sh_size = ts->ts_strsz;
  333         hdr->kh_shdr[SHDR_STRTAB].sh_link = 0;
  334         hdr->kh_shdr[SHDR_STRTAB].sh_info = 0;
  335         hdr->kh_shdr[SHDR_STRTAB].sh_addralign = sizeof(char);
  336         hdr->kh_shdr[SHDR_STRTAB].sh_entsize = 0;
  337 
  338         /* Fourth section - shstrtab */
  339         hdr->kh_shdr[SHDR_SHSTRTAB].sh_name = 1 + sizeof(STR_SYMTAB) +
  340             sizeof(STR_STRTAB);
  341         hdr->kh_shdr[SHDR_SHSTRTAB].sh_type = SHT_STRTAB;
  342         hdr->kh_shdr[SHDR_SHSTRTAB].sh_flags = 0;
  343         hdr->kh_shdr[SHDR_SHSTRTAB].sh_addr = 0;
  344         hdr->kh_shdr[SHDR_SHSTRTAB].sh_offset =
  345             offsetof(struct ksyms_hdr, kh_shstrtab);
  346         hdr->kh_shdr[SHDR_SHSTRTAB].sh_size = sizeof(ksyms_shstrtab);
  347         hdr->kh_shdr[SHDR_SHSTRTAB].sh_link = 0;
  348         hdr->kh_shdr[SHDR_SHSTRTAB].sh_info = 0;
  349         hdr->kh_shdr[SHDR_SHSTRTAB].sh_addralign = 0 /* sizeof(char) */;
  350         hdr->kh_shdr[SHDR_SHSTRTAB].sh_entsize = 0;
  351 
  352         /* Copy shstrtab into the header. */
  353         bcopy(ksyms_shstrtab, hdr->kh_shstrtab, sizeof(ksyms_shstrtab));
  354 
  355         to.to_sc = sc;
  356         to.to_symoff = hdr->kh_shdr[SHDR_SYMTAB].sh_offset;
  357         to.to_stroff = hdr->kh_shdr[SHDR_STRTAB].sh_offset;
  358         to.to_stridx = 0;
  359         to.to_resid = sc->sc_objsz - sizeof(struct ksyms_hdr);
  360 
  361         /* emit header */
  362         error = ksyms_emit(sc, hdr, 0, sizeof(*hdr));
  363         free(hdr, M_KSYMS);
  364         if (error != 0)
  365                 return (error);
  366 
  367         /* Add symbol and string tables for each kernel module. */
  368         error = linker_file_foreach(ksyms_add, &to);
  369         if (error != 0)
  370                 return (error);
  371         if (to.to_resid != 0)
  372                 return (ENXIO);
  373         return (0);
  374 }
  375 
  376 static void
  377 ksyms_cdevpriv_dtr(void *data)
  378 {
  379         struct ksyms_softc *sc;
  380         vm_object_t obj;
  381 
  382         sc = (struct ksyms_softc *)data;
  383 
  384         sx_xlock(&ksyms_mtx);
  385         LIST_REMOVE(sc, sc_list);
  386         sx_xunlock(&ksyms_mtx);
  387         obj = sc->sc_obj;
  388         if (obj != NULL)
  389                 vm_object_deallocate(obj);
  390         free(sc, M_KSYMS);
  391 }
  392 
  393 static int
  394 ksyms_open(struct cdev *dev, int flags, int fmt __unused, struct thread *td)
  395 {
  396         struct tsizes ts;
  397         struct ksyms_softc *sc;
  398         vm_size_t elfsz;
  399         int error, try;
  400 
  401         /*
  402          * Limit one open() per process. The process must close()
  403          * before open()'ing again.
  404          */
  405         sx_xlock(&ksyms_mtx);
  406         LIST_FOREACH(sc, &ksyms_list, sc_list) {
  407                 if (sc->sc_proc == td->td_proc) {
  408                         sx_xunlock(&ksyms_mtx);
  409                         return (EBUSY);
  410                 }
  411         }
  412 
  413         sc = malloc(sizeof(*sc), M_KSYMS, M_WAITOK | M_ZERO);
  414         sc->sc_proc = td->td_proc;
  415         LIST_INSERT_HEAD(&ksyms_list, sc, sc_list);
  416         sx_xunlock(&ksyms_mtx);
  417 
  418         error = devfs_set_cdevpriv(sc, ksyms_cdevpriv_dtr);
  419         if (error != 0) {
  420                 ksyms_cdevpriv_dtr(sc);
  421                 return (error);
  422         }
  423 
  424         /*
  425          * MOD_SLOCK doesn't work here (because of a lock reversal with
  426          * KLD_SLOCK).  Therefore, simply try up to 3 times to get a "clean"
  427          * snapshot of the kernel symbol table.  This should work fine in the
  428          * rare case of a kernel module being loaded/unloaded at the same
  429          * time.
  430          */
  431         for (try = 0; try < 3; try++) {
  432                 ksyms_size_calc(&ts);
  433                 elfsz = sizeof(struct ksyms_hdr) + ts.ts_symsz + ts.ts_strsz;
  434 
  435                 sc->sc_obj = vm_object_allocate(OBJT_DEFAULT,
  436                     OFF_TO_IDX(round_page(elfsz)));
  437                 sc->sc_objsz = elfsz;
  438 
  439                 error = ksyms_snapshot(sc, &ts);
  440                 if (error == 0)
  441                         break;
  442 
  443                 vm_object_deallocate(sc->sc_obj);
  444                 sc->sc_obj = NULL;
  445         }
  446         return (error);
  447 }
  448 
  449 static int
  450 ksyms_read(struct cdev *dev, struct uio *uio, int flags __unused)
  451 {
  452         struct ksyms_softc *sc;
  453         int error;
  454 
  455         error = devfs_get_cdevpriv((void **)&sc);
  456         if (error != 0)
  457                 return (error);
  458         return (uiomove_object(sc->sc_obj, sc->sc_objsz, uio));
  459 }
  460 
  461 static int
  462 ksyms_mmap_single(struct cdev *dev, vm_ooffset_t *offset, vm_size_t size,
  463     vm_object_t *objp, int nprot)
  464 {
  465         struct ksyms_softc *sc;
  466         vm_object_t obj;
  467         int error;
  468 
  469         error = devfs_get_cdevpriv((void **)&sc);
  470         if (error != 0)
  471                 return (error);
  472 
  473         if (*offset < 0 || *offset >= round_page(sc->sc_objsz) ||
  474             size > round_page(sc->sc_objsz) - *offset ||
  475             (nprot & ~PROT_READ) != 0)
  476                 return (EINVAL);
  477 
  478         obj = sc->sc_obj;
  479         vm_object_reference(obj);
  480         *objp = obj;
  481         return (0);
  482 }
  483 
  484 static int
  485 ksyms_modevent(module_t mod __unused, int type, void *data __unused)
  486 {
  487         int error;
  488 
  489         error = 0;
  490         switch (type) {
  491         case MOD_LOAD:
  492                 sx_init(&ksyms_mtx, "KSyms mtx");
  493                 ksyms_dev = make_dev(&ksyms_cdevsw, 0, UID_ROOT, GID_WHEEL,
  494                     0400, KSYMS_DNAME);
  495                 break;
  496         case MOD_UNLOAD:
  497                 if (!LIST_EMPTY(&ksyms_list))
  498                         return (EBUSY);
  499                 destroy_dev(ksyms_dev);
  500                 sx_destroy(&ksyms_mtx);
  501                 break;
  502         case MOD_SHUTDOWN:
  503                 break;
  504         default:
  505                 error = EOPNOTSUPP;
  506                 break;
  507         }
  508         return (error);
  509 }
  510 
  511 DEV_MODULE(ksyms, ksyms_modevent, NULL);
  512 MODULE_VERSION(ksyms, 1);
Cache object: 18809dc5a0dbde199084ddbe24cc77fe
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/dev/ksyms/ksyms.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/ksyms/ksyms.c
