Home | History | Annotate | Line # | Download | only in kern
kern_ksyms.c revision 1.17
      1  1.17      cube /*	$NetBSD: kern_ksyms.c,v 1.17 2003/11/17 10:16:18 cube Exp $	*/
      2   1.1     ragge /*
      3   1.1     ragge  * Copyright (c) 2001, 2003 Anders Magnusson (ragge (at) ludd.luth.se).
      4   1.1     ragge  * All rights reserved.
      5   1.1     ragge  *
      6   1.1     ragge  * Redistribution and use in source and binary forms, with or without
      7   1.1     ragge  * modification, are permitted provided that the following conditions
      8   1.1     ragge  * are met:
      9   1.1     ragge  * 1. Redistributions of source code must retain the above copyright
     10   1.1     ragge  *    notice, this list of conditions and the following disclaimer.
     11   1.1     ragge  * 2. Redistributions in binary form must reproduce the above copyright
     12   1.1     ragge  *    notice, this list of conditions and the following disclaimer in the
     13   1.1     ragge  *    documentation and/or other materials provided with the distribution.
     14   1.1     ragge  * 3. The name of the author may not be used to endorse or promote products
     15   1.1     ragge  *    derived from this software without specific prior written permission
     16   1.1     ragge  *
     17   1.1     ragge  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     18   1.1     ragge  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     19   1.1     ragge  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     20   1.1     ragge  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     21   1.1     ragge  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     22   1.1     ragge  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23   1.1     ragge  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24   1.1     ragge  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25   1.1     ragge  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26   1.1     ragge  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27   1.1     ragge  */
     28   1.1     ragge 
     29   1.1     ragge /*
     30   1.1     ragge  * Code to deal with in-kernel symbol table management + /dev/ksyms.
     31   1.1     ragge  *
     32   1.1     ragge  * For each loaded module the symbol table info is kept track of by a
     33   1.1     ragge  * struct, placed in a circular list. The first entry is the kernel
     34   1.1     ragge  * symbol table.
     35   1.1     ragge  */
     36   1.1     ragge 
     37   1.1     ragge /*
     38   1.1     ragge  * TODO:
     39   1.1     ragge  *	Change the ugly way of adding new symbols (comes with linker)
     40   1.1     ragge  *	Add kernel locking stuff.
     41   1.1     ragge  *	(Ev) add support for poll.
     42   1.1     ragge  *	(Ev) fix support for mmap.
     43   1.1     ragge  *
     44   1.1     ragge  *	Export ksyms internal logic for use in post-mortem debuggers?
     45   1.1     ragge  *	  Need to move struct symtab to ksyms.h for that.
     46   1.1     ragge  */
     47  1.11  jdolecek 
     48  1.11  jdolecek #include <sys/cdefs.h>
     49  1.17      cube __KERNEL_RCSID(0, "$NetBSD: kern_ksyms.c,v 1.17 2003/11/17 10:16:18 cube Exp $");
     50   1.1     ragge 
     51   1.1     ragge #ifdef _KERNEL
     52   1.1     ragge #include "opt_ddb.h"
     53   1.3     ragge #include "opt_ddbparam.h"	/* for SYMTAB_SPACE */
     54   1.1     ragge #endif
     55   1.1     ragge 
     56   1.1     ragge #include <sys/param.h>
     57   1.1     ragge #include <sys/errno.h>
     58   1.1     ragge #include <sys/queue.h>
     59   1.1     ragge #include <sys/exec.h>
     60   1.1     ragge #include <sys/systm.h>
     61   1.1     ragge #include <sys/conf.h>
     62   1.1     ragge #include <sys/device.h>
     63   1.1     ragge #include <sys/malloc.h>
     64   1.1     ragge #include <sys/proc.h>
     65   1.1     ragge 
     66   1.1     ragge #include <machine/elf_machdep.h> /* XXX */
     67   1.1     ragge #define ELFSIZE ARCH_ELFSIZE
     68   1.1     ragge 
     69   1.1     ragge #include <sys/exec_elf.h>
     70   1.1     ragge #include <sys/ksyms.h>
     71   1.1     ragge 
     72   1.1     ragge #include <lib/libkern/libkern.h>
     73   1.1     ragge 
     74   1.1     ragge #ifdef DDB
     75   1.1     ragge #include <ddb/db_output.h>
     76   1.1     ragge #endif
     77   1.1     ragge 
     78   1.1     ragge #include "ksyms.h"
     79   1.1     ragge 
     80   1.1     ragge static int ksymsinited = 0;
     81   1.1     ragge 
     82   1.1     ragge #if NKSYMS
     83   1.1     ragge static void ksyms_hdr_init(caddr_t hdraddr);
     84   1.1     ragge static void ksyms_sizes_calc(void);
     85   1.1     ragge static int ksyms_isopen;
     86   1.5     ragge static int ksyms_maxlen;
     87   1.1     ragge #endif
     88   1.1     ragge 
     89   1.1     ragge #ifdef KSYMS_DEBUG
     90   1.1     ragge #define	FOLLOW_CALLS		1
     91   1.1     ragge #define	FOLLOW_MORE_CALLS	2
     92   1.1     ragge #define	FOLLOW_DEVKSYMS		4
     93   1.1     ragge static int ksyms_debug;
     94   1.1     ragge #endif
     95   1.1     ragge 
     96   1.1     ragge #if NKSYMS
     97   1.1     ragge dev_type_open(ksymsopen);
     98   1.1     ragge dev_type_close(ksymsclose);
     99   1.1     ragge dev_type_read(ksymsread);
    100   1.1     ragge dev_type_write(ksymswrite);
    101   1.1     ragge dev_type_ioctl(ksymsioctl);
    102   1.1     ragge 
    103   1.1     ragge const struct cdevsw ksyms_cdevsw = {
    104   1.1     ragge 	ksymsopen, ksymsclose, ksymsread, ksymswrite, ksymsioctl,
    105   1.1     ragge 	nullstop, notty, nopoll, nommap, nullkqfilter, DV_DULL
    106   1.1     ragge };
    107   1.1     ragge #endif
    108   1.1     ragge 
    109   1.3     ragge #ifdef SYMTAB_SPACE
    110   1.3     ragge #define		SYMTAB_FILLER	"|This is the symbol table!"
    111   1.3     ragge 
    112   1.3     ragge char		db_symtab[SYMTAB_SPACE] = SYMTAB_FILLER;
    113   1.3     ragge int		db_symtabsize = SYMTAB_SPACE;
    114   1.3     ragge #endif
    115   1.1     ragge 
    116   1.1     ragge /*
    117   1.1     ragge  * Store the different symbol tables in a double-linked list.
    118   1.1     ragge  */
    119   1.1     ragge struct symtab {
    120   1.1     ragge 	CIRCLEQ_ENTRY(symtab) sd_queue;
    121   1.9  jdolecek 	const char *sd_name;	/* Name of this table */
    122   1.1     ragge 	Elf_Sym *sd_symstart;	/* Address of symbol table */
    123   1.1     ragge 	caddr_t sd_strstart;	/* Adderss of corresponding string table */
    124  1.17      cube 	int sd_usroffset;	/* Real address for userspace */
    125   1.1     ragge 	int sd_symsize;		/* Size in bytes of symbol table */
    126   1.1     ragge 	int sd_strsize;		/* Size of string table */
    127   1.1     ragge 	int *sd_symnmoff;	/* Used when calculating the name offset */
    128   1.1     ragge };
    129   1.1     ragge 
    130   1.1     ragge static CIRCLEQ_HEAD(, symtab) symtab_queue =
    131   1.1     ragge     CIRCLEQ_HEAD_INITIALIZER(symtab_queue);
    132   1.1     ragge 
    133   1.1     ragge static struct symtab kernel_symtab;
    134   1.1     ragge 
    135   1.8     ragge #define	USE_PTREE
    136   1.8     ragge #ifdef USE_PTREE
    137   1.8     ragge /*
    138   1.8     ragge  * Patricia-tree-based lookup structure for the in-kernel global symbols.
    139   1.8     ragge  * Based on a design by Mikael Sundstrom, msm (at) sm.luth.se.
    140   1.8     ragge  */
    141   1.8     ragge struct ptree {
    142   1.8     ragge 	int16_t bitno;
    143   1.8     ragge 	int16_t lr[2];
    144   1.8     ragge } *symb;
    145   1.8     ragge static int16_t baseidx;
    146   1.8     ragge static int treex = 1;
    147   1.8     ragge 
    148   1.8     ragge #define	P_BIT(key, bit) ((key[bit >> 3] >> (bit & 7)) & 1)
    149   1.8     ragge #define	STRING(idx) kernel_symtab.sd_symstart[idx].st_name + \
    150   1.8     ragge 			kernel_symtab.sd_strstart
    151   1.8     ragge 
    152   1.8     ragge /*
    153   1.8     ragge  * Walk down the tree until a terminal node is found.
    154   1.8     ragge  */
    155   1.8     ragge static int
    156   1.8     ragge symbol_traverse(char *key)
    157   1.8     ragge {
    158   1.8     ragge 	int16_t nb, rbit = baseidx;
    159   1.8     ragge 
    160   1.8     ragge 	while (rbit > 0) {
    161   1.8     ragge 		nb = symb[rbit].bitno;
    162   1.8     ragge 		rbit = symb[rbit].lr[P_BIT(key, nb)];
    163   1.8     ragge 	}
    164   1.8     ragge 	return -rbit;
    165   1.8     ragge }
    166   1.8     ragge 
    167   1.8     ragge static int
    168   1.8     ragge ptree_add(char *key, int val)
    169   1.8     ragge {
    170   1.8     ragge 	int idx;
    171  1.15  christos 	int nix, cix, bit, rbit, sb, lastrbit, svbit = 0, ix;
    172   1.8     ragge 	char *m, *k;
    173   1.8     ragge 
    174   1.8     ragge 	if (baseidx == 0) {
    175   1.8     ragge 		baseidx = -val;
    176   1.8     ragge 		return 0; /* First element */
    177   1.8     ragge 	}
    178   1.8     ragge 
    179   1.8     ragge 	/* Get string to match against */
    180   1.8     ragge 	idx = symbol_traverse(key);
    181   1.8     ragge 
    182   1.8     ragge 	/* Find first mismatching bit */
    183   1.8     ragge 	m = STRING(idx);
    184   1.8     ragge 	k = key;
    185   1.8     ragge 	if (strcmp(m, k) == 0)
    186   1.8     ragge 		return 1;
    187   1.8     ragge 
    188   1.8     ragge 	for (cix = 0; *m && *k && *m == *k; m++, k++, cix += 8)
    189   1.8     ragge 		;
    190   1.8     ragge 	ix = ffs((int)*m ^ (int)*k) - 1;
    191   1.8     ragge 	cix += ix;
    192   1.8     ragge 
    193   1.8     ragge 	/* Create new node */
    194   1.8     ragge 	nix = treex++;
    195   1.8     ragge 	bit = P_BIT(key, cix);
    196   1.8     ragge 	symb[nix].bitno = cix;
    197   1.8     ragge 	symb[nix].lr[bit] = -val;
    198   1.8     ragge 
    199   1.8     ragge 	/* Find where to insert node */
    200   1.8     ragge 	rbit = baseidx;
    201   1.8     ragge 	lastrbit = 0;
    202   1.8     ragge 	for (;;) {
    203   1.8     ragge 		if (rbit < 0)
    204   1.8     ragge 			break;
    205   1.8     ragge 		sb = symb[rbit].bitno;
    206   1.8     ragge 		if (sb > cix)
    207   1.8     ragge 			break;
    208   1.8     ragge 		if (sb == cix)
    209   1.8     ragge 			printf("symb[rbit].bitno == cix!!!\n");
    210   1.8     ragge 		lastrbit = rbit;
    211   1.8     ragge 		svbit = P_BIT(key, sb);
    212   1.8     ragge 		rbit = symb[rbit].lr[svbit];
    213   1.8     ragge 	}
    214   1.8     ragge 
    215   1.8     ragge 	/* Do the actual insertion */
    216   1.8     ragge 	if (lastrbit == 0) {
    217   1.8     ragge 		/* first element */
    218   1.8     ragge 		symb[nix].lr[!bit] = baseidx;
    219   1.8     ragge 		baseidx = nix;
    220   1.8     ragge 	} else {
    221   1.8     ragge 		symb[nix].lr[!bit] = rbit;
    222   1.8     ragge 		symb[lastrbit].lr[svbit] = nix;
    223   1.8     ragge 	}
    224   1.8     ragge 	return 0;
    225   1.8     ragge }
    226   1.8     ragge 
    227   1.8     ragge static int
    228   1.8     ragge ptree_find(char *key)
    229   1.8     ragge {
    230   1.8     ragge 	int idx;
    231   1.8     ragge 
    232   1.8     ragge 	if (baseidx == 0)
    233   1.8     ragge 		return 0;
    234   1.8     ragge 	idx = symbol_traverse(key);
    235   1.8     ragge 
    236   1.8     ragge 	if (strcmp(key, STRING(idx)) == 0)
    237   1.8     ragge 		return idx;
    238   1.8     ragge 	return 0;
    239   1.8     ragge }
    240   1.8     ragge 
    241   1.8     ragge static void
    242   1.8     ragge ptree_gen(char *off, struct symtab *tab)
    243   1.8     ragge {
    244   1.8     ragge 	Elf_Sym *sym;
    245  1.16     ragge 	int i, nsym;
    246   1.8     ragge 
    247   1.8     ragge 	if (off != NULL)
    248   1.8     ragge 		symb = (struct ptree *)ALIGN(off);
    249   1.8     ragge 	else
    250   1.8     ragge 		symb = malloc((tab->sd_symsize/sizeof(Elf_Sym)) *
    251   1.8     ragge 		    sizeof(struct ptree), M_DEVBUF, M_WAITOK);
    252   1.8     ragge 	symb--; /* sym index won't be 0 */
    253   1.8     ragge 
    254   1.8     ragge 	sym = tab->sd_symstart;
    255  1.16     ragge 	if ((nsym = tab->sd_symsize/sizeof(Elf_Sym)) > INT16_MAX) {
    256  1.16     ragge 		printf("Too many symbols for tree, skipping %d symbols\n",
    257  1.16     ragge 		    nsym-INT16_MAX);
    258  1.16     ragge 		nsym = INT16_MAX;
    259  1.16     ragge 	}
    260  1.16     ragge 	for (i = 1; i < nsym; i++) {
    261   1.8     ragge 		if (ELF_ST_BIND(sym[i].st_info) != STB_GLOBAL)
    262   1.8     ragge 			continue;
    263   1.8     ragge 		ptree_add(tab->sd_strstart+sym[i].st_name, i);
    264   1.8     ragge 	}
    265   1.8     ragge }
    266   1.8     ragge #endif
    267   1.8     ragge 
    268   1.1     ragge /*
    269   1.1     ragge  * Finds a certain symbol name in a certain symbol table.
    270   1.1     ragge  */
    271   1.1     ragge static Elf_Sym *
    272  1.17      cube findsym(char *name, struct symtab *table, int userreq)
    273   1.1     ragge {
    274   1.1     ragge 	Elf_Sym *start = table->sd_symstart;
    275   1.1     ragge 	int i, sz = table->sd_symsize/sizeof(Elf_Sym);
    276   1.1     ragge 	char *np;
    277  1.17      cube 	caddr_t realstart = table->sd_strstart - (userreq ? 0 : table->sd_usroffset);
    278   1.1     ragge 
    279   1.8     ragge #ifdef USE_PTREE
    280   1.8     ragge 	if (table == &kernel_symtab && (i = ptree_find(name)) != 0)
    281   1.8     ragge 		return &start[i];
    282   1.8     ragge #endif
    283   1.8     ragge 
    284   1.1     ragge 	for (i = 0; i < sz; i++) {
    285  1.17      cube 		np = realstart + start[i].st_name;
    286   1.1     ragge 		if (name[0] == np[0] && name[1] == np[1] &&
    287   1.1     ragge 		    strcmp(name, np) == 0)
    288   1.1     ragge 			return &start[i];
    289   1.1     ragge 	}
    290   1.1     ragge 	return NULL;
    291   1.1     ragge }
    292   1.1     ragge 
    293   1.1     ragge /*
    294   1.1     ragge  * The "attach" is in reality done in ksyms_init().
    295   1.1     ragge  */
    296   1.1     ragge void ksymsattach(int);
    297   1.1     ragge void
    298   1.1     ragge ksymsattach(int arg)
    299   1.1     ragge {
    300   1.8     ragge 
    301   1.8     ragge #ifdef USE_PTREE
    302   1.8     ragge 	if (baseidx == 0)
    303   1.8     ragge 		ptree_gen(0, &kernel_symtab);
    304   1.8     ragge #endif
    305   1.8     ragge 
    306   1.1     ragge }
    307   1.1     ragge 
    308   1.1     ragge /*
    309   1.1     ragge  * Add a symbol table named name.
    310   1.1     ragge  * This is intended for use when the kernel loader enters the table.
    311   1.1     ragge  */
    312   1.1     ragge static void
    313   1.9  jdolecek addsymtab(const char *name, Elf_Ehdr *ehdr, struct symtab *tab)
    314   1.1     ragge {
    315   1.1     ragge 	caddr_t start = (caddr_t)ehdr;
    316   1.8     ragge 	caddr_t send;
    317   1.1     ragge 	Elf_Shdr *shdr;
    318   1.8     ragge 	Elf_Sym *sym, *nsym;
    319   1.8     ragge 	int i, j, n, g;
    320   1.8     ragge 	char *str;
    321   1.1     ragge 
    322   1.1     ragge 	/* Find the symbol table and the corresponding string table. */
    323   1.1     ragge 	shdr = (Elf_Shdr *)(start + ehdr->e_shoff);
    324   1.1     ragge 	for (i = 1; i < ehdr->e_shnum; i++) {
    325   1.1     ragge 		if (shdr[i].sh_type != SHT_SYMTAB)
    326   1.1     ragge 			continue;
    327   1.1     ragge 		if (shdr[i].sh_offset == 0)
    328   1.1     ragge 			continue;
    329   1.1     ragge 		tab->sd_symstart = (Elf_Sym *)(start + shdr[i].sh_offset);
    330   1.1     ragge 		tab->sd_symsize = shdr[i].sh_size;
    331   1.1     ragge 		j = shdr[i].sh_link;
    332   1.1     ragge 		if (shdr[j].sh_offset == 0)
    333   1.1     ragge 			continue; /* Can this happen? */
    334   1.1     ragge 		tab->sd_strstart = start + shdr[j].sh_offset;
    335   1.1     ragge 		tab->sd_strsize = shdr[j].sh_size;
    336   1.1     ragge 		break;
    337   1.1     ragge 	}
    338   1.1     ragge 	tab->sd_name = name;
    339   1.8     ragge 	send = tab->sd_strstart + tab->sd_strsize;
    340   1.8     ragge 
    341   1.8     ragge #ifdef KSYMS_DEBUG
    342   1.8     ragge 	printf("start %p sym %p symsz %d str %p strsz %d send %p\n",
    343   1.8     ragge 	    start, tab->sd_symstart, tab->sd_symsize,
    344   1.8     ragge 	    tab->sd_strstart, tab->sd_strsize, send);
    345   1.8     ragge #endif
    346   1.1     ragge 
    347   1.8     ragge 	/*
    348   1.8     ragge 	 * Pack symbol table by removing all file name references
    349   1.8     ragge 	 * and overwrite the elf header.
    350   1.8     ragge 	 */
    351   1.8     ragge 	sym = tab->sd_symstart;
    352   1.8     ragge 	nsym = (Elf_Sym *)start;
    353   1.8     ragge 	str = tab->sd_strstart;
    354   1.8     ragge 	for (g = i = n = 0; i < tab->sd_symsize/sizeof(Elf_Sym); i++) {
    355   1.8     ragge 		if (i == 0) {
    356   1.8     ragge 			nsym[n++] = sym[i];
    357   1.8     ragge 			continue;
    358   1.8     ragge 		}
    359   1.8     ragge 		/*
    360   1.8     ragge 		 * Remove useless symbols.
    361   1.8     ragge 		 * Should actually remove all typeless symbols.
    362   1.8     ragge 		 */
    363   1.5     ragge 		if (sym[i].st_name == 0)
    364   1.8     ragge 			continue; /* Skip nameless entries */
    365   1.8     ragge 		if (ELF_ST_TYPE(sym[i].st_info) == STT_FILE)
    366   1.8     ragge 			continue; /* Skip filenames */
    367   1.8     ragge 		if (ELF_ST_TYPE(sym[i].st_info) == STT_NOTYPE &&
    368   1.8     ragge 		    sym[i].st_value == 0 &&
    369   1.8     ragge 		    strcmp(str + sym[i].st_name, "*ABS*") == 0)
    370   1.8     ragge 			continue; /* XXX */
    371   1.8     ragge 		if (ELF_ST_TYPE(sym[i].st_info) == STT_NOTYPE &&
    372   1.8     ragge 		    strcmp(str + sym[i].st_name, "gcc2_compiled.") == 0)
    373   1.8     ragge 			continue; /* XXX */
    374   1.8     ragge 
    375   1.8     ragge #ifndef DDB
    376   1.8     ragge 		/* Only need global symbols */
    377   1.8     ragge 		if (ELF_ST_BIND(sym[i].st_info) != STB_GLOBAL)
    378   1.5     ragge 			continue;
    379   1.8     ragge #endif
    380   1.8     ragge 
    381   1.8     ragge 		/* Save symbol. Set it as an absolute offset */
    382   1.8     ragge 		nsym[n] = sym[i];
    383   1.8     ragge 		nsym[n].st_shndx = SHN_ABS;
    384   1.8     ragge 		if (ELF_ST_BIND(nsym[n].st_info) == STB_GLOBAL)
    385   1.8     ragge 			g++;
    386   1.6      tron #if NKSYMS
    387   1.8     ragge 		j = strlen(nsym[n].st_name + tab->sd_strstart) + 1;
    388   1.5     ragge 		if (j > ksyms_maxlen)
    389   1.5     ragge 			ksyms_maxlen = j;
    390   1.6      tron #endif
    391   1.8     ragge 		n++;
    392   1.8     ragge 
    393   1.5     ragge 	}
    394   1.8     ragge 	tab->sd_symstart = nsym;
    395   1.8     ragge 	tab->sd_symsize = n * sizeof(Elf_Sym);
    396   1.8     ragge 
    397   1.8     ragge #ifdef notyet
    398   1.8     ragge 	/*
    399   1.8     ragge 	 * Remove left-over strings.
    400   1.8     ragge 	 */
    401   1.8     ragge 	sym = tab->sd_symstart;
    402   1.8     ragge 	str = (caddr_t)tab->sd_symstart + tab->sd_symsize;
    403   1.8     ragge 	str[0] = 0;
    404   1.8     ragge 	n = 1;
    405   1.8     ragge 	for (i = 1; i < tab->sd_symsize/sizeof(Elf_Sym); i++) {
    406  1.10    itojun 		strcpy(str + n, tab->sd_strstart + sym[i].st_name);
    407   1.8     ragge 		sym[i].st_name = n;
    408   1.8     ragge 		n += strlen(str+n) + 1;
    409   1.8     ragge 	}
    410   1.8     ragge 	tab->sd_strstart = str;
    411   1.8     ragge 	tab->sd_strsize = n;
    412   1.8     ragge 
    413   1.8     ragge #ifdef KSYMS_DEBUG
    414   1.8     ragge 	printf("str %p strsz %d send %p\n", str, n, send);
    415   1.8     ragge #endif
    416   1.8     ragge #endif
    417   1.1     ragge 
    418   1.1     ragge 	CIRCLEQ_INSERT_HEAD(&symtab_queue, tab, sd_queue);
    419   1.8     ragge 
    420   1.8     ragge #ifdef notyet
    421   1.8     ragge #ifdef USE_PTREE
    422   1.8     ragge 	/* Try to use the freed space, if possible */
    423   1.8     ragge 	if (send - str - n > g * sizeof(struct ptree))
    424   1.8     ragge 		ptree_gen(str + n, tab);
    425   1.8     ragge #endif
    426   1.8     ragge #endif
    427   1.1     ragge }
    428   1.1     ragge 
    429   1.1     ragge /*
    430   1.1     ragge  * Setup the kernel symbol table stuff.
    431   1.1     ragge  */
    432   1.1     ragge void
    433   1.4     ragge ksyms_init(int symsize, void *start, void *end)
    434   1.1     ragge {
    435   1.3     ragge 	Elf_Ehdr *ehdr;
    436   1.3     ragge 
    437   1.3     ragge #ifdef SYMTAB_SPACE
    438   1.3     ragge 	if (symsize <= 0 &&
    439   1.3     ragge 	    strncmp(db_symtab, SYMTAB_FILLER, sizeof(SYMTAB_FILLER))) {
    440   1.3     ragge 		symsize = db_symtabsize;
    441   1.3     ragge 		start = db_symtab;
    442   1.3     ragge 		end = db_symtab + db_symtabsize;
    443   1.3     ragge 	}
    444   1.3     ragge #endif
    445   1.3     ragge 	if (symsize <= 0) {
    446   1.3     ragge 		printf("[ Kernel symbol table missing! ]\n");
    447   1.3     ragge 		return;
    448   1.3     ragge 	}
    449   1.3     ragge 
    450   1.3     ragge 	/* Sanity check */
    451   1.3     ragge 	if (ALIGNED_POINTER(start, long) == 0) {
    452   1.3     ragge 		printf("[ Kernel symbol table has bad start address %p ]\n",
    453   1.3     ragge 		    start);
    454   1.3     ragge 		return;
    455   1.3     ragge 	}
    456   1.3     ragge 
    457   1.3     ragge 	ehdr = (Elf_Ehdr *)start;
    458   1.1     ragge 
    459   1.1     ragge 	/* check if this is a valid ELF header */
    460   1.1     ragge 	/* No reason to verify arch type, the kernel is actually running! */
    461   1.1     ragge 	if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) ||
    462   1.1     ragge 	    ehdr->e_ident[EI_CLASS] != ELFCLASS ||
    463   1.1     ragge 	    ehdr->e_version > 1) {
    464   1.3     ragge #ifdef notyet /* DDB */
    465   1.3     ragge 		if (ddb_init(symsize, start, end))
    466   1.3     ragge 			return; /* old-style symbol table */
    467   1.3     ragge #endif
    468   1.3     ragge 		printf("[ Kernel symbol table invalid! ]\n");
    469   1.1     ragge 		return; /* nothing to do */
    470   1.1     ragge 	}
    471   1.1     ragge 
    472   1.8     ragge #if NKSYMS
    473   1.8     ragge 	/* Loaded header will be scratched in addsymtab */
    474   1.8     ragge 	ksyms_hdr_init(start);
    475   1.8     ragge #endif
    476   1.8     ragge 
    477   1.1     ragge 	addsymtab("netbsd", ehdr, &kernel_symtab);
    478   1.8     ragge 
    479   1.1     ragge #if NKSYMS
    480   1.1     ragge 	ksyms_sizes_calc();
    481   1.1     ragge #endif
    482   1.8     ragge 
    483   1.1     ragge 	ksymsinited = 1;
    484   1.8     ragge 
    485   1.1     ragge #ifdef DEBUG
    486   1.1     ragge 	printf("Loaded initial symtab at %p, strtab at %p, # entries %ld\n",
    487   1.1     ragge 	    kernel_symtab.sd_symstart, kernel_symtab.sd_strstart,
    488   1.2     ragge 	    (long)kernel_symtab.sd_symsize/sizeof(Elf_Sym));
    489   1.1     ragge #endif
    490   1.1     ragge }
    491   1.1     ragge 
    492   1.1     ragge /*
    493   1.1     ragge  * Get the value associated with a symbol.
    494   1.1     ragge  * "mod" is the module name, or null if any module.
    495   1.1     ragge  * "sym" is the symbol name.
    496   1.1     ragge  * "val" is a pointer to the corresponding value, if call succeeded.
    497   1.1     ragge  * Returns 0 if success or ENOENT if no such entry.
    498   1.1     ragge  */
    499   1.1     ragge int
    500  1.17      cube ksyms_getval(const char *mod, char *sym, unsigned long *val, int type, int userreq)
    501   1.1     ragge {
    502   1.1     ragge 	struct symtab *st;
    503   1.1     ragge 	Elf_Sym *es;
    504   1.1     ragge 
    505   1.1     ragge 	if (ksymsinited == 0)
    506   1.1     ragge 		return ENOENT;
    507   1.1     ragge 
    508   1.1     ragge #ifdef KSYMS_DEBUG
    509   1.1     ragge 	if (ksyms_debug & FOLLOW_CALLS)
    510   1.1     ragge 		printf("ksyms_getval: mod %s sym %s valp %p\n", mod, sym, val);
    511   1.1     ragge #endif
    512   1.1     ragge 
    513   1.1     ragge 	CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
    514   1.1     ragge 		if (mod && strcmp(st->sd_name, mod))
    515   1.1     ragge 			continue;
    516  1.17      cube 		if ((es = findsym(sym, st, userreq)) == NULL)
    517   1.1     ragge 			continue;
    518   1.1     ragge 
    519   1.1     ragge 		/* Skip if bad binding */
    520   1.1     ragge 		if (type == KSYMS_EXTERN &&
    521   1.1     ragge 		    ELF_ST_BIND(es->st_info) != STB_GLOBAL)
    522   1.1     ragge 			continue;
    523   1.1     ragge 
    524   1.1     ragge 		if (val)
    525   1.1     ragge 			*val = es->st_value;
    526   1.1     ragge 		return 0;
    527   1.1     ragge 	}
    528   1.1     ragge 	return ENOENT;
    529   1.1     ragge }
    530   1.1     ragge 
    531   1.1     ragge /*
    532   1.1     ragge  * Get "mod" and "symbol" associated with an address.
    533   1.1     ragge  * Returns 0 if success or ENOENT if no such entry.
    534   1.1     ragge  */
    535   1.1     ragge int
    536   1.9  jdolecek ksyms_getname(const char **mod, char **sym, vaddr_t v, int f)
    537   1.1     ragge {
    538   1.1     ragge 	struct symtab *st;
    539   1.1     ragge 	Elf_Sym *les, *es = NULL;
    540   1.1     ragge 	vaddr_t laddr = 0;
    541  1.15  christos 	const char *lmod = NULL;
    542  1.15  christos 	char *stable = NULL;
    543   1.1     ragge 	int type, i, sz;
    544   1.1     ragge 
    545   1.1     ragge 	if (ksymsinited == 0)
    546   1.1     ragge 		return ENOENT;
    547   1.1     ragge 
    548   1.1     ragge 	CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
    549   1.1     ragge 		sz = st->sd_symsize/sizeof(Elf_Sym);
    550   1.1     ragge 		for (i = 0; i < sz; i++) {
    551   1.1     ragge 			les = st->sd_symstart + i;
    552   1.1     ragge 			type = ELF_ST_TYPE(les->st_info);
    553   1.1     ragge 
    554   1.1     ragge 			if ((f & KSYMS_PROC) && (type != STT_FUNC))
    555   1.1     ragge 				continue;
    556   1.1     ragge 
    557   1.1     ragge 			if (type == STT_NOTYPE)
    558   1.1     ragge 				continue;
    559   1.1     ragge 
    560   1.1     ragge 			if (((f & KSYMS_ANY) == 0) &&
    561   1.1     ragge 			    (type != STT_FUNC) && (type != STT_OBJECT))
    562   1.1     ragge 				continue;
    563   1.1     ragge 
    564   1.1     ragge 			if ((les->st_value <= v) && (les->st_value > laddr)) {
    565   1.1     ragge 				laddr = les->st_value;
    566   1.1     ragge 				es = les;
    567   1.1     ragge 				lmod = st->sd_name;
    568  1.17      cube 				stable = st->sd_strstart - st->sd_usroffset;
    569   1.1     ragge 			}
    570   1.1     ragge 		}
    571   1.1     ragge 	}
    572   1.1     ragge 	if (es == NULL)
    573   1.1     ragge 		return ENOENT;
    574   1.1     ragge 	if ((f & KSYMS_EXACT) && (v != es->st_value))
    575   1.1     ragge 		return ENOENT;
    576   1.1     ragge 	if (mod)
    577   1.1     ragge 		*mod = lmod;
    578   1.1     ragge 	if (sym)
    579   1.1     ragge 		*sym = stable + es->st_name;
    580   1.1     ragge 	return 0;
    581   1.1     ragge }
    582   1.1     ragge 
    583   1.1     ragge #if NKSYMS
    584   1.1     ragge static int symsz, strsz;
    585   1.1     ragge 
    586   1.1     ragge static void
    587   1.1     ragge ksyms_sizes_calc(void)
    588   1.1     ragge {
    589   1.1     ragge         struct symtab *st;
    590   1.1     ragge 	int i;
    591   1.1     ragge 
    592   1.1     ragge         symsz = strsz = 0;
    593   1.1     ragge         CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
    594   1.1     ragge 		if (st != &kernel_symtab) {
    595   1.1     ragge 			for (i = 0; i < st->sd_symsize/sizeof(Elf_Sym); i++)
    596   1.1     ragge 				st->sd_symstart[i].st_name =
    597   1.1     ragge 				    strsz + st->sd_symnmoff[i];
    598  1.17      cube 			st->sd_usroffset = strsz;
    599   1.1     ragge 		}
    600   1.1     ragge                 symsz += st->sd_symsize;
    601   1.1     ragge                 strsz += st->sd_strsize;
    602  1.17      cube         }
    603   1.1     ragge }
    604   1.1     ragge #endif
    605   1.1     ragge 
    606   1.1     ragge /*
    607   1.1     ragge  * Temporary work buffers for dynamic loaded symbol tables.
    608   1.1     ragge  * Will go away when in-kernel linker is in place.
    609   1.1     ragge  */
    610   1.1     ragge #define	NSAVEDSYMS 512
    611   1.1     ragge #define	SZSYMNAMES NSAVEDSYMS*8		/* Just an approximation */
    612   1.1     ragge static Elf_Sym savedsyms[NSAVEDSYMS];
    613   1.1     ragge static int symnmoff[NSAVEDSYMS];
    614   1.1     ragge static char symnames[SZSYMNAMES];
    615   1.1     ragge static int cursyms, curnamep;
    616   1.1     ragge 
    617   1.1     ragge /*
    618   1.1     ragge  * Add a symbol to the temporary save area for symbols.
    619   1.1     ragge  * This routine will go away when the in-kernel linker is in place.
    620   1.1     ragge  */
    621   1.1     ragge static void
    622   1.1     ragge addsym(Elf_Sym *sym, char *name)
    623   1.1     ragge {
    624   1.1     ragge 	int len;
    625   1.1     ragge 
    626   1.1     ragge #ifdef KSYMS_DEBUG
    627   1.1     ragge 	if (ksyms_debug & FOLLOW_MORE_CALLS)
    628   1.1     ragge 		printf("addsym: name %s val %lx\n", name, (long)sym->st_value);
    629   1.1     ragge #endif
    630   1.1     ragge 	if (cursyms == NSAVEDSYMS ||
    631   1.5     ragge 	    ((len = strlen(name) + 1) + curnamep) > SZSYMNAMES) {
    632   1.1     ragge 		printf("addsym: too many sumbols, skipping '%s'\n", name);
    633   1.1     ragge 		return;
    634   1.1     ragge 	}
    635  1.10    itojun 	strlcpy(&symnames[curnamep], name, sizeof(symnames) - curnamep);
    636   1.1     ragge 	savedsyms[cursyms] = *sym;
    637   1.1     ragge 	symnmoff[cursyms] = savedsyms[cursyms].st_name = curnamep;
    638   1.5     ragge 	curnamep += len;
    639   1.7     ragge #if NKSYMS
    640   1.5     ragge 	if (len > ksyms_maxlen)
    641   1.5     ragge 		ksyms_maxlen = len;
    642   1.6      tron #endif
    643   1.1     ragge 	cursyms++;
    644   1.1     ragge }
    645   1.1     ragge /*
    646   1.1     ragge  * Adds a symbol table.
    647   1.1     ragge  * "name" is the module name, "start" and "size" is where the symbol table
    648   1.1     ragge  * is located, and "type" is in which binary format the symbol table is.
    649   1.1     ragge  * New memory for keeping the symbol table is allocated in this function.
    650   1.1     ragge  * Returns 0 if success and EEXIST if the module name is in use.
    651   1.1     ragge  */
    652   1.1     ragge int
    653   1.9  jdolecek ksyms_addsymtab(const char *mod, void *symstart, vsize_t symsize,
    654   1.1     ragge     char *strstart, vsize_t strsize)
    655   1.1     ragge {
    656   1.1     ragge 	Elf_Sym *sym = symstart;
    657   1.1     ragge 	struct symtab *st;
    658  1.14     ragge 	unsigned long rval;
    659   1.1     ragge 	int i;
    660   1.9  jdolecek 	char *str, *name;
    661   1.1     ragge 
    662   1.1     ragge #ifdef KSYMS_DEBUG
    663   1.1     ragge 	if (ksyms_debug & FOLLOW_CALLS)
    664   1.1     ragge 		printf("ksyms_addsymtab: mod %s symsize %lx strsize %lx\n",
    665   1.1     ragge 		    mod, symsize, strsize);
    666   1.1     ragge #endif
    667   1.1     ragge 
    668   1.1     ragge #if NKSYMS
    669   1.1     ragge 	/*
    670   1.1     ragge 	 * Do not try to add a symbol table while someone is reading
    671   1.1     ragge 	 * from /dev/ksyms.
    672   1.1     ragge 	 */
    673   1.1     ragge 	while (ksyms_isopen != 0)
    674   1.1     ragge 		tsleep(&ksyms_isopen, PWAIT, "ksyms", 0);
    675   1.1     ragge #endif
    676   1.1     ragge 
    677   1.1     ragge 	/* Check if this symtab already loaded */
    678   1.1     ragge 	CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
    679   1.1     ragge 		if (strcmp(mod, st->sd_name) == 0)
    680   1.1     ragge 			return EEXIST;
    681   1.1     ragge 	}
    682   1.1     ragge 
    683   1.1     ragge 	/*
    684   1.1     ragge 	 * XXX - Only add a symbol if it do not exist already.
    685   1.1     ragge 	 * This is because of a flaw in the current LKM implementation,
    686   1.1     ragge 	 * the loop will be removed once the in-kernel linker is in place.
    687   1.1     ragge 	 */
    688   1.1     ragge 	cursyms = curnamep = 0;
    689   1.1     ragge 	for (i = 0; i < symsize/sizeof(Elf_Sym); i++) {
    690   1.1     ragge 		if (sym[i].st_name == 0)
    691   1.1     ragge 			continue; /* Just ignore */
    692   1.1     ragge 
    693   1.1     ragge 		/* check validity of the symbol */
    694   1.1     ragge 		/* XXX - save local symbols if DDB */
    695   1.1     ragge 		if (ELF_ST_BIND(sym[i].st_info) != STB_GLOBAL)
    696   1.1     ragge 			continue;
    697   1.1     ragge 
    698   1.1     ragge 		/* Check if the symbol exists */
    699  1.17      cube 		if (ksyms_getval_from_kernel(NULL, strstart + sym[i].st_name,
    700   1.1     ragge 		    &rval, KSYMS_EXTERN) == 0) {
    701   1.1     ragge 			/* Check (and complain) about differing values */
    702   1.1     ragge 			if (sym[i].st_value != rval) {
    703   1.1     ragge 				printf("%s: symbol '%s' redeclared with "
    704   1.1     ragge 				    "different value (%lx != %lx)\n",
    705   1.1     ragge 				    mod, strstart + sym[i].st_name,
    706   1.1     ragge 				    rval, (long)sym[i].st_value);
    707   1.1     ragge 			}
    708   1.1     ragge 		} else
    709   1.1     ragge 			/* Ok, save this symbol */
    710   1.1     ragge 			addsym(&sym[i], strstart + sym[i].st_name);
    711   1.1     ragge 	}
    712   1.5     ragge 
    713   1.1     ragge 	sym = malloc(sizeof(Elf_Sym)*cursyms, M_DEVBUF, M_WAITOK);
    714   1.1     ragge 	str = malloc(curnamep, M_DEVBUF, M_WAITOK);
    715   1.1     ragge 	memcpy(sym, savedsyms, sizeof(Elf_Sym)*cursyms);
    716   1.1     ragge 	memcpy(str, symnames, curnamep);
    717   1.1     ragge 
    718   1.1     ragge 	st = malloc(sizeof(struct symtab), M_DEVBUF, M_WAITOK);
    719  1.10    itojun 	i = strlen(mod) + 1;
    720  1.10    itojun 	name = malloc(i, M_DEVBUF, M_WAITOK);
    721  1.10    itojun 	strlcpy(name, mod, i);
    722   1.9  jdolecek 	st->sd_name = name;
    723   1.1     ragge 	st->sd_symnmoff = malloc(sizeof(int)*cursyms, M_DEVBUF, M_WAITOK);
    724   1.1     ragge 	memcpy(st->sd_symnmoff, symnmoff, sizeof(int)*cursyms);
    725   1.1     ragge 	st->sd_symstart = sym;
    726   1.1     ragge 	st->sd_symsize = sizeof(Elf_Sym)*cursyms;
    727   1.1     ragge 	st->sd_strstart = str;
    728   1.1     ragge 	st->sd_strsize = curnamep;
    729   1.1     ragge 
    730   1.1     ragge 	/* Make them absolute references */
    731   1.1     ragge 	sym = st->sd_symstart;
    732   1.1     ragge 	for (i = 0; i < st->sd_symsize/sizeof(Elf_Sym); i++)
    733   1.1     ragge 		sym[i].st_shndx = SHN_ABS;
    734   1.1     ragge 
    735   1.1     ragge 	CIRCLEQ_INSERT_TAIL(&symtab_queue, st, sd_queue);
    736   1.1     ragge #if NKSYMS
    737   1.1     ragge 	ksyms_sizes_calc();
    738   1.1     ragge #endif
    739   1.1     ragge 	return 0;
    740   1.1     ragge }
    741   1.1     ragge 
    742   1.1     ragge /*
    743   1.1     ragge  * Remove a symbol table specified by name.
    744   1.1     ragge  * Returns 0 if success, EBUSY if device open and ENOENT if no such name.
    745   1.1     ragge  */
    746   1.1     ragge int
    747   1.9  jdolecek ksyms_delsymtab(const char *mod)
    748   1.1     ragge {
    749   1.1     ragge 	struct symtab *st;
    750   1.1     ragge 	int found = 0;
    751   1.1     ragge 
    752   1.1     ragge #if NKSYMS
    753   1.1     ragge 	/*
    754   1.1     ragge 	 * Do not try to delete a symbol table while someone is reading
    755   1.1     ragge 	 * from /dev/ksyms.
    756   1.1     ragge 	 */
    757   1.1     ragge 	while (ksyms_isopen != 0)
    758   1.1     ragge 		tsleep(&ksyms_isopen, PWAIT, "ksyms", 0);
    759   1.1     ragge #endif
    760   1.1     ragge 
    761   1.1     ragge 	CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
    762   1.1     ragge 		if (strcmp(mod, st->sd_name) == 0) {
    763   1.1     ragge 			found = 1;
    764   1.1     ragge 			break;
    765   1.1     ragge 		}
    766   1.1     ragge 	}
    767   1.1     ragge 	if (found == 0)
    768   1.1     ragge 		return ENOENT;
    769   1.1     ragge 	CIRCLEQ_REMOVE(&symtab_queue, st, sd_queue);
    770   1.1     ragge 	free(st->sd_symstart, M_DEVBUF);
    771   1.1     ragge 	free(st->sd_strstart, M_DEVBUF);
    772   1.1     ragge 	free(st->sd_symnmoff, M_DEVBUF);
    773   1.9  jdolecek 	/* LINTED - const castaway */
    774   1.9  jdolecek 	free((void *)st->sd_name, M_DEVBUF);
    775   1.1     ragge 	free(st, M_DEVBUF);
    776   1.1     ragge #if NKSYMS
    777   1.1     ragge 	ksyms_sizes_calc();
    778   1.1     ragge #endif
    779   1.1     ragge 	return 0;
    780   1.1     ragge }
    781   1.1     ragge 
    782  1.17      cube int
    783  1.17      cube ksyms_rensymtab(const char *old, const char *new)
    784  1.17      cube {
    785  1.17      cube 	struct symtab *st, *oldst = NULL;
    786  1.17      cube 	char *newstr;
    787  1.17      cube 
    788  1.17      cube 	CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
    789  1.17      cube 		if (strcmp(old, st->sd_name) == 0)
    790  1.17      cube 			oldst = st;
    791  1.17      cube 		if (strcmp(new, st->sd_name) == 0)
    792  1.17      cube 			return (EEXIST);
    793  1.17      cube 	}
    794  1.17      cube 	if (oldst == NULL)
    795  1.17      cube 		return (ENOENT);
    796  1.17      cube 
    797  1.17      cube 	newstr = malloc(strlen(new)+1, M_DEVBUF, M_WAITOK);
    798  1.17      cube 	if (!newstr)
    799  1.17      cube 		return (ENOMEM);
    800  1.17      cube 	strcpy(newstr, new);
    801  1.17      cube 	free((char *)oldst->sd_name, M_DEVBUF);
    802  1.17      cube 	oldst->sd_name = newstr;
    803  1.17      cube 
    804  1.17      cube 	return (0);
    805  1.17      cube }
    806  1.17      cube 
    807   1.1     ragge #ifdef DDB
    808   1.1     ragge 
    809   1.1     ragge /*
    810   1.1     ragge  * Keep sifting stuff here, to avoid export of ksyms internals.
    811   1.1     ragge  */
    812   1.1     ragge int
    813   1.1     ragge ksyms_sift(char *mod, char *sym, int mode)
    814   1.1     ragge {
    815   1.1     ragge 	struct symtab *st;
    816   1.1     ragge 	char *sb;
    817   1.1     ragge 	int i, sz;
    818   1.1     ragge 
    819   1.1     ragge 	if (ksymsinited == 0)
    820   1.1     ragge 		return ENOENT;
    821   1.1     ragge 
    822   1.1     ragge 	CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
    823   1.1     ragge 		if (mod && strcmp(mod, st->sd_name))
    824   1.1     ragge 			continue;
    825   1.1     ragge 		sb = st->sd_strstart;
    826   1.1     ragge 
    827   1.1     ragge 		sz = st->sd_symsize/sizeof(Elf_Sym);
    828   1.1     ragge 		for (i = 0; i < sz; i++) {
    829   1.1     ragge 			Elf_Sym *les = st->sd_symstart + i;
    830   1.1     ragge 			char c;
    831   1.1     ragge 
    832  1.17      cube 			if (strstr(sb + les->st_name - st->sd_usroffset, sym)
    833  1.17      cube 			    == NULL)
    834   1.1     ragge 				continue;
    835   1.1     ragge 
    836   1.1     ragge 			if (mode == 'F') {
    837   1.1     ragge 				switch (ELF_ST_TYPE(les->st_info)) {
    838   1.1     ragge 				case STT_OBJECT:
    839   1.1     ragge 					c = '+';
    840   1.1     ragge 					break;
    841   1.1     ragge 				case STT_FUNC:
    842   1.1     ragge 					c = '*';
    843   1.1     ragge 					break;
    844   1.1     ragge 				case STT_SECTION:
    845   1.1     ragge 					c = '&';
    846   1.1     ragge 					break;
    847   1.1     ragge 				case STT_FILE:
    848   1.1     ragge 					c = '/';
    849   1.1     ragge 					break;
    850   1.1     ragge 				default:
    851   1.1     ragge 					c = ' ';
    852   1.1     ragge 					break;
    853   1.1     ragge 				}
    854  1.17      cube 				db_printf("%s%c ", sb + les->st_name -
    855  1.17      cube 				    st->sd_usroffset, c);
    856   1.1     ragge 			} else
    857  1.17      cube 				db_printf("%s ", sb + les->st_name -
    858  1.17      cube 				    st->sd_usroffset);
    859   1.1     ragge 		}
    860   1.1     ragge 	}
    861   1.1     ragge 	return ENOENT;
    862   1.1     ragge }
    863   1.1     ragge #endif
    864   1.1     ragge 
    865   1.1     ragge #if NKSYMS
    866   1.1     ragge 
    867   1.1     ragge /*
    868   1.1     ragge  * Static allocated ELF header.
    869   1.1     ragge  * Basic info is filled in at attach, sizes at open.
    870   1.1     ragge  */
    871   1.1     ragge #define	SYMTAB		1
    872   1.1     ragge #define	STRTAB		2
    873   1.1     ragge #define	SHSTRTAB	3
    874   1.1     ragge #define NSECHDR		4
    875   1.1     ragge 
    876   1.1     ragge #define	NPRGHDR		2
    877   1.1     ragge #define	SHSTRSIZ	28
    878   1.1     ragge 
    879   1.1     ragge static struct ksyms_hdr {
    880   1.1     ragge 	Elf_Ehdr	kh_ehdr;
    881   1.1     ragge 	Elf_Phdr	kh_phdr[NPRGHDR];
    882   1.1     ragge 	Elf_Shdr	kh_shdr[NSECHDR];
    883   1.1     ragge 	char 		kh_strtab[SHSTRSIZ];
    884   1.1     ragge } ksyms_hdr;
    885   1.1     ragge 
    886   1.1     ragge 
    887   1.1     ragge void
    888   1.1     ragge ksyms_hdr_init(caddr_t hdraddr)
    889   1.1     ragge {
    890   1.1     ragge 
    891   1.1     ragge 	/* Copy the loaded elf exec header */
    892   1.1     ragge 	memcpy(&ksyms_hdr.kh_ehdr, hdraddr, sizeof(Elf_Ehdr));
    893   1.1     ragge 
    894   1.1     ragge 	/* Set correct program/section header sizes, offsets and numbers */
    895   1.1     ragge 	ksyms_hdr.kh_ehdr.e_phoff = offsetof(struct ksyms_hdr, kh_phdr[0]);
    896   1.1     ragge 	ksyms_hdr.kh_ehdr.e_phentsize = sizeof(Elf_Phdr);
    897   1.1     ragge 	ksyms_hdr.kh_ehdr.e_phnum = NPRGHDR;
    898   1.1     ragge 	ksyms_hdr.kh_ehdr.e_shoff = offsetof(struct ksyms_hdr, kh_shdr[0]);
    899   1.1     ragge 	ksyms_hdr.kh_ehdr.e_shentsize = sizeof(Elf_Shdr);
    900   1.1     ragge 	ksyms_hdr.kh_ehdr.e_shnum = NSECHDR;
    901   1.1     ragge 	ksyms_hdr.kh_ehdr.e_shstrndx = NSECHDR - 1; /* Last section */
    902   1.1     ragge 
    903   1.1     ragge 	/*
    904   1.1     ragge 	 * Keep program headers zeroed (unused).
    905   1.1     ragge 	 * The section headers are hand-crafted.
    906   1.1     ragge 	 * First section is section zero.
    907   1.1     ragge 	 */
    908   1.1     ragge 
    909   1.1     ragge 	/* Second section header; ".symtab" */
    910   1.1     ragge 	ksyms_hdr.kh_shdr[SYMTAB].sh_name = 1; /* Section 3 offset */
    911   1.1     ragge 	ksyms_hdr.kh_shdr[SYMTAB].sh_type = SHT_SYMTAB;
    912   1.1     ragge 	ksyms_hdr.kh_shdr[SYMTAB].sh_offset = sizeof(struct ksyms_hdr);
    913   1.1     ragge /*	ksyms_hdr.kh_shdr[SYMTAB].sh_size = filled in at open */
    914   1.1     ragge 	ksyms_hdr.kh_shdr[SYMTAB].sh_link = 2; /* Corresponding strtab */
    915   1.1     ragge 	ksyms_hdr.kh_shdr[SYMTAB].sh_info = 0; /* XXX */
    916   1.1     ragge 	ksyms_hdr.kh_shdr[SYMTAB].sh_addralign = sizeof(long);
    917   1.1     ragge 	ksyms_hdr.kh_shdr[SYMTAB].sh_entsize = sizeof(Elf_Sym);
    918   1.1     ragge 
    919   1.1     ragge 	/* Third section header; ".strtab" */
    920   1.1     ragge 	ksyms_hdr.kh_shdr[STRTAB].sh_name = 9; /* Section 3 offset */
    921   1.1     ragge 	ksyms_hdr.kh_shdr[STRTAB].sh_type = SHT_STRTAB;
    922   1.1     ragge /*	ksyms_hdr.kh_shdr[STRTAB].sh_offset = filled in at open */
    923   1.1     ragge /*	ksyms_hdr.kh_shdr[STRTAB].sh_size = filled in at open */
    924   1.1     ragge /*	ksyms_hdr.kh_shdr[STRTAB].sh_link = kept zero */
    925   1.1     ragge 	ksyms_hdr.kh_shdr[STRTAB].sh_info = 0;
    926   1.1     ragge 	ksyms_hdr.kh_shdr[STRTAB].sh_addralign = sizeof(char);
    927   1.1     ragge 	ksyms_hdr.kh_shdr[STRTAB].sh_entsize = 0;
    928   1.1     ragge 
    929   1.1     ragge 	/* Fourth section, ".shstrtab" */
    930   1.1     ragge 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_name = 17; /* This section name offset */
    931   1.1     ragge 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_type = SHT_STRTAB;
    932   1.1     ragge 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_offset =
    933   1.1     ragge 	    offsetof(struct ksyms_hdr, kh_strtab);
    934   1.1     ragge 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_size = SHSTRSIZ;
    935   1.1     ragge 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_addralign = sizeof(char);
    936   1.1     ragge 
    937   1.1     ragge 	/* Set section names */
    938  1.10    itojun 	strlcpy(&ksyms_hdr.kh_strtab[1], ".symtab",
    939  1.10    itojun 	    sizeof(ksyms_hdr.kh_strtab) - 1);
    940  1.10    itojun 	strlcpy(&ksyms_hdr.kh_strtab[9], ".strtab",
    941  1.10    itojun 	    sizeof(ksyms_hdr.kh_strtab) - 9);
    942  1.10    itojun 	strlcpy(&ksyms_hdr.kh_strtab[17], ".shstrtab",
    943  1.10    itojun 	    sizeof(ksyms_hdr.kh_strtab) - 17);
    944   1.1     ragge };
    945   1.1     ragge 
    946   1.1     ragge int
    947  1.13      fvdl ksymsopen(dev_t dev, int oflags, int devtype, struct proc *p)
    948   1.1     ragge {
    949   1.1     ragge 
    950   1.1     ragge 	if (minor(dev))
    951   1.1     ragge 		return ENXIO;
    952   1.1     ragge 
    953   1.1     ragge 	ksyms_hdr.kh_shdr[SYMTAB].sh_size = symsz;
    954   1.1     ragge 	ksyms_hdr.kh_shdr[STRTAB].sh_offset = symsz +
    955   1.1     ragge 	    ksyms_hdr.kh_shdr[SYMTAB].sh_offset;
    956   1.1     ragge 	ksyms_hdr.kh_shdr[STRTAB].sh_size = strsz;
    957   1.1     ragge 	ksyms_isopen = 1;
    958   1.1     ragge 
    959   1.1     ragge #ifdef KSYMS_DEBUG
    960   1.1     ragge 	if (ksyms_debug & FOLLOW_DEVKSYMS)
    961   1.1     ragge 		printf("ksymsopen: symsz 0x%x strsz 0x%x\n", symsz, strsz);
    962   1.1     ragge #endif
    963   1.1     ragge 
    964   1.1     ragge 	return 0;
    965   1.1     ragge }
    966   1.1     ragge 
    967   1.1     ragge int
    968  1.13      fvdl ksymsclose(dev_t dev, int oflags, int devtype, struct proc *p)
    969   1.1     ragge {
    970   1.1     ragge 
    971   1.1     ragge #ifdef KSYMS_DEBUG
    972   1.1     ragge 	if (ksyms_debug & FOLLOW_DEVKSYMS)
    973   1.1     ragge 		printf("ksymsclose\n");
    974   1.1     ragge #endif
    975   1.1     ragge 
    976   1.1     ragge 	ksyms_isopen = 0;
    977   1.1     ragge 	wakeup(&ksyms_isopen);
    978   1.1     ragge 	return 0;
    979   1.1     ragge }
    980   1.1     ragge 
    981   1.1     ragge #define	HDRSIZ	sizeof(struct ksyms_hdr)
    982   1.1     ragge 
    983   1.1     ragge int
    984   1.1     ragge ksymsread(dev_t dev, struct uio *uio, int ioflag)
    985   1.1     ragge {
    986   1.1     ragge 	struct symtab *st;
    987   1.1     ragge 	size_t filepos, inpos, off;
    988   1.1     ragge 
    989   1.1     ragge #ifdef KSYMS_DEBUG
    990   1.1     ragge 	if (ksyms_debug & FOLLOW_DEVKSYMS)
    991   1.1     ragge 		printf("ksymsread: offset 0x%llx resid 0x%lx\n",
    992   1.1     ragge 		    (long long)uio->uio_offset, uio->uio_resid);
    993   1.1     ragge #endif
    994   1.1     ragge 	if (ksymsinited == 0)
    995   1.1     ragge 		return ENXIO;
    996   1.1     ragge 
    997   1.1     ragge 	off = uio->uio_offset;
    998   1.1     ragge 	if (off >= (strsz + symsz + HDRSIZ))
    999   1.1     ragge 		return 0; /* End of symtab */
   1000   1.1     ragge 	/*
   1001   1.1     ragge 	 * First: Copy out the ELF header.
   1002   1.1     ragge 	 */
   1003   1.1     ragge 	if (off < HDRSIZ)
   1004   1.1     ragge 		uiomove((char *)&ksyms_hdr + off, HDRSIZ - off, uio);
   1005   1.1     ragge 
   1006   1.1     ragge 	/*
   1007   1.1     ragge 	 * Copy out the symbol table.
   1008   1.1     ragge 	 */
   1009   1.1     ragge 	filepos = HDRSIZ;
   1010   1.1     ragge 	CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
   1011   1.1     ragge 		if (uio->uio_resid == 0)
   1012   1.1     ragge 			return 0;
   1013   1.1     ragge 		if (uio->uio_offset <= st->sd_symsize + filepos) {
   1014   1.1     ragge 			inpos = uio->uio_offset - filepos;
   1015   1.1     ragge 			uiomove((char *)st->sd_symstart + inpos,
   1016   1.1     ragge 			   st->sd_symsize - inpos, uio);
   1017   1.1     ragge 		}
   1018   1.1     ragge 		filepos += st->sd_symsize;
   1019   1.1     ragge 	}
   1020   1.1     ragge 
   1021   1.1     ragge 	if (filepos != HDRSIZ + symsz)
   1022   1.1     ragge 		panic("ksymsread: unsunc");
   1023   1.1     ragge 
   1024   1.1     ragge 	/*
   1025   1.1     ragge 	 * Copy out the string table
   1026   1.1     ragge 	 */
   1027   1.1     ragge 	CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
   1028   1.1     ragge 		if (uio->uio_resid == 0)
   1029   1.1     ragge 			return 0;
   1030   1.1     ragge 		if (uio->uio_offset <= st->sd_strsize + filepos) {
   1031   1.1     ragge 			inpos = uio->uio_offset - filepos;
   1032   1.1     ragge 			uiomove((char *)st->sd_strstart + inpos,
   1033   1.1     ragge 			   st->sd_strsize - inpos, uio);
   1034   1.1     ragge 		}
   1035   1.1     ragge 		filepos += st->sd_strsize;
   1036   1.1     ragge 	}
   1037   1.1     ragge 	return 0;
   1038   1.1     ragge }
   1039   1.1     ragge 
   1040   1.1     ragge int
   1041   1.1     ragge ksymswrite(dev_t dev, struct uio *uio, int ioflag)
   1042   1.1     ragge {
   1043   1.1     ragge 	return EROFS;
   1044   1.1     ragge }
   1045   1.1     ragge 
   1046   1.1     ragge int
   1047  1.13      fvdl ksymsioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p)
   1048   1.1     ragge {
   1049   1.1     ragge 	struct ksyms_gsymbol *kg = (struct ksyms_gsymbol *)data;
   1050   1.1     ragge 	struct symtab *st;
   1051  1.15  christos 	Elf_Sym *sym = NULL;
   1052   1.1     ragge 	unsigned long val;
   1053   1.1     ragge 	int error = 0;
   1054  1.15  christos 	char *str = NULL;
   1055   1.5     ragge 
   1056   1.5     ragge 	if (cmd == KIOCGVALUE || cmd == KIOCGSYMBOL)
   1057   1.5     ragge 		str = malloc(ksyms_maxlen, M_DEVBUF, M_WAITOK);
   1058   1.1     ragge 
   1059   1.1     ragge 	switch (cmd) {
   1060   1.1     ragge 	case KIOCGVALUE:
   1061   1.1     ragge 		/*
   1062   1.1     ragge 		 * Use the in-kernel symbol lookup code for fast
   1063   1.1     ragge 		 * retreival of a value.
   1064   1.1     ragge 		 */
   1065   1.5     ragge 		if ((error = copyinstr(kg->kg_name, str, ksyms_maxlen, NULL)))
   1066   1.1     ragge 			break;
   1067  1.17      cube 		if ((error = ksyms_getval_from_userland(NULL, str, &val, KSYMS_EXTERN)))
   1068   1.1     ragge 			break;
   1069   1.1     ragge 		error = copyout(&val, kg->kg_value, sizeof(long));
   1070   1.1     ragge 		break;
   1071   1.1     ragge 
   1072   1.1     ragge 	case KIOCGSYMBOL:
   1073   1.1     ragge 		/*
   1074   1.1     ragge 		 * Use the in-kernel symbol lookup code for fast
   1075   1.1     ragge 		 * retreival of a symbol.
   1076   1.1     ragge 		 */
   1077   1.5     ragge 		if ((error = copyinstr(kg->kg_name, str, ksyms_maxlen, NULL)))
   1078   1.1     ragge 			break;
   1079   1.1     ragge 		CIRCLEQ_FOREACH(st, &symtab_queue, sd_queue) {
   1080  1.17      cube 			if ((sym = findsym(str, st, 1)) == NULL) /* from userland */
   1081   1.1     ragge 				continue;
   1082   1.1     ragge 
   1083   1.1     ragge 			/* Skip if bad binding */
   1084   1.1     ragge 			if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL) {
   1085   1.1     ragge 				sym = NULL;
   1086   1.1     ragge 				continue;
   1087   1.1     ragge 			}
   1088   1.1     ragge 			break;
   1089   1.1     ragge 		}
   1090   1.1     ragge 		if (sym != NULL)
   1091   1.1     ragge 			error = copyout(sym, kg->kg_sym, sizeof(Elf_Sym));
   1092   1.1     ragge 		else
   1093   1.1     ragge 			error = ENOENT;
   1094   1.1     ragge 		break;
   1095   1.1     ragge 
   1096   1.1     ragge 	case KIOCGSIZE:
   1097   1.1     ragge 		/*
   1098   1.1     ragge 		 * Get total size of symbol table.
   1099   1.1     ragge 		 */
   1100   1.1     ragge 		*(int *)data = strsz + symsz + HDRSIZ;
   1101   1.1     ragge 		break;
   1102   1.1     ragge 
   1103   1.1     ragge 	default:
   1104   1.1     ragge 		error = ENOTTY;
   1105   1.1     ragge 		break;
   1106   1.1     ragge 	}
   1107   1.5     ragge 
   1108   1.5     ragge 	if (cmd == KIOCGVALUE || cmd == KIOCGSYMBOL)
   1109   1.5     ragge 		free(str, M_DEVBUF);
   1110   1.5     ragge 
   1111   1.5     ragge 	return error;
   1112   1.1     ragge }
   1113   1.1     ragge #endif
   1114