1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * kallsyms.c: in-kernel printing of symbolic oopses and stack traces. |
4 | * |
5 | * Rewritten and vastly simplified by Rusty Russell for in-kernel |
6 | * module loader: |
7 | * Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation |
8 | * |
9 | * ChangeLog: |
10 | * |
11 | * (25/Aug/2004) Paulo Marques <pmarques@grupopie.com> |
12 | * Changed the compression method from stem compression to "table lookup" |
13 | * compression (see scripts/kallsyms.c for a more complete description) |
14 | */ |
15 | #include <linux/kallsyms.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> /* for cond_resched */ |
23 | #include <linux/ctype.h> |
24 | #include <linux/slab.h> |
25 | #include <linux/filter.h> |
26 | #include <linux/ftrace.h> |
27 | #include <linux/kprobes.h> |
28 | #include <linux/build_bug.h> |
29 | #include <linux/compiler.h> |
30 | #include <linux/module.h> |
31 | #include <linux/kernel.h> |
32 | #include <linux/bsearch.h> |
33 | #include <linux/btf_ids.h> |
34 | |
35 | #include "kallsyms_internal.h" |
36 | |
37 | /* |
38 | * Expand a compressed symbol data into the resulting uncompressed string, |
39 | * if uncompressed string is too long (>= maxlen), it will be truncated, |
40 | * given the offset to where the symbol is in the compressed stream. |
41 | */ |
42 | static unsigned int kallsyms_expand_symbol(unsigned int off, |
43 | char *result, size_t maxlen) |
44 | { |
45 | int len, skipped_first = 0; |
46 | const char *tptr; |
47 | const u8 *data; |
48 | |
49 | /* Get the compressed symbol length from the first symbol byte. */ |
50 | data = &kallsyms_names[off]; |
51 | len = *data; |
52 | data++; |
53 | off++; |
54 | |
55 | /* If MSB is 1, it is a "big" symbol, so needs an additional byte. */ |
56 | if ((len & 0x80) != 0) { |
57 | len = (len & 0x7F) | (*data << 7); |
58 | data++; |
59 | off++; |
60 | } |
61 | |
62 | /* |
63 | * Update the offset to return the offset for the next symbol on |
64 | * the compressed stream. |
65 | */ |
66 | off += len; |
67 | |
68 | /* |
69 | * For every byte on the compressed symbol data, copy the table |
70 | * entry for that byte. |
71 | */ |
72 | while (len) { |
73 | tptr = &kallsyms_token_table[kallsyms_token_index[*data]]; |
74 | data++; |
75 | len--; |
76 | |
77 | while (*tptr) { |
78 | if (skipped_first) { |
79 | if (maxlen <= 1) |
80 | goto tail; |
81 | *result = *tptr; |
82 | result++; |
83 | maxlen--; |
84 | } else |
85 | skipped_first = 1; |
86 | tptr++; |
87 | } |
88 | } |
89 | |
90 | tail: |
91 | if (maxlen) |
92 | *result = '\0'; |
93 | |
94 | /* Return to offset to the next symbol. */ |
95 | return off; |
96 | } |
97 | |
98 | /* |
99 | * Get symbol type information. This is encoded as a single char at the |
100 | * beginning of the symbol name. |
101 | */ |
102 | static char kallsyms_get_symbol_type(unsigned int off) |
103 | { |
104 | /* |
105 | * Get just the first code, look it up in the token table, |
106 | * and return the first char from this token. |
107 | */ |
108 | return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]]; |
109 | } |
110 | |
111 | |
112 | /* |
113 | * Find the offset on the compressed stream given and index in the |
114 | * kallsyms array. |
115 | */ |
116 | static unsigned int get_symbol_offset(unsigned long pos) |
117 | { |
118 | const u8 *name; |
119 | int i, len; |
120 | |
121 | /* |
122 | * Use the closest marker we have. We have markers every 256 positions, |
123 | * so that should be close enough. |
124 | */ |
125 | name = &kallsyms_names[kallsyms_markers[pos >> 8]]; |
126 | |
127 | /* |
128 | * Sequentially scan all the symbols up to the point we're searching |
129 | * for. Every symbol is stored in a [<len>][<len> bytes of data] format, |
130 | * so we just need to add the len to the current pointer for every |
131 | * symbol we wish to skip. |
132 | */ |
133 | for (i = 0; i < (pos & 0xFF); i++) { |
134 | len = *name; |
135 | |
136 | /* |
137 | * If MSB is 1, it is a "big" symbol, so we need to look into |
138 | * the next byte (and skip it, too). |
139 | */ |
140 | if ((len & 0x80) != 0) |
141 | len = ((len & 0x7F) | (name[1] << 7)) + 1; |
142 | |
143 | name = name + len + 1; |
144 | } |
145 | |
146 | return name - kallsyms_names; |
147 | } |
148 | |
149 | unsigned long kallsyms_sym_address(int idx) |
150 | { |
151 | if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE)) |
152 | return kallsyms_addresses[idx]; |
153 | |
154 | /* values are unsigned offsets if --absolute-percpu is not in effect */ |
155 | if (!IS_ENABLED(CONFIG_KALLSYMS_ABSOLUTE_PERCPU)) |
156 | return kallsyms_relative_base + (u32)kallsyms_offsets[idx]; |
157 | |
158 | /* ...otherwise, positive offsets are absolute values */ |
159 | if (kallsyms_offsets[idx] >= 0) |
160 | return kallsyms_offsets[idx]; |
161 | |
162 | /* ...and negative offsets are relative to kallsyms_relative_base - 1 */ |
163 | return kallsyms_relative_base - 1 - kallsyms_offsets[idx]; |
164 | } |
165 | |
166 | static void cleanup_symbol_name(char *s) |
167 | { |
168 | char *res; |
169 | |
170 | if (!IS_ENABLED(CONFIG_LTO_CLANG)) |
171 | return; |
172 | |
173 | /* |
174 | * LLVM appends various suffixes for local functions and variables that |
175 | * must be promoted to global scope as part of LTO. This can break |
176 | * hooking of static functions with kprobes. '.' is not a valid |
177 | * character in an identifier in C. Suffixes only in LLVM LTO observed: |
178 | * - foo.llvm.[0-9a-f]+ |
179 | */ |
180 | res = strstr(s, ".llvm." ); |
181 | if (res) |
182 | *res = '\0'; |
183 | |
184 | return; |
185 | } |
186 | |
187 | static int compare_symbol_name(const char *name, char *namebuf) |
188 | { |
189 | /* The kallsyms_seqs_of_names is sorted based on names after |
190 | * cleanup_symbol_name() (see scripts/kallsyms.c) if clang lto is enabled. |
191 | * To ensure correct bisection in kallsyms_lookup_names(), do |
192 | * cleanup_symbol_name(namebuf) before comparing name and namebuf. |
193 | */ |
194 | cleanup_symbol_name(s: namebuf); |
195 | return strcmp(name, namebuf); |
196 | } |
197 | |
198 | static unsigned int get_symbol_seq(int index) |
199 | { |
200 | unsigned int i, seq = 0; |
201 | |
202 | for (i = 0; i < 3; i++) |
203 | seq = (seq << 8) | kallsyms_seqs_of_names[3 * index + i]; |
204 | |
205 | return seq; |
206 | } |
207 | |
208 | static int kallsyms_lookup_names(const char *name, |
209 | unsigned int *start, |
210 | unsigned int *end) |
211 | { |
212 | int ret; |
213 | int low, mid, high; |
214 | unsigned int seq, off; |
215 | char namebuf[KSYM_NAME_LEN]; |
216 | |
217 | low = 0; |
218 | high = kallsyms_num_syms - 1; |
219 | |
220 | while (low <= high) { |
221 | mid = low + (high - low) / 2; |
222 | seq = get_symbol_seq(index: mid); |
223 | off = get_symbol_offset(pos: seq); |
224 | kallsyms_expand_symbol(off, result: namebuf, ARRAY_SIZE(namebuf)); |
225 | ret = compare_symbol_name(name, namebuf); |
226 | if (ret > 0) |
227 | low = mid + 1; |
228 | else if (ret < 0) |
229 | high = mid - 1; |
230 | else |
231 | break; |
232 | } |
233 | |
234 | if (low > high) |
235 | return -ESRCH; |
236 | |
237 | low = mid; |
238 | while (low) { |
239 | seq = get_symbol_seq(index: low - 1); |
240 | off = get_symbol_offset(pos: seq); |
241 | kallsyms_expand_symbol(off, result: namebuf, ARRAY_SIZE(namebuf)); |
242 | if (compare_symbol_name(name, namebuf)) |
243 | break; |
244 | low--; |
245 | } |
246 | *start = low; |
247 | |
248 | if (end) { |
249 | high = mid; |
250 | while (high < kallsyms_num_syms - 1) { |
251 | seq = get_symbol_seq(index: high + 1); |
252 | off = get_symbol_offset(pos: seq); |
253 | kallsyms_expand_symbol(off, result: namebuf, ARRAY_SIZE(namebuf)); |
254 | if (compare_symbol_name(name, namebuf)) |
255 | break; |
256 | high++; |
257 | } |
258 | *end = high; |
259 | } |
260 | |
261 | return 0; |
262 | } |
263 | |
264 | /* Lookup the address for this symbol. Returns 0 if not found. */ |
265 | unsigned long kallsyms_lookup_name(const char *name) |
266 | { |
267 | int ret; |
268 | unsigned int i; |
269 | |
270 | /* Skip the search for empty string. */ |
271 | if (!*name) |
272 | return 0; |
273 | |
274 | ret = kallsyms_lookup_names(name, start: &i, NULL); |
275 | if (!ret) |
276 | return kallsyms_sym_address(idx: get_symbol_seq(index: i)); |
277 | |
278 | return module_kallsyms_lookup_name(name); |
279 | } |
280 | |
281 | /* |
282 | * Iterate over all symbols in vmlinux. For symbols from modules use |
283 | * module_kallsyms_on_each_symbol instead. |
284 | */ |
285 | int kallsyms_on_each_symbol(int (*fn)(void *, const char *, unsigned long), |
286 | void *data) |
287 | { |
288 | char namebuf[KSYM_NAME_LEN]; |
289 | unsigned long i; |
290 | unsigned int off; |
291 | int ret; |
292 | |
293 | for (i = 0, off = 0; i < kallsyms_num_syms; i++) { |
294 | off = kallsyms_expand_symbol(off, result: namebuf, ARRAY_SIZE(namebuf)); |
295 | ret = fn(data, namebuf, kallsyms_sym_address(idx: i)); |
296 | if (ret != 0) |
297 | return ret; |
298 | cond_resched(); |
299 | } |
300 | return 0; |
301 | } |
302 | |
303 | int kallsyms_on_each_match_symbol(int (*fn)(void *, unsigned long), |
304 | const char *name, void *data) |
305 | { |
306 | int ret; |
307 | unsigned int i, start, end; |
308 | |
309 | ret = kallsyms_lookup_names(name, start: &start, end: &end); |
310 | if (ret) |
311 | return 0; |
312 | |
313 | for (i = start; !ret && i <= end; i++) { |
314 | ret = fn(data, kallsyms_sym_address(idx: get_symbol_seq(index: i))); |
315 | cond_resched(); |
316 | } |
317 | |
318 | return ret; |
319 | } |
320 | |
321 | static unsigned long get_symbol_pos(unsigned long addr, |
322 | unsigned long *symbolsize, |
323 | unsigned long *offset) |
324 | { |
325 | unsigned long symbol_start = 0, symbol_end = 0; |
326 | unsigned long i, low, high, mid; |
327 | |
328 | /* This kernel should never had been booted. */ |
329 | if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE)) |
330 | BUG_ON(!kallsyms_addresses); |
331 | else |
332 | BUG_ON(!kallsyms_offsets); |
333 | |
334 | /* Do a binary search on the sorted kallsyms_addresses array. */ |
335 | low = 0; |
336 | high = kallsyms_num_syms; |
337 | |
338 | while (high - low > 1) { |
339 | mid = low + (high - low) / 2; |
340 | if (kallsyms_sym_address(idx: mid) <= addr) |
341 | low = mid; |
342 | else |
343 | high = mid; |
344 | } |
345 | |
346 | /* |
347 | * Search for the first aliased symbol. Aliased |
348 | * symbols are symbols with the same address. |
349 | */ |
350 | while (low && kallsyms_sym_address(idx: low-1) == kallsyms_sym_address(idx: low)) |
351 | --low; |
352 | |
353 | symbol_start = kallsyms_sym_address(idx: low); |
354 | |
355 | /* Search for next non-aliased symbol. */ |
356 | for (i = low + 1; i < kallsyms_num_syms; i++) { |
357 | if (kallsyms_sym_address(idx: i) > symbol_start) { |
358 | symbol_end = kallsyms_sym_address(idx: i); |
359 | break; |
360 | } |
361 | } |
362 | |
363 | /* If we found no next symbol, we use the end of the section. */ |
364 | if (!symbol_end) { |
365 | if (is_kernel_inittext(addr)) |
366 | symbol_end = (unsigned long)_einittext; |
367 | else if (IS_ENABLED(CONFIG_KALLSYMS_ALL)) |
368 | symbol_end = (unsigned long)_end; |
369 | else |
370 | symbol_end = (unsigned long)_etext; |
371 | } |
372 | |
373 | if (symbolsize) |
374 | *symbolsize = symbol_end - symbol_start; |
375 | if (offset) |
376 | *offset = addr - symbol_start; |
377 | |
378 | return low; |
379 | } |
380 | |
381 | /* |
382 | * Lookup an address but don't bother to find any names. |
383 | */ |
384 | int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize, |
385 | unsigned long *offset) |
386 | { |
387 | char namebuf[KSYM_NAME_LEN]; |
388 | |
389 | if (is_ksym_addr(addr)) { |
390 | get_symbol_pos(addr, symbolsize, offset); |
391 | return 1; |
392 | } |
393 | return !!module_address_lookup(addr, symbolsize, offset, NULL, NULL, namebuf) || |
394 | !!__bpf_address_lookup(addr, size: symbolsize, off: offset, sym: namebuf); |
395 | } |
396 | |
397 | static const char *kallsyms_lookup_buildid(unsigned long addr, |
398 | unsigned long *symbolsize, |
399 | unsigned long *offset, char **modname, |
400 | const unsigned char **modbuildid, char *namebuf) |
401 | { |
402 | const char *ret; |
403 | |
404 | namebuf[KSYM_NAME_LEN - 1] = 0; |
405 | namebuf[0] = 0; |
406 | |
407 | if (is_ksym_addr(addr)) { |
408 | unsigned long pos; |
409 | |
410 | pos = get_symbol_pos(addr, symbolsize, offset); |
411 | /* Grab name */ |
412 | kallsyms_expand_symbol(off: get_symbol_offset(pos), |
413 | result: namebuf, KSYM_NAME_LEN); |
414 | if (modname) |
415 | *modname = NULL; |
416 | if (modbuildid) |
417 | *modbuildid = NULL; |
418 | |
419 | ret = namebuf; |
420 | goto found; |
421 | } |
422 | |
423 | /* See if it's in a module or a BPF JITed image. */ |
424 | ret = module_address_lookup(addr, symbolsize, offset, |
425 | modname, modbuildid, namebuf); |
426 | if (!ret) |
427 | ret = bpf_address_lookup(addr, size: symbolsize, |
428 | off: offset, modname, sym: namebuf); |
429 | |
430 | if (!ret) |
431 | ret = ftrace_mod_address_lookup(addr, size: symbolsize, |
432 | off: offset, modname, sym: namebuf); |
433 | |
434 | found: |
435 | cleanup_symbol_name(s: namebuf); |
436 | return ret; |
437 | } |
438 | |
439 | /* |
440 | * Lookup an address |
441 | * - modname is set to NULL if it's in the kernel. |
442 | * - We guarantee that the returned name is valid until we reschedule even if. |
443 | * It resides in a module. |
444 | * - We also guarantee that modname will be valid until rescheduled. |
445 | */ |
446 | const char *kallsyms_lookup(unsigned long addr, |
447 | unsigned long *symbolsize, |
448 | unsigned long *offset, |
449 | char **modname, char *namebuf) |
450 | { |
451 | return kallsyms_lookup_buildid(addr, symbolsize, offset, modname, |
452 | NULL, namebuf); |
453 | } |
454 | |
455 | int lookup_symbol_name(unsigned long addr, char *symname) |
456 | { |
457 | int res; |
458 | |
459 | symname[0] = '\0'; |
460 | symname[KSYM_NAME_LEN - 1] = '\0'; |
461 | |
462 | if (is_ksym_addr(addr)) { |
463 | unsigned long pos; |
464 | |
465 | pos = get_symbol_pos(addr, NULL, NULL); |
466 | /* Grab name */ |
467 | kallsyms_expand_symbol(off: get_symbol_offset(pos), |
468 | result: symname, KSYM_NAME_LEN); |
469 | goto found; |
470 | } |
471 | /* See if it's in a module. */ |
472 | res = lookup_module_symbol_name(addr, symname); |
473 | if (res) |
474 | return res; |
475 | |
476 | found: |
477 | cleanup_symbol_name(s: symname); |
478 | return 0; |
479 | } |
480 | |
481 | /* Look up a kernel symbol and return it in a text buffer. */ |
482 | static int __sprint_symbol(char *buffer, unsigned long address, |
483 | int symbol_offset, int add_offset, int add_buildid) |
484 | { |
485 | char *modname; |
486 | const unsigned char *buildid; |
487 | const char *name; |
488 | unsigned long offset, size; |
489 | int len; |
490 | |
491 | address += symbol_offset; |
492 | name = kallsyms_lookup_buildid(addr: address, symbolsize: &size, offset: &offset, modname: &modname, modbuildid: &buildid, |
493 | namebuf: buffer); |
494 | if (!name) |
495 | return sprintf(buf: buffer, fmt: "0x%lx" , address - symbol_offset); |
496 | |
497 | if (name != buffer) |
498 | strcpy(p: buffer, q: name); |
499 | len = strlen(buffer); |
500 | offset -= symbol_offset; |
501 | |
502 | if (add_offset) |
503 | len += sprintf(buf: buffer + len, fmt: "+%#lx/%#lx" , offset, size); |
504 | |
505 | if (modname) { |
506 | len += sprintf(buf: buffer + len, fmt: " [%s" , modname); |
507 | #if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID) |
508 | if (add_buildid && buildid) { |
509 | /* build ID should match length of sprintf */ |
510 | #if IS_ENABLED(CONFIG_MODULES) |
511 | static_assert(sizeof(typeof_member(struct module, build_id)) == 20); |
512 | #endif |
513 | len += sprintf(buf: buffer + len, fmt: " %20phN" , buildid); |
514 | } |
515 | #endif |
516 | len += sprintf(buf: buffer + len, fmt: "]" ); |
517 | } |
518 | |
519 | return len; |
520 | } |
521 | |
522 | /** |
523 | * sprint_symbol - Look up a kernel symbol and return it in a text buffer |
524 | * @buffer: buffer to be stored |
525 | * @address: address to lookup |
526 | * |
527 | * This function looks up a kernel symbol with @address and stores its name, |
528 | * offset, size and module name to @buffer if possible. If no symbol was found, |
529 | * just saves its @address as is. |
530 | * |
531 | * This function returns the number of bytes stored in @buffer. |
532 | */ |
533 | int sprint_symbol(char *buffer, unsigned long address) |
534 | { |
535 | return __sprint_symbol(buffer, address, symbol_offset: 0, add_offset: 1, add_buildid: 0); |
536 | } |
537 | EXPORT_SYMBOL_GPL(sprint_symbol); |
538 | |
539 | /** |
540 | * sprint_symbol_build_id - Look up a kernel symbol and return it in a text buffer |
541 | * @buffer: buffer to be stored |
542 | * @address: address to lookup |
543 | * |
544 | * This function looks up a kernel symbol with @address and stores its name, |
545 | * offset, size, module name and module build ID to @buffer if possible. If no |
546 | * symbol was found, just saves its @address as is. |
547 | * |
548 | * This function returns the number of bytes stored in @buffer. |
549 | */ |
550 | int sprint_symbol_build_id(char *buffer, unsigned long address) |
551 | { |
552 | return __sprint_symbol(buffer, address, symbol_offset: 0, add_offset: 1, add_buildid: 1); |
553 | } |
554 | EXPORT_SYMBOL_GPL(sprint_symbol_build_id); |
555 | |
556 | /** |
557 | * sprint_symbol_no_offset - Look up a kernel symbol and return it in a text buffer |
558 | * @buffer: buffer to be stored |
559 | * @address: address to lookup |
560 | * |
561 | * This function looks up a kernel symbol with @address and stores its name |
562 | * and module name to @buffer if possible. If no symbol was found, just saves |
563 | * its @address as is. |
564 | * |
565 | * This function returns the number of bytes stored in @buffer. |
566 | */ |
567 | int sprint_symbol_no_offset(char *buffer, unsigned long address) |
568 | { |
569 | return __sprint_symbol(buffer, address, symbol_offset: 0, add_offset: 0, add_buildid: 0); |
570 | } |
571 | EXPORT_SYMBOL_GPL(sprint_symbol_no_offset); |
572 | |
573 | /** |
574 | * sprint_backtrace - Look up a backtrace symbol and return it in a text buffer |
575 | * @buffer: buffer to be stored |
576 | * @address: address to lookup |
577 | * |
578 | * This function is for stack backtrace and does the same thing as |
579 | * sprint_symbol() but with modified/decreased @address. If there is a |
580 | * tail-call to the function marked "noreturn", gcc optimized out code after |
581 | * the call so that the stack-saved return address could point outside of the |
582 | * caller. This function ensures that kallsyms will find the original caller |
583 | * by decreasing @address. |
584 | * |
585 | * This function returns the number of bytes stored in @buffer. |
586 | */ |
587 | int sprint_backtrace(char *buffer, unsigned long address) |
588 | { |
589 | return __sprint_symbol(buffer, address, symbol_offset: -1, add_offset: 1, add_buildid: 0); |
590 | } |
591 | |
592 | /** |
593 | * sprint_backtrace_build_id - Look up a backtrace symbol and return it in a text buffer |
594 | * @buffer: buffer to be stored |
595 | * @address: address to lookup |
596 | * |
597 | * This function is for stack backtrace and does the same thing as |
598 | * sprint_symbol() but with modified/decreased @address. If there is a |
599 | * tail-call to the function marked "noreturn", gcc optimized out code after |
600 | * the call so that the stack-saved return address could point outside of the |
601 | * caller. This function ensures that kallsyms will find the original caller |
602 | * by decreasing @address. This function also appends the module build ID to |
603 | * the @buffer if @address is within a kernel module. |
604 | * |
605 | * This function returns the number of bytes stored in @buffer. |
606 | */ |
607 | int sprint_backtrace_build_id(char *buffer, unsigned long address) |
608 | { |
609 | return __sprint_symbol(buffer, address, symbol_offset: -1, add_offset: 1, add_buildid: 1); |
610 | } |
611 | |
612 | /* To avoid using get_symbol_offset for every symbol, we carry prefix along. */ |
613 | struct kallsym_iter { |
614 | loff_t pos; |
615 | loff_t pos_mod_end; |
616 | loff_t pos_ftrace_mod_end; |
617 | loff_t pos_bpf_end; |
618 | unsigned long value; |
619 | unsigned int nameoff; /* If iterating in core kernel symbols. */ |
620 | char type; |
621 | char name[KSYM_NAME_LEN]; |
622 | char module_name[MODULE_NAME_LEN]; |
623 | int exported; |
624 | int show_value; |
625 | }; |
626 | |
627 | static int get_ksymbol_mod(struct kallsym_iter *iter) |
628 | { |
629 | int ret = module_get_kallsym(symnum: iter->pos - kallsyms_num_syms, |
630 | value: &iter->value, type: &iter->type, |
631 | name: iter->name, module_name: iter->module_name, |
632 | exported: &iter->exported); |
633 | if (ret < 0) { |
634 | iter->pos_mod_end = iter->pos; |
635 | return 0; |
636 | } |
637 | |
638 | return 1; |
639 | } |
640 | |
641 | /* |
642 | * ftrace_mod_get_kallsym() may also get symbols for pages allocated for ftrace |
643 | * purposes. In that case "__builtin__ftrace" is used as a module name, even |
644 | * though "__builtin__ftrace" is not a module. |
645 | */ |
646 | static int get_ksymbol_ftrace_mod(struct kallsym_iter *iter) |
647 | { |
648 | int ret = ftrace_mod_get_kallsym(symnum: iter->pos - iter->pos_mod_end, |
649 | value: &iter->value, type: &iter->type, |
650 | name: iter->name, module_name: iter->module_name, |
651 | exported: &iter->exported); |
652 | if (ret < 0) { |
653 | iter->pos_ftrace_mod_end = iter->pos; |
654 | return 0; |
655 | } |
656 | |
657 | return 1; |
658 | } |
659 | |
660 | static int get_ksymbol_bpf(struct kallsym_iter *iter) |
661 | { |
662 | int ret; |
663 | |
664 | strscpy(p: iter->module_name, q: "bpf" , MODULE_NAME_LEN); |
665 | iter->exported = 0; |
666 | ret = bpf_get_kallsym(symnum: iter->pos - iter->pos_ftrace_mod_end, |
667 | value: &iter->value, type: &iter->type, |
668 | sym: iter->name); |
669 | if (ret < 0) { |
670 | iter->pos_bpf_end = iter->pos; |
671 | return 0; |
672 | } |
673 | |
674 | return 1; |
675 | } |
676 | |
677 | /* |
678 | * This uses "__builtin__kprobes" as a module name for symbols for pages |
679 | * allocated for kprobes' purposes, even though "__builtin__kprobes" is not a |
680 | * module. |
681 | */ |
682 | static int get_ksymbol_kprobe(struct kallsym_iter *iter) |
683 | { |
684 | strscpy(p: iter->module_name, q: "__builtin__kprobes" , MODULE_NAME_LEN); |
685 | iter->exported = 0; |
686 | return kprobe_get_kallsym(symnum: iter->pos - iter->pos_bpf_end, |
687 | value: &iter->value, type: &iter->type, |
688 | sym: iter->name) < 0 ? 0 : 1; |
689 | } |
690 | |
691 | /* Returns space to next name. */ |
692 | static unsigned long get_ksymbol_core(struct kallsym_iter *iter) |
693 | { |
694 | unsigned off = iter->nameoff; |
695 | |
696 | iter->module_name[0] = '\0'; |
697 | iter->value = kallsyms_sym_address(idx: iter->pos); |
698 | |
699 | iter->type = kallsyms_get_symbol_type(off); |
700 | |
701 | off = kallsyms_expand_symbol(off, result: iter->name, ARRAY_SIZE(iter->name)); |
702 | |
703 | return off - iter->nameoff; |
704 | } |
705 | |
706 | static void reset_iter(struct kallsym_iter *iter, loff_t new_pos) |
707 | { |
708 | iter->name[0] = '\0'; |
709 | iter->nameoff = get_symbol_offset(pos: new_pos); |
710 | iter->pos = new_pos; |
711 | if (new_pos == 0) { |
712 | iter->pos_mod_end = 0; |
713 | iter->pos_ftrace_mod_end = 0; |
714 | iter->pos_bpf_end = 0; |
715 | } |
716 | } |
717 | |
718 | /* |
719 | * The end position (last + 1) of each additional kallsyms section is recorded |
720 | * in iter->pos_..._end as each section is added, and so can be used to |
721 | * determine which get_ksymbol_...() function to call next. |
722 | */ |
723 | static int update_iter_mod(struct kallsym_iter *iter, loff_t pos) |
724 | { |
725 | iter->pos = pos; |
726 | |
727 | if ((!iter->pos_mod_end || iter->pos_mod_end > pos) && |
728 | get_ksymbol_mod(iter)) |
729 | return 1; |
730 | |
731 | if ((!iter->pos_ftrace_mod_end || iter->pos_ftrace_mod_end > pos) && |
732 | get_ksymbol_ftrace_mod(iter)) |
733 | return 1; |
734 | |
735 | if ((!iter->pos_bpf_end || iter->pos_bpf_end > pos) && |
736 | get_ksymbol_bpf(iter)) |
737 | return 1; |
738 | |
739 | return get_ksymbol_kprobe(iter); |
740 | } |
741 | |
742 | /* Returns false if pos at or past end of file. */ |
743 | static int update_iter(struct kallsym_iter *iter, loff_t pos) |
744 | { |
745 | /* Module symbols can be accessed randomly. */ |
746 | if (pos >= kallsyms_num_syms) |
747 | return update_iter_mod(iter, pos); |
748 | |
749 | /* If we're not on the desired position, reset to new position. */ |
750 | if (pos != iter->pos) |
751 | reset_iter(iter, new_pos: pos); |
752 | |
753 | iter->nameoff += get_ksymbol_core(iter); |
754 | iter->pos++; |
755 | |
756 | return 1; |
757 | } |
758 | |
759 | static void *s_next(struct seq_file *m, void *p, loff_t *pos) |
760 | { |
761 | (*pos)++; |
762 | |
763 | if (!update_iter(iter: m->private, pos: *pos)) |
764 | return NULL; |
765 | return p; |
766 | } |
767 | |
768 | static void *s_start(struct seq_file *m, loff_t *pos) |
769 | { |
770 | if (!update_iter(iter: m->private, pos: *pos)) |
771 | return NULL; |
772 | return m->private; |
773 | } |
774 | |
775 | static void s_stop(struct seq_file *m, void *p) |
776 | { |
777 | } |
778 | |
779 | static int s_show(struct seq_file *m, void *p) |
780 | { |
781 | void *value; |
782 | struct kallsym_iter *iter = m->private; |
783 | |
784 | /* Some debugging symbols have no name. Ignore them. */ |
785 | if (!iter->name[0]) |
786 | return 0; |
787 | |
788 | value = iter->show_value ? (void *)iter->value : NULL; |
789 | |
790 | if (iter->module_name[0]) { |
791 | char type; |
792 | |
793 | /* |
794 | * Label it "global" if it is exported, |
795 | * "local" if not exported. |
796 | */ |
797 | type = iter->exported ? toupper(iter->type) : |
798 | tolower(iter->type); |
799 | seq_printf(m, fmt: "%px %c %s\t[%s]\n" , value, |
800 | type, iter->name, iter->module_name); |
801 | } else |
802 | seq_printf(m, fmt: "%px %c %s\n" , value, |
803 | iter->type, iter->name); |
804 | return 0; |
805 | } |
806 | |
807 | static const struct seq_operations kallsyms_op = { |
808 | .start = s_start, |
809 | .next = s_next, |
810 | .stop = s_stop, |
811 | .show = s_show |
812 | }; |
813 | |
814 | #ifdef CONFIG_BPF_SYSCALL |
815 | |
816 | struct bpf_iter__ksym { |
817 | __bpf_md_ptr(struct bpf_iter_meta *, meta); |
818 | __bpf_md_ptr(struct kallsym_iter *, ksym); |
819 | }; |
820 | |
821 | static int ksym_prog_seq_show(struct seq_file *m, bool in_stop) |
822 | { |
823 | struct bpf_iter__ksym ctx; |
824 | struct bpf_iter_meta meta; |
825 | struct bpf_prog *prog; |
826 | |
827 | meta.seq = m; |
828 | prog = bpf_iter_get_info(meta: &meta, in_stop); |
829 | if (!prog) |
830 | return 0; |
831 | |
832 | ctx.meta = &meta; |
833 | ctx.ksym = m ? m->private : NULL; |
834 | return bpf_iter_run_prog(prog, ctx: &ctx); |
835 | } |
836 | |
837 | static int bpf_iter_ksym_seq_show(struct seq_file *m, void *p) |
838 | { |
839 | return ksym_prog_seq_show(m, in_stop: false); |
840 | } |
841 | |
842 | static void bpf_iter_ksym_seq_stop(struct seq_file *m, void *p) |
843 | { |
844 | if (!p) |
845 | (void) ksym_prog_seq_show(m, in_stop: true); |
846 | else |
847 | s_stop(m, p); |
848 | } |
849 | |
850 | static const struct seq_operations bpf_iter_ksym_ops = { |
851 | .start = s_start, |
852 | .next = s_next, |
853 | .stop = bpf_iter_ksym_seq_stop, |
854 | .show = bpf_iter_ksym_seq_show, |
855 | }; |
856 | |
857 | static int bpf_iter_ksym_init(void *priv_data, struct bpf_iter_aux_info *aux) |
858 | { |
859 | struct kallsym_iter *iter = priv_data; |
860 | |
861 | reset_iter(iter, new_pos: 0); |
862 | |
863 | /* cache here as in kallsyms_open() case; use current process |
864 | * credentials to tell BPF iterators if values should be shown. |
865 | */ |
866 | iter->show_value = kallsyms_show_value(current_cred()); |
867 | |
868 | return 0; |
869 | } |
870 | |
871 | DEFINE_BPF_ITER_FUNC(ksym, struct bpf_iter_meta *meta, struct kallsym_iter *ksym) |
872 | |
873 | static const struct bpf_iter_seq_info ksym_iter_seq_info = { |
874 | .seq_ops = &bpf_iter_ksym_ops, |
875 | .init_seq_private = bpf_iter_ksym_init, |
876 | .fini_seq_private = NULL, |
877 | .seq_priv_size = sizeof(struct kallsym_iter), |
878 | }; |
879 | |
880 | static struct bpf_iter_reg ksym_iter_reg_info = { |
881 | .target = "ksym" , |
882 | .feature = BPF_ITER_RESCHED, |
883 | .ctx_arg_info_size = 1, |
884 | .ctx_arg_info = { |
885 | { offsetof(struct bpf_iter__ksym, ksym), |
886 | PTR_TO_BTF_ID_OR_NULL }, |
887 | }, |
888 | .seq_info = &ksym_iter_seq_info, |
889 | }; |
890 | |
891 | BTF_ID_LIST(btf_ksym_iter_id) |
892 | BTF_ID(struct, kallsym_iter) |
893 | |
894 | static int __init bpf_ksym_iter_register(void) |
895 | { |
896 | ksym_iter_reg_info.ctx_arg_info[0].btf_id = *btf_ksym_iter_id; |
897 | return bpf_iter_reg_target(reg_info: &ksym_iter_reg_info); |
898 | } |
899 | |
900 | late_initcall(bpf_ksym_iter_register); |
901 | |
902 | #endif /* CONFIG_BPF_SYSCALL */ |
903 | |
904 | static int kallsyms_open(struct inode *inode, struct file *file) |
905 | { |
906 | /* |
907 | * We keep iterator in m->private, since normal case is to |
908 | * s_start from where we left off, so we avoid doing |
909 | * using get_symbol_offset for every symbol. |
910 | */ |
911 | struct kallsym_iter *iter; |
912 | iter = __seq_open_private(file, &kallsyms_op, sizeof(*iter)); |
913 | if (!iter) |
914 | return -ENOMEM; |
915 | reset_iter(iter, new_pos: 0); |
916 | |
917 | /* |
918 | * Instead of checking this on every s_show() call, cache |
919 | * the result here at open time. |
920 | */ |
921 | iter->show_value = kallsyms_show_value(cred: file->f_cred); |
922 | return 0; |
923 | } |
924 | |
925 | #ifdef CONFIG_KGDB_KDB |
926 | const char *kdb_walk_kallsyms(loff_t *pos) |
927 | { |
928 | static struct kallsym_iter kdb_walk_kallsyms_iter; |
929 | if (*pos == 0) { |
930 | memset(&kdb_walk_kallsyms_iter, 0, |
931 | sizeof(kdb_walk_kallsyms_iter)); |
932 | reset_iter(iter: &kdb_walk_kallsyms_iter, new_pos: 0); |
933 | } |
934 | while (1) { |
935 | if (!update_iter(iter: &kdb_walk_kallsyms_iter, pos: *pos)) |
936 | return NULL; |
937 | ++*pos; |
938 | /* Some debugging symbols have no name. Ignore them. */ |
939 | if (kdb_walk_kallsyms_iter.name[0]) |
940 | return kdb_walk_kallsyms_iter.name; |
941 | } |
942 | } |
943 | #endif /* CONFIG_KGDB_KDB */ |
944 | |
945 | static const struct proc_ops kallsyms_proc_ops = { |
946 | .proc_open = kallsyms_open, |
947 | .proc_read = seq_read, |
948 | .proc_lseek = seq_lseek, |
949 | .proc_release = seq_release_private, |
950 | }; |
951 | |
952 | static int __init kallsyms_init(void) |
953 | { |
954 | proc_create(name: "kallsyms" , mode: 0444, NULL, proc_ops: &kallsyms_proc_ops); |
955 | return 0; |
956 | } |
957 | device_initcall(kallsyms_init); |
958 | |