kern_ksyms.c revision 1.73 1 /* $NetBSD: kern_ksyms.c,v 1.73 2014/08/17 21:17:44 joerg Exp $ */
2
3 /*-
4 * Copyright (c) 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software developed for The NetBSD Foundation
8 * by Andrew Doran.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 2001, 2003 Anders Magnusson (ragge (at) ludd.luth.se).
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. The name of the author may not be used to endorse or promote products
45 * derived from this software without specific prior written permission
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
48 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
50 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
51 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
52 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
53 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
54 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
55 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
56 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
57 */
58
59 /*
60 * Code to deal with in-kernel symbol table management + /dev/ksyms.
61 *
62 * For each loaded module the symbol table info is kept track of by a
63 * struct, placed in a circular list. The first entry is the kernel
64 * symbol table.
65 */
66
67 /*
68 * TODO:
69 *
70 * Add support for mmap, poll.
71 */
72
73 #include <sys/cdefs.h>
74 __KERNEL_RCSID(0, "$NetBSD: kern_ksyms.c,v 1.73 2014/08/17 21:17:44 joerg Exp $");
75
76 #if defined(_KERNEL) && defined(_KERNEL_OPT)
77 #include "opt_ddb.h"
78 #include "opt_dtrace.h"
79 #endif
80
81 #define _KSYMS_PRIVATE
82
83 #include <sys/param.h>
84 #include <sys/queue.h>
85 #include <sys/exec.h>
86 #include <sys/systm.h>
87 #include <sys/conf.h>
88 #include <sys/kmem.h>
89 #include <sys/proc.h>
90 #include <sys/atomic.h>
91 #include <sys/ksyms.h>
92
93 #ifdef DDB
94 #include <ddb/db_output.h>
95 #endif
96
97 #include "ksyms.h"
98
99 #define KSYMS_MAX_ID 65536
100 #ifdef KDTRACE_HOOKS
101 static uint32_t ksyms_nmap[KSYMS_MAX_ID]; /* sorted symbol table map */
102 #else
103 static uint32_t *ksyms_nmap = NULL;
104 #endif
105
106 static int ksyms_maxlen;
107 static bool ksyms_isopen;
108 static bool ksyms_initted;
109 static bool ksyms_loaded;
110 static kmutex_t ksyms_lock __cacheline_aligned;
111 static struct ksyms_symtab kernel_symtab;
112
113 void ksymsattach(int);
114 static void ksyms_hdr_init(void *);
115 static void ksyms_sizes_calc(void);
116
117 #ifdef KSYMS_DEBUG
118 #define FOLLOW_CALLS 1
119 #define FOLLOW_MORE_CALLS 2
120 #define FOLLOW_DEVKSYMS 4
121 static int ksyms_debug;
122 #endif
123
124 #define SYMTAB_FILLER "|This is the symbol table!"
125
126 #ifdef COPY_SYMTAB
127 extern char db_symtab[];
128 extern int db_symtabsize;
129 #endif
130
131 /*
132 * used by savecore(8) so non-static
133 */
134 struct ksyms_hdr ksyms_hdr;
135 int ksyms_symsz;
136 int ksyms_strsz;
137 int ksyms_ctfsz; /* this is not currently used by savecore(8) */
138 TAILQ_HEAD(, ksyms_symtab) ksyms_symtabs =
139 TAILQ_HEAD_INITIALIZER(ksyms_symtabs);
140
141 static int
142 ksyms_verify(void *symstart, void *strstart)
143 {
144 #if defined(DIAGNOSTIC) || defined(DEBUG)
145 if (symstart == NULL)
146 printf("ksyms: Symbol table not found\n");
147 if (strstart == NULL)
148 printf("ksyms: String table not found\n");
149 if (symstart == NULL || strstart == NULL)
150 printf("ksyms: Perhaps the kernel is stripped?\n");
151 #endif
152 if (symstart == NULL || strstart == NULL)
153 return 0;
154 return 1;
155 }
156
157 /*
158 * Finds a certain symbol name in a certain symbol table.
159 */
160 static Elf_Sym *
161 findsym(const char *name, struct ksyms_symtab *table, int type)
162 {
163 Elf_Sym *sym, *maxsym;
164 int low, mid, high, nglob;
165 char *str, *cmp;
166
167 sym = table->sd_symstart;
168 str = table->sd_strstart - table->sd_usroffset;
169 nglob = table->sd_nglob;
170 low = 0;
171 high = nglob;
172
173 /*
174 * Start with a binary search of all global symbols in this table.
175 * Global symbols must have unique names.
176 */
177 while (low < high) {
178 mid = (low + high) >> 1;
179 cmp = sym[mid].st_name + str;
180 if (cmp[0] < name[0] || strcmp(cmp, name) < 0) {
181 low = mid + 1;
182 } else {
183 high = mid;
184 }
185 }
186 KASSERT(low == high);
187 if (__predict_true(low < nglob &&
188 strcmp(sym[low].st_name + str, name) == 0)) {
189 KASSERT(ELF_ST_BIND(sym[low].st_info) == STB_GLOBAL);
190 return &sym[low];
191 }
192
193 /*
194 * Perform a linear search of local symbols (rare). Many local
195 * symbols with the same name can exist so are not included in
196 * the binary search.
197 */
198 if (type != KSYMS_EXTERN) {
199 maxsym = sym + table->sd_symsize / sizeof(Elf_Sym);
200 for (sym += nglob; sym < maxsym; sym++) {
201 if (strcmp(name, sym->st_name + str) == 0) {
202 return sym;
203 }
204 }
205 }
206 return NULL;
207 }
208
209 /*
210 * The "attach" is in reality done in ksyms_init().
211 */
212 void
213 ksymsattach(int arg)
214 {
215
216 }
217
218 void
219 ksyms_init(void)
220 {
221
222 #ifdef COPY_SYMTAB
223 if (!ksyms_loaded &&
224 strncmp(db_symtab, SYMTAB_FILLER, sizeof(SYMTAB_FILLER))) {
225 ksyms_addsyms_elf(db_symtabsize, db_symtab,
226 db_symtab + db_symtabsize);
227 }
228 #endif
229
230 if (!ksyms_initted) {
231 mutex_init(&ksyms_lock, MUTEX_DEFAULT, IPL_NONE);
232 ksyms_initted = true;
233 }
234 }
235
236 /*
237 * Add a symbol table.
238 * This is intended for use when the symbol table and its corresponding
239 * string table are easily available. If they are embedded in an ELF
240 * image, use addsymtab_elf() instead.
241 *
242 * name - Symbol's table name.
243 * symstart, symsize - Address and size of the symbol table.
244 * strstart, strsize - Address and size of the string table.
245 * tab - Symbol table to be updated with this information.
246 * newstart - Address to which the symbol table has to be copied during
247 * shrinking. If NULL, it is not moved.
248 */
249 static const char *addsymtab_strstart;
250
251 static int
252 addsymtab_compar(const void *a, const void *b)
253 {
254 const Elf_Sym *sa, *sb;
255
256 sa = a;
257 sb = b;
258
259 /*
260 * Split the symbol table into two, with globals at the start
261 * and locals at the end.
262 */
263 if (ELF_ST_BIND(sa->st_info) != ELF_ST_BIND(sb->st_info)) {
264 if (ELF_ST_BIND(sa->st_info) == STB_GLOBAL) {
265 return -1;
266 }
267 if (ELF_ST_BIND(sb->st_info) == STB_GLOBAL) {
268 return 1;
269 }
270 }
271
272 /* Within each band, sort by name. */
273 return strcmp(sa->st_name + addsymtab_strstart,
274 sb->st_name + addsymtab_strstart);
275 }
276
277 static void
278 addsymtab(const char *name, void *symstart, size_t symsize,
279 void *strstart, size_t strsize, struct ksyms_symtab *tab,
280 void *newstart, void *ctfstart, size_t ctfsize, uint32_t *nmap)
281 {
282 Elf_Sym *sym, *nsym, ts;
283 int i, j, n, nglob;
284 char *str;
285 int nsyms = symsize / sizeof(Elf_Sym);
286
287 /* Sanity check for pre-allocated map table used during startup. */
288 if ((nmap == ksyms_nmap) && (nsyms >= KSYMS_MAX_ID)) {
289 printf("kern_ksyms: ERROR %d > %d, increase KSYMS_MAX_ID\n",
290 nsyms, KSYMS_MAX_ID);
291
292 /* truncate for now */
293 nsyms = KSYMS_MAX_ID - 1;
294 }
295
296 tab->sd_symstart = symstart;
297 tab->sd_symsize = symsize;
298 tab->sd_strstart = strstart;
299 tab->sd_strsize = strsize;
300 tab->sd_name = name;
301 tab->sd_minsym = UINTPTR_MAX;
302 tab->sd_maxsym = 0;
303 tab->sd_usroffset = 0;
304 tab->sd_gone = false;
305 tab->sd_ctfstart = ctfstart;
306 tab->sd_ctfsize = ctfsize;
307 tab->sd_nmap = nmap;
308 tab->sd_nmapsize = nsyms;
309 #ifdef KSYMS_DEBUG
310 printf("newstart %p sym %p ksyms_symsz %zu str %p strsz %zu send %p\n",
311 newstart, symstart, symsize, strstart, strsize,
312 tab->sd_strstart + tab->sd_strsize);
313 #endif
314
315 if (nmap) {
316 memset(nmap, 0, nsyms * sizeof(uint32_t));
317 }
318
319 /* Pack symbol table by removing all file name references. */
320 sym = tab->sd_symstart;
321 nsym = (Elf_Sym *)newstart;
322 str = tab->sd_strstart;
323 nglob = 0;
324 for (i = n = 0; i < nsyms; i++) {
325
326 /* This breaks CTF mapping, so don't do it when
327 * DTrace is enabled
328 */
329 #ifndef KDTRACE_HOOKS
330 /*
331 * Remove useless symbols.
332 * Should actually remove all typeless symbols.
333 */
334 if (sym[i].st_name == 0)
335 continue; /* Skip nameless entries */
336 if (sym[i].st_shndx == SHN_UNDEF)
337 continue; /* Skip external references */
338 if (ELF_ST_TYPE(sym[i].st_info) == STT_FILE)
339 continue; /* Skip filenames */
340 if (ELF_ST_TYPE(sym[i].st_info) == STT_NOTYPE &&
341 sym[i].st_value == 0 &&
342 strcmp(str + sym[i].st_name, "*ABS*") == 0)
343 continue; /* XXX */
344 if (ELF_ST_TYPE(sym[i].st_info) == STT_NOTYPE &&
345 strcmp(str + sym[i].st_name, "gcc2_compiled.") == 0)
346 continue; /* XXX */
347 #endif
348
349 /* Save symbol. Set it as an absolute offset */
350 nsym[n] = sym[i];
351
352 #ifdef KDTRACE_HOOKS
353 if (nmap != NULL) {
354 /*
355 * Save the size, replace it with the symbol id so
356 * the mapping can be done after the cleanup and sort.
357 */
358 nmap[i] = nsym[n].st_size;
359 nsym[n].st_size = i + 1; /* zero is reserved */
360 }
361 #endif
362
363 nsym[n].st_shndx = SHBSS;
364 j = strlen(nsym[n].st_name + str) + 1;
365 if (j > ksyms_maxlen)
366 ksyms_maxlen = j;
367 nglob += (ELF_ST_BIND(nsym[n].st_info) == STB_GLOBAL);
368
369 /* Compute min and max symbols. */
370 if (strcmp(str + sym[i].st_name, "*ABS*") != 0
371 && ELF_ST_TYPE(nsym[n].st_info) != STT_NOTYPE) {
372 if (nsym[n].st_value < tab->sd_minsym) {
373 tab->sd_minsym = nsym[n].st_value;
374 }
375 if (nsym[n].st_value > tab->sd_maxsym) {
376 tab->sd_maxsym = nsym[n].st_value;
377 }
378 }
379 n++;
380 }
381
382 /* Fill the rest of the record, and sort the symbols. */
383 tab->sd_symstart = nsym;
384 tab->sd_symsize = n * sizeof(Elf_Sym);
385 tab->sd_nglob = nglob;
386 addsymtab_strstart = str;
387 if (kheapsort(nsym, n, sizeof(Elf_Sym), addsymtab_compar, &ts) != 0)
388 panic("addsymtab");
389
390 #ifdef KDTRACE_HOOKS
391 /*
392 * Build the mapping from original symbol id to new symbol table.
393 * Deleted symbols will have a zero map, indices will be one based
394 * instead of zero based.
395 * Resulting map is sd_nmap[original_index] = new_index + 1
396 */
397 if (nmap != NULL) {
398 int new;
399 for (new = 0; new < n; new++) {
400 uint32_t orig = nsym[new].st_size - 1;
401 uint32_t size = nmap[orig];
402
403 nmap[orig] = new + 1;
404
405 /* restore the size */
406 nsym[new].st_size = size;
407 }
408 }
409 #endif
410
411 /* ksymsread() is unlocked, so membar. */
412 membar_producer();
413 TAILQ_INSERT_TAIL(&ksyms_symtabs, tab, sd_queue);
414 ksyms_sizes_calc();
415 ksyms_loaded = true;
416 }
417
418 /*
419 * Setup the kernel symbol table stuff.
420 */
421 void
422 ksyms_addsyms_elf(int symsize, void *start, void *end)
423 {
424 int i, j;
425 Elf_Shdr *shdr;
426 char *symstart = NULL, *strstart = NULL;
427 size_t strsize = 0;
428 Elf_Ehdr *ehdr;
429 char *ctfstart = NULL;
430 size_t ctfsize = 0;
431
432 if (symsize <= 0) {
433 printf("[ Kernel symbol table missing! ]\n");
434 return;
435 }
436
437 /* Sanity check */
438 if (ALIGNED_POINTER(start, long) == 0) {
439 printf("[ Kernel symbol table has bad start address %p ]\n",
440 start);
441 return;
442 }
443
444 ehdr = (Elf_Ehdr *)start;
445
446 /* check if this is a valid ELF header */
447 /* No reason to verify arch type, the kernel is actually running! */
448 if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) ||
449 ehdr->e_ident[EI_CLASS] != ELFCLASS ||
450 ehdr->e_version > 1) {
451 printf("[ Kernel symbol table invalid! ]\n");
452 return; /* nothing to do */
453 }
454
455 /* Loaded header will be scratched in addsymtab */
456 ksyms_hdr_init(start);
457
458 /* Find the symbol table and the corresponding string table. */
459 shdr = (Elf_Shdr *)((uint8_t *)start + ehdr->e_shoff);
460 for (i = 1; i < ehdr->e_shnum; i++) {
461 if (shdr[i].sh_type != SHT_SYMTAB)
462 continue;
463 if (shdr[i].sh_offset == 0)
464 continue;
465 symstart = (uint8_t *)start + shdr[i].sh_offset;
466 symsize = shdr[i].sh_size;
467 j = shdr[i].sh_link;
468 if (shdr[j].sh_offset == 0)
469 continue; /* Can this happen? */
470 strstart = (uint8_t *)start + shdr[j].sh_offset;
471 strsize = shdr[j].sh_size;
472 break;
473 }
474
475 #ifdef KDTRACE_HOOKS
476 /* Find the CTF section */
477 shdr = (Elf_Shdr *)((uint8_t *)start + ehdr->e_shoff);
478 if (ehdr->e_shstrndx != 0) {
479 char *shstr = (uint8_t *)start +
480 shdr[ehdr->e_shstrndx].sh_offset;
481 for (i = 1; i < ehdr->e_shnum; i++) {
482 #ifdef DEBUG
483 printf("ksyms: checking %s\n", &shstr[shdr[i].sh_name]);
484 #endif
485 if (shdr[i].sh_type != SHT_PROGBITS)
486 continue;
487 if (strncmp(".SUNW_ctf", &shstr[shdr[i].sh_name], 10)
488 != 0)
489 continue;
490 ctfstart = (uint8_t *)start + shdr[i].sh_offset;
491 ctfsize = shdr[i].sh_size;
492 ksyms_ctfsz = ctfsize;
493 #ifdef DEBUG
494 aprint_normal("Found CTF at %p, size 0x%zx\n",
495 ctfstart, ctfsize);
496 #endif
497 break;
498 }
499 #ifdef DEBUG
500 } else {
501 printf("ksyms: e_shstrndx == 0\n");
502 #endif
503 }
504 #endif
505
506 if (!ksyms_verify(symstart, strstart))
507 return;
508
509 addsymtab("netbsd", symstart, symsize, strstart, strsize,
510 &kernel_symtab, symstart, ctfstart, ctfsize, ksyms_nmap);
511
512 #ifdef DEBUG
513 aprint_normal("Loaded initial symtab at %p, strtab at %p, # entries %ld\n",
514 kernel_symtab.sd_symstart, kernel_symtab.sd_strstart,
515 (long)kernel_symtab.sd_symsize/sizeof(Elf_Sym));
516 #endif
517 }
518
519 /*
520 * Setup the kernel symbol table stuff.
521 * Use this when the address of the symbol and string tables are known;
522 * otherwise use ksyms_init with an ELF image.
523 * We need to pass a minimal ELF header which will later be completed by
524 * ksyms_hdr_init and handed off to userland through /dev/ksyms. We use
525 * a void *rather than a pointer to avoid exposing the Elf_Ehdr type.
526 */
527 void
528 ksyms_addsyms_explicit(void *ehdr, void *symstart, size_t symsize,
529 void *strstart, size_t strsize)
530 {
531
532 if (!ksyms_verify(symstart, strstart))
533 return;
534
535 ksyms_hdr_init(ehdr);
536 addsymtab("netbsd", symstart, symsize, strstart, strsize,
537 &kernel_symtab, symstart, NULL, 0, ksyms_nmap);
538 }
539
540 /*
541 * Get the value associated with a symbol.
542 * "mod" is the module name, or null if any module.
543 * "sym" is the symbol name.
544 * "val" is a pointer to the corresponding value, if call succeeded.
545 * Returns 0 if success or ENOENT if no such entry.
546 *
547 * Call with ksyms_lock, unless known that the symbol table can't change.
548 */
549 int
550 ksyms_getval_unlocked(const char *mod, const char *sym, unsigned long *val,
551 int type)
552 {
553 struct ksyms_symtab *st;
554 Elf_Sym *es;
555
556 #ifdef KSYMS_DEBUG
557 if (ksyms_debug & FOLLOW_CALLS)
558 printf("ksyms_getval_unlocked: mod %s sym %s valp %p\n",
559 mod, sym, val);
560 #endif
561
562 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
563 if (__predict_false(st->sd_gone))
564 continue;
565 if (mod != NULL && strcmp(st->sd_name, mod))
566 continue;
567 if ((es = findsym(sym, st, type)) != NULL) {
568 *val = es->st_value;
569 return 0;
570 }
571 }
572 return ENOENT;
573 }
574
575 int
576 ksyms_getval(const char *mod, const char *sym, unsigned long *val, int type)
577 {
578 int rc;
579
580 if (!ksyms_loaded)
581 return ENOENT;
582
583 mutex_enter(&ksyms_lock);
584 rc = ksyms_getval_unlocked(mod, sym, val, type);
585 mutex_exit(&ksyms_lock);
586 return rc;
587 }
588
589 struct ksyms_symtab *
590 ksyms_get_mod(const char *mod)
591 {
592 struct ksyms_symtab *st;
593
594 mutex_enter(&ksyms_lock);
595 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
596 if (__predict_false(st->sd_gone))
597 continue;
598 if (mod != NULL && strcmp(st->sd_name, mod))
599 continue;
600 break;
601 }
602 mutex_exit(&ksyms_lock);
603
604 return st;
605 }
606
607
608 /*
609 * ksyms_mod_foreach()
610 *
611 * Iterate over the symbol table of the specified module, calling the callback
612 * handler for each symbol. Stop iterating if the handler return is non-zero.
613 *
614 */
615
616 int
617 ksyms_mod_foreach(const char *mod, ksyms_callback_t callback, void *opaque)
618 {
619 struct ksyms_symtab *st;
620 Elf_Sym *sym, *maxsym;
621 char *str;
622 int symindx;
623
624 if (!ksyms_loaded)
625 return ENOENT;
626
627 mutex_enter(&ksyms_lock);
628
629 /* find the module */
630 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
631 if (__predict_false(st->sd_gone))
632 continue;
633 if (mod != NULL && strcmp(st->sd_name, mod))
634 continue;
635
636 sym = st->sd_symstart;
637 str = st->sd_strstart - st->sd_usroffset;
638
639 /* now iterate through the symbols */
640 maxsym = sym + st->sd_symsize / sizeof(Elf_Sym);
641 for (symindx = 0; sym < maxsym; sym++, symindx++) {
642 if (callback(str + sym->st_name, symindx,
643 (void *)sym->st_value,
644 sym->st_size,
645 sym->st_info,
646 opaque) != 0) {
647 break;
648 }
649 }
650 }
651 mutex_exit(&ksyms_lock);
652
653 return 0;
654 }
655
656 /*
657 * Get "mod" and "symbol" associated with an address.
658 * Returns 0 if success or ENOENT if no such entry.
659 *
660 * Call with ksyms_lock, unless known that the symbol table can't change.
661 */
662 int
663 ksyms_getname(const char **mod, const char **sym, vaddr_t v, int f)
664 {
665 struct ksyms_symtab *st;
666 Elf_Sym *les, *es = NULL;
667 vaddr_t laddr = 0;
668 const char *lmod = NULL;
669 char *stable = NULL;
670 int type, i, sz;
671
672 if (!ksyms_loaded)
673 return ENOENT;
674
675 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
676 if (st->sd_gone)
677 continue;
678 if (v < st->sd_minsym || v > st->sd_maxsym)
679 continue;
680 sz = st->sd_symsize/sizeof(Elf_Sym);
681 for (i = 0; i < sz; i++) {
682 les = st->sd_symstart + i;
683 type = ELF_ST_TYPE(les->st_info);
684
685 if ((f & KSYMS_PROC) && (type != STT_FUNC))
686 continue;
687
688 if (type == STT_NOTYPE)
689 continue;
690
691 if (((f & KSYMS_ANY) == 0) &&
692 (type != STT_FUNC) && (type != STT_OBJECT))
693 continue;
694
695 if ((les->st_value <= v) && (les->st_value > laddr)) {
696 laddr = les->st_value;
697 es = les;
698 lmod = st->sd_name;
699 stable = st->sd_strstart - st->sd_usroffset;
700 }
701 }
702 }
703 if (es == NULL)
704 return ENOENT;
705 if ((f & KSYMS_EXACT) && (v != es->st_value))
706 return ENOENT;
707 if (mod)
708 *mod = lmod;
709 if (sym)
710 *sym = stable + es->st_name;
711 return 0;
712 }
713
714 /*
715 * Add a symbol table from a loadable module.
716 */
717 void
718 ksyms_modload(const char *name, void *symstart, vsize_t symsize,
719 char *strstart, vsize_t strsize)
720 {
721 struct ksyms_symtab *st;
722
723 st = kmem_zalloc(sizeof(*st), KM_SLEEP);
724 mutex_enter(&ksyms_lock);
725 addsymtab(name, symstart, symsize, strstart, strsize, st, symstart,
726 NULL, 0, NULL);
727 mutex_exit(&ksyms_lock);
728 }
729
730 /*
731 * Remove a symbol table from a loadable module.
732 */
733 void
734 ksyms_modunload(const char *name)
735 {
736 struct ksyms_symtab *st;
737
738 mutex_enter(&ksyms_lock);
739 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
740 if (st->sd_gone)
741 continue;
742 if (strcmp(name, st->sd_name) != 0)
743 continue;
744 st->sd_gone = true;
745 if (!ksyms_isopen) {
746 TAILQ_REMOVE(&ksyms_symtabs, st, sd_queue);
747 ksyms_sizes_calc();
748 kmem_free(st, sizeof(*st));
749 }
750 break;
751 }
752 mutex_exit(&ksyms_lock);
753 KASSERT(st != NULL);
754 }
755
756 #ifdef DDB
757 /*
758 * Keep sifting stuff here, to avoid export of ksyms internals.
759 *
760 * Systems is expected to be quiescent, so no locking done.
761 */
762 int
763 ksyms_sift(char *mod, char *sym, int mode)
764 {
765 struct ksyms_symtab *st;
766 char *sb;
767 int i, sz;
768
769 if (!ksyms_loaded)
770 return ENOENT;
771
772 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
773 if (st->sd_gone)
774 continue;
775 if (mod && strcmp(mod, st->sd_name))
776 continue;
777 sb = st->sd_strstart - st->sd_usroffset;
778
779 sz = st->sd_symsize/sizeof(Elf_Sym);
780 for (i = 0; i < sz; i++) {
781 Elf_Sym *les = st->sd_symstart + i;
782 char c;
783
784 if (strstr(sb + les->st_name, sym) == NULL)
785 continue;
786
787 if (mode == 'F') {
788 switch (ELF_ST_TYPE(les->st_info)) {
789 case STT_OBJECT:
790 c = '+';
791 break;
792 case STT_FUNC:
793 c = '*';
794 break;
795 case STT_SECTION:
796 c = '&';
797 break;
798 case STT_FILE:
799 c = '/';
800 break;
801 default:
802 c = ' ';
803 break;
804 }
805 db_printf("%s%c ", sb + les->st_name, c);
806 } else
807 db_printf("%s ", sb + les->st_name);
808 }
809 }
810 return ENOENT;
811 }
812 #endif /* DDB */
813
814 /*
815 * In case we exposing the symbol table to the userland using the pseudo-
816 * device /dev/ksyms, it is easier to provide all the tables as one.
817 * However, it means we have to change all the st_name fields for the
818 * symbols so they match the ELF image that the userland will read
819 * through the device.
820 *
821 * The actual (correct) value of st_name is preserved through a global
822 * offset stored in the symbol table structure.
823 *
824 * Call with ksyms_lock held.
825 */
826 static void
827 ksyms_sizes_calc(void)
828 {
829 struct ksyms_symtab *st;
830 int i, delta;
831
832 ksyms_symsz = ksyms_strsz = 0;
833 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
834 delta = ksyms_strsz - st->sd_usroffset;
835 if (delta != 0) {
836 for (i = 0; i < st->sd_symsize/sizeof(Elf_Sym); i++)
837 st->sd_symstart[i].st_name += delta;
838 st->sd_usroffset = ksyms_strsz;
839 }
840 ksyms_symsz += st->sd_symsize;
841 ksyms_strsz += st->sd_strsize;
842 }
843 }
844
845 static void
846 ksyms_hdr_init(void *hdraddr)
847 {
848
849 /* Copy the loaded elf exec header */
850 memcpy(&ksyms_hdr.kh_ehdr, hdraddr, sizeof(Elf_Ehdr));
851
852 /* Set correct program/section header sizes, offsets and numbers */
853 ksyms_hdr.kh_ehdr.e_phoff = offsetof(struct ksyms_hdr, kh_phdr[0]);
854 ksyms_hdr.kh_ehdr.e_phentsize = sizeof(Elf_Phdr);
855 ksyms_hdr.kh_ehdr.e_phnum = NPRGHDR;
856 ksyms_hdr.kh_ehdr.e_shoff = offsetof(struct ksyms_hdr, kh_shdr[0]);
857 ksyms_hdr.kh_ehdr.e_shentsize = sizeof(Elf_Shdr);
858 ksyms_hdr.kh_ehdr.e_shnum = NSECHDR;
859 ksyms_hdr.kh_ehdr.e_shstrndx = SHSTRTAB;
860
861 /* Text/data - fake */
862 ksyms_hdr.kh_phdr[0].p_type = PT_LOAD;
863 ksyms_hdr.kh_phdr[0].p_memsz = (unsigned long)-1L;
864 ksyms_hdr.kh_phdr[0].p_flags = PF_R | PF_X | PF_W;
865
866 /* First section is null */
867
868 /* Second section header; ".symtab" */
869 ksyms_hdr.kh_shdr[SYMTAB].sh_name = 1; /* Section 3 offset */
870 ksyms_hdr.kh_shdr[SYMTAB].sh_type = SHT_SYMTAB;
871 ksyms_hdr.kh_shdr[SYMTAB].sh_offset = sizeof(struct ksyms_hdr);
872 /* ksyms_hdr.kh_shdr[SYMTAB].sh_size = filled in at open */
873 ksyms_hdr.kh_shdr[SYMTAB].sh_link = 2; /* Corresponding strtab */
874 ksyms_hdr.kh_shdr[SYMTAB].sh_addralign = sizeof(long);
875 ksyms_hdr.kh_shdr[SYMTAB].sh_entsize = sizeof(Elf_Sym);
876
877 /* Third section header; ".strtab" */
878 ksyms_hdr.kh_shdr[STRTAB].sh_name = 9; /* Section 3 offset */
879 ksyms_hdr.kh_shdr[STRTAB].sh_type = SHT_STRTAB;
880 /* ksyms_hdr.kh_shdr[STRTAB].sh_offset = filled in at open */
881 /* ksyms_hdr.kh_shdr[STRTAB].sh_size = filled in at open */
882 ksyms_hdr.kh_shdr[STRTAB].sh_addralign = sizeof(char);
883
884 /* Fourth section, ".shstrtab" */
885 ksyms_hdr.kh_shdr[SHSTRTAB].sh_name = 17; /* This section name offset */
886 ksyms_hdr.kh_shdr[SHSTRTAB].sh_type = SHT_STRTAB;
887 ksyms_hdr.kh_shdr[SHSTRTAB].sh_offset =
888 offsetof(struct ksyms_hdr, kh_strtab);
889 ksyms_hdr.kh_shdr[SHSTRTAB].sh_size = SHSTRSIZ;
890 ksyms_hdr.kh_shdr[SHSTRTAB].sh_addralign = sizeof(char);
891
892 /* Fifth section, ".bss". All symbols reside here. */
893 ksyms_hdr.kh_shdr[SHBSS].sh_name = 27; /* This section name offset */
894 ksyms_hdr.kh_shdr[SHBSS].sh_type = SHT_NOBITS;
895 ksyms_hdr.kh_shdr[SHBSS].sh_offset = 0;
896 ksyms_hdr.kh_shdr[SHBSS].sh_size = (unsigned long)-1L;
897 ksyms_hdr.kh_shdr[SHBSS].sh_addralign = PAGE_SIZE;
898 ksyms_hdr.kh_shdr[SHBSS].sh_flags = SHF_ALLOC | SHF_EXECINSTR;
899
900 /* Sixth section header; ".SUNW_ctf" */
901 ksyms_hdr.kh_shdr[SHCTF].sh_name = 32; /* Section 6 offset */
902 ksyms_hdr.kh_shdr[SHCTF].sh_type = SHT_PROGBITS;
903 /* ksyms_hdr.kh_shdr[SHCTF].sh_offset = filled in at open */
904 /* ksyms_hdr.kh_shdr[SHCTF].sh_size = filled in at open */
905 ksyms_hdr.kh_shdr[SHCTF].sh_link = SYMTAB; /* Corresponding symtab */
906 ksyms_hdr.kh_shdr[SHCTF].sh_addralign = sizeof(char);
907
908 /* Set section names */
909 strlcpy(&ksyms_hdr.kh_strtab[1], ".symtab",
910 sizeof(ksyms_hdr.kh_strtab) - 1);
911 strlcpy(&ksyms_hdr.kh_strtab[9], ".strtab",
912 sizeof(ksyms_hdr.kh_strtab) - 9);
913 strlcpy(&ksyms_hdr.kh_strtab[17], ".shstrtab",
914 sizeof(ksyms_hdr.kh_strtab) - 17);
915 strlcpy(&ksyms_hdr.kh_strtab[27], ".bss",
916 sizeof(ksyms_hdr.kh_strtab) - 27);
917 strlcpy(&ksyms_hdr.kh_strtab[32], ".SUNW_ctf",
918 sizeof(ksyms_hdr.kh_strtab) - 32);
919 }
920
921 static int
922 ksymsopen(dev_t dev, int oflags, int devtype, struct lwp *l)
923 {
924
925 if (minor(dev) != 0 || !ksyms_loaded)
926 return ENXIO;
927
928 /*
929 * Create a "snapshot" of the kernel symbol table. Setting
930 * ksyms_isopen will prevent symbol tables from being freed.
931 */
932 mutex_enter(&ksyms_lock);
933 ksyms_hdr.kh_shdr[SYMTAB].sh_size = ksyms_symsz;
934 ksyms_hdr.kh_shdr[SYMTAB].sh_info = ksyms_symsz / sizeof(Elf_Sym);
935 ksyms_hdr.kh_shdr[STRTAB].sh_offset = ksyms_symsz +
936 ksyms_hdr.kh_shdr[SYMTAB].sh_offset;
937 ksyms_hdr.kh_shdr[STRTAB].sh_size = ksyms_strsz;
938 ksyms_hdr.kh_shdr[SHCTF].sh_offset = ksyms_strsz +
939 ksyms_hdr.kh_shdr[STRTAB].sh_offset;
940 ksyms_hdr.kh_shdr[SHCTF].sh_size = ksyms_ctfsz;
941 ksyms_isopen = true;
942 mutex_exit(&ksyms_lock);
943
944 return 0;
945 }
946
947 static int
948 ksymsclose(dev_t dev, int oflags, int devtype, struct lwp *l)
949 {
950 struct ksyms_symtab *st, *next;
951 bool resize;
952
953 /* Discard refernces to symbol tables. */
954 mutex_enter(&ksyms_lock);
955 ksyms_isopen = false;
956 resize = false;
957 for (st = TAILQ_FIRST(&ksyms_symtabs); st != NULL; st = next) {
958 next = TAILQ_NEXT(st, sd_queue);
959 if (st->sd_gone) {
960 TAILQ_REMOVE(&ksyms_symtabs, st, sd_queue);
961 kmem_free(st, sizeof(*st));
962 resize = true;
963 }
964 }
965 if (resize)
966 ksyms_sizes_calc();
967 mutex_exit(&ksyms_lock);
968
969 return 0;
970 }
971
972 static int
973 ksymsread(dev_t dev, struct uio *uio, int ioflag)
974 {
975 struct ksyms_symtab *st;
976 size_t filepos, inpos, off;
977 int error;
978
979 /*
980 * First: Copy out the ELF header. XXX Lose if ksymsopen()
981 * occurs during read of the header.
982 */
983 off = uio->uio_offset;
984 if (off < sizeof(struct ksyms_hdr)) {
985 error = uiomove((char *)&ksyms_hdr + off,
986 sizeof(struct ksyms_hdr) - off, uio);
987 if (error != 0)
988 return error;
989 }
990
991 /*
992 * Copy out the symbol table.
993 */
994 filepos = sizeof(struct ksyms_hdr);
995 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
996 if (uio->uio_resid == 0)
997 return 0;
998 if (uio->uio_offset <= st->sd_symsize + filepos) {
999 inpos = uio->uio_offset - filepos;
1000 error = uiomove((char *)st->sd_symstart + inpos,
1001 st->sd_symsize - inpos, uio);
1002 if (error != 0)
1003 return error;
1004 }
1005 filepos += st->sd_symsize;
1006 }
1007
1008 /*
1009 * Copy out the string table
1010 */
1011 KASSERT(filepos == sizeof(struct ksyms_hdr) +
1012 ksyms_hdr.kh_shdr[SYMTAB].sh_size);
1013 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
1014 if (uio->uio_resid == 0)
1015 return 0;
1016 if (uio->uio_offset <= st->sd_strsize + filepos) {
1017 inpos = uio->uio_offset - filepos;
1018 error = uiomove((char *)st->sd_strstart + inpos,
1019 st->sd_strsize - inpos, uio);
1020 if (error != 0)
1021 return error;
1022 }
1023 filepos += st->sd_strsize;
1024 }
1025
1026 /*
1027 * Copy out the CTF table.
1028 */
1029 st = TAILQ_FIRST(&ksyms_symtabs);
1030 if (st->sd_ctfstart != NULL) {
1031 if (uio->uio_resid == 0)
1032 return 0;
1033 if (uio->uio_offset <= st->sd_ctfsize + filepos) {
1034 inpos = uio->uio_offset - filepos;
1035 error = uiomove((char *)st->sd_ctfstart + inpos,
1036 st->sd_ctfsize - inpos, uio);
1037 if (error != 0)
1038 return error;
1039 }
1040 filepos += st->sd_ctfsize;
1041 }
1042
1043 return 0;
1044 }
1045
1046 static int
1047 ksymswrite(dev_t dev, struct uio *uio, int ioflag)
1048 {
1049
1050 return EROFS;
1051 }
1052
1053 static int
1054 ksymsioctl(dev_t dev, u_long cmd, void *data, int fflag, struct lwp *l)
1055 {
1056 struct ksyms_gsymbol *kg = (struct ksyms_gsymbol *)data;
1057 struct ksyms_symtab *st;
1058 Elf_Sym *sym = NULL, copy;
1059 unsigned long val;
1060 int error = 0;
1061 char *str = NULL;
1062 int len;
1063
1064 /* Read ksyms_maxlen only once while not holding the lock. */
1065 len = ksyms_maxlen;
1066
1067 if (cmd == KIOCGVALUE || cmd == KIOCGSYMBOL) {
1068 str = kmem_alloc(len, KM_SLEEP);
1069 if ((error = copyinstr(kg->kg_name, str, len, NULL)) != 0) {
1070 kmem_free(str, len);
1071 return error;
1072 }
1073 }
1074
1075 switch (cmd) {
1076 case KIOCGVALUE:
1077 /*
1078 * Use the in-kernel symbol lookup code for fast
1079 * retreival of a value.
1080 */
1081 error = ksyms_getval(NULL, str, &val, KSYMS_EXTERN);
1082 if (error == 0)
1083 error = copyout(&val, kg->kg_value, sizeof(long));
1084 kmem_free(str, len);
1085 break;
1086
1087 case KIOCGSYMBOL:
1088 /*
1089 * Use the in-kernel symbol lookup code for fast
1090 * retreival of a symbol.
1091 */
1092 mutex_enter(&ksyms_lock);
1093 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
1094 if (st->sd_gone)
1095 continue;
1096 if ((sym = findsym(str, st, KSYMS_ANY)) == NULL)
1097 continue;
1098 #ifdef notdef
1099 /* Skip if bad binding */
1100 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL) {
1101 sym = NULL;
1102 continue;
1103 }
1104 #endif
1105 break;
1106 }
1107 if (sym != NULL) {
1108 memcpy(©, sym, sizeof(copy));
1109 mutex_exit(&ksyms_lock);
1110 error = copyout(©, kg->kg_sym, sizeof(Elf_Sym));
1111 } else {
1112 mutex_exit(&ksyms_lock);
1113 error = ENOENT;
1114 }
1115 kmem_free(str, len);
1116 break;
1117
1118 case KIOCGSIZE:
1119 /*
1120 * Get total size of symbol table.
1121 */
1122 mutex_enter(&ksyms_lock);
1123 *(int *)data = ksyms_strsz + ksyms_symsz +
1124 sizeof(struct ksyms_hdr);
1125 mutex_exit(&ksyms_lock);
1126 break;
1127
1128 default:
1129 error = ENOTTY;
1130 break;
1131 }
1132
1133 return error;
1134 }
1135
1136 const struct cdevsw ksyms_cdevsw = {
1137 .d_open = ksymsopen,
1138 .d_close = ksymsclose,
1139 .d_read = ksymsread,
1140 .d_write = ksymswrite,
1141 .d_ioctl = ksymsioctl,
1142 .d_stop = nullstop,
1143 .d_tty = notty,
1144 .d_poll = nopoll,
1145 .d_mmap = nommap,
1146 .d_kqfilter = nullkqfilter,
1147 .d_discard = nodiscard,
1148 .d_flag = D_OTHER | D_MPSAFE
1149 };
1150