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