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