~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/kallsyms.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
185 int 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 }
202 EXPORT_SYMBOL_GPL(kallsyms_on_each_symbol);
203 
204 static 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         /* This kernel should never had been booted. */
212         BUG_ON(!kallsyms_addresses);
213 
214         /* Do a binary search on the sorted kallsyms_addresses array. */
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          * Search for the first aliased symbol. Aliased
228          * symbols are symbols with the same address.
229          */
230         while (low && kallsyms_addresses[low-1] == kallsyms_addresses[low])
231                 --low;
232 
233         symbol_start = kallsyms_addresses[low];
234 
235         /* Search for next non-aliased symbol. */
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         /* If we found no next symbol, we use the end of the section. */
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  * Lookup an address but don't bother to find any names.
263  */
264 int 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  * Lookup an address
276  * - modname is set to NULL if it's in the kernel.
277  * - We guarantee that the returned name is valid until we reschedule even if.
278  *   It resides in a module.
279  * - We also guarantee that modname will be valid until rescheduled.
280  */
281 const 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                 /* Grab name */
294                 kallsyms_expand_symbol(get_symbol_offset(pos), namebuf);
295                 if (modname)
296                         *modname = NULL;
297                 return namebuf;
298         }
299 
300         /* See if it's in a module. */
301         return module_address_lookup(addr, symbolsize, offset, modname,
302                                      namebuf);
303 }
304 
305 int 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                 /* Grab name */
315                 kallsyms_expand_symbol(get_symbol_offset(pos), symname);
316                 return 0;
317         }
318         /* See if it's in a module. */
319         return lookup_module_symbol_name(addr, symname);
320 }
321 
322 int 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                 /* Grab name */
333                 kallsyms_expand_symbol(get_symbol_offset(pos), name);
334                 modname[0] = '\0';
335                 return 0;
336         }
337         /* See if it's in a module. */
338         return lookup_module_symbol_attrs(addr, size, offset, modname, name);
339 }
340 
341 /* Look up a kernel symbol and return it in a text buffer. */
342 int 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 }
366 EXPORT_SYMBOL_GPL(sprint_symbol);
367 
368 /* Look up a kernel symbol and print it to the kernel messages. */
369 void __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 }
377 EXPORT_SYMBOL(__print_symbol);
378 
379 /* To avoid using get_symbol_offset for every symbol, we carry prefix along. */
380 struct kallsym_iter {
381         loff_t pos;
382         unsigned long value;
383         unsigned int nameoff; /* If iterating in core kernel symbols. */
384         char type;
385         char name[KSYM_NAME_LEN];
386         char module_name[MODULE_NAME_LEN];
387         int exported;
388 };
389 
390 static 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 /* Returns space to next name. */
400 static 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 
414 static 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 /* Returns false if pos at or past end of file. */
422 static int update_iter(struct kallsym_iter *iter, loff_t pos)
423 {
424         /* Module symbols can be accessed randomly. */
425         if (pos >= kallsyms_num_syms) {
426                 iter->pos = pos;
427                 return get_ksymbol_mod(iter);
428         }
429 
430         /* If we're not on the desired position, reset to new position. */
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 
440 static 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 
449 static 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 
456 static void s_stop(struct seq_file *m, void *p)
457 {
458 }
459 
460 static int s_show(struct seq_file *m, void *p)
461 {
462         struct kallsym_iter *iter = m->private;
463 
464         /* Some debugging symbols have no name.  Ignore them. */
465         if (!iter->name[0])
466                 return 0;
467 
468         if (iter->module_name[0]) {
469                 char type;
470 
471                 /*
472                  * Label it "global" if it is exported,
473                  * "local" if not exported.
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 
487 static const struct seq_operations kallsyms_op = {
488         .start = s_start,
489         .next = s_next,
490         .stop = s_stop,
491         .show = s_show
492 };
493 
494 static int kallsyms_open(struct inode *inode, struct file *file)
495 {
496         /*
497          * We keep iterator in m->private, since normal case is to
498          * s_start from where we left off, so we avoid doing
499          * using get_symbol_offset for every symbol.
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 
517 static 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 
524 static int __init kallsyms_init(void)
525 {
526         proc_create("kallsyms", 0444, NULL, &kallsyms_operations);
527         return 0;
528 }
529 device_initcall(kallsyms_init);
530 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp