Home | History | Annotate | Line # | Download | only in kern
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(&copy, sym, sizeof(copy));
   1109 			mutex_exit(&ksyms_lock);
   1110 			error = copyout(&copy, 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