sys/dev/ksyms/ksyms.c

   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/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_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 static void
 364 ksyms_cdevpriv_dtr(void *data)
 365 {
 366         struct ksyms_softc *sc;
 367
 368         sc = (struct ksyms_softc *)data;
 369
 370         mtx_lock(&ksyms_mtx);
 371         LIST_REMOVE(sc, sc_list);
 372         mtx_unlock(&ksyms_mtx);
 373         free(sc, M_KSYMS);
 374 }
 375
 376 /* ARGSUSED */
 377 static int
 378 ksyms_open(struct cdev *dev, int flags, int fmt __unused, struct thread *td)
 379 {
 380         struct tsizes ts;
 381         size_t total_elf_sz;
 382         int error, try;
 383         struct ksyms_softc *sc;
 384
 385         /*
 386          *  Limit one open() per process. The process must close()
 387          *  before open()'ing again.
 388          */
 389         mtx_lock(&ksyms_mtx);
 390         LIST_FOREACH(sc, &ksyms_list, sc_list) {
 391                 if (sc->sc_proc == td->td_proc) {
 392                         mtx_unlock(&ksyms_mtx);
 393                         return (EBUSY);
 394                 }
 395         }
 396
 397         sc = (struct ksyms_softc *) malloc(sizeof (*sc), M_KSYMS,
 398             M_NOWAIT|M_ZERO);
 399
 400         if (sc == NULL) {
 401                 mtx_unlock(&ksyms_mtx);
 402                 return (ENOMEM);
 403         }
 404         sc->sc_proc = td->td_proc;
 405         sc->sc_pmap = &td->td_proc->p_vmspace->vm_pmap;
 406         LIST_INSERT_HEAD(&ksyms_list, sc, sc_list);
 407         mtx_unlock(&ksyms_mtx);
 408
 409         error = devfs_set_cdevpriv(sc, ksyms_cdevpriv_dtr);
 410         if (error)
 411                 goto failed;
 412
 413         /*
 414          * MOD_SLOCK doesn't work here (because of a lock reversal with
 415          * KLD_SLOCK).  Therefore, simply try upto 3 times to get a "clean"
 416          * snapshot of the kernel symbol table.  This should work fine in the
 417          * rare case of a kernel module being loaded/unloaded at the same
 418          * time.
 419          */
 420         for(try = 0; try < 3; try++) {
 421                 /*
 422                 * Map a buffer in the calling process memory space and
 423                 * create a snapshot of the kernel symbol table in it.
 424                 */
 425
 426                 /* Compute the size of buffer needed. */
 427                 ksyms_size_calc(&ts);
 428                 total_elf_sz = sizeof(struct ksyms_hdr) + ts.ts_symsz +
 429                         ts.ts_strsz;
 430
 431                 error = copyout_map(td, &(sc->sc_uaddr),
 432                                 (vm_size_t) total_elf_sz);
 433                 if (error)
 434                         break;
 435                 sc->sc_usize = total_elf_sz;
 436
 437                 error = ksyms_snapshot(&ts, sc->sc_uaddr, total_elf_sz);
 438                 if (!error)  {
 439                         /* Successful Snapshot */
 440                         return (0);
 441                 }
 442
 443                 /* Snapshot failed, unmap the memory and try again */
 444                 (void) copyout_unmap(td, sc->sc_uaddr, sc->sc_usize);
 445         }
 446
 447 failed:
 448         ksyms_cdevpriv_dtr(sc);
 449         return (error);
 450 }
 451
 452 /* ARGSUSED */
 453 static int
 454 ksyms_read(struct cdev *dev, struct uio *uio, int flags __unused)
 455 {
 456         int error;
 457         size_t len, sz;
 458         struct ksyms_softc *sc;
 459         off_t off;
 460         char *buf;
 461         vm_size_t ubase;
 462
 463         error = devfs_get_cdevpriv((void **)&sc);
 464         if (error)
 465                 return (error);
 466
 467         off = uio->uio_offset;
 468         len = uio->uio_resid;
 469
 470         if (off < 0 || off > sc->sc_usize)
 471                 return (EFAULT);
 472
 473         if (len > (sc->sc_usize - off))
 474                 len = sc->sc_usize - off;
 475
 476         if (len == 0)
 477                 return (0);
 478
 479         /*
 480          * Since the snapshot buffer is in the user space we have to copy it
 481          * in to the kernel and then back out.  The extra copy saves valuable
 482          * kernel memory.
 483          */
 484         buf = malloc(PAGE_SIZE, M_KSYMS, M_WAITOK);
 485         ubase = sc->sc_uaddr + off;
 486
 487         while (len) {
 488
 489                 sz = min(PAGE_SIZE, len);
 490                 if (copyin((void *)ubase, buf, sz))
 491                         error = EFAULT;
 492                 else
 493                         error = uiomove(buf, sz, uio);
 494
 495                 if (error)
 496                         break;
 497
 498                 len -= sz;
 499                 ubase += sz;
 500         }
 501         free(buf, M_KSYMS);
 502
 503         return (error);
 504 }
 505
 506 /* ARGSUSED */
 507 static int
 508 ksyms_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int32_t flag __unused,
 509     struct thread *td __unused)
 510 {
 511         int error = 0;
 512         struct ksyms_softc *sc;
 513
 514         error = devfs_get_cdevpriv((void **)&sc);
 515         if (error)
 516                 return (error);
 517
 518         switch (cmd) {
 519         case KIOCGSIZE:
 520                 /*
 521                  * Return the size (in bytes) of the symbol table
 522                  * snapshot.
 523                  */
 524                 *(size_t *)data = sc->sc_usize;
 525                 break;
 526
 527         case KIOCGADDR:
 528                 /*
 529                  * Return the address of the symbol table snapshot.
 530                  * XXX - compat32 version of this?
 531                  */
 532                 *(void **)data = (void *)sc->sc_uaddr;
 533                 break;
 534
 535         default:
 536                 error = ENOTTY;
 537                 break;
 538         }
 539
 540         return (error);
 541 }
 542
 543 /* ARGUSED */
 544 static int
 545 ksyms_mmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr,
 546                 int prot __unused, vm_memattr_t *memattr __unused)
 547 {
 548         struct ksyms_softc *sc;
 549         int error;
 550
 551         error = devfs_get_cdevpriv((void **)&sc);
 552         if (error)
 553                 return (error);
 554
 555         /*
 556          * XXX mmap() will actually map the symbol table into the process
 557          * address space again.
 558          */
 559         if (offset > round_page(sc->sc_usize) ||
 560             (*paddr = pmap_extract(sc->sc_pmap,
 561             (vm_offset_t)sc->sc_uaddr + offset)) == 0)
 562                 return (-1);
 563
 564         return (0);
 565 }
 566
 567 /* ARGUSED */
 568 static int
 569 ksyms_close(struct cdev *dev, int flags __unused, int fmt __unused,
 570                 struct thread *td)
 571 {
 572         int error = 0;
 573         struct ksyms_softc *sc;
 574
 575         error = devfs_get_cdevpriv((void **)&sc);
 576         if (error)
 577                 return (error);
 578
 579         /* Unmap the buffer from the process address space. */
 580         error = copyout_unmap(td, sc->sc_uaddr, sc->sc_usize);
 581
 582         return (error);
 583 }
 584
 585 /* ARGSUSED */
 586 static int
 587 ksyms_modevent(module_t mod __unused, int type, void *data __unused)
 588 {
 589         int error = 0;
 590
 591         switch (type) {
 592         case MOD_LOAD:
 593                 mtx_init(&ksyms_mtx, "KSyms mtx", NULL, MTX_DEF);
 594                 ksyms_dev = make_dev(&ksyms_cdevsw, 0, UID_ROOT, GID_WHEEL,
 595                     0444, KSYMS_DNAME);
 596                 break;
 597
 598         case MOD_UNLOAD:
 599                 if (!LIST_EMPTY(&ksyms_list))
 600                         return (EBUSY);
 601                 destroy_dev(ksyms_dev);
 602                 mtx_destroy(&ksyms_mtx);
 603                 break;
 604
 605         case MOD_SHUTDOWN:
 606                 break;
 607
 608         default:
 609                 error = EOPNOTSUPP;
 610                 break;
 611         }
 612         return (error);
 613 }
 614
 615 DEV_MODULE(ksyms, ksyms_modevent, NULL);
 616 MODULE_VERSION(ksyms, 1);