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