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/dev/ksyms/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: releng/8.2/sys/dev/ksyms/ksyms.c 203184 2010-01-30 12:11:21Z antoine $
   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/ksyms.h>
   36 #include <sys/linker.h>
   37 #include <sys/malloc.h>
   38 #include <sys/mman.h>
   39 #include <sys/module.h>
   40 #include <sys/mutex.h>
   41 #include <sys/proc.h>
   42 #include <sys/queue.h>
   43 #include <sys/resourcevar.h>
   44 #include <sys/stat.h>
   45 #include <sys/uio.h>
   46 
   47 #include <machine/elf.h>
   48 
   49 #include <vm/pmap.h>
   50 #include <vm/vm.h>
   51 #include <vm/vm_extern.h>
   52 #include <vm/vm_map.h>
   53 
   54 #include "linker_if.h"
   55 
   56 #define SHDR_NULL       0
   57 #define SHDR_SYMTAB     1
   58 #define SHDR_STRTAB     2
   59 #define SHDR_SHSTRTAB   3
   60 
   61 #define SHDR_NUM        4
   62 
   63 #define STR_SYMTAB      ".symtab"
   64 #define STR_STRTAB      ".strtab"
   65 #define STR_SHSTRTAB    ".shstrtab" 
   66 
   67 #define KSYMS_DNAME     "ksyms"
   68 
   69 static  d_open_t        ksyms_open;
   70 static  d_read_t        ksyms_read;
   71 static  d_close_t       ksyms_close;
   72 static  d_ioctl_t       ksyms_ioctl;
   73 static  d_mmap_t        ksyms_mmap;
   74 
   75 static struct cdevsw ksyms_cdevsw = {
   76     .d_version  =       D_VERSION,
   77     .d_flags    =       D_PSEUDO | D_TRACKCLOSE,
   78     .d_open     =       ksyms_open,
   79     .d_close    =       ksyms_close,
   80     .d_read     =       ksyms_read,
   81     .d_ioctl    =       ksyms_ioctl,
   82     .d_mmap     =       ksyms_mmap,
   83     .d_name     =       KSYMS_DNAME     
   84 };
   85 
   86 struct ksyms_softc {
   87         LIST_ENTRY(ksyms_softc) sc_list;
   88         vm_offset_t             sc_uaddr;
   89         size_t                  sc_usize;
   90         pmap_t                  sc_pmap;
   91         struct proc            *sc_proc;
   92 };
   93 
   94 static struct mtx                ksyms_mtx;
   95 static struct cdev              *ksyms_dev;
   96 static LIST_HEAD(, ksyms_softc)  ksyms_list = 
   97         LIST_HEAD_INITIALIZER(ksyms_list);
   98 
   99 static const char       ksyms_shstrtab[] = 
  100         "\0" STR_SYMTAB "\0" STR_STRTAB "\0" STR_SHSTRTAB "\0";
  101 
  102 struct ksyms_hdr {
  103         Elf_Ehdr        kh_ehdr;
  104         Elf_Phdr        kh_txtphdr;
  105         Elf_Phdr        kh_datphdr;
  106         Elf_Shdr        kh_shdr[SHDR_NUM];
  107         char            kh_shstrtab[sizeof(ksyms_shstrtab)];
  108 };
  109         
  110 struct tsizes {
  111         size_t          ts_symsz;
  112         size_t          ts_strsz;
  113 };
  114 
  115 struct toffsets {
  116         vm_offset_t     to_symoff;
  117         vm_offset_t     to_stroff;
  118         unsigned        to_stridx;
  119         size_t          to_resid;
  120 };
  121 
  122 static MALLOC_DEFINE(M_KSYMS, "KSYMS", "Kernel Symbol Table");
  123 
  124 /*
  125  * Get the symbol and string table sizes for a kernel module. Add it to the
  126  * running total. 
  127  */
  128 static int
  129 ksyms_size_permod(linker_file_t lf, void *arg)
  130 {
  131         struct tsizes *ts;
  132         const Elf_Sym *symtab;
  133         caddr_t strtab;
  134         long syms;
  135         
  136         ts = arg;
  137     
  138         syms = LINKER_SYMTAB_GET(lf, &symtab);
  139         ts->ts_symsz += syms * sizeof(Elf_Sym);
  140         ts->ts_strsz += LINKER_STRTAB_GET(lf, &strtab);
  141         
  142         return (0);
  143 }
  144 
  145 /*
  146  * For kernel module get the symbol and string table sizes, returning the
  147  * totals in *ts. 
  148  */
  149 static void 
  150 ksyms_size_calc(struct tsizes *ts)
  151 {
  152         ts->ts_symsz = 0;
  153         ts->ts_strsz = 0;
  154     
  155         (void) linker_file_foreach(ksyms_size_permod, ts);
  156 }
  157 
  158 #define KSYMS_EMIT(src, des, sz) do {                           \
  159                 copyout(src, (void *)des, sz);                  \
  160                 des += sz;                                      \
  161         } while (0)
  162 
  163 #define SYMBLKSZ        256 * sizeof (Elf_Sym)
  164 
  165 /*
  166  * For a kernel module, add the symbol and string tables into the
  167  * snapshot buffer.  Fix up the offsets in the tables.
  168  */
  169 static int
  170 ksyms_add(linker_file_t lf, void *arg)
  171 {
  172         struct toffsets *to;
  173         const Elf_Sym *symtab;
  174         Elf_Sym *symp;
  175         caddr_t strtab;
  176         long symsz;
  177         size_t strsz, numsyms;
  178         linker_symval_t symval;
  179         char *buf;
  180         int i, nsyms, len;
  181         
  182         to = arg;
  183     
  184         MOD_SLOCK;
  185         numsyms =  LINKER_SYMTAB_GET(lf, &symtab);
  186         strsz = LINKER_STRTAB_GET(lf, &strtab);
  187         symsz = numsyms * sizeof(Elf_Sym);
  188         
  189         buf = malloc(SYMBLKSZ, M_KSYMS, M_WAITOK);
  190         
  191         while (symsz > 0) {
  192                 len = min(SYMBLKSZ, symsz);
  193                 bcopy(symtab, buf, len);
  194 
  195                 /* 
  196                  * Fix up symbol table for kernel modules: 
  197                  *   string offsets need adjusted 
  198                  *   symbol values made absolute
  199                  */
  200                 symp = (Elf_Sym *) buf;
  201                 nsyms = len / sizeof (Elf_Sym);
  202                 for (i = 0; i < nsyms; i++) {
  203                         symp[i].st_name += to->to_stridx;
  204                         if (lf->id > 1 && LINKER_SYMBOL_VALUES(lf, 
  205                                 (c_linker_sym_t) &symtab[i], &symval) == 0) {
  206                                 symp[i].st_value = (uintptr_t) symval.value;
  207                         }
  208                 }
  209 
  210                 if (len > to->to_resid) { 
  211                         MOD_SUNLOCK;
  212                         free(buf, M_KSYMS);
  213                         return (ENXIO);
  214                 } else
  215                         to->to_resid -= len;
  216                 KSYMS_EMIT(buf, to->to_symoff, len);
  217 
  218                 symtab += nsyms;
  219                 symsz -= len;
  220         }
  221         free(buf, M_KSYMS);
  222         MOD_SUNLOCK;
  223         
  224         if (strsz > to->to_resid)
  225                 return (ENXIO);
  226         else
  227                 to->to_resid -= strsz;
  228         KSYMS_EMIT(strtab, to->to_stroff, strsz);
  229         to->to_stridx += strsz;
  230         
  231         return (0);
  232 }
  233 
  234 /*
  235  * Create a single ELF symbol table for the kernel and kernel modules loaded
  236  * at this time. Write this snapshot out in the process address space. Return
  237  * 0 on success, otherwise error.
  238  */
  239 static int
  240 ksyms_snapshot(struct tsizes *ts, vm_offset_t uaddr, size_t resid)
  241 {
  242 
  243         struct ksyms_hdr *hdr;
  244         struct toffsets  to;
  245         int error = 0;
  246 
  247         /* Be kernel stack friendly */
  248         hdr = malloc(sizeof (*hdr), M_KSYMS, M_WAITOK|M_ZERO);
  249 
  250         /* 
  251          * Create the ELF header. 
  252          */
  253         hdr->kh_ehdr.e_ident[EI_PAD] = 0;
  254         hdr->kh_ehdr.e_ident[EI_MAG0] = ELFMAG0;
  255         hdr->kh_ehdr.e_ident[EI_MAG1] = ELFMAG1;
  256         hdr->kh_ehdr.e_ident[EI_MAG2] = ELFMAG2;
  257         hdr->kh_ehdr.e_ident[EI_MAG3] = ELFMAG3;
  258         hdr->kh_ehdr.e_ident[EI_DATA] = ELF_DATA;
  259         hdr->kh_ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
  260         hdr->kh_ehdr.e_ident[EI_CLASS] = ELF_CLASS;
  261         hdr->kh_ehdr.e_ident[EI_VERSION] = EV_CURRENT;
  262         hdr->kh_ehdr.e_ident[EI_ABIVERSION] = 0;
  263         hdr->kh_ehdr.e_type = ET_EXEC;
  264         hdr->kh_ehdr.e_machine = ELF_ARCH;
  265         hdr->kh_ehdr.e_version = EV_CURRENT;
  266         hdr->kh_ehdr.e_entry = 0;
  267         hdr->kh_ehdr.e_phoff = offsetof(struct ksyms_hdr, kh_txtphdr);
  268         hdr->kh_ehdr.e_shoff = offsetof(struct ksyms_hdr, kh_shdr);
  269         hdr->kh_ehdr.e_flags = 0;
  270         hdr->kh_ehdr.e_ehsize = sizeof(Elf_Ehdr);
  271         hdr->kh_ehdr.e_phentsize = sizeof(Elf_Phdr);
  272         hdr->kh_ehdr.e_phnum = 2;       /* Text and Data */ 
  273         hdr->kh_ehdr.e_shentsize = sizeof(Elf_Shdr);
  274         hdr->kh_ehdr.e_shnum = SHDR_NUM;
  275         hdr->kh_ehdr.e_shstrndx = SHDR_SHSTRTAB;
  276 
  277         /* 
  278          * Add both the text and data Program headers. 
  279          */
  280         hdr->kh_txtphdr.p_type = PT_LOAD;
  281         /* XXX - is there a way to put the actual .text addr/size here? */
  282         hdr->kh_txtphdr.p_vaddr = 0;  
  283         hdr->kh_txtphdr.p_memsz = 0; 
  284         hdr->kh_txtphdr.p_flags = PF_R | PF_X;
  285     
  286         hdr->kh_datphdr.p_type = PT_LOAD;
  287         /* XXX - is there a way to put the actual .data addr/size here? */
  288         hdr->kh_datphdr.p_vaddr = 0; 
  289         hdr->kh_datphdr.p_memsz = 0; 
  290         hdr->kh_datphdr.p_flags = PF_R | PF_W | PF_X;
  291 
  292         /* 
  293          * Add the Section headers: null, symtab, strtab, shstrtab, 
  294          */
  295 
  296         /* First section header - null */
  297         
  298         /* Second section header - symtab */
  299         hdr->kh_shdr[SHDR_SYMTAB].sh_name = 1; /* String offset (skip null) */
  300         hdr->kh_shdr[SHDR_SYMTAB].sh_type = SHT_SYMTAB;
  301         hdr->kh_shdr[SHDR_SYMTAB].sh_flags = 0;
  302         hdr->kh_shdr[SHDR_SYMTAB].sh_addr = 0;
  303         hdr->kh_shdr[SHDR_SYMTAB].sh_offset = sizeof(*hdr);
  304         hdr->kh_shdr[SHDR_SYMTAB].sh_size = ts->ts_symsz;
  305         hdr->kh_shdr[SHDR_SYMTAB].sh_link = SHDR_STRTAB;        
  306         hdr->kh_shdr[SHDR_SYMTAB].sh_info = ts->ts_symsz / sizeof(Elf_Sym); 
  307         hdr->kh_shdr[SHDR_SYMTAB].sh_addralign = sizeof(long);
  308         hdr->kh_shdr[SHDR_SYMTAB].sh_entsize = sizeof(Elf_Sym);
  309 
  310         /* Third section header - strtab */
  311         hdr->kh_shdr[SHDR_STRTAB].sh_name = 1 + sizeof(STR_SYMTAB); 
  312         hdr->kh_shdr[SHDR_STRTAB].sh_type = SHT_STRTAB;
  313         hdr->kh_shdr[SHDR_STRTAB].sh_flags = 0;
  314         hdr->kh_shdr[SHDR_STRTAB].sh_addr = 0;
  315         hdr->kh_shdr[SHDR_STRTAB].sh_offset = 
  316             hdr->kh_shdr[SHDR_SYMTAB].sh_offset + ts->ts_symsz; 
  317         hdr->kh_shdr[SHDR_STRTAB].sh_size = ts->ts_strsz;
  318         hdr->kh_shdr[SHDR_STRTAB].sh_link = 0;
  319         hdr->kh_shdr[SHDR_STRTAB].sh_info = 0;
  320         hdr->kh_shdr[SHDR_STRTAB].sh_addralign = sizeof(char);
  321         hdr->kh_shdr[SHDR_STRTAB].sh_entsize = 0;
  322         
  323         /* Fourth section - shstrtab */
  324         hdr->kh_shdr[SHDR_SHSTRTAB].sh_name = 1 + sizeof(STR_SYMTAB) +
  325             sizeof(STR_STRTAB);
  326         hdr->kh_shdr[SHDR_SHSTRTAB].sh_type = SHT_STRTAB;
  327         hdr->kh_shdr[SHDR_SHSTRTAB].sh_flags = 0;
  328         hdr->kh_shdr[SHDR_SHSTRTAB].sh_addr = 0;
  329         hdr->kh_shdr[SHDR_SHSTRTAB].sh_offset = 
  330             offsetof(struct ksyms_hdr, kh_shstrtab);
  331         hdr->kh_shdr[SHDR_SHSTRTAB].sh_size = sizeof(ksyms_shstrtab);
  332         hdr->kh_shdr[SHDR_SHSTRTAB].sh_link = 0;
  333         hdr->kh_shdr[SHDR_SHSTRTAB].sh_info = 0;
  334         hdr->kh_shdr[SHDR_SHSTRTAB].sh_addralign = 0 /* sizeof(char) */;
  335         hdr->kh_shdr[SHDR_SHSTRTAB].sh_entsize = 0;
  336 
  337         /* Copy shstrtab into the header */
  338         bcopy(ksyms_shstrtab, hdr->kh_shstrtab, sizeof(ksyms_shstrtab));
  339         
  340         to.to_symoff = uaddr + hdr->kh_shdr[SHDR_SYMTAB].sh_offset;
  341         to.to_stroff = uaddr + hdr->kh_shdr[SHDR_STRTAB].sh_offset;
  342         to.to_stridx = 0;
  343         if (sizeof(struct ksyms_hdr) > resid) {
  344                 free(hdr, M_KSYMS);
  345                 return (ENXIO);
  346         }
  347         to.to_resid = resid - sizeof(struct ksyms_hdr);
  348 
  349         /* Emit Header */
  350         copyout(hdr, (void *)uaddr, sizeof(struct ksyms_hdr));
  351         
  352         free(hdr, M_KSYMS);
  353 
  354         /* Add symbol and string tables for each kernelmodule */
  355         error = linker_file_foreach(ksyms_add, &to); 
  356 
  357         if (to.to_resid != 0)
  358                 return (ENXIO);
  359 
  360         return (error);
  361 }
  362 
  363 /*
  364  * Map some anonymous memory in user space of size sz, rounded up to the page
  365  * boundary.
  366  */
  367 static int
  368 ksyms_map(struct thread *td, vm_offset_t *addr, size_t sz)
  369 {
  370         struct vmspace *vms = td->td_proc->p_vmspace;
  371         int error;
  372         vm_size_t size;
  373 
  374         
  375         /* 
  376          * Map somewhere after heap in process memory.
  377          */
  378         PROC_LOCK(td->td_proc);
  379         *addr = round_page((vm_offset_t)vms->vm_daddr + 
  380             lim_max(td->td_proc, RLIMIT_DATA));
  381         PROC_UNLOCK(td->td_proc);
  382 
  383         /* round size up to page boundry */
  384         size = (vm_size_t) round_page(sz);
  385     
  386         error = vm_mmap(&vms->vm_map, addr, size, PROT_READ | PROT_WRITE, 
  387             VM_PROT_ALL, MAP_PRIVATE | MAP_ANON, OBJT_DEFAULT, NULL, 0);
  388         
  389         return (error);
  390 }
  391 
  392 /*
  393  * Unmap memory in user space.
  394  */
  395 static int
  396 ksyms_unmap(struct thread *td, vm_offset_t addr, size_t sz)
  397 {
  398         vm_map_t map;
  399         vm_size_t size;
  400     
  401         map = &td->td_proc->p_vmspace->vm_map;
  402         size = (vm_size_t) round_page(sz);      
  403 
  404         if (!vm_map_remove(map, addr, addr + size))
  405                 return (EINVAL);
  406 
  407         return (0);
  408 }
  409 
  410 static void
  411 ksyms_cdevpriv_dtr(void *data)
  412 {
  413         struct ksyms_softc *sc;
  414 
  415         sc = (struct ksyms_softc *)data; 
  416 
  417         mtx_lock(&ksyms_mtx);
  418         LIST_REMOVE(sc, sc_list);
  419         mtx_unlock(&ksyms_mtx);
  420         free(sc, M_KSYMS);
  421 }
  422 
  423 /* ARGSUSED */
  424 static int
  425 ksyms_open(struct cdev *dev, int flags, int fmt __unused, struct thread *td)
  426 {
  427         struct tsizes ts;
  428         size_t total_elf_sz;
  429         int error, try;
  430         struct ksyms_softc *sc;
  431         
  432         /* 
  433          *  Limit one open() per process. The process must close()
  434          *  before open()'ing again.
  435          */ 
  436         mtx_lock(&ksyms_mtx);
  437         LIST_FOREACH(sc, &ksyms_list, sc_list) {
  438                 if (sc->sc_proc == td->td_proc) {
  439                         mtx_unlock(&ksyms_mtx);
  440                         return (EBUSY);
  441                 }
  442         }
  443 
  444         sc = (struct ksyms_softc *) malloc(sizeof (*sc), M_KSYMS, 
  445             M_NOWAIT|M_ZERO);
  446 
  447         if (sc == NULL) {
  448                 mtx_unlock(&ksyms_mtx);
  449                 return (ENOMEM);
  450         }
  451         sc->sc_proc = td->td_proc;
  452         sc->sc_pmap = &td->td_proc->p_vmspace->vm_pmap;
  453         LIST_INSERT_HEAD(&ksyms_list, sc, sc_list);
  454         mtx_unlock(&ksyms_mtx);
  455 
  456         error = devfs_set_cdevpriv(sc, ksyms_cdevpriv_dtr);
  457         if (error) 
  458                 goto failed;
  459 
  460         /*
  461          * MOD_SLOCK doesn't work here (because of a lock reversal with 
  462          * KLD_SLOCK).  Therefore, simply try upto 3 times to get a "clean"
  463          * snapshot of the kernel symbol table.  This should work fine in the
  464          * rare case of a kernel module being loaded/unloaded at the same
  465          * time. 
  466          */
  467         for(try = 0; try < 3; try++) {
  468                 /*
  469                 * Map a buffer in the calling process memory space and
  470                 * create a snapshot of the kernel symbol table in it.
  471                 */
  472         
  473                 /* Compute the size of buffer needed. */
  474                 ksyms_size_calc(&ts);
  475                 total_elf_sz = sizeof(struct ksyms_hdr) + ts.ts_symsz + 
  476                         ts.ts_strsz; 
  477 
  478                 error = ksyms_map(td, &(sc->sc_uaddr), 
  479                                 (vm_size_t) total_elf_sz);
  480                 if (error)
  481                         break;
  482                 sc->sc_usize = total_elf_sz;    
  483 
  484                 error = ksyms_snapshot(&ts, sc->sc_uaddr, total_elf_sz); 
  485                 if (!error)  {
  486                         /* Successful Snapshot */
  487                         return (0); 
  488                 }
  489                 
  490                 /* Snapshot failed, unmap the memory and try again */ 
  491                 (void) ksyms_unmap(td, sc->sc_uaddr, sc->sc_usize);
  492         }
  493 
  494 failed:
  495         ksyms_cdevpriv_dtr(sc);
  496         return (error);
  497 }
  498 
  499 /* ARGSUSED */
  500 static int
  501 ksyms_read(struct cdev *dev, struct uio *uio, int flags __unused)
  502 {
  503         int error;
  504         size_t len, sz;
  505         struct ksyms_softc *sc;
  506         off_t off;
  507         char *buf;
  508         vm_size_t ubase;
  509     
  510         error = devfs_get_cdevpriv((void **)&sc);
  511         if (error)
  512                 return (error);
  513     
  514         off = uio->uio_offset;
  515         len = uio->uio_resid;   
  516     
  517         if (off < 0 || off > sc->sc_usize)
  518                 return (EFAULT);
  519 
  520         if (len > (sc->sc_usize - off))
  521                 len = sc->sc_usize - off;
  522 
  523         if (len == 0)
  524                 return (0);
  525 
  526         /*
  527          * Since the snapshot buffer is in the user space we have to copy it
  528          * in to the kernel and then back out.  The extra copy saves valuable
  529          * kernel memory.
  530          */
  531         buf = malloc(PAGE_SIZE, M_KSYMS, M_WAITOK);
  532         ubase = sc->sc_uaddr + off;
  533 
  534         while (len) {
  535 
  536                 sz = min(PAGE_SIZE, len);
  537                 if (copyin((void *)ubase, buf, sz))
  538                         error = EFAULT; 
  539                 else
  540                         error = uiomove(buf, sz, uio);
  541                 
  542                 if (error)
  543                         break;
  544         
  545                 len -= sz;
  546                 ubase += sz;
  547         }
  548         free(buf, M_KSYMS);
  549 
  550         return (error);
  551 }
  552 
  553 /* ARGSUSED */
  554 static int
  555 ksyms_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int32_t flag __unused,
  556     struct thread *td __unused)
  557 {
  558         int error = 0;
  559         struct ksyms_softc *sc;
  560 
  561         error = devfs_get_cdevpriv((void **)&sc);
  562         if (error)
  563                 return (error);
  564 
  565         switch (cmd) {
  566         case KIOCGSIZE:
  567                 /* 
  568                  * Return the size (in bytes) of the symbol table
  569                  * snapshot.
  570                  */
  571                 *(size_t *)data = sc->sc_usize;
  572                 break;
  573                 
  574         case KIOCGADDR:
  575                 /*
  576                  * Return the address of the symbol table snapshot.
  577                  * XXX - compat32 version of this?
  578                  */
  579                 *(void **)data = (void *)sc->sc_uaddr;
  580                 break;
  581                 
  582         default:
  583                 error = ENOTTY;
  584                 break;
  585         }
  586 
  587         return (error);
  588 }
  589 
  590 /* ARGUSED */
  591 static int
  592 ksyms_mmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr,
  593                 int prot __unused)
  594 {
  595         struct ksyms_softc *sc;
  596         int error;
  597 
  598         error = devfs_get_cdevpriv((void **)&sc);
  599         if (error)
  600                 return (error);
  601 
  602         /*
  603          * XXX mmap() will actually map the symbol table into the process
  604          * address space again.
  605          */
  606         if (offset > round_page(sc->sc_usize) || 
  607             (*paddr = pmap_extract(sc->sc_pmap, 
  608             (vm_offset_t)sc->sc_uaddr + offset)) == 0) 
  609                 return (-1);
  610 
  611         return (0);
  612 }
  613 
  614 /* ARGUSED */
  615 static int
  616 ksyms_close(struct cdev *dev, int flags __unused, int fmt __unused,
  617                 struct thread *td)
  618 {
  619         int error = 0;
  620         struct ksyms_softc *sc;
  621         
  622         error = devfs_get_cdevpriv((void **)&sc);
  623         if (error)
  624                 return (error);
  625 
  626         /* Unmap the buffer from the process address space. */
  627         error = ksyms_unmap(td, sc->sc_uaddr, sc->sc_usize);
  628 
  629         devfs_clear_cdevpriv();
  630 
  631         return (error);
  632 }
  633 
  634 /* ARGSUSED */
  635 static int
  636 ksyms_modevent(module_t mod __unused, int type, void *data __unused)
  637 {
  638         int error = 0;
  639 
  640         switch (type) {
  641         case MOD_LOAD:
  642                 mtx_init(&ksyms_mtx, "KSyms mtx", NULL, MTX_DEF);
  643                 ksyms_dev = make_dev(&ksyms_cdevsw, 0, UID_ROOT, GID_WHEEL,
  644                     0444, KSYMS_DNAME);
  645                 break;
  646 
  647         case MOD_UNLOAD:
  648                 if (!LIST_EMPTY(&ksyms_list))
  649                         return (EBUSY);
  650                 destroy_dev(ksyms_dev);
  651                 mtx_destroy(&ksyms_mtx);
  652                 break;
  653 
  654         case MOD_SHUTDOWN:
  655                 break;
  656 
  657         default:
  658                 error = EOPNOTSUPP;
  659                 break;
  660         }
  661         return (error);
  662 }
  663 
  664 DEV_MODULE(ksyms, ksyms_modevent, NULL);
  665 MODULE_VERSION(ksyms, 1);

Cache object: 25bc60d733224a38d79e83da6a25882e


[ 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.