FreeBSD/Linux Kernel Cross Reference
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: 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
|