1
2
3
4
5
6
7
8
9
10
11
12
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>
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
37
38
39extern const unsigned long kallsyms_addresses[] __attribute__((weak));
40extern const u8 kallsyms_names[] __attribute__((weak));
41
42
43
44
45
46extern const unsigned long kallsyms_num_syms
47__attribute__((weak, section(".rodata")));
48
49extern const u8 kallsyms_token_table[] __attribute__((weak));
50extern const u16 kallsyms_token_index[] __attribute__((weak));
51
52extern const unsigned long kallsyms_markers[] __attribute__((weak));
53
54static inline int is_kernel_inittext(unsigned long addr)
55{
56 if (addr >= (unsigned long)_sinittext
57 && addr <= (unsigned long)_einittext)
58 return 1;
59 return 0;
60}
61
62static inline int is_kernel_text(unsigned long addr)
63{
64 if ((addr >= (unsigned long)_stext && addr <= (unsigned long)_etext) ||
65 arch_is_kernel_text(addr))
66 return 1;
67 return in_gate_area_no_mm(addr);
68}
69
70static 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
77static int is_ksym_addr(unsigned long addr)
78{
79 if (all_var)
80 return is_kernel(addr);
81
82 return is_kernel_text(addr) || is_kernel_inittext(addr);
83}
84
85
86
87
88
89
90static 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
97 data = &kallsyms_names[off];
98 len = *data;
99 data++;
100
101
102
103
104
105 off += len + 1;
106
107
108
109
110
111 while (len) {
112 tptr = &kallsyms_token_table[kallsyms_token_index[*data]];
113 data++;
114 len--;
115
116 while (*tptr) {
117 if (skipped_first) {
118 if (maxlen <= 1)
119 goto tail;
120 *result = *tptr;
121 result++;
122 maxlen--;
123 } else
124 skipped_first = 1;
125 tptr++;
126 }
127 }
128
129tail:
130 if (maxlen)
131 *result = '\0';
132
133
134 return off;
135}
136
137
138
139
140
141static char kallsyms_get_symbol_type(unsigned int off)
142{
143
144
145
146
147 return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]];
148}
149
150
151
152
153
154
155static unsigned int get_symbol_offset(unsigned long pos)
156{
157 const u8 *name;
158 int i;
159
160
161
162
163
164 name = &kallsyms_names[kallsyms_markers[pos >> 8]];
165
166
167
168
169
170
171
172 for (i = 0; i < (pos & 0xFF); i++)
173 name = name + (*name) + 1;
174
175 return name - kallsyms_names;
176}
177
178
179unsigned long kallsyms_lookup_name(const char *name)
180{
181 char namebuf[KSYM_NAME_LEN];
182 unsigned long i;
183 unsigned int off;
184
185 for (i = 0, off = 0; i < kallsyms_num_syms; i++) {
186 off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
187
188 if (strcmp(namebuf, name) == 0)
189 return kallsyms_addresses[i];
190 }
191 return module_kallsyms_lookup_name(name);
192}
193EXPORT_SYMBOL_GPL(kallsyms_lookup_name);
194
195int 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 for (i = 0, off = 0; i < kallsyms_num_syms; i++) {
205 off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
206 ret = fn(data, namebuf, NULL, kallsyms_addresses[i]);
207 if (ret != 0)
208 return ret;
209 }
210 return module_kallsyms_on_each_symbol(fn, data);
211}
212EXPORT_SYMBOL_GPL(kallsyms_on_each_symbol);
213
214static 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
222 BUG_ON(!kallsyms_addresses);
223
224
225 low = 0;
226 high = kallsyms_num_syms;
227
228 while (high - low > 1) {
229 mid = low + (high - low) / 2;
230 if (kallsyms_addresses[mid] <= addr)
231 low = mid;
232 else
233 high = mid;
234 }
235
236
237
238
239
240 while (low && kallsyms_addresses[low-1] == kallsyms_addresses[low])
241 --low;
242
243 symbol_start = kallsyms_addresses[low];
244
245
246 for (i = low + 1; i < kallsyms_num_syms; i++) {
247 if (kallsyms_addresses[i] > symbol_start) {
248 symbol_end = kallsyms_addresses[i];
249 break;
250 }
251 }
252
253
254 if (!symbol_end) {
255 if (is_kernel_inittext(addr))
256 symbol_end = (unsigned long)_einittext;
257 else if (all_var)
258 symbol_end = (unsigned long)_end;
259 else
260 symbol_end = (unsigned long)_etext;
261 }
262
263 if (symbolsize)
264 *symbolsize = symbol_end - symbol_start;
265 if (offset)
266 *offset = addr - symbol_start;
267
268 return low;
269}
270
271
272
273
274int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize,
275 unsigned long *offset)
276{
277 char namebuf[KSYM_NAME_LEN];
278 if (is_ksym_addr(addr))
279 return !!get_symbol_pos(addr, symbolsize, offset);
280
281 return !!module_address_lookup(addr, symbolsize, offset, NULL, namebuf);
282}
283
284
285
286
287
288
289
290
291const char *kallsyms_lookup(unsigned long addr,
292 unsigned long *symbolsize,
293 unsigned long *offset,
294 char **modname, char *namebuf)
295{
296 namebuf[KSYM_NAME_LEN - 1] = 0;
297 namebuf[0] = 0;
298
299 if (is_ksym_addr(addr)) {
300 unsigned long pos;
301
302 pos = get_symbol_pos(addr, symbolsize, offset);
303
304 kallsyms_expand_symbol(get_symbol_offset(pos),
305 namebuf, KSYM_NAME_LEN);
306 if (modname)
307 *modname = NULL;
308 return namebuf;
309 }
310
311
312 return module_address_lookup(addr, symbolsize, offset, modname,
313 namebuf);
314}
315
316int lookup_symbol_name(unsigned long addr, char *symname)
317{
318 symname[0] = '\0';
319 symname[KSYM_NAME_LEN - 1] = '\0';
320
321 if (is_ksym_addr(addr)) {
322 unsigned long pos;
323
324 pos = get_symbol_pos(addr, NULL, NULL);
325
326 kallsyms_expand_symbol(get_symbol_offset(pos),
327 symname, KSYM_NAME_LEN);
328 return 0;
329 }
330
331 return lookup_module_symbol_name(addr, symname);
332}
333
334int lookup_symbol_attrs(unsigned long addr, unsigned long *size,
335 unsigned long *offset, char *modname, char *name)
336{
337 name[0] = '\0';
338 name[KSYM_NAME_LEN - 1] = '\0';
339
340 if (is_ksym_addr(addr)) {
341 unsigned long pos;
342
343 pos = get_symbol_pos(addr, size, offset);
344
345 kallsyms_expand_symbol(get_symbol_offset(pos),
346 name, KSYM_NAME_LEN);
347 modname[0] = '\0';
348 return 0;
349 }
350
351 return lookup_module_symbol_attrs(addr, size, offset, modname, name);
352}
353
354
355static 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 address += symbol_offset;
364 name = kallsyms_lookup(address, &size, &offset, &modname, buffer);
365 if (!name)
366 return sprintf(buffer, "0x%lx", address);
367
368 if (name != buffer)
369 strcpy(buffer, name);
370 len = strlen(buffer);
371 offset -= symbol_offset;
372
373 if (add_offset)
374 len += sprintf(buffer + len, "+%#lx/%#lx", offset, size);
375
376 if (modname)
377 len += sprintf(buffer + len, " [%s]", modname);
378
379 return len;
380}
381
382
383
384
385
386
387
388
389
390
391
392
393int sprint_symbol(char *buffer, unsigned long address)
394{
395 return __sprint_symbol(buffer, address, 0, 1);
396}
397EXPORT_SYMBOL_GPL(sprint_symbol);
398
399
400
401
402
403
404
405
406
407
408
409
410int sprint_symbol_no_offset(char *buffer, unsigned long address)
411{
412 return __sprint_symbol(buffer, address, 0, 0);
413}
414EXPORT_SYMBOL_GPL(sprint_symbol_no_offset);
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430int sprint_backtrace(char *buffer, unsigned long address)
431{
432 return __sprint_symbol(buffer, address, -1, 1);
433}
434
435
436void __print_symbol(const char *fmt, unsigned long address)
437{
438 char buffer[KSYM_SYMBOL_LEN];
439
440 sprint_symbol(buffer, address);
441
442 printk(fmt, buffer);
443}
444EXPORT_SYMBOL(__print_symbol);
445
446
447struct kallsym_iter {
448 loff_t pos;
449 unsigned long value;
450 unsigned int nameoff;
451 char type;
452 char name[KSYM_NAME_LEN];
453 char module_name[MODULE_NAME_LEN];
454 int exported;
455};
456
457static int get_ksymbol_mod(struct kallsym_iter *iter)
458{
459 if (module_get_kallsym(iter->pos - kallsyms_num_syms, &iter->value,
460 &iter->type, iter->name, iter->module_name,
461 &iter->exported) < 0)
462 return 0;
463 return 1;
464}
465
466
467static unsigned long get_ksymbol_core(struct kallsym_iter *iter)
468{
469 unsigned off = iter->nameoff;
470
471 iter->module_name[0] = '\0';
472 iter->value = kallsyms_addresses[iter->pos];
473
474 iter->type = kallsyms_get_symbol_type(off);
475
476 off = kallsyms_expand_symbol(off, iter->name, ARRAY_SIZE(iter->name));
477
478 return off - iter->nameoff;
479}
480
481static void reset_iter(struct kallsym_iter *iter, loff_t new_pos)
482{
483 iter->name[0] = '\0';
484 iter->nameoff = get_symbol_offset(new_pos);
485 iter->pos = new_pos;
486}
487
488
489static int update_iter(struct kallsym_iter *iter, loff_t pos)
490{
491
492 if (pos >= kallsyms_num_syms) {
493 iter->pos = pos;
494 return get_ksymbol_mod(iter);
495 }
496
497
498 if (pos != iter->pos)
499 reset_iter(iter, pos);
500
501 iter->nameoff += get_ksymbol_core(iter);
502 iter->pos++;
503
504 return 1;
505}
506
507static void *s_next(struct seq_file *m, void *p, loff_t *pos)
508{
509 (*pos)++;
510
511 if (!update_iter(m->private, *pos))
512 return NULL;
513 return p;
514}
515
516static void *s_start(struct seq_file *m, loff_t *pos)
517{
518 if (!update_iter(m->private, *pos))
519 return NULL;
520 return m->private;
521}
522
523static void s_stop(struct seq_file *m, void *p)
524{
525}
526
527static int s_show(struct seq_file *m, void *p)
528{
529 struct kallsym_iter *iter = m->private;
530
531
532 if (!iter->name[0])
533 return 0;
534
535 if (iter->module_name[0]) {
536 char type;
537
538
539
540
541
542 type = iter->exported ? toupper(iter->type) :
543 tolower(iter->type);
544 seq_printf(m, "%pK %c %s\t[%s]\n", (void *)iter->value,
545 type, iter->name, iter->module_name);
546 } else
547 seq_printf(m, "%pK %c %s\n", (void *)iter->value,
548 iter->type, iter->name);
549 return 0;
550}
551
552static const struct seq_operations kallsyms_op = {
553 .start = s_start,
554 .next = s_next,
555 .stop = s_stop,
556 .show = s_show
557};
558
559static int kallsyms_open(struct inode *inode, struct file *file)
560{
561
562
563
564
565
566 struct kallsym_iter *iter;
567 int ret;
568
569 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
570 if (!iter)
571 return -ENOMEM;
572 reset_iter(iter, 0);
573
574 ret = seq_open(file, &kallsyms_op);
575 if (ret == 0)
576 ((struct seq_file *)file->private_data)->private = iter;
577 else
578 kfree(iter);
579 return ret;
580}
581
582#ifdef CONFIG_KGDB_KDB
583const 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
596 if (kdb_walk_kallsyms_iter.name[0])
597 return kdb_walk_kallsyms_iter.name;
598 }
599}
600#endif
601
602static 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
609static int __init kallsyms_init(void)
610{
611 proc_create("kallsyms", 0444, NULL, &kallsyms_operations);
612 return 0;
613}
614device_initcall(kallsyms_init);
615