]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
67fc4e0c | 19 | #include <linux/kdb.h> |
1da177e4 LT |
20 | #include <linux/err.h> |
21 | #include <linux/proc_fs.h> | |
4e57b681 | 22 | #include <linux/sched.h> /* for cond_resched */ |
1da177e4 | 23 | #include <linux/mm.h> |
07354a00 | 24 | #include <linux/ctype.h> |
5a0e3ad6 | 25 | #include <linux/slab.h> |
74451e66 | 26 | #include <linux/filter.h> |
52f5684c | 27 | #include <linux/compiler.h> |
1da177e4 LT |
28 | |
29 | #include <asm/sections.h> | |
30 | ||
ad6ccfad MK |
31 | /* |
32 | * These will be re-linked against their real values | |
33 | * during the second link stage. | |
34 | */ | |
52f5684c | 35 | extern const unsigned long kallsyms_addresses[] __weak; |
2213e9a6 | 36 | extern const int kallsyms_offsets[] __weak; |
52f5684c | 37 | extern const u8 kallsyms_names[] __weak; |
1da177e4 | 38 | |
ad6ccfad MK |
39 | /* |
40 | * Tell the compiler that the count isn't in the small data section if the arch | |
41 | * has one (eg: FRV). | |
9e6c1e63 DH |
42 | */ |
43 | extern const unsigned long kallsyms_num_syms | |
2ea03891 | 44 | __attribute__((weak, section(".rodata"))); |
9e6c1e63 | 45 | |
2213e9a6 AB |
46 | extern const unsigned long kallsyms_relative_base |
47 | __attribute__((weak, section(".rodata"))); | |
48 | ||
52f5684c GID |
49 | extern const u8 kallsyms_token_table[] __weak; |
50 | extern const u16 kallsyms_token_index[] __weak; | |
1da177e4 | 51 | |
52f5684c | 52 | extern const unsigned long kallsyms_markers[] __weak; |
1da177e4 LT |
53 | |
54 | static 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 | ||
62 | static inline int is_kernel_text(unsigned long addr) | |
63 | { | |
128e8db3 MF |
64 | if ((addr >= (unsigned long)_stext && addr <= (unsigned long)_etext) || |
65 | arch_is_kernel_text(addr)) | |
1da177e4 | 66 | return 1; |
cae5d390 | 67 | return in_gate_area_no_mm(addr); |
1da177e4 LT |
68 | } |
69 | ||
70 | static inline int is_kernel(unsigned long addr) | |
71 | { | |
72 | if (addr >= (unsigned long)_stext && addr <= (unsigned long)_end) | |
73 | return 1; | |
cae5d390 | 74 | return in_gate_area_no_mm(addr); |
1da177e4 LT |
75 | } |
76 | ||
ffc50891 FBH |
77 | static int is_ksym_addr(unsigned long addr) |
78 | { | |
63b23e2c | 79 | if (IS_ENABLED(CONFIG_KALLSYMS_ALL)) |
ffc50891 FBH |
80 | return is_kernel(addr); |
81 | ||
a3b81113 | 82 | return is_kernel_text(addr) || is_kernel_inittext(addr); |
ffc50891 FBH |
83 | } |
84 | ||
ad6ccfad MK |
85 | /* |
86 | * Expand a compressed symbol data into the resulting uncompressed string, | |
e3f26752 | 87 | * if uncompressed string is too long (>= maxlen), it will be truncated, |
ad6ccfad MK |
88 | * given the offset to where the symbol is in the compressed stream. |
89 | */ | |
e3f26752 CG |
90 | static unsigned int kallsyms_expand_symbol(unsigned int off, |
91 | char *result, size_t maxlen) | |
1da177e4 LT |
92 | { |
93 | int len, skipped_first = 0; | |
aad09470 | 94 | const u8 *tptr, *data; |
1da177e4 | 95 | |
ad6ccfad | 96 | /* Get the compressed symbol length from the first symbol byte. */ |
1da177e4 LT |
97 | data = &kallsyms_names[off]; |
98 | len = *data; | |
99 | data++; | |
100 | ||
ad6ccfad MK |
101 | /* |
102 | * Update the offset to return the offset for the next symbol on | |
103 | * the compressed stream. | |
104 | */ | |
1da177e4 LT |
105 | off += len + 1; |
106 | ||
ad6ccfad MK |
107 | /* |
108 | * For every byte on the compressed symbol data, copy the table | |
109 | * entry for that byte. | |
110 | */ | |
111 | while (len) { | |
112 | tptr = &kallsyms_token_table[kallsyms_token_index[*data]]; | |
1da177e4 LT |
113 | data++; |
114 | len--; | |
115 | ||
116 | while (*tptr) { | |
ad6ccfad | 117 | if (skipped_first) { |
e3f26752 CG |
118 | if (maxlen <= 1) |
119 | goto tail; | |
1da177e4 LT |
120 | *result = *tptr; |
121 | result++; | |
e3f26752 | 122 | maxlen--; |
1da177e4 LT |
123 | } else |
124 | skipped_first = 1; | |
125 | tptr++; | |
126 | } | |
127 | } | |
128 | ||
e3f26752 CG |
129 | tail: |
130 | if (maxlen) | |
131 | *result = '\0'; | |
1da177e4 | 132 | |
ad6ccfad | 133 | /* Return to offset to the next symbol. */ |
1da177e4 LT |
134 | return off; |
135 | } | |
136 | ||
ad6ccfad MK |
137 | /* |
138 | * Get symbol type information. This is encoded as a single char at the | |
139 | * beginning of the symbol name. | |
140 | */ | |
1da177e4 LT |
141 | static char kallsyms_get_symbol_type(unsigned int off) |
142 | { | |
ad6ccfad MK |
143 | /* |
144 | * Get just the first code, look it up in the token table, | |
145 | * and return the first char from this token. | |
146 | */ | |
147 | return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]]; | |
1da177e4 LT |
148 | } |
149 | ||
150 | ||
ad6ccfad MK |
151 | /* |
152 | * Find the offset on the compressed stream given and index in the | |
153 | * kallsyms array. | |
154 | */ | |
1da177e4 LT |
155 | static unsigned int get_symbol_offset(unsigned long pos) |
156 | { | |
aad09470 | 157 | const u8 *name; |
1da177e4 LT |
158 | int i; |
159 | ||
ad6ccfad MK |
160 | /* |
161 | * Use the closest marker we have. We have markers every 256 positions, | |
162 | * so that should be close enough. | |
163 | */ | |
164 | name = &kallsyms_names[kallsyms_markers[pos >> 8]]; | |
1da177e4 | 165 | |
ad6ccfad MK |
166 | /* |
167 | * Sequentially scan all the symbols up to the point we're searching | |
168 | * for. Every symbol is stored in a [<len>][<len> bytes of data] format, | |
169 | * so we just need to add the len to the current pointer for every | |
170 | * symbol we wish to skip. | |
171 | */ | |
172 | for (i = 0; i < (pos & 0xFF); i++) | |
1da177e4 LT |
173 | name = name + (*name) + 1; |
174 | ||
175 | return name - kallsyms_names; | |
176 | } | |
177 | ||
2213e9a6 AB |
178 | static unsigned long kallsyms_sym_address(int idx) |
179 | { | |
180 | if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE)) | |
181 | return kallsyms_addresses[idx]; | |
182 | ||
183 | /* values are unsigned offsets if --absolute-percpu is not in effect */ | |
184 | if (!IS_ENABLED(CONFIG_KALLSYMS_ABSOLUTE_PERCPU)) | |
185 | return kallsyms_relative_base + (u32)kallsyms_offsets[idx]; | |
186 | ||
187 | /* ...otherwise, positive offsets are absolute values */ | |
188 | if (kallsyms_offsets[idx] >= 0) | |
189 | return kallsyms_offsets[idx]; | |
190 | ||
191 | /* ...and negative offsets are relative to kallsyms_relative_base - 1 */ | |
192 | return kallsyms_relative_base - 1 - kallsyms_offsets[idx]; | |
193 | } | |
194 | ||
1da177e4 LT |
195 | /* Lookup the address for this symbol. Returns 0 if not found. */ |
196 | unsigned long kallsyms_lookup_name(const char *name) | |
197 | { | |
9281acea | 198 | char namebuf[KSYM_NAME_LEN]; |
1da177e4 LT |
199 | unsigned long i; |
200 | unsigned int off; | |
201 | ||
202 | for (i = 0, off = 0; i < kallsyms_num_syms; i++) { | |
e3f26752 | 203 | off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf)); |
1da177e4 LT |
204 | |
205 | if (strcmp(namebuf, name) == 0) | |
2213e9a6 | 206 | return kallsyms_sym_address(i); |
1da177e4 LT |
207 | } |
208 | return module_kallsyms_lookup_name(name); | |
209 | } | |
f60d24d2 | 210 | EXPORT_SYMBOL_GPL(kallsyms_lookup_name); |
1da177e4 | 211 | |
75a66614 AK |
212 | int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *, |
213 | unsigned long), | |
214 | void *data) | |
215 | { | |
216 | char namebuf[KSYM_NAME_LEN]; | |
217 | unsigned long i; | |
218 | unsigned int off; | |
219 | int ret; | |
220 | ||
221 | for (i = 0, off = 0; i < kallsyms_num_syms; i++) { | |
e3f26752 | 222 | off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf)); |
2213e9a6 | 223 | ret = fn(data, namebuf, NULL, kallsyms_sym_address(i)); |
75a66614 AK |
224 | if (ret != 0) |
225 | return ret; | |
226 | } | |
227 | return module_kallsyms_on_each_symbol(fn, data); | |
228 | } | |
229 | EXPORT_SYMBOL_GPL(kallsyms_on_each_symbol); | |
230 | ||
ffc50891 FBH |
231 | static unsigned long get_symbol_pos(unsigned long addr, |
232 | unsigned long *symbolsize, | |
233 | unsigned long *offset) | |
234 | { | |
235 | unsigned long symbol_start = 0, symbol_end = 0; | |
236 | unsigned long i, low, high, mid; | |
237 | ||
2ea03891 | 238 | /* This kernel should never had been booted. */ |
2213e9a6 AB |
239 | if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE)) |
240 | BUG_ON(!kallsyms_addresses); | |
241 | else | |
242 | BUG_ON(!kallsyms_offsets); | |
2ea03891 | 243 | |
ad6ccfad | 244 | /* Do a binary search on the sorted kallsyms_addresses array. */ |
ffc50891 FBH |
245 | low = 0; |
246 | high = kallsyms_num_syms; | |
247 | ||
248 | while (high - low > 1) { | |
2fc9c4e1 | 249 | mid = low + (high - low) / 2; |
2213e9a6 | 250 | if (kallsyms_sym_address(mid) <= addr) |
ffc50891 FBH |
251 | low = mid; |
252 | else | |
253 | high = mid; | |
254 | } | |
255 | ||
256 | /* | |
ad6ccfad MK |
257 | * Search for the first aliased symbol. Aliased |
258 | * symbols are symbols with the same address. | |
ffc50891 | 259 | */ |
2213e9a6 | 260 | while (low && kallsyms_sym_address(low-1) == kallsyms_sym_address(low)) |
ffc50891 FBH |
261 | --low; |
262 | ||
2213e9a6 | 263 | symbol_start = kallsyms_sym_address(low); |
ffc50891 | 264 | |
ad6ccfad | 265 | /* Search for next non-aliased symbol. */ |
ffc50891 | 266 | for (i = low + 1; i < kallsyms_num_syms; i++) { |
2213e9a6 AB |
267 | if (kallsyms_sym_address(i) > symbol_start) { |
268 | symbol_end = kallsyms_sym_address(i); | |
ffc50891 FBH |
269 | break; |
270 | } | |
271 | } | |
272 | ||
ad6ccfad | 273 | /* If we found no next symbol, we use the end of the section. */ |
ffc50891 FBH |
274 | if (!symbol_end) { |
275 | if (is_kernel_inittext(addr)) | |
276 | symbol_end = (unsigned long)_einittext; | |
63b23e2c | 277 | else if (IS_ENABLED(CONFIG_KALLSYMS_ALL)) |
ffc50891 FBH |
278 | symbol_end = (unsigned long)_end; |
279 | else | |
280 | symbol_end = (unsigned long)_etext; | |
281 | } | |
282 | ||
ffb45122 AD |
283 | if (symbolsize) |
284 | *symbolsize = symbol_end - symbol_start; | |
285 | if (offset) | |
286 | *offset = addr - symbol_start; | |
ffc50891 FBH |
287 | |
288 | return low; | |
289 | } | |
290 | ||
291 | /* | |
292 | * Lookup an address but don't bother to find any names. | |
293 | */ | |
294 | int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize, | |
295 | unsigned long *offset) | |
296 | { | |
6dd06c9f | 297 | char namebuf[KSYM_NAME_LEN]; |
74451e66 | 298 | |
ffc50891 FBH |
299 | if (is_ksym_addr(addr)) |
300 | return !!get_symbol_pos(addr, symbolsize, offset); | |
74451e66 DB |
301 | return !!module_address_lookup(addr, symbolsize, offset, NULL, namebuf) || |
302 | !!__bpf_address_lookup(addr, symbolsize, offset, namebuf); | |
ffc50891 FBH |
303 | } |
304 | ||
1da177e4 LT |
305 | /* |
306 | * Lookup an address | |
ad6ccfad MK |
307 | * - modname is set to NULL if it's in the kernel. |
308 | * - We guarantee that the returned name is valid until we reschedule even if. | |
309 | * It resides in a module. | |
310 | * - We also guarantee that modname will be valid until rescheduled. | |
1da177e4 LT |
311 | */ |
312 | const char *kallsyms_lookup(unsigned long addr, | |
313 | unsigned long *symbolsize, | |
314 | unsigned long *offset, | |
315 | char **modname, char *namebuf) | |
316 | { | |
74451e66 DB |
317 | const char *ret; |
318 | ||
9281acea | 319 | namebuf[KSYM_NAME_LEN - 1] = 0; |
1da177e4 LT |
320 | namebuf[0] = 0; |
321 | ||
ffc50891 FBH |
322 | if (is_ksym_addr(addr)) { |
323 | unsigned long pos; | |
1da177e4 | 324 | |
ffc50891 | 325 | pos = get_symbol_pos(addr, symbolsize, offset); |
1da177e4 | 326 | /* Grab name */ |
e3f26752 CG |
327 | kallsyms_expand_symbol(get_symbol_offset(pos), |
328 | namebuf, KSYM_NAME_LEN); | |
7a74fc49 KM |
329 | if (modname) |
330 | *modname = NULL; | |
1da177e4 LT |
331 | return namebuf; |
332 | } | |
333 | ||
74451e66 DB |
334 | /* See if it's in a module or a BPF JITed image. */ |
335 | ret = module_address_lookup(addr, symbolsize, offset, | |
336 | modname, namebuf); | |
337 | if (!ret) | |
338 | ret = bpf_address_lookup(addr, symbolsize, | |
339 | offset, modname, namebuf); | |
340 | return ret; | |
1da177e4 LT |
341 | } |
342 | ||
9d65cb4a AD |
343 | int lookup_symbol_name(unsigned long addr, char *symname) |
344 | { | |
345 | symname[0] = '\0'; | |
9281acea | 346 | symname[KSYM_NAME_LEN - 1] = '\0'; |
9d65cb4a AD |
347 | |
348 | if (is_ksym_addr(addr)) { | |
349 | unsigned long pos; | |
350 | ||
351 | pos = get_symbol_pos(addr, NULL, NULL); | |
352 | /* Grab name */ | |
e3f26752 CG |
353 | kallsyms_expand_symbol(get_symbol_offset(pos), |
354 | symname, KSYM_NAME_LEN); | |
9d65cb4a AD |
355 | return 0; |
356 | } | |
ad6ccfad | 357 | /* See if it's in a module. */ |
9d65cb4a AD |
358 | return lookup_module_symbol_name(addr, symname); |
359 | } | |
360 | ||
a5c43dae AD |
361 | int lookup_symbol_attrs(unsigned long addr, unsigned long *size, |
362 | unsigned long *offset, char *modname, char *name) | |
363 | { | |
364 | name[0] = '\0'; | |
9281acea | 365 | name[KSYM_NAME_LEN - 1] = '\0'; |
a5c43dae AD |
366 | |
367 | if (is_ksym_addr(addr)) { | |
368 | unsigned long pos; | |
369 | ||
370 | pos = get_symbol_pos(addr, size, offset); | |
371 | /* Grab name */ | |
e3f26752 CG |
372 | kallsyms_expand_symbol(get_symbol_offset(pos), |
373 | name, KSYM_NAME_LEN); | |
a5c43dae AD |
374 | modname[0] = '\0'; |
375 | return 0; | |
376 | } | |
ad6ccfad | 377 | /* See if it's in a module. */ |
a5c43dae AD |
378 | return lookup_module_symbol_attrs(addr, size, offset, modname, name); |
379 | } | |
380 | ||
42e38083 | 381 | /* Look up a kernel symbol and return it in a text buffer. */ |
0f77a8d3 | 382 | static int __sprint_symbol(char *buffer, unsigned long address, |
4796dd20 | 383 | int symbol_offset, int add_offset) |
1da177e4 LT |
384 | { |
385 | char *modname; | |
386 | const char *name; | |
387 | unsigned long offset, size; | |
966c8c12 | 388 | int len; |
1da177e4 | 389 | |
0f77a8d3 | 390 | address += symbol_offset; |
966c8c12 | 391 | name = kallsyms_lookup(address, &size, &offset, &modname, buffer); |
1da177e4 | 392 | if (!name) |
b86280aa | 393 | return sprintf(buffer, "0x%lx", address - symbol_offset); |
19769b76 | 394 | |
966c8c12 HD |
395 | if (name != buffer) |
396 | strcpy(buffer, name); | |
397 | len = strlen(buffer); | |
0f77a8d3 | 398 | offset -= symbol_offset; |
966c8c12 | 399 | |
4796dd20 SB |
400 | if (add_offset) |
401 | len += sprintf(buffer + len, "+%#lx/%#lx", offset, size); | |
402 | ||
19769b76 | 403 | if (modname) |
4796dd20 | 404 | len += sprintf(buffer + len, " [%s]", modname); |
966c8c12 HD |
405 | |
406 | return len; | |
42e38083 | 407 | } |
0f77a8d3 NK |
408 | |
409 | /** | |
410 | * sprint_symbol - Look up a kernel symbol and return it in a text buffer | |
411 | * @buffer: buffer to be stored | |
412 | * @address: address to lookup | |
413 | * | |
414 | * This function looks up a kernel symbol with @address and stores its name, | |
415 | * offset, size and module name to @buffer if possible. If no symbol was found, | |
416 | * just saves its @address as is. | |
417 | * | |
418 | * This function returns the number of bytes stored in @buffer. | |
419 | */ | |
420 | int sprint_symbol(char *buffer, unsigned long address) | |
421 | { | |
4796dd20 | 422 | return __sprint_symbol(buffer, address, 0, 1); |
0f77a8d3 | 423 | } |
ad6ccfad | 424 | EXPORT_SYMBOL_GPL(sprint_symbol); |
42e38083 | 425 | |
4796dd20 SB |
426 | /** |
427 | * sprint_symbol_no_offset - Look up a kernel symbol and return it in a text buffer | |
428 | * @buffer: buffer to be stored | |
429 | * @address: address to lookup | |
430 | * | |
431 | * This function looks up a kernel symbol with @address and stores its name | |
432 | * and module name to @buffer if possible. If no symbol was found, just saves | |
433 | * its @address as is. | |
434 | * | |
435 | * This function returns the number of bytes stored in @buffer. | |
436 | */ | |
437 | int sprint_symbol_no_offset(char *buffer, unsigned long address) | |
438 | { | |
439 | return __sprint_symbol(buffer, address, 0, 0); | |
440 | } | |
441 | EXPORT_SYMBOL_GPL(sprint_symbol_no_offset); | |
442 | ||
0f77a8d3 NK |
443 | /** |
444 | * sprint_backtrace - Look up a backtrace symbol and return it in a text buffer | |
445 | * @buffer: buffer to be stored | |
446 | * @address: address to lookup | |
447 | * | |
448 | * This function is for stack backtrace and does the same thing as | |
449 | * sprint_symbol() but with modified/decreased @address. If there is a | |
450 | * tail-call to the function marked "noreturn", gcc optimized out code after | |
451 | * the call so that the stack-saved return address could point outside of the | |
452 | * caller. This function ensures that kallsyms will find the original caller | |
453 | * by decreasing @address. | |
454 | * | |
455 | * This function returns the number of bytes stored in @buffer. | |
456 | */ | |
457 | int sprint_backtrace(char *buffer, unsigned long address) | |
458 | { | |
4796dd20 | 459 | return __sprint_symbol(buffer, address, -1, 1); |
0f77a8d3 NK |
460 | } |
461 | ||
42e38083 RP |
462 | /* Look up a kernel symbol and print it to the kernel messages. */ |
463 | void __print_symbol(const char *fmt, unsigned long address) | |
464 | { | |
465 | char buffer[KSYM_SYMBOL_LEN]; | |
466 | ||
467 | sprint_symbol(buffer, address); | |
468 | ||
1da177e4 LT |
469 | printk(fmt, buffer); |
470 | } | |
ad6ccfad | 471 | EXPORT_SYMBOL(__print_symbol); |
1da177e4 LT |
472 | |
473 | /* To avoid using get_symbol_offset for every symbol, we carry prefix along. */ | |
ad6ccfad | 474 | struct kallsym_iter { |
1da177e4 | 475 | loff_t pos; |
74451e66 | 476 | loff_t pos_mod_end; |
1da177e4 | 477 | unsigned long value; |
ad6ccfad | 478 | unsigned int nameoff; /* If iterating in core kernel symbols. */ |
1da177e4 | 479 | char type; |
9281acea TH |
480 | char name[KSYM_NAME_LEN]; |
481 | char module_name[MODULE_NAME_LEN]; | |
ea07890a | 482 | int exported; |
1da177e4 LT |
483 | }; |
484 | ||
1da177e4 LT |
485 | static int get_ksymbol_mod(struct kallsym_iter *iter) |
486 | { | |
74451e66 DB |
487 | int ret = module_get_kallsym(iter->pos - kallsyms_num_syms, |
488 | &iter->value, &iter->type, | |
489 | iter->name, iter->module_name, | |
490 | &iter->exported); | |
491 | if (ret < 0) { | |
492 | iter->pos_mod_end = iter->pos; | |
1da177e4 | 493 | return 0; |
74451e66 DB |
494 | } |
495 | ||
1da177e4 LT |
496 | return 1; |
497 | } | |
498 | ||
74451e66 DB |
499 | static int get_ksymbol_bpf(struct kallsym_iter *iter) |
500 | { | |
501 | iter->module_name[0] = '\0'; | |
502 | iter->exported = 0; | |
503 | return bpf_get_kallsym(iter->pos - iter->pos_mod_end, | |
504 | &iter->value, &iter->type, | |
505 | iter->name) < 0 ? 0 : 1; | |
506 | } | |
507 | ||
1da177e4 LT |
508 | /* Returns space to next name. */ |
509 | static unsigned long get_ksymbol_core(struct kallsym_iter *iter) | |
510 | { | |
511 | unsigned off = iter->nameoff; | |
512 | ||
ea07890a | 513 | iter->module_name[0] = '\0'; |
2213e9a6 | 514 | iter->value = kallsyms_sym_address(iter->pos); |
1da177e4 LT |
515 | |
516 | iter->type = kallsyms_get_symbol_type(off); | |
517 | ||
e3f26752 | 518 | off = kallsyms_expand_symbol(off, iter->name, ARRAY_SIZE(iter->name)); |
1da177e4 LT |
519 | |
520 | return off - iter->nameoff; | |
521 | } | |
522 | ||
523 | static void reset_iter(struct kallsym_iter *iter, loff_t new_pos) | |
524 | { | |
525 | iter->name[0] = '\0'; | |
526 | iter->nameoff = get_symbol_offset(new_pos); | |
527 | iter->pos = new_pos; | |
74451e66 DB |
528 | if (new_pos == 0) |
529 | iter->pos_mod_end = 0; | |
530 | } | |
531 | ||
532 | static int update_iter_mod(struct kallsym_iter *iter, loff_t pos) | |
533 | { | |
534 | iter->pos = pos; | |
535 | ||
536 | if (iter->pos_mod_end > 0 && | |
537 | iter->pos_mod_end < iter->pos) | |
538 | return get_ksymbol_bpf(iter); | |
539 | ||
540 | if (!get_ksymbol_mod(iter)) | |
541 | return get_ksymbol_bpf(iter); | |
542 | ||
543 | return 1; | |
1da177e4 LT |
544 | } |
545 | ||
546 | /* Returns false if pos at or past end of file. */ | |
547 | static int update_iter(struct kallsym_iter *iter, loff_t pos) | |
548 | { | |
549 | /* Module symbols can be accessed randomly. */ | |
74451e66 DB |
550 | if (pos >= kallsyms_num_syms) |
551 | return update_iter_mod(iter, pos); | |
ad6ccfad | 552 | |
1da177e4 LT |
553 | /* If we're not on the desired position, reset to new position. */ |
554 | if (pos != iter->pos) | |
555 | reset_iter(iter, pos); | |
556 | ||
557 | iter->nameoff += get_ksymbol_core(iter); | |
558 | iter->pos++; | |
559 | ||
560 | return 1; | |
561 | } | |
562 | ||
563 | static void *s_next(struct seq_file *m, void *p, loff_t *pos) | |
564 | { | |
565 | (*pos)++; | |
566 | ||
567 | if (!update_iter(m->private, *pos)) | |
568 | return NULL; | |
569 | return p; | |
570 | } | |
571 | ||
572 | static void *s_start(struct seq_file *m, loff_t *pos) | |
573 | { | |
574 | if (!update_iter(m->private, *pos)) | |
575 | return NULL; | |
576 | return m->private; | |
577 | } | |
578 | ||
579 | static void s_stop(struct seq_file *m, void *p) | |
580 | { | |
581 | } | |
582 | ||
583 | static int s_show(struct seq_file *m, void *p) | |
584 | { | |
585 | struct kallsym_iter *iter = m->private; | |
586 | ||
ad6ccfad | 587 | /* Some debugging symbols have no name. Ignore them. */ |
1da177e4 LT |
588 | if (!iter->name[0]) |
589 | return 0; | |
590 | ||
ea07890a AD |
591 | if (iter->module_name[0]) { |
592 | char type; | |
593 | ||
ad6ccfad MK |
594 | /* |
595 | * Label it "global" if it is exported, | |
596 | * "local" if not exported. | |
597 | */ | |
ea07890a AD |
598 | type = iter->exported ? toupper(iter->type) : |
599 | tolower(iter->type); | |
9f36e2c4 KC |
600 | seq_printf(m, "%pK %c %s\t[%s]\n", (void *)iter->value, |
601 | type, iter->name, iter->module_name); | |
ea07890a | 602 | } else |
9f36e2c4 KC |
603 | seq_printf(m, "%pK %c %s\n", (void *)iter->value, |
604 | iter->type, iter->name); | |
1da177e4 LT |
605 | return 0; |
606 | } | |
607 | ||
15ad7cdc | 608 | static const struct seq_operations kallsyms_op = { |
1da177e4 LT |
609 | .start = s_start, |
610 | .next = s_next, | |
611 | .stop = s_stop, | |
612 | .show = s_show | |
613 | }; | |
614 | ||
615 | static int kallsyms_open(struct inode *inode, struct file *file) | |
616 | { | |
ad6ccfad MK |
617 | /* |
618 | * We keep iterator in m->private, since normal case is to | |
1da177e4 | 619 | * s_start from where we left off, so we avoid doing |
ad6ccfad MK |
620 | * using get_symbol_offset for every symbol. |
621 | */ | |
1da177e4 | 622 | struct kallsym_iter *iter; |
0049f26a | 623 | iter = __seq_open_private(file, &kallsyms_op, sizeof(*iter)); |
1da177e4 LT |
624 | if (!iter) |
625 | return -ENOMEM; | |
626 | reset_iter(iter, 0); | |
627 | ||
0049f26a | 628 | return 0; |
1da177e4 LT |
629 | } |
630 | ||
67fc4e0c JW |
631 | #ifdef CONFIG_KGDB_KDB |
632 | const char *kdb_walk_kallsyms(loff_t *pos) | |
633 | { | |
634 | static struct kallsym_iter kdb_walk_kallsyms_iter; | |
635 | if (*pos == 0) { | |
636 | memset(&kdb_walk_kallsyms_iter, 0, | |
637 | sizeof(kdb_walk_kallsyms_iter)); | |
638 | reset_iter(&kdb_walk_kallsyms_iter, 0); | |
639 | } | |
640 | while (1) { | |
641 | if (!update_iter(&kdb_walk_kallsyms_iter, *pos)) | |
642 | return NULL; | |
643 | ++*pos; | |
644 | /* Some debugging symbols have no name. Ignore them. */ | |
645 | if (kdb_walk_kallsyms_iter.name[0]) | |
646 | return kdb_walk_kallsyms_iter.name; | |
647 | } | |
648 | } | |
649 | #endif /* CONFIG_KGDB_KDB */ | |
650 | ||
15ad7cdc | 651 | static const struct file_operations kallsyms_operations = { |
1da177e4 LT |
652 | .open = kallsyms_open, |
653 | .read = seq_read, | |
654 | .llseek = seq_lseek, | |
5a0c6a0d | 655 | .release = seq_release_private, |
1da177e4 LT |
656 | }; |
657 | ||
658 | static int __init kallsyms_init(void) | |
659 | { | |
33e0d57f | 660 | proc_create("kallsyms", 0444, NULL, &kallsyms_operations); |
1da177e4 LT |
661 | return 0; |
662 | } | |
ad6ccfad | 663 | device_initcall(kallsyms_init); |