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_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_ooffset_t offset, vm_paddr_t *paddr, 593 int prot __unused, vm_memattr_t *memattr __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); 666