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/err.h>
20#include <linux/proc_fs.h>
21#include <linux/sched.h>
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
35
36
37extern const unsigned long kallsyms_addresses[] __attribute__((weak));
38extern const u8 kallsyms_names[] __attribute__((weak));
39
40
41
42
43
44extern const unsigned long kallsyms_num_syms
45__attribute__((weak, section(".rodata")));
46
47extern const u8 kallsyms_token_table[] __attribute__((weak));
48extern const u16 kallsyms_token_index[] __attribute__((weak));
49
50extern const unsigned long kallsyms_markers[] __attribute__((weak));
51
52static 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
60static 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
68static 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
75static 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
85
86
87static unsigned int kallsyms_expand_symbol(unsigned int off, char *result)
88{
89 int len, skipped_first = 0;
90 const u8 *tptr, *data;
91
92
93 data = &kallsyms_names[off];
94 len = *data;
95 data++;
96
97
98
99
100
101 off += len + 1;
102
103
104
105
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
125 return off;
126}
127
128
129
130
131
132static char kallsyms_get_symbol_type(unsigned int off)
133{
134
135
136
137
138 return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]];
139}
140
141
142
143
144
145
146static unsigned int get_symbol_offset(unsigned long pos)
147{
148 const u8 *name;
149 int i;
150
151
152
153
154
155 name = &kallsyms_names[kallsyms_markers[pos >> 8]];
156
157
158
159
160
161
162
163 for (i = 0; i < (pos & 0xFF); i++)
164 name = name + (*name) + 1;
165
166 return name - kallsyms_names;
167}
168
169
170unsigned 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
185int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *,
186 unsigned long),
187 void *data)
188{
189 char namebuf[KSYM_NAME_LEN];
190 unsigned long i;
191 unsigned int off;
192 int ret;
193
194 for (i = 0, off = 0; i < kallsyms_num_syms; i++) {
195 off = kallsyms_expand_symbol(off, namebuf);
196 ret = fn(data, namebuf, NULL, kallsyms_addresses[i]);
197 if (ret != 0)
198 return ret;
199 }
200 return module_kallsyms_on_each_symbol(fn, data);
201}
202EXPORT_SYMBOL_GPL(kallsyms_on_each_symbol);
203
204static unsigned long get_symbol_pos(unsigned long addr,
205 unsigned long *symbolsize,
206 unsigned long *offset)
207{
208 unsigned long symbol_start = 0, symbol_end = 0;
209 unsigned long i, low, high, mid;
210
211
212 BUG_ON(!kallsyms_addresses);
213
214
215 low = 0;
216 high = kallsyms_num_syms;
217
218 while (high - low > 1) {
219 mid = low + (high - low) / 2;
220 if (kallsyms_addresses[mid] <= addr)
221 low = mid;
222 else
223 high = mid;
224 }
225
226
227
228
229
230 while (low && kallsyms_addresses[low-1] == kallsyms_addresses[low])
231 --low;
232
233 symbol_start = kallsyms_addresses[low];
234
235
236 for (i = low + 1; i < kallsyms_num_syms; i++) {
237 if (kallsyms_addresses[i] > symbol_start) {
238 symbol_end = kallsyms_addresses[i];
239 break;
240 }
241 }
242
243
244 if (!symbol_end) {
245 if (is_kernel_inittext(addr))
246 symbol_end = (unsigned long)_einittext;
247 else if (all_var)
248 symbol_end = (unsigned long)_end;
249 else
250 symbol_end = (unsigned long)_etext;
251 }
252
253 if (symbolsize)
254 *symbolsize = symbol_end - symbol_start;
255 if (offset)
256 *offset = addr - symbol_start;
257
258 return low;
259}
260
261
262
263
264int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize,
265 unsigned long *offset)
266{
267 char namebuf[KSYM_NAME_LEN];
268 if (is_ksym_addr(addr))
269 return !!get_symbol_pos(addr, symbolsize, offset);
270
271 return !!module_address_lookup(addr, symbolsize, offset, NULL, namebuf);
272}
273
274
275
276
277
278
279
280
281const char *kallsyms_lookup(unsigned long addr,
282 unsigned long *symbolsize,
283 unsigned long *offset,
284 char **modname, char *namebuf)
285{
286 namebuf[KSYM_NAME_LEN - 1] = 0;
287 namebuf[0] = 0;
288
289 if (is_ksym_addr(addr)) {
290 unsigned long pos;
291
292 pos = get_symbol_pos(addr, symbolsize, offset);
293
294 kallsyms_expand_symbol(get_symbol_offset(pos), namebuf);
295 if (modname)
296 *modname = NULL;
297 return namebuf;
298 }
299
300
301 return module_address_lookup(addr, symbolsize, offset, modname,
302 namebuf);
303}
304
305int lookup_symbol_name(unsigned long addr, char *symname)
306{
307 symname[0] = '\0';
308 symname[KSYM_NAME_LEN - 1] = '\0';
309
310 if (is_ksym_addr(addr)) {
311 unsigned long pos;
312
313 pos = get_symbol_pos(addr, NULL, NULL);
314
315 kallsyms_expand_symbol(get_symbol_offset(pos), symname);
316 return 0;
317 }
318
319 return lookup_module_symbol_name(addr, symname);
320}
321
322int lookup_symbol_attrs(unsigned long addr, unsigned long *size,
323 unsigned long *offset, char *modname, char *name)
324{
325 name[0] = '\0';
326 name[KSYM_NAME_LEN - 1] = '\0';
327
328 if (is_ksym_addr(addr)) {
329 unsigned long pos;
330
331 pos = get_symbol_pos(addr, size, offset);
332
333 kallsyms_expand_symbol(get_symbol_offset(pos), name);
334 modname[0] = '\0';
335 return 0;
336 }
337
338 return lookup_module_symbol_attrs(addr, size, offset, modname, name);
339}
340
341
342int sprint_symbol(char *buffer, unsigned long address)
343{
344 char *modname;
345 const char *name;
346 unsigned long offset, size;
347 int len;
348
349 name = kallsyms_lookup(address, &size, &offset, &modname, buffer);
350 if (!name)
351 return sprintf(buffer, "0x%lx", address);
352
353 if (name != buffer)
354 strcpy(buffer, name);
355 len = strlen(buffer);
356 buffer += len;
357
358 if (modname)
359 len += sprintf(buffer, "+%#lx/%#lx [%s]",
360 offset, size, modname);
361 else
362 len += sprintf(buffer, "+%#lx/%#lx", offset, size);
363
364 return len;
365}
366EXPORT_SYMBOL_GPL(sprint_symbol);
367
368
369void __print_symbol(const char *fmt, unsigned long address)
370{
371 char buffer[KSYM_SYMBOL_LEN];
372
373 sprint_symbol(buffer, address);
374
375 printk(fmt, buffer);
376}
377EXPORT_SYMBOL(__print_symbol);
378
379
380struct kallsym_iter {
381 loff_t pos;
382 unsigned long value;
383 unsigned int nameoff;
384 char type;
385 char name[KSYM_NAME_LEN];
386 char module_name[MODULE_NAME_LEN];
387 int exported;
388};
389
390static int get_ksymbol_mod(struct kallsym_iter *iter)
391{
392 if (module_get_kallsym(iter->pos - kallsyms_num_syms, &iter->value,
393 &iter->type, iter->name, iter->module_name,
394 &iter->exported) < 0)
395 return 0;
396 return 1;
397}
398
399
400static unsigned long get_ksymbol_core(struct kallsym_iter *iter)
401{
402 unsigned off = iter->nameoff;
403
404 iter->module_name[0] = '\0';
405 iter->value = kallsyms_addresses[iter->pos];
406
407 iter->type = kallsyms_get_symbol_type(off);
408
409 off = kallsyms_expand_symbol(off, iter->name);
410
411 return off - iter->nameoff;
412}
413
414static void reset_iter(struct kallsym_iter *iter, loff_t new_pos)
415{
416 iter->name[0] = '\0';
417 iter->nameoff = get_symbol_offset(new_pos);
418 iter->pos = new_pos;
419}
420
421
422static int update_iter(struct kallsym_iter *iter, loff_t pos)
423{
424
425 if (pos >= kallsyms_num_syms) {
426 iter->pos = pos;
427 return get_ksymbol_mod(iter);
428 }
429
430
431 if (pos != iter->pos)
432 reset_iter(iter, pos);
433
434 iter->nameoff += get_ksymbol_core(iter);
435 iter->pos++;
436
437 return 1;
438}
439
440static void *s_next(struct seq_file *m, void *p, loff_t *pos)
441{
442 (*pos)++;
443
444 if (!update_iter(m->private, *pos))
445 return NULL;
446 return p;
447}
448
449static void *s_start(struct seq_file *m, loff_t *pos)
450{
451 if (!update_iter(m->private, *pos))
452 return NULL;
453 return m->private;
454}
455
456static void s_stop(struct seq_file *m, void *p)
457{
458}
459
460static int s_show(struct seq_file *m, void *p)
461{
462 struct kallsym_iter *iter = m->private;
463
464
465 if (!iter->name[0])
466 return 0;
467
468 if (iter->module_name[0]) {
469 char type;
470
471
472
473
474
475 type = iter->exported ? toupper(iter->type) :
476 tolower(iter->type);
477 seq_printf(m, "%0*lx %c %s\t[%s]\n",
478 (int)(2 * sizeof(void *)),
479 iter->value, type, iter->name, iter->module_name);
480 } else
481 seq_printf(m, "%0*lx %c %s\n",
482 (int)(2 * sizeof(void *)),
483 iter->value, iter->type, iter->name);
484 return 0;
485}
486
487static const struct seq_operations kallsyms_op = {
488 .start = s_start,
489 .next = s_next,
490 .stop = s_stop,
491 .show = s_show
492};
493
494static int kallsyms_open(struct inode *inode, struct file *file)
495{
496
497
498
499
500
501 struct kallsym_iter *iter;
502 int ret;
503
504 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
505 if (!iter)
506 return -ENOMEM;
507 reset_iter(iter, 0);
508
509 ret = seq_open(file, &kallsyms_op);
510 if (ret == 0)
511 ((struct seq_file *)file->private_data)->private = iter;
512 else
513 kfree(iter);
514 return ret;
515}
516
517static const struct file_operations kallsyms_operations = {
518 .open = kallsyms_open,
519 .read = seq_read,
520 .llseek = seq_lseek,
521 .release = seq_release_private,
522};
523
524static int __init kallsyms_init(void)
525{
526 proc_create("kallsyms", 0444, NULL, &kallsyms_operations);
527 return 0;
528}
529device_initcall(kallsyms_init);
530