Branch data Line data Source code
1 : : /*
2 : : * kallsyms.c: in-kernel printing of symbolic oopses and stack traces.
3 : : *
4 : : * Rewritten and vastly simplified by Rusty Russell for in-kernel
5 : : * module loader:
6 : : * Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
7 : : *
8 : : * ChangeLog:
9 : : *
10 : : * (25/Aug/2004) Paulo Marques <pmarques@grupopie.com>
11 : : * Changed the compression method from stem compression to "table lookup"
12 : : * compression (see scripts/kallsyms.c for a more complete description)
13 : : */
14 : : #include <linux/kallsyms.h>
15 : : #include <linux/module.h>
16 : : #include <linux/init.h>
17 : : #include <linux/seq_file.h>
18 : : #include <linux/fs.h>
19 : : #include <linux/kdb.h>
20 : : #include <linux/err.h>
21 : : #include <linux/proc_fs.h>
22 : : #include <linux/sched.h> /* for cond_resched */
23 : : #include <linux/mm.h>
24 : : #include <linux/ctype.h>
25 : : #include <linux/slab.h>
26 : :
27 : : #include <asm/sections.h>
28 : :
29 : : #ifdef CONFIG_KALLSYMS_ALL
30 : : #define all_var 1
31 : : #else
32 : : #define all_var 0
33 : : #endif
34 : :
35 : : /*
36 : : * These will be re-linked against their real values
37 : : * during the second link stage.
38 : : */
39 : : extern const unsigned long kallsyms_addresses[] __attribute__((weak));
40 : : extern const u8 kallsyms_names[] __attribute__((weak));
41 : :
42 : : /*
43 : : * Tell the compiler that the count isn't in the small data section if the arch
44 : : * has one (eg: FRV).
45 : : */
46 : : extern const unsigned long kallsyms_num_syms
47 : : __attribute__((weak, section(".rodata")));
48 : :
49 : : extern const u8 kallsyms_token_table[] __attribute__((weak));
50 : : extern const u16 kallsyms_token_index[] __attribute__((weak));
51 : :
52 : : extern const unsigned long kallsyms_markers[] __attribute__((weak));
53 : :
54 : : static inline int is_kernel_inittext(unsigned long addr)
55 : : {
56 [ + - ][ + + ]: 25 : if (addr >= (unsigned long)_sinittext
57 [ - + ][ + + ]: 25 : && addr <= (unsigned long)_einittext)
58 : : return 1;
59 : : return 0;
60 : : }
61 : :
62 : : static inline int is_kernel_text(unsigned long addr)
63 : : {
64 [ + + ][ + + ]: 157 : if ((addr >= (unsigned long)_stext && addr <= (unsigned long)_etext) ||
65 : : arch_is_kernel_text(addr))
66 : : return 1;
67 : 19 : return in_gate_area_no_mm(addr);
68 : : }
69 : :
70 : : static inline int is_kernel(unsigned long addr)
71 : : {
72 : : if (addr >= (unsigned long)_stext && addr <= (unsigned long)_end)
73 : : return 1;
74 : : return in_gate_area_no_mm(addr);
75 : : }
76 : :
77 : 0 : static int is_ksym_addr(unsigned long addr)
78 : : {
79 : : if (all_var)
80 : : return is_kernel(addr);
81 : :
82 [ + + ][ + + ]: 176 : return is_kernel_text(addr) || is_kernel_inittext(addr);
83 : : }
84 : :
85 : : /*
86 : : * Expand a compressed symbol data into the resulting uncompressed string,
87 : : * if uncompressed string is too long (>= maxlen), it will be truncated,
88 : : * given the offset to where the symbol is in the compressed stream.
89 : : */
90 : 0 : static unsigned int kallsyms_expand_symbol(unsigned int off,
91 : : char *result, size_t maxlen)
92 : : {
93 : : int len, skipped_first = 0;
94 : : const u8 *tptr, *data;
95 : :
96 : : /* Get the compressed symbol length from the first symbol byte. */
97 : 42790 : data = &kallsyms_names[off];
98 : 42790 : len = *data;
99 : 42790 : data++;
100 : :
101 : : /*
102 : : * Update the offset to return the offset for the next symbol on
103 : : * the compressed stream.
104 : : */
105 : 42790 : off += len + 1;
106 : :
107 : : /*
108 : : * For every byte on the compressed symbol data, copy the table
109 : : * entry for that byte.
110 : : */
111 [ + + ]: 522326 : while (len) {
112 : 479536 : tptr = &kallsyms_token_table[kallsyms_token_index[*data]];
113 : 479536 : data++;
114 : 479536 : len--;
115 : :
116 [ + + ]: 1449849 : while (*tptr) {
117 [ + + ]: 970313 : if (skipped_first) {
118 [ + ]: 927523 : if (maxlen <= 1)
119 : : goto tail;
120 : 927523 : *result = *tptr;
121 : 927523 : result++;
122 : 927523 : maxlen--;
123 : : } else
124 : : skipped_first = 1;
125 : 970313 : tptr++;
126 : : }
127 : : }
128 : :
129 : : tail:
130 [ # # ]: 0 : if (maxlen)
131 : 42790 : *result = '\0';
132 : :
133 : : /* Return to offset to the next symbol. */
134 : 0 : return off;
135 : : }
136 : :
137 : : /*
138 : : * Get symbol type information. This is encoded as a single char at the
139 : : * beginning of the symbol name.
140 : : */
141 : : static char kallsyms_get_symbol_type(unsigned int off)
142 : : {
143 : : /*
144 : : * Get just the first code, look it up in the token table,
145 : : * and return the first char from this token.
146 : : */
147 : 42646 : return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]];
148 : : }
149 : :
150 : :
151 : : /*
152 : : * Find the offset on the compressed stream given and index in the
153 : : * kallsyms array.
154 : : */
155 : : static unsigned int get_symbol_offset(unsigned long pos)
156 : : {
157 : : const u8 *name;
158 : : int i;
159 : :
160 : : /*
161 : : * Use the closest marker we have. We have markers every 256 positions,
162 : : * so that should be close enough.
163 : : */
164 : 42834 : name = &kallsyms_names[kallsyms_markers[pos >> 8]];
165 : :
166 : : /*
167 : : * Sequentially scan all the symbols up to the point we're searching
168 : : * for. Every symbol is stored in a [<len>][<len> bytes of data] format,
169 : : * so we just need to add the len to the current pointer for every
170 : : * symbol we wish to skip.
171 : : */
172 [ # # ][ # # ]: 19840 : for (i = 0; i < (pos & 0xFF); i++)
[ + + ][ + + ]
173 : 19696 : name = name + (*name) + 1;
174 : :
175 : 145 : return name - kallsyms_names;
176 : : }
177 : :
178 : : /* Lookup the address for this symbol. Returns 0 if not found. */
179 : 0 : unsigned long kallsyms_lookup_name(const char *name)
180 : : {
181 : : char namebuf[KSYM_NAME_LEN];
182 : : unsigned long i;
183 : : unsigned int off;
184 : :
185 [ # # ]: 0 : for (i = 0, off = 0; i < kallsyms_num_syms; i++) {
186 : 0 : off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
187 : :
188 [ # # ]: 0 : if (strcmp(namebuf, name) == 0)
189 : 0 : return kallsyms_addresses[i];
190 : : }
191 : 0 : return module_kallsyms_lookup_name(name);
192 : : }
193 : : EXPORT_SYMBOL_GPL(kallsyms_lookup_name);
194 : :
195 : 0 : int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *,
196 : : unsigned long),
197 : : void *data)
198 : : {
199 : : char namebuf[KSYM_NAME_LEN];
200 : : unsigned long i;
201 : : unsigned int off;
202 : : int ret;
203 : :
204 [ # # ]: 0 : for (i = 0, off = 0; i < kallsyms_num_syms; i++) {
205 : 0 : off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
206 : 0 : ret = fn(data, namebuf, NULL, kallsyms_addresses[i]);
207 [ # # ]: 0 : if (ret != 0)
208 : : return ret;
209 : : }
210 : 0 : return module_kallsyms_on_each_symbol(fn, data);
211 : : }
212 : : EXPORT_SYMBOL_GPL(kallsyms_on_each_symbol);
213 : :
214 : 0 : static unsigned long get_symbol_pos(unsigned long addr,
215 : : unsigned long *symbolsize,
216 : : unsigned long *offset)
217 : : {
218 : : unsigned long symbol_start = 0, symbol_end = 0;
219 : : unsigned long i, low, high, mid;
220 : :
221 : : /* This kernel should never had been booted. */
222 [ - + ]: 144 : BUG_ON(!kallsyms_addresses);
223 : :
224 : : /* Do a binary search on the sorted kallsyms_addresses array. */
225 : : low = 0;
226 : 144 : high = kallsyms_num_syms;
227 : :
228 [ + + ]: 2380 : while (high - low > 1) {
229 : 2236 : mid = low + (high - low) / 2;
230 [ + + ]: 2236 : if (kallsyms_addresses[mid] <= addr)
231 : : low = mid;
232 : : else
233 : : high = mid;
234 : : }
235 : :
236 : : /*
237 : : * Search for the first aliased symbol. Aliased
238 : : * symbols are symbols with the same address.
239 : : */
240 [ + - ][ + + ]: 146 : while (low && kallsyms_addresses[low-1] == kallsyms_addresses[low])
241 : : --low;
242 : :
243 : 144 : symbol_start = kallsyms_addresses[low];
244 : :
245 : : /* Search for next non-aliased symbol. */
246 [ + + ]: 146 : for (i = low + 1; i < kallsyms_num_syms; i++) {
247 [ + + ]: 140 : if (kallsyms_addresses[i] > symbol_start) {
248 : : symbol_end = kallsyms_addresses[i];
249 : : break;
250 : : }
251 : : }
252 : :
253 : : /* If we found no next symbol, we use the end of the section. */
254 [ + + ]: 144 : if (!symbol_end) {
255 [ + - ]: 6 : if (is_kernel_inittext(addr))
256 : 6 : symbol_end = (unsigned long)_einittext;
257 : : else if (all_var)
258 : : symbol_end = (unsigned long)_end;
259 : : else
260 : 0 : symbol_end = (unsigned long)_etext;
261 : : }
262 : :
263 [ # # ]: 144 : if (symbolsize)
264 : 113 : *symbolsize = symbol_end - symbol_start;
265 [ # # ]: 0 : if (offset)
266 : 113 : *offset = addr - symbol_start;
267 : :
268 : 0 : return low;
269 : : }
270 : :
271 : : /*
272 : : * Lookup an address but don't bother to find any names.
273 : : */
274 : 0 : int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize,
275 : : unsigned long *offset)
276 : : {
277 : : char namebuf[KSYM_NAME_LEN];
278 [ # # ]: 0 : if (is_ksym_addr(addr))
279 : 0 : return !!get_symbol_pos(addr, symbolsize, offset);
280 : :
281 : 0 : return !!module_address_lookup(addr, symbolsize, offset, NULL, namebuf);
282 : : }
283 : :
284 : : /*
285 : : * Lookup an address
286 : : * - modname is set to NULL if it's in the kernel.
287 : : * - We guarantee that the returned name is valid until we reschedule even if.
288 : : * It resides in a module.
289 : : * - We also guarantee that modname will be valid until rescheduled.
290 : : */
291 : 0 : const char *kallsyms_lookup(unsigned long addr,
292 : : unsigned long *symbolsize,
293 : : unsigned long *offset,
294 : : char **modname, char *namebuf)
295 : : {
296 : 115 : namebuf[KSYM_NAME_LEN - 1] = 0;
297 : 115 : namebuf[0] = 0;
298 : :
299 [ + + ]: 115 : if (is_ksym_addr(addr)) {
300 : : unsigned long pos;
301 : :
302 : 113 : pos = get_symbol_pos(addr, symbolsize, offset);
303 : : /* Grab name */
304 : 113 : kallsyms_expand_symbol(get_symbol_offset(pos),
305 : : namebuf, KSYM_NAME_LEN);
306 [ + - ]: 228 : if (modname)
307 : 113 : *modname = NULL;
308 : 113 : return namebuf;
309 : : }
310 : :
311 : : /* See if it's in a module. */
312 : 2 : return module_address_lookup(addr, symbolsize, offset, modname,
313 : : namebuf);
314 : : }
315 : :
316 : 0 : int lookup_symbol_name(unsigned long addr, char *symname)
317 : : {
318 : 42 : symname[0] = '\0';
319 : 42 : symname[KSYM_NAME_LEN - 1] = '\0';
320 : :
321 [ + + ]: 42 : if (is_ksym_addr(addr)) {
322 : : unsigned long pos;
323 : :
324 : 31 : pos = get_symbol_pos(addr, NULL, NULL);
325 : : /* Grab name */
326 : 31 : kallsyms_expand_symbol(get_symbol_offset(pos),
327 : : symname, KSYM_NAME_LEN);
328 : 31 : return 0;
329 : : }
330 : : /* See if it's in a module. */
331 : 11 : return lookup_module_symbol_name(addr, symname);
332 : : }
333 : :
334 : 0 : int lookup_symbol_attrs(unsigned long addr, unsigned long *size,
335 : : unsigned long *offset, char *modname, char *name)
336 : : {
337 : 0 : name[0] = '\0';
338 : 0 : name[KSYM_NAME_LEN - 1] = '\0';
339 : :
340 [ # # ]: 0 : if (is_ksym_addr(addr)) {
341 : : unsigned long pos;
342 : :
343 : 0 : pos = get_symbol_pos(addr, size, offset);
344 : : /* Grab name */
345 : 0 : kallsyms_expand_symbol(get_symbol_offset(pos),
346 : : name, KSYM_NAME_LEN);
347 : 0 : modname[0] = '\0';
348 : 0 : return 0;
349 : : }
350 : : /* See if it's in a module. */
351 : 0 : return lookup_module_symbol_attrs(addr, size, offset, modname, name);
352 : : }
353 : :
354 : : /* Look up a kernel symbol and return it in a text buffer. */
355 : 0 : static int __sprint_symbol(char *buffer, unsigned long address,
356 : : int symbol_offset, int add_offset)
357 : : {
358 : : char *modname;
359 : : const char *name;
360 : : unsigned long offset, size;
361 : : int len;
362 : :
363 : 115 : address += symbol_offset;
364 : 115 : name = kallsyms_lookup(address, &size, &offset, &modname, buffer);
365 [ + + ]: 230 : if (!name)
366 : 2 : return sprintf(buffer, "0x%lx", address);
367 : :
368 [ - + ]: 228 : if (name != buffer)
369 : 0 : strcpy(buffer, name);
370 : 113 : len = strlen(buffer);
371 : 113 : offset -= symbol_offset;
372 : :
373 [ + + ]: 113 : if (add_offset)
374 : 109 : len += sprintf(buffer + len, "+%#lx/%#lx", offset, size);
375 : :
376 [ - + ]: 113 : if (modname)
377 : 0 : len += sprintf(buffer + len, " [%s]", modname);
378 : :
379 : 113 : return len;
380 : : }
381 : :
382 : : /**
383 : : * sprint_symbol - Look up a kernel symbol and return it in a text buffer
384 : : * @buffer: buffer to be stored
385 : : * @address: address to lookup
386 : : *
387 : : * This function looks up a kernel symbol with @address and stores its name,
388 : : * offset, size and module name to @buffer if possible. If no symbol was found,
389 : : * just saves its @address as is.
390 : : *
391 : : * This function returns the number of bytes stored in @buffer.
392 : : */
393 : 0 : int sprint_symbol(char *buffer, unsigned long address)
394 : : {
395 : 111 : return __sprint_symbol(buffer, address, 0, 1);
396 : : }
397 : : EXPORT_SYMBOL_GPL(sprint_symbol);
398 : :
399 : : /**
400 : : * sprint_symbol_no_offset - Look up a kernel symbol and return it in a text buffer
401 : : * @buffer: buffer to be stored
402 : : * @address: address to lookup
403 : : *
404 : : * This function looks up a kernel symbol with @address and stores its name
405 : : * and module name to @buffer if possible. If no symbol was found, just saves
406 : : * its @address as is.
407 : : *
408 : : * This function returns the number of bytes stored in @buffer.
409 : : */
410 : 0 : int sprint_symbol_no_offset(char *buffer, unsigned long address)
411 : : {
412 : 4 : return __sprint_symbol(buffer, address, 0, 0);
413 : : }
414 : : EXPORT_SYMBOL_GPL(sprint_symbol_no_offset);
415 : :
416 : : /**
417 : : * sprint_backtrace - Look up a backtrace symbol and return it in a text buffer
418 : : * @buffer: buffer to be stored
419 : : * @address: address to lookup
420 : : *
421 : : * This function is for stack backtrace and does the same thing as
422 : : * sprint_symbol() but with modified/decreased @address. If there is a
423 : : * tail-call to the function marked "noreturn", gcc optimized out code after
424 : : * the call so that the stack-saved return address could point outside of the
425 : : * caller. This function ensures that kallsyms will find the original caller
426 : : * by decreasing @address.
427 : : *
428 : : * This function returns the number of bytes stored in @buffer.
429 : : */
430 : 0 : int sprint_backtrace(char *buffer, unsigned long address)
431 : : {
432 : 0 : return __sprint_symbol(buffer, address, -1, 1);
433 : : }
434 : :
435 : : /* Look up a kernel symbol and print it to the kernel messages. */
436 : 0 : void __print_symbol(const char *fmt, unsigned long address)
437 : : {
438 : : char buffer[KSYM_SYMBOL_LEN];
439 : :
440 : : sprint_symbol(buffer, address);
441 : :
442 : 0 : printk(fmt, buffer);
443 : 0 : }
444 : : EXPORT_SYMBOL(__print_symbol);
445 : :
446 : : /* To avoid using get_symbol_offset for every symbol, we carry prefix along. */
447 : : struct kallsym_iter {
448 : : loff_t pos;
449 : : unsigned long value;
450 : : unsigned int nameoff; /* If iterating in core kernel symbols. */
451 : : char type;
452 : : char name[KSYM_NAME_LEN];
453 : : char module_name[MODULE_NAME_LEN];
454 : : int exported;
455 : : };
456 : :
457 : 0 : static int get_ksymbol_mod(struct kallsym_iter *iter)
458 : : {
459 [ - + ]: 2 : if (module_get_kallsym(iter->pos - kallsyms_num_syms, &iter->value,
460 : 2 : &iter->type, iter->name, iter->module_name,
461 : : &iter->exported) < 0)
462 : : return 0;
463 : 0 : return 1;
464 : : }
465 : :
466 : : /* Returns space to next name. */
467 : 0 : static unsigned long get_ksymbol_core(struct kallsym_iter *iter)
468 : : {
469 : 42646 : unsigned off = iter->nameoff;
470 : :
471 : 42646 : iter->module_name[0] = '\0';
472 : 42646 : iter->value = kallsyms_addresses[iter->pos];
473 : :
474 : 42646 : iter->type = kallsyms_get_symbol_type(off);
475 : :
476 : 42646 : off = kallsyms_expand_symbol(off, iter->name, ARRAY_SIZE(iter->name));
477 : :
478 : 42646 : return off - iter->nameoff;
479 : : }
480 : :
481 : : static void reset_iter(struct kallsym_iter *iter, loff_t new_pos)
482 : : {
483 : 1 : iter->name[0] = '\0';
484 : 1 : iter->nameoff = get_symbol_offset(new_pos);
485 : 0 : iter->pos = new_pos;
486 : : }
487 : :
488 : : /* Returns false if pos at or past end of file. */
489 : 0 : static int update_iter(struct kallsym_iter *iter, loff_t pos)
490 : : {
491 : : /* Module symbols can be accessed randomly. */
492 [ + + ]: 42648 : if (pos >= kallsyms_num_syms) {
493 : 2 : iter->pos = pos;
494 : 2 : return get_ksymbol_mod(iter);
495 : : }
496 : :
497 : : /* If we're not on the desired position, reset to new position. */
498 [ + ]: 42646 : if (pos != iter->pos)
499 : : reset_iter(iter, pos);
500 : :
501 : 0 : iter->nameoff += get_ksymbol_core(iter);
502 : 42646 : iter->pos++;
503 : :
504 : 42646 : return 1;
505 : : }
506 : :
507 : 0 : static void *s_next(struct seq_file *m, void *p, loff_t *pos)
508 : : {
509 : 41243 : (*pos)++;
510 : :
511 [ + + ]: 41243 : if (!update_iter(m->private, *pos))
512 : : return NULL;
513 : 41242 : return p;
514 : : }
515 : :
516 : 0 : static void *s_start(struct seq_file *m, loff_t *pos)
517 : : {
518 [ + + ]: 1405 : if (!update_iter(m->private, *pos))
519 : : return NULL;
520 : 1404 : return m->private;
521 : : }
522 : :
523 : 0 : static void s_stop(struct seq_file *m, void *p)
524 : : {
525 : 1405 : }
526 : :
527 : 0 : static int s_show(struct seq_file *m, void *p)
528 : : {
529 : 42646 : struct kallsym_iter *iter = m->private;
530 : :
531 : : /* Some debugging symbols have no name. Ignore them. */
532 [ + ]: 42646 : if (!iter->name[0])
533 : : return 0;
534 : :
535 [ - + ]: 85292 : if (iter->module_name[0]) {
536 : : char type;
537 : :
538 : : /*
539 : : * Label it "global" if it is exported,
540 : : * "local" if not exported.
541 : : */
542 [ # # ]: 0 : type = iter->exported ? toupper(iter->type) :
543 : 0 : tolower(iter->type);
544 : 0 : seq_printf(m, "%pK %c %s\t[%s]\n", (void *)iter->value,
545 : 0 : type, iter->name, iter->module_name);
546 : : } else
547 : 42646 : seq_printf(m, "%pK %c %s\n", (void *)iter->value,
548 : 85292 : iter->type, iter->name);
549 : : return 0;
550 : : }
551 : :
552 : : static const struct seq_operations kallsyms_op = {
553 : : .start = s_start,
554 : : .next = s_next,
555 : : .stop = s_stop,
556 : : .show = s_show
557 : : };
558 : :
559 : 0 : static int kallsyms_open(struct inode *inode, struct file *file)
560 : : {
561 : : /*
562 : : * We keep iterator in m->private, since normal case is to
563 : : * s_start from where we left off, so we avoid doing
564 : : * using get_symbol_offset for every symbol.
565 : : */
566 : : struct kallsym_iter *iter;
567 : : int ret;
568 : :
569 : : iter = kmalloc(sizeof(*iter), GFP_KERNEL);
570 [ + - ]: 1 : if (!iter)
571 : : return -ENOMEM;
572 : : reset_iter(iter, 0);
573 : :
574 : 1 : ret = seq_open(file, &kallsyms_op);
575 [ + - ]: 2 : if (ret == 0)
576 : 1 : ((struct seq_file *)file->private_data)->private = iter;
577 : : else
578 : 0 : kfree(iter);
579 : 1 : return ret;
580 : : }
581 : :
582 : : #ifdef CONFIG_KGDB_KDB
583 : : const char *kdb_walk_kallsyms(loff_t *pos)
584 : : {
585 : : static struct kallsym_iter kdb_walk_kallsyms_iter;
586 : : if (*pos == 0) {
587 : : memset(&kdb_walk_kallsyms_iter, 0,
588 : : sizeof(kdb_walk_kallsyms_iter));
589 : : reset_iter(&kdb_walk_kallsyms_iter, 0);
590 : : }
591 : : while (1) {
592 : : if (!update_iter(&kdb_walk_kallsyms_iter, *pos))
593 : : return NULL;
594 : : ++*pos;
595 : : /* Some debugging symbols have no name. Ignore them. */
596 : : if (kdb_walk_kallsyms_iter.name[0])
597 : : return kdb_walk_kallsyms_iter.name;
598 : : }
599 : : }
600 : : #endif /* CONFIG_KGDB_KDB */
601 : :
602 : : static const struct file_operations kallsyms_operations = {
603 : : .open = kallsyms_open,
604 : : .read = seq_read,
605 : : .llseek = seq_lseek,
606 : : .release = seq_release_private,
607 : : };
608 : :
609 : 0 : static int __init kallsyms_init(void)
610 : : {
611 : : proc_create("kallsyms", 0444, NULL, &kallsyms_operations);
612 : 0 : return 0;
613 : : }
614 : : device_initcall(kallsyms_init);
|
