2 * kallsyms.c: in-kernel printing of symbolic oopses and stack traces.
4 * Rewritten and vastly simplified by Rusty Russell for in-kernel
6 * Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
7 * Stem compression by Andi Kleen.
9 #include <linux/kallsyms.h>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/seq_file.h>
14 #include <linux/err.h>
15 #include <linux/proc_fs.h>
17 /* These will be re-linked against their real values during the second link stage */
18 extern unsigned long kallsyms_addresses[] __attribute__((weak));
19 extern unsigned long kallsyms_num_syms __attribute__((weak));
20 extern char kallsyms_names[] __attribute__((weak));
22 /* Defined by the linker script. */
23 extern char _stext[], _etext[], _sinittext[], _einittext[];
25 static inline int is_kernel_inittext(unsigned long addr)
27 if (addr >= (unsigned long)_sinittext
28 && addr <= (unsigned long)_einittext)
33 static inline int is_kernel_text(unsigned long addr)
35 if (addr >= (unsigned long)_stext && addr <= (unsigned long)_etext)
40 /* Lookup the address for this symbol. Returns 0 if not found. */
41 unsigned long kallsyms_lookup_name(const char *name)
47 for (i = 0, knames = kallsyms_names; i < kallsyms_num_syms; i++) {
48 unsigned prefix = *knames++;
50 strlcpy(namebuf + prefix, knames, 127 - prefix);
51 if (strcmp(namebuf, name) == 0)
52 return kallsyms_addresses[i];
54 knames += strlen(knames) + 1;
56 return module_kallsyms_lookup_name(name);
59 /* Lookup an address. modname is set to NULL if it's in the kernel. */
60 const char *kallsyms_lookup(unsigned long addr,
61 unsigned long *symbolsize,
62 unsigned long *offset,
63 char **modname, char *namebuf)
65 unsigned long i, best = 0;
67 /* This kernel should never had been booted. */
68 BUG_ON(!kallsyms_addresses);
73 if (is_kernel_text(addr) || is_kernel_inittext(addr)) {
74 unsigned long symbol_end;
75 char *name = kallsyms_names;
77 /* They're sorted, we could be clever here, but who cares? */
78 for (i = 0; i < kallsyms_num_syms; i++) {
79 if (kallsyms_addresses[i] > kallsyms_addresses[best] &&
80 kallsyms_addresses[i] <= addr)
85 for (i = 0; i <= best; i++) {
86 unsigned prefix = *name++;
87 strncpy(namebuf + prefix, name, 127 - prefix);
88 name += strlen(name) + 1;
91 /* Base symbol size on next symbol. */
92 if (best + 1 < kallsyms_num_syms)
93 symbol_end = kallsyms_addresses[best + 1];
94 else if (is_kernel_inittext(addr))
95 symbol_end = (unsigned long)_einittext;
97 symbol_end = (unsigned long)_etext;
99 *symbolsize = symbol_end - kallsyms_addresses[best];
101 *offset = addr - kallsyms_addresses[best];
105 return module_address_lookup(addr, symbolsize, offset, modname);
108 /* Replace "%s" in format with address, or returns -errno. */
109 void __print_symbol(const char *fmt, unsigned long address)
113 unsigned long offset, size;
116 name = kallsyms_lookup(address, &size, &offset, &modname, namebuf);
119 char addrstr[sizeof("0x%lx") + (BITS_PER_LONG*3/10)];
121 sprintf(addrstr, "0x%lx", address);
122 printk(fmt, addrstr);
127 /* This is pretty small. */
128 char buffer[sizeof("%s+%#lx/%#lx [%s]")
129 + strlen(name) + 2*(BITS_PER_LONG*3/10)
132 sprintf(buffer, "%s+%#lx/%#lx [%s]",
133 name, offset, size, modname);
136 char buffer[sizeof("%s+%#lx/%#lx")
137 + strlen(name) + 2*(BITS_PER_LONG*3/10)];
139 sprintf(buffer, "%s+%#lx/%#lx", name, offset, size);
144 /* To avoid O(n^2) iteration, we carry prefix along. */
148 struct module *owner;
150 unsigned int nameoff; /* If iterating in core kernel symbols */
155 /* Only label it "global" if it is exported. */
156 static void upcase_if_global(struct kallsym_iter *iter)
158 if (is_exported(iter->name, iter->owner))
159 iter->type += 'A' - 'a';
162 static int get_ksymbol_mod(struct kallsym_iter *iter)
164 iter->owner = module_get_kallsym(iter->pos - kallsyms_num_syms,
166 &iter->type, iter->name);
167 if (iter->owner == NULL)
170 upcase_if_global(iter);
174 static void get_ksymbol_core(struct kallsym_iter *iter)
178 /* First char of each symbol name indicates prefix length
179 shared with previous name (stem compression). */
180 stemlen = kallsyms_names[iter->nameoff++];
182 strlcpy(iter->name+stemlen, kallsyms_names+iter->nameoff, 128-stemlen);
183 iter->nameoff += strlen(kallsyms_names + iter->nameoff) + 1;
185 iter->value = kallsyms_addresses[iter->pos];
188 upcase_if_global(iter);
191 static void reset_iter(struct kallsym_iter *iter)
193 iter->name[0] = '\0';
198 /* Returns false if pos at or past end of file. */
199 static int update_iter(struct kallsym_iter *iter, loff_t pos)
201 /* Module symbols can be accessed randomly. */
202 if (pos >= kallsyms_num_syms) {
204 return get_ksymbol_mod(iter);
207 /* If we're past the desired position, reset to start. */
211 /* We need to iterate through the previous symbols: can be slow */
212 for (; iter->pos != pos; iter->pos++) {
213 get_ksymbol_core(iter);
219 static void *s_next(struct seq_file *m, void *p, loff_t *pos)
223 if (!update_iter(m->private, *pos))
228 static void *s_start(struct seq_file *m, loff_t *pos)
230 if (!update_iter(m->private, *pos))
235 static void s_stop(struct seq_file *m, void *p)
239 static int s_show(struct seq_file *m, void *p)
241 struct kallsym_iter *iter = m->private;
243 /* Some debugging symbols have no name. Ignore them. */
248 seq_printf(m, "%0*lx %c %s\t[%s]\n",
249 (int)(2*sizeof(void*)),
250 iter->value, iter->type, iter->name,
251 module_name(iter->owner));
253 seq_printf(m, "%0*lx %c %s\n",
254 (int)(2*sizeof(void*)),
255 iter->value, iter->type, iter->name);
259 struct seq_operations kallsyms_op = {
266 static int kallsyms_open(struct inode *inode, struct file *file)
268 /* We keep iterator in m->private, since normal case is to
269 * s_start from where we left off, so we avoid O(N^2). */
270 struct kallsym_iter *iter;
273 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
278 ret = seq_open(file, &kallsyms_op);
280 ((struct seq_file *)file->private_data)->private = iter;
286 static int kallsyms_release(struct inode *inode, struct file *file)
288 struct seq_file *m = (struct seq_file *)file->private_data;
290 return seq_release(inode, file);
293 static struct file_operations kallsyms_operations = {
294 .open = kallsyms_open,
297 .release = kallsyms_release,
300 int __init kallsyms_init(void)
302 struct proc_dir_entry *entry;
304 entry = create_proc_entry("kallsyms", 0444, NULL);
306 entry->proc_fops = &kallsyms_operations;
309 __initcall(kallsyms_init);
311 EXPORT_SYMBOL(kallsyms_lookup);
312 EXPORT_SYMBOL(__print_symbol);