1457c8996SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * kallsyms.c: in-kernel printing of symbolic oopses and stack traces.
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Rewritten and vastly simplified by Rusty Russell for in-kernel
61da177e4SLinus Torvalds * module loader:
71da177e4SLinus Torvalds * Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
81da177e4SLinus Torvalds *
91da177e4SLinus Torvalds * ChangeLog:
101da177e4SLinus Torvalds *
111da177e4SLinus Torvalds * (25/Aug/2004) Paulo Marques <pmarques@grupopie.com>
121da177e4SLinus Torvalds * Changed the compression method from stem compression to "table lookup"
131da177e4SLinus Torvalds * compression (see scripts/kallsyms.c for a more complete description)
141da177e4SLinus Torvalds */
151da177e4SLinus Torvalds #include <linux/kallsyms.h>
161da177e4SLinus Torvalds #include <linux/init.h>
171da177e4SLinus Torvalds #include <linux/seq_file.h>
181da177e4SLinus Torvalds #include <linux/fs.h>
1967fc4e0cSJason Wessel #include <linux/kdb.h>
201da177e4SLinus Torvalds #include <linux/err.h>
211da177e4SLinus Torvalds #include <linux/proc_fs.h>
224e57b681STim Schmielau #include <linux/sched.h> /* for cond_resched */
2307354a00SAdam B. Jerome #include <linux/ctype.h>
245a0e3ad6STejun Heo #include <linux/slab.h>
2574451e66SDaniel Borkmann #include <linux/filter.h>
26aba4b5c2SSteven Rostedt (VMware) #include <linux/ftrace.h>
27d002b8bcSAdrian Hunter #include <linux/kprobes.h>
289294523eSStephen Boyd #include <linux/build_bug.h>
2952f5684cSGideon Israel Dsouza #include <linux/compiler.h>
309294523eSStephen Boyd #include <linux/module.h>
319294523eSStephen Boyd #include <linux/kernel.h>
32bed0d9a5SJiri Olsa #include <linux/bsearch.h>
33647cafa2SAlan Maguire #include <linux/btf_ids.h>
341da177e4SLinus Torvalds
3571f8c155SStephen Brennan #include "kallsyms_internal.h"
361da177e4SLinus Torvalds
37ad6ccfadSManish Katiyar /*
38ad6ccfadSManish Katiyar * Expand a compressed symbol data into the resulting uncompressed string,
39e3f26752SChen Gang * if uncompressed string is too long (>= maxlen), it will be truncated,
40ad6ccfadSManish Katiyar * given the offset to where the symbol is in the compressed stream.
41ad6ccfadSManish Katiyar */
kallsyms_expand_symbol(unsigned int off,char * result,size_t maxlen)42e3f26752SChen Gang static unsigned int kallsyms_expand_symbol(unsigned int off,
43e3f26752SChen Gang char *result, size_t maxlen)
441da177e4SLinus Torvalds {
451da177e4SLinus Torvalds int len, skipped_first = 0;
46cde26a6eSMasahiro Yamada const char *tptr;
47cde26a6eSMasahiro Yamada const u8 *data;
481da177e4SLinus Torvalds
49ad6ccfadSManish Katiyar /* Get the compressed symbol length from the first symbol byte. */
501da177e4SLinus Torvalds data = &kallsyms_names[off];
511da177e4SLinus Torvalds len = *data;
521da177e4SLinus Torvalds data++;
5373bbb944SMiguel Ojeda off++;
5473bbb944SMiguel Ojeda
5573bbb944SMiguel Ojeda /* If MSB is 1, it is a "big" symbol, so needs an additional byte. */
5673bbb944SMiguel Ojeda if ((len & 0x80) != 0) {
5773bbb944SMiguel Ojeda len = (len & 0x7F) | (*data << 7);
5873bbb944SMiguel Ojeda data++;
5973bbb944SMiguel Ojeda off++;
6073bbb944SMiguel Ojeda }
611da177e4SLinus Torvalds
62ad6ccfadSManish Katiyar /*
63ad6ccfadSManish Katiyar * Update the offset to return the offset for the next symbol on
64ad6ccfadSManish Katiyar * the compressed stream.
65ad6ccfadSManish Katiyar */
6673bbb944SMiguel Ojeda off += len;
671da177e4SLinus Torvalds
68ad6ccfadSManish Katiyar /*
69ad6ccfadSManish Katiyar * For every byte on the compressed symbol data, copy the table
70ad6ccfadSManish Katiyar * entry for that byte.
71ad6ccfadSManish Katiyar */
721da177e4SLinus Torvalds while (len) {
731da177e4SLinus Torvalds tptr = &kallsyms_token_table[kallsyms_token_index[*data]];
741da177e4SLinus Torvalds data++;
751da177e4SLinus Torvalds len--;
761da177e4SLinus Torvalds
771da177e4SLinus Torvalds while (*tptr) {
781da177e4SLinus Torvalds if (skipped_first) {
79e3f26752SChen Gang if (maxlen <= 1)
80e3f26752SChen Gang goto tail;
811da177e4SLinus Torvalds *result = *tptr;
821da177e4SLinus Torvalds result++;
83e3f26752SChen Gang maxlen--;
841da177e4SLinus Torvalds } else
851da177e4SLinus Torvalds skipped_first = 1;
861da177e4SLinus Torvalds tptr++;
871da177e4SLinus Torvalds }
881da177e4SLinus Torvalds }
891da177e4SLinus Torvalds
90e3f26752SChen Gang tail:
91e3f26752SChen Gang if (maxlen)
921da177e4SLinus Torvalds *result = '\0';
931da177e4SLinus Torvalds
94ad6ccfadSManish Katiyar /* Return to offset to the next symbol. */
951da177e4SLinus Torvalds return off;
961da177e4SLinus Torvalds }
971da177e4SLinus Torvalds
98ad6ccfadSManish Katiyar /*
99ad6ccfadSManish Katiyar * Get symbol type information. This is encoded as a single char at the
100ad6ccfadSManish Katiyar * beginning of the symbol name.
101ad6ccfadSManish Katiyar */
kallsyms_get_symbol_type(unsigned int off)1021da177e4SLinus Torvalds static char kallsyms_get_symbol_type(unsigned int off)
1031da177e4SLinus Torvalds {
104ad6ccfadSManish Katiyar /*
105ad6ccfadSManish Katiyar * Get just the first code, look it up in the token table,
106ad6ccfadSManish Katiyar * and return the first char from this token.
107ad6ccfadSManish Katiyar */
1081da177e4SLinus Torvalds return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]];
1091da177e4SLinus Torvalds }
1101da177e4SLinus Torvalds
1111da177e4SLinus Torvalds
112ad6ccfadSManish Katiyar /*
113ad6ccfadSManish Katiyar * Find the offset on the compressed stream given and index in the
114ad6ccfadSManish Katiyar * kallsyms array.
115ad6ccfadSManish Katiyar */
get_symbol_offset(unsigned long pos)1161da177e4SLinus Torvalds static unsigned int get_symbol_offset(unsigned long pos)
1171da177e4SLinus Torvalds {
118aad09470SJan Beulich const u8 *name;
11973bbb944SMiguel Ojeda int i, len;
1201da177e4SLinus Torvalds
121ad6ccfadSManish Katiyar /*
122ad6ccfadSManish Katiyar * Use the closest marker we have. We have markers every 256 positions,
123ad6ccfadSManish Katiyar * so that should be close enough.
124ad6ccfadSManish Katiyar */
1251da177e4SLinus Torvalds name = &kallsyms_names[kallsyms_markers[pos >> 8]];
1261da177e4SLinus Torvalds
127ad6ccfadSManish Katiyar /*
128ad6ccfadSManish Katiyar * Sequentially scan all the symbols up to the point we're searching
129ad6ccfadSManish Katiyar * for. Every symbol is stored in a [<len>][<len> bytes of data] format,
130ad6ccfadSManish Katiyar * so we just need to add the len to the current pointer for every
131ad6ccfadSManish Katiyar * symbol we wish to skip.
132ad6ccfadSManish Katiyar */
13373bbb944SMiguel Ojeda for (i = 0; i < (pos & 0xFF); i++) {
13473bbb944SMiguel Ojeda len = *name;
13573bbb944SMiguel Ojeda
13673bbb944SMiguel Ojeda /*
13773bbb944SMiguel Ojeda * If MSB is 1, it is a "big" symbol, so we need to look into
13873bbb944SMiguel Ojeda * the next byte (and skip it, too).
13973bbb944SMiguel Ojeda */
14073bbb944SMiguel Ojeda if ((len & 0x80) != 0)
14173bbb944SMiguel Ojeda len = ((len & 0x7F) | (name[1] << 7)) + 1;
14273bbb944SMiguel Ojeda
14373bbb944SMiguel Ojeda name = name + len + 1;
14473bbb944SMiguel Ojeda }
1451da177e4SLinus Torvalds
1461da177e4SLinus Torvalds return name - kallsyms_names;
1471da177e4SLinus Torvalds }
1481da177e4SLinus Torvalds
kallsyms_sym_address(int idx)14930f3bb09SZhen Lei unsigned long kallsyms_sym_address(int idx)
1502213e9a6SArd Biesheuvel {
1512213e9a6SArd Biesheuvel if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE))
1522213e9a6SArd Biesheuvel return kallsyms_addresses[idx];
1532213e9a6SArd Biesheuvel
1542213e9a6SArd Biesheuvel /* values are unsigned offsets if --absolute-percpu is not in effect */
1552213e9a6SArd Biesheuvel if (!IS_ENABLED(CONFIG_KALLSYMS_ABSOLUTE_PERCPU))
1562213e9a6SArd Biesheuvel return kallsyms_relative_base + (u32)kallsyms_offsets[idx];
1572213e9a6SArd Biesheuvel
1582213e9a6SArd Biesheuvel /* ...otherwise, positive offsets are absolute values */
1592213e9a6SArd Biesheuvel if (kallsyms_offsets[idx] >= 0)
1602213e9a6SArd Biesheuvel return kallsyms_offsets[idx];
1612213e9a6SArd Biesheuvel
1622213e9a6SArd Biesheuvel /* ...and negative offsets are relative to kallsyms_relative_base - 1 */
1632213e9a6SArd Biesheuvel return kallsyms_relative_base - 1 - kallsyms_offsets[idx];
1642213e9a6SArd Biesheuvel }
1652213e9a6SArd Biesheuvel
cleanup_symbol_name(char * s)166*76903a96SYonghong Song static void cleanup_symbol_name(char *s)
1678b8e6b5dSSami Tolvanen {
1688b8e6b5dSSami Tolvanen char *res;
1698b8e6b5dSSami Tolvanen
1706eb4bd92SNick Desaulniers if (!IS_ENABLED(CONFIG_LTO_CLANG))
171*76903a96SYonghong Song return;
1728b8e6b5dSSami Tolvanen
1736eb4bd92SNick Desaulniers /*
1746eb4bd92SNick Desaulniers * LLVM appends various suffixes for local functions and variables that
1756eb4bd92SNick Desaulniers * must be promoted to global scope as part of LTO. This can break
1766eb4bd92SNick Desaulniers * hooking of static functions with kprobes. '.' is not a valid
1778cc32a9bSYonghong Song * character in an identifier in C. Suffixes only in LLVM LTO observed:
1786eb4bd92SNick Desaulniers * - foo.llvm.[0-9a-f]+
1796eb4bd92SNick Desaulniers */
1808cc32a9bSYonghong Song res = strstr(s, ".llvm.");
181*76903a96SYonghong Song if (res)
1826eb4bd92SNick Desaulniers *res = '\0';
1836eb4bd92SNick Desaulniers
184*76903a96SYonghong Song return;
1856eb4bd92SNick Desaulniers }
1868b8e6b5dSSami Tolvanen
compare_symbol_name(const char * name,char * namebuf)18760443c88SZhen Lei static int compare_symbol_name(const char *name, char *namebuf)
18860443c88SZhen Lei {
18933f0467fSYonghong Song /* The kallsyms_seqs_of_names is sorted based on names after
19033f0467fSYonghong Song * cleanup_symbol_name() (see scripts/kallsyms.c) if clang lto is enabled.
19133f0467fSYonghong Song * To ensure correct bisection in kallsyms_lookup_names(), do
19233f0467fSYonghong Song * cleanup_symbol_name(namebuf) before comparing name and namebuf.
19333f0467fSYonghong Song */
19433f0467fSYonghong Song cleanup_symbol_name(namebuf);
19533f0467fSYonghong Song return strcmp(name, namebuf);
19660443c88SZhen Lei }
19760443c88SZhen Lei
get_symbol_seq(int index)19819bd8981SZhen Lei static unsigned int get_symbol_seq(int index)
19919bd8981SZhen Lei {
20019bd8981SZhen Lei unsigned int i, seq = 0;
20119bd8981SZhen Lei
20219bd8981SZhen Lei for (i = 0; i < 3; i++)
20319bd8981SZhen Lei seq = (seq << 8) | kallsyms_seqs_of_names[3 * index + i];
20419bd8981SZhen Lei
20519bd8981SZhen Lei return seq;
20619bd8981SZhen Lei }
20719bd8981SZhen Lei
kallsyms_lookup_names(const char * name,unsigned int * start,unsigned int * end)20860443c88SZhen Lei static int kallsyms_lookup_names(const char *name,
20960443c88SZhen Lei unsigned int *start,
21060443c88SZhen Lei unsigned int *end)
21160443c88SZhen Lei {
21260443c88SZhen Lei int ret;
21360443c88SZhen Lei int low, mid, high;
21460443c88SZhen Lei unsigned int seq, off;
21560443c88SZhen Lei char namebuf[KSYM_NAME_LEN];
21660443c88SZhen Lei
21760443c88SZhen Lei low = 0;
21860443c88SZhen Lei high = kallsyms_num_syms - 1;
21960443c88SZhen Lei
22060443c88SZhen Lei while (low <= high) {
22160443c88SZhen Lei mid = low + (high - low) / 2;
22219bd8981SZhen Lei seq = get_symbol_seq(mid);
22360443c88SZhen Lei off = get_symbol_offset(seq);
22460443c88SZhen Lei kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
22560443c88SZhen Lei ret = compare_symbol_name(name, namebuf);
22660443c88SZhen Lei if (ret > 0)
22760443c88SZhen Lei low = mid + 1;
22860443c88SZhen Lei else if (ret < 0)
22960443c88SZhen Lei high = mid - 1;
23060443c88SZhen Lei else
23160443c88SZhen Lei break;
23260443c88SZhen Lei }
23360443c88SZhen Lei
23460443c88SZhen Lei if (low > high)
23560443c88SZhen Lei return -ESRCH;
23660443c88SZhen Lei
23760443c88SZhen Lei low = mid;
23860443c88SZhen Lei while (low) {
23919bd8981SZhen Lei seq = get_symbol_seq(low - 1);
24060443c88SZhen Lei off = get_symbol_offset(seq);
24160443c88SZhen Lei kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
24260443c88SZhen Lei if (compare_symbol_name(name, namebuf))
24360443c88SZhen Lei break;
24460443c88SZhen Lei low--;
24560443c88SZhen Lei }
24660443c88SZhen Lei *start = low;
24760443c88SZhen Lei
24860443c88SZhen Lei if (end) {
24960443c88SZhen Lei high = mid;
25060443c88SZhen Lei while (high < kallsyms_num_syms - 1) {
25119bd8981SZhen Lei seq = get_symbol_seq(high + 1);
25260443c88SZhen Lei off = get_symbol_offset(seq);
25360443c88SZhen Lei kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
25460443c88SZhen Lei if (compare_symbol_name(name, namebuf))
25560443c88SZhen Lei break;
25660443c88SZhen Lei high++;
25760443c88SZhen Lei }
25860443c88SZhen Lei *end = high;
25960443c88SZhen Lei }
26060443c88SZhen Lei
26160443c88SZhen Lei return 0;
26260443c88SZhen Lei }
26360443c88SZhen Lei
2641da177e4SLinus Torvalds /* Lookup the address for this symbol. Returns 0 if not found. */
kallsyms_lookup_name(const char * name)2651da177e4SLinus Torvalds unsigned long kallsyms_lookup_name(const char *name)
2661da177e4SLinus Torvalds {
26760443c88SZhen Lei int ret;
26860443c88SZhen Lei unsigned int i;
2691da177e4SLinus Torvalds
270aecf489fSJiri Olsa /* Skip the search for empty string. */
271aecf489fSJiri Olsa if (!*name)
272aecf489fSJiri Olsa return 0;
273aecf489fSJiri Olsa
27460443c88SZhen Lei ret = kallsyms_lookup_names(name, &i, NULL);
27560443c88SZhen Lei if (!ret)
27619bd8981SZhen Lei return kallsyms_sym_address(get_symbol_seq(i));
2771da177e4SLinus Torvalds
2781da177e4SLinus Torvalds return module_kallsyms_lookup_name(name);
2791da177e4SLinus Torvalds }
2801da177e4SLinus Torvalds
281013c1667SChristoph Hellwig /*
282013c1667SChristoph Hellwig * Iterate over all symbols in vmlinux. For symbols from modules use
283013c1667SChristoph Hellwig * module_kallsyms_on_each_symbol instead.
284013c1667SChristoph Hellwig */
kallsyms_on_each_symbol(int (* fn)(void *,const char *,unsigned long),void * data)2853703bd54SZhen Lei int kallsyms_on_each_symbol(int (*fn)(void *, const char *, unsigned long),
28675a66614SAnders Kaseorg void *data)
28775a66614SAnders Kaseorg {
28875a66614SAnders Kaseorg char namebuf[KSYM_NAME_LEN];
28975a66614SAnders Kaseorg unsigned long i;
29075a66614SAnders Kaseorg unsigned int off;
29175a66614SAnders Kaseorg int ret;
29275a66614SAnders Kaseorg
29375a66614SAnders Kaseorg for (i = 0, off = 0; i < kallsyms_num_syms; i++) {
294e3f26752SChen Gang off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
2953703bd54SZhen Lei ret = fn(data, namebuf, kallsyms_sym_address(i));
29675a66614SAnders Kaseorg if (ret != 0)
29775a66614SAnders Kaseorg return ret;
298f5bdb34bSDavid Vernet cond_resched();
29975a66614SAnders Kaseorg }
300013c1667SChristoph Hellwig return 0;
30175a66614SAnders Kaseorg }
30275a66614SAnders Kaseorg
kallsyms_on_each_match_symbol(int (* fn)(void *,unsigned long),const char * name,void * data)3034dc533e0SZhen Lei int kallsyms_on_each_match_symbol(int (*fn)(void *, unsigned long),
3044dc533e0SZhen Lei const char *name, void *data)
3054dc533e0SZhen Lei {
3064dc533e0SZhen Lei int ret;
3074dc533e0SZhen Lei unsigned int i, start, end;
3084dc533e0SZhen Lei
3094dc533e0SZhen Lei ret = kallsyms_lookup_names(name, &start, &end);
3104dc533e0SZhen Lei if (ret)
3114dc533e0SZhen Lei return 0;
3124dc533e0SZhen Lei
3134dc533e0SZhen Lei for (i = start; !ret && i <= end; i++) {
3144dc533e0SZhen Lei ret = fn(data, kallsyms_sym_address(get_symbol_seq(i)));
3154dc533e0SZhen Lei cond_resched();
3164dc533e0SZhen Lei }
3174dc533e0SZhen Lei
3184dc533e0SZhen Lei return ret;
3194dc533e0SZhen Lei }
3204dc533e0SZhen Lei
get_symbol_pos(unsigned long addr,unsigned long * symbolsize,unsigned long * offset)321ffc50891SFranck Bui-Huu static unsigned long get_symbol_pos(unsigned long addr,
322ffc50891SFranck Bui-Huu unsigned long *symbolsize,
323ffc50891SFranck Bui-Huu unsigned long *offset)
324ffc50891SFranck Bui-Huu {
325ffc50891SFranck Bui-Huu unsigned long symbol_start = 0, symbol_end = 0;
326ffc50891SFranck Bui-Huu unsigned long i, low, high, mid;
327ffc50891SFranck Bui-Huu
3282ea03891SSam Ravnborg /* This kernel should never had been booted. */
3292213e9a6SArd Biesheuvel if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE))
3302ea03891SSam Ravnborg BUG_ON(!kallsyms_addresses);
3312213e9a6SArd Biesheuvel else
3322213e9a6SArd Biesheuvel BUG_ON(!kallsyms_offsets);
3332ea03891SSam Ravnborg
334ad6ccfadSManish Katiyar /* Do a binary search on the sorted kallsyms_addresses array. */
335ffc50891SFranck Bui-Huu low = 0;
336ffc50891SFranck Bui-Huu high = kallsyms_num_syms;
337ffc50891SFranck Bui-Huu
338ffc50891SFranck Bui-Huu while (high - low > 1) {
3392fc9c4e1SVegard Nossum mid = low + (high - low) / 2;
3402213e9a6SArd Biesheuvel if (kallsyms_sym_address(mid) <= addr)
341ffc50891SFranck Bui-Huu low = mid;
342ffc50891SFranck Bui-Huu else
343ffc50891SFranck Bui-Huu high = mid;
344ffc50891SFranck Bui-Huu }
345ffc50891SFranck Bui-Huu
346ffc50891SFranck Bui-Huu /*
347ad6ccfadSManish Katiyar * Search for the first aliased symbol. Aliased
348ad6ccfadSManish Katiyar * symbols are symbols with the same address.
349ffc50891SFranck Bui-Huu */
3502213e9a6SArd Biesheuvel while (low && kallsyms_sym_address(low-1) == kallsyms_sym_address(low))
351ffc50891SFranck Bui-Huu --low;
352ffc50891SFranck Bui-Huu
3532213e9a6SArd Biesheuvel symbol_start = kallsyms_sym_address(low);
354ffc50891SFranck Bui-Huu
355ad6ccfadSManish Katiyar /* Search for next non-aliased symbol. */
356ffc50891SFranck Bui-Huu for (i = low + 1; i < kallsyms_num_syms; i++) {
3572213e9a6SArd Biesheuvel if (kallsyms_sym_address(i) > symbol_start) {
3582213e9a6SArd Biesheuvel symbol_end = kallsyms_sym_address(i);
359ffc50891SFranck Bui-Huu break;
360ffc50891SFranck Bui-Huu }
361ffc50891SFranck Bui-Huu }
362ffc50891SFranck Bui-Huu
363ad6ccfadSManish Katiyar /* If we found no next symbol, we use the end of the section. */
364ffc50891SFranck Bui-Huu if (!symbol_end) {
365ffc50891SFranck Bui-Huu if (is_kernel_inittext(addr))
366ffc50891SFranck Bui-Huu symbol_end = (unsigned long)_einittext;
36763b23e2cSMasahiro Yamada else if (IS_ENABLED(CONFIG_KALLSYMS_ALL))
368ffc50891SFranck Bui-Huu symbol_end = (unsigned long)_end;
369ffc50891SFranck Bui-Huu else
370ffc50891SFranck Bui-Huu symbol_end = (unsigned long)_etext;
371ffc50891SFranck Bui-Huu }
372ffc50891SFranck Bui-Huu
373ffb45122SAlexey Dobriyan if (symbolsize)
374ffc50891SFranck Bui-Huu *symbolsize = symbol_end - symbol_start;
375ffb45122SAlexey Dobriyan if (offset)
376ffc50891SFranck Bui-Huu *offset = addr - symbol_start;
377ffc50891SFranck Bui-Huu
378ffc50891SFranck Bui-Huu return low;
379ffc50891SFranck Bui-Huu }
380ffc50891SFranck Bui-Huu
381ffc50891SFranck Bui-Huu /*
382ffc50891SFranck Bui-Huu * Lookup an address but don't bother to find any names.
383ffc50891SFranck Bui-Huu */
kallsyms_lookup_size_offset(unsigned long addr,unsigned long * symbolsize,unsigned long * offset)384ffc50891SFranck Bui-Huu int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize,
385ffc50891SFranck Bui-Huu unsigned long *offset)
386ffc50891SFranck Bui-Huu {
3876dd06c9fSRusty Russell char namebuf[KSYM_NAME_LEN];
38874451e66SDaniel Borkmann
3892a1a3fa0SMarc Zyngier if (is_ksym_addr(addr)) {
3902a1a3fa0SMarc Zyngier get_symbol_pos(addr, symbolsize, offset);
3912a1a3fa0SMarc Zyngier return 1;
3922a1a3fa0SMarc Zyngier }
3939294523eSStephen Boyd return !!module_address_lookup(addr, symbolsize, offset, NULL, NULL, namebuf) ||
39474451e66SDaniel Borkmann !!__bpf_address_lookup(addr, symbolsize, offset, namebuf);
395ffc50891SFranck Bui-Huu }
396ffc50891SFranck Bui-Huu
kallsyms_lookup_buildid(unsigned long addr,unsigned long * symbolsize,unsigned long * offset,char ** modname,const unsigned char ** modbuildid,char * namebuf)3979294523eSStephen Boyd static const char *kallsyms_lookup_buildid(unsigned long addr,
3981da177e4SLinus Torvalds unsigned long *symbolsize,
3999294523eSStephen Boyd unsigned long *offset, char **modname,
4009294523eSStephen Boyd const unsigned char **modbuildid, char *namebuf)
4011da177e4SLinus Torvalds {
40274451e66SDaniel Borkmann const char *ret;
40374451e66SDaniel Borkmann
4049281aceaSTejun Heo namebuf[KSYM_NAME_LEN - 1] = 0;
4051da177e4SLinus Torvalds namebuf[0] = 0;
4061da177e4SLinus Torvalds
407ffc50891SFranck Bui-Huu if (is_ksym_addr(addr)) {
408ffc50891SFranck Bui-Huu unsigned long pos;
4091da177e4SLinus Torvalds
410ffc50891SFranck Bui-Huu pos = get_symbol_pos(addr, symbolsize, offset);
4111da177e4SLinus Torvalds /* Grab name */
412e3f26752SChen Gang kallsyms_expand_symbol(get_symbol_offset(pos),
413e3f26752SChen Gang namebuf, KSYM_NAME_LEN);
4147a74fc49SKyle McMartin if (modname)
4151da177e4SLinus Torvalds *modname = NULL;
4169294523eSStephen Boyd if (modbuildid)
4179294523eSStephen Boyd *modbuildid = NULL;
4188b8e6b5dSSami Tolvanen
4198b8e6b5dSSami Tolvanen ret = namebuf;
4208b8e6b5dSSami Tolvanen goto found;
4211da177e4SLinus Torvalds }
4221da177e4SLinus Torvalds
42374451e66SDaniel Borkmann /* See if it's in a module or a BPF JITed image. */
42474451e66SDaniel Borkmann ret = module_address_lookup(addr, symbolsize, offset,
4259294523eSStephen Boyd modname, modbuildid, namebuf);
42674451e66SDaniel Borkmann if (!ret)
42774451e66SDaniel Borkmann ret = bpf_address_lookup(addr, symbolsize,
42874451e66SDaniel Borkmann offset, modname, namebuf);
429aba4b5c2SSteven Rostedt (VMware)
430aba4b5c2SSteven Rostedt (VMware) if (!ret)
431aba4b5c2SSteven Rostedt (VMware) ret = ftrace_mod_address_lookup(addr, symbolsize,
432aba4b5c2SSteven Rostedt (VMware) offset, modname, namebuf);
4338b8e6b5dSSami Tolvanen
4348b8e6b5dSSami Tolvanen found:
4358b8e6b5dSSami Tolvanen cleanup_symbol_name(namebuf);
43674451e66SDaniel Borkmann return ret;
4371da177e4SLinus Torvalds }
4381da177e4SLinus Torvalds
4399294523eSStephen Boyd /*
4409294523eSStephen Boyd * Lookup an address
4419294523eSStephen Boyd * - modname is set to NULL if it's in the kernel.
4429294523eSStephen Boyd * - We guarantee that the returned name is valid until we reschedule even if.
4439294523eSStephen Boyd * It resides in a module.
4449294523eSStephen Boyd * - We also guarantee that modname will be valid until rescheduled.
4459294523eSStephen Boyd */
kallsyms_lookup(unsigned long addr,unsigned long * symbolsize,unsigned long * offset,char ** modname,char * namebuf)4469294523eSStephen Boyd const char *kallsyms_lookup(unsigned long addr,
4479294523eSStephen Boyd unsigned long *symbolsize,
4489294523eSStephen Boyd unsigned long *offset,
4499294523eSStephen Boyd char **modname, char *namebuf)
4509294523eSStephen Boyd {
4519294523eSStephen Boyd return kallsyms_lookup_buildid(addr, symbolsize, offset, modname,
4529294523eSStephen Boyd NULL, namebuf);
4539294523eSStephen Boyd }
4549294523eSStephen Boyd
lookup_symbol_name(unsigned long addr,char * symname)4559d65cb4aSAlexey Dobriyan int lookup_symbol_name(unsigned long addr, char *symname)
4569d65cb4aSAlexey Dobriyan {
4578b8e6b5dSSami Tolvanen int res;
4588b8e6b5dSSami Tolvanen
4599d65cb4aSAlexey Dobriyan symname[0] = '\0';
4609281aceaSTejun Heo symname[KSYM_NAME_LEN - 1] = '\0';
4619d65cb4aSAlexey Dobriyan
4629d65cb4aSAlexey Dobriyan if (is_ksym_addr(addr)) {
4639d65cb4aSAlexey Dobriyan unsigned long pos;
4649d65cb4aSAlexey Dobriyan
4659d65cb4aSAlexey Dobriyan pos = get_symbol_pos(addr, NULL, NULL);
4669d65cb4aSAlexey Dobriyan /* Grab name */
467e3f26752SChen Gang kallsyms_expand_symbol(get_symbol_offset(pos),
468e3f26752SChen Gang symname, KSYM_NAME_LEN);
4698b8e6b5dSSami Tolvanen goto found;
4709d65cb4aSAlexey Dobriyan }
471ad6ccfadSManish Katiyar /* See if it's in a module. */
4728b8e6b5dSSami Tolvanen res = lookup_module_symbol_name(addr, symname);
4738b8e6b5dSSami Tolvanen if (res)
4748b8e6b5dSSami Tolvanen return res;
4758b8e6b5dSSami Tolvanen
4768b8e6b5dSSami Tolvanen found:
4778b8e6b5dSSami Tolvanen cleanup_symbol_name(symname);
4788b8e6b5dSSami Tolvanen return 0;
4799d65cb4aSAlexey Dobriyan }
4809d65cb4aSAlexey Dobriyan
48142e38083SRobert Peterson /* Look up a kernel symbol and return it in a text buffer. */
__sprint_symbol(char * buffer,unsigned long address,int symbol_offset,int add_offset,int add_buildid)4820f77a8d3SNamhyung Kim static int __sprint_symbol(char *buffer, unsigned long address,
4839294523eSStephen Boyd int symbol_offset, int add_offset, int add_buildid)
4841da177e4SLinus Torvalds {
4851da177e4SLinus Torvalds char *modname;
4869294523eSStephen Boyd const unsigned char *buildid;
4871da177e4SLinus Torvalds const char *name;
4881da177e4SLinus Torvalds unsigned long offset, size;
489966c8c12SHugh Dickins int len;
4901da177e4SLinus Torvalds
4910f77a8d3SNamhyung Kim address += symbol_offset;
4929294523eSStephen Boyd name = kallsyms_lookup_buildid(address, &size, &offset, &modname, &buildid,
4939294523eSStephen Boyd buffer);
4941da177e4SLinus Torvalds if (!name)
495b86280aaSNamhyung Kim return sprintf(buffer, "0x%lx", address - symbol_offset);
49619769b76SAndrew Morton
497966c8c12SHugh Dickins if (name != buffer)
498966c8c12SHugh Dickins strcpy(buffer, name);
499966c8c12SHugh Dickins len = strlen(buffer);
5000f77a8d3SNamhyung Kim offset -= symbol_offset;
501966c8c12SHugh Dickins
5024796dd20SStephen Boyd if (add_offset)
5034796dd20SStephen Boyd len += sprintf(buffer + len, "+%#lx/%#lx", offset, size);
5044796dd20SStephen Boyd
5059294523eSStephen Boyd if (modname) {
5069294523eSStephen Boyd len += sprintf(buffer + len, " [%s", modname);
5079294523eSStephen Boyd #if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID)
5089294523eSStephen Boyd if (add_buildid && buildid) {
5099294523eSStephen Boyd /* build ID should match length of sprintf */
5109294523eSStephen Boyd #if IS_ENABLED(CONFIG_MODULES)
5119294523eSStephen Boyd static_assert(sizeof(typeof_member(struct module, build_id)) == 20);
5129294523eSStephen Boyd #endif
5139294523eSStephen Boyd len += sprintf(buffer + len, " %20phN", buildid);
5149294523eSStephen Boyd }
5159294523eSStephen Boyd #endif
5169294523eSStephen Boyd len += sprintf(buffer + len, "]");
5179294523eSStephen Boyd }
518966c8c12SHugh Dickins
519966c8c12SHugh Dickins return len;
5201da177e4SLinus Torvalds }
5210f77a8d3SNamhyung Kim
5220f77a8d3SNamhyung Kim /**
5230f77a8d3SNamhyung Kim * sprint_symbol - Look up a kernel symbol and return it in a text buffer
5240f77a8d3SNamhyung Kim * @buffer: buffer to be stored
5250f77a8d3SNamhyung Kim * @address: address to lookup
5260f77a8d3SNamhyung Kim *
5270f77a8d3SNamhyung Kim * This function looks up a kernel symbol with @address and stores its name,
5280f77a8d3SNamhyung Kim * offset, size and module name to @buffer if possible. If no symbol was found,
5290f77a8d3SNamhyung Kim * just saves its @address as is.
5300f77a8d3SNamhyung Kim *
5310f77a8d3SNamhyung Kim * This function returns the number of bytes stored in @buffer.
5320f77a8d3SNamhyung Kim */
sprint_symbol(char * buffer,unsigned long address)5330f77a8d3SNamhyung Kim int sprint_symbol(char *buffer, unsigned long address)
5340f77a8d3SNamhyung Kim {
5359294523eSStephen Boyd return __sprint_symbol(buffer, address, 0, 1, 0);
5360f77a8d3SNamhyung Kim }
537ad6ccfadSManish Katiyar EXPORT_SYMBOL_GPL(sprint_symbol);
53842e38083SRobert Peterson
5390f77a8d3SNamhyung Kim /**
5409294523eSStephen Boyd * sprint_symbol_build_id - Look up a kernel symbol and return it in a text buffer
5419294523eSStephen Boyd * @buffer: buffer to be stored
5429294523eSStephen Boyd * @address: address to lookup
5439294523eSStephen Boyd *
5449294523eSStephen Boyd * This function looks up a kernel symbol with @address and stores its name,
5459294523eSStephen Boyd * offset, size, module name and module build ID to @buffer if possible. If no
5469294523eSStephen Boyd * symbol was found, just saves its @address as is.
5479294523eSStephen Boyd *
5489294523eSStephen Boyd * This function returns the number of bytes stored in @buffer.
5499294523eSStephen Boyd */
sprint_symbol_build_id(char * buffer,unsigned long address)5509294523eSStephen Boyd int sprint_symbol_build_id(char *buffer, unsigned long address)
5519294523eSStephen Boyd {
5529294523eSStephen Boyd return __sprint_symbol(buffer, address, 0, 1, 1);
5539294523eSStephen Boyd }
5549294523eSStephen Boyd EXPORT_SYMBOL_GPL(sprint_symbol_build_id);
5559294523eSStephen Boyd
5569294523eSStephen Boyd /**
5574796dd20SStephen Boyd * sprint_symbol_no_offset - Look up a kernel symbol and return it in a text buffer
5584796dd20SStephen Boyd * @buffer: buffer to be stored
5594796dd20SStephen Boyd * @address: address to lookup
5604796dd20SStephen Boyd *
5614796dd20SStephen Boyd * This function looks up a kernel symbol with @address and stores its name
5624796dd20SStephen Boyd * and module name to @buffer if possible. If no symbol was found, just saves
5634796dd20SStephen Boyd * its @address as is.
5644796dd20SStephen Boyd *
5654796dd20SStephen Boyd * This function returns the number of bytes stored in @buffer.
5664796dd20SStephen Boyd */
sprint_symbol_no_offset(char * buffer,unsigned long address)5674796dd20SStephen Boyd int sprint_symbol_no_offset(char *buffer, unsigned long address)
5684796dd20SStephen Boyd {
5699294523eSStephen Boyd return __sprint_symbol(buffer, address, 0, 0, 0);
5704796dd20SStephen Boyd }
5714796dd20SStephen Boyd EXPORT_SYMBOL_GPL(sprint_symbol_no_offset);
5724796dd20SStephen Boyd
5734796dd20SStephen Boyd /**
5740f77a8d3SNamhyung Kim * sprint_backtrace - Look up a backtrace symbol and return it in a text buffer
5750f77a8d3SNamhyung Kim * @buffer: buffer to be stored
5760f77a8d3SNamhyung Kim * @address: address to lookup
5770f77a8d3SNamhyung Kim *
5780f77a8d3SNamhyung Kim * This function is for stack backtrace and does the same thing as
5790f77a8d3SNamhyung Kim * sprint_symbol() but with modified/decreased @address. If there is a
5800f77a8d3SNamhyung Kim * tail-call to the function marked "noreturn", gcc optimized out code after
5810f77a8d3SNamhyung Kim * the call so that the stack-saved return address could point outside of the
5820f77a8d3SNamhyung Kim * caller. This function ensures that kallsyms will find the original caller
5830f77a8d3SNamhyung Kim * by decreasing @address.
5840f77a8d3SNamhyung Kim *
5850f77a8d3SNamhyung Kim * This function returns the number of bytes stored in @buffer.
5860f77a8d3SNamhyung Kim */
sprint_backtrace(char * buffer,unsigned long address)5870f77a8d3SNamhyung Kim int sprint_backtrace(char *buffer, unsigned long address)
5880f77a8d3SNamhyung Kim {
5899294523eSStephen Boyd return __sprint_symbol(buffer, address, -1, 1, 0);
5909294523eSStephen Boyd }
5919294523eSStephen Boyd
5929294523eSStephen Boyd /**
5939294523eSStephen Boyd * sprint_backtrace_build_id - Look up a backtrace symbol and return it in a text buffer
5949294523eSStephen Boyd * @buffer: buffer to be stored
5959294523eSStephen Boyd * @address: address to lookup
5969294523eSStephen Boyd *
5979294523eSStephen Boyd * This function is for stack backtrace and does the same thing as
5989294523eSStephen Boyd * sprint_symbol() but with modified/decreased @address. If there is a
5999294523eSStephen Boyd * tail-call to the function marked "noreturn", gcc optimized out code after
6009294523eSStephen Boyd * the call so that the stack-saved return address could point outside of the
6019294523eSStephen Boyd * caller. This function ensures that kallsyms will find the original caller
6029294523eSStephen Boyd * by decreasing @address. This function also appends the module build ID to
6039294523eSStephen Boyd * the @buffer if @address is within a kernel module.
6049294523eSStephen Boyd *
6059294523eSStephen Boyd * This function returns the number of bytes stored in @buffer.
6069294523eSStephen Boyd */
sprint_backtrace_build_id(char * buffer,unsigned long address)6079294523eSStephen Boyd int sprint_backtrace_build_id(char *buffer, unsigned long address)
6089294523eSStephen Boyd {
6099294523eSStephen Boyd return __sprint_symbol(buffer, address, -1, 1, 1);
6100f77a8d3SNamhyung Kim }
6110f77a8d3SNamhyung Kim
6121da177e4SLinus Torvalds /* To avoid using get_symbol_offset for every symbol, we carry prefix along. */
613ad6ccfadSManish Katiyar struct kallsym_iter {
6141da177e4SLinus Torvalds loff_t pos;
61574451e66SDaniel Borkmann loff_t pos_mod_end;
6166171a031SSteven Rostedt (VMware) loff_t pos_ftrace_mod_end;
617d002b8bcSAdrian Hunter loff_t pos_bpf_end;
6181da177e4SLinus Torvalds unsigned long value;
619ad6ccfadSManish Katiyar unsigned int nameoff; /* If iterating in core kernel symbols. */
6201da177e4SLinus Torvalds char type;
6219281aceaSTejun Heo char name[KSYM_NAME_LEN];
6229281aceaSTejun Heo char module_name[MODULE_NAME_LEN];
623ea07890aSAlexey Dobriyan int exported;
624c0f3ea15SLinus Torvalds int show_value;
6251da177e4SLinus Torvalds };
6261da177e4SLinus Torvalds
get_ksymbol_mod(struct kallsym_iter * iter)6271da177e4SLinus Torvalds static int get_ksymbol_mod(struct kallsym_iter *iter)
6281da177e4SLinus Torvalds {
62915d5daa0SArnd Bergmann int ret = module_get_kallsym(iter->pos - kallsyms_num_syms,
63074451e66SDaniel Borkmann &iter->value, &iter->type,
63174451e66SDaniel Borkmann iter->name, iter->module_name,
63274451e66SDaniel Borkmann &iter->exported);
63374451e66SDaniel Borkmann if (ret < 0) {
63474451e66SDaniel Borkmann iter->pos_mod_end = iter->pos;
6351da177e4SLinus Torvalds return 0;
63674451e66SDaniel Borkmann }
63774451e66SDaniel Borkmann
6381da177e4SLinus Torvalds return 1;
6391da177e4SLinus Torvalds }
6401da177e4SLinus Torvalds
641fc0ea795SAdrian Hunter /*
642fc0ea795SAdrian Hunter * ftrace_mod_get_kallsym() may also get symbols for pages allocated for ftrace
643fc0ea795SAdrian Hunter * purposes. In that case "__builtin__ftrace" is used as a module name, even
644fc0ea795SAdrian Hunter * though "__builtin__ftrace" is not a module.
645fc0ea795SAdrian Hunter */
get_ksymbol_ftrace_mod(struct kallsym_iter * iter)6466171a031SSteven Rostedt (VMware) static int get_ksymbol_ftrace_mod(struct kallsym_iter *iter)
6476171a031SSteven Rostedt (VMware) {
6486171a031SSteven Rostedt (VMware) int ret = ftrace_mod_get_kallsym(iter->pos - iter->pos_mod_end,
6496171a031SSteven Rostedt (VMware) &iter->value, &iter->type,
6506171a031SSteven Rostedt (VMware) iter->name, iter->module_name,
6516171a031SSteven Rostedt (VMware) &iter->exported);
6526171a031SSteven Rostedt (VMware) if (ret < 0) {
6536171a031SSteven Rostedt (VMware) iter->pos_ftrace_mod_end = iter->pos;
6546171a031SSteven Rostedt (VMware) return 0;
6556171a031SSteven Rostedt (VMware) }
6566171a031SSteven Rostedt (VMware)
6576171a031SSteven Rostedt (VMware) return 1;
6586171a031SSteven Rostedt (VMware) }
6596171a031SSteven Rostedt (VMware)
get_ksymbol_bpf(struct kallsym_iter * iter)66074451e66SDaniel Borkmann static int get_ksymbol_bpf(struct kallsym_iter *iter)
66174451e66SDaniel Borkmann {
662d002b8bcSAdrian Hunter int ret;
663d002b8bcSAdrian Hunter
66433457938SAzeem Shaikh strscpy(iter->module_name, "bpf", MODULE_NAME_LEN);
66574451e66SDaniel Borkmann iter->exported = 0;
666d002b8bcSAdrian Hunter ret = bpf_get_kallsym(iter->pos - iter->pos_ftrace_mod_end,
667d002b8bcSAdrian Hunter &iter->value, &iter->type,
668d002b8bcSAdrian Hunter iter->name);
669d002b8bcSAdrian Hunter if (ret < 0) {
670d002b8bcSAdrian Hunter iter->pos_bpf_end = iter->pos;
671d002b8bcSAdrian Hunter return 0;
672d002b8bcSAdrian Hunter }
673d002b8bcSAdrian Hunter
674d002b8bcSAdrian Hunter return 1;
675d002b8bcSAdrian Hunter }
676d002b8bcSAdrian Hunter
677d002b8bcSAdrian Hunter /*
678d002b8bcSAdrian Hunter * This uses "__builtin__kprobes" as a module name for symbols for pages
679d002b8bcSAdrian Hunter * allocated for kprobes' purposes, even though "__builtin__kprobes" is not a
680d002b8bcSAdrian Hunter * module.
681d002b8bcSAdrian Hunter */
get_ksymbol_kprobe(struct kallsym_iter * iter)682d002b8bcSAdrian Hunter static int get_ksymbol_kprobe(struct kallsym_iter *iter)
683d002b8bcSAdrian Hunter {
68433457938SAzeem Shaikh strscpy(iter->module_name, "__builtin__kprobes", MODULE_NAME_LEN);
685d002b8bcSAdrian Hunter iter->exported = 0;
686d002b8bcSAdrian Hunter return kprobe_get_kallsym(iter->pos - iter->pos_bpf_end,
68774451e66SDaniel Borkmann &iter->value, &iter->type,
68874451e66SDaniel Borkmann iter->name) < 0 ? 0 : 1;
68974451e66SDaniel Borkmann }
69074451e66SDaniel Borkmann
6911da177e4SLinus Torvalds /* Returns space to next name. */
get_ksymbol_core(struct kallsym_iter * iter)6921da177e4SLinus Torvalds static unsigned long get_ksymbol_core(struct kallsym_iter *iter)
6931da177e4SLinus Torvalds {
6941da177e4SLinus Torvalds unsigned off = iter->nameoff;
6951da177e4SLinus Torvalds
696ea07890aSAlexey Dobriyan iter->module_name[0] = '\0';
6972213e9a6SArd Biesheuvel iter->value = kallsyms_sym_address(iter->pos);
6981da177e4SLinus Torvalds
6991da177e4SLinus Torvalds iter->type = kallsyms_get_symbol_type(off);
7001da177e4SLinus Torvalds
701e3f26752SChen Gang off = kallsyms_expand_symbol(off, iter->name, ARRAY_SIZE(iter->name));
7021da177e4SLinus Torvalds
7031da177e4SLinus Torvalds return off - iter->nameoff;
7041da177e4SLinus Torvalds }
7051da177e4SLinus Torvalds
reset_iter(struct kallsym_iter * iter,loff_t new_pos)7061da177e4SLinus Torvalds static void reset_iter(struct kallsym_iter *iter, loff_t new_pos)
7071da177e4SLinus Torvalds {
7081da177e4SLinus Torvalds iter->name[0] = '\0';
7091da177e4SLinus Torvalds iter->nameoff = get_symbol_offset(new_pos);
7101da177e4SLinus Torvalds iter->pos = new_pos;
7116171a031SSteven Rostedt (VMware) if (new_pos == 0) {
71274451e66SDaniel Borkmann iter->pos_mod_end = 0;
7136171a031SSteven Rostedt (VMware) iter->pos_ftrace_mod_end = 0;
714d002b8bcSAdrian Hunter iter->pos_bpf_end = 0;
7156171a031SSteven Rostedt (VMware) }
71674451e66SDaniel Borkmann }
71774451e66SDaniel Borkmann
718b9667942SAdrian Hunter /*
719b9667942SAdrian Hunter * The end position (last + 1) of each additional kallsyms section is recorded
720b9667942SAdrian Hunter * in iter->pos_..._end as each section is added, and so can be used to
721b9667942SAdrian Hunter * determine which get_ksymbol_...() function to call next.
722b9667942SAdrian Hunter */
update_iter_mod(struct kallsym_iter * iter,loff_t pos)72374451e66SDaniel Borkmann static int update_iter_mod(struct kallsym_iter *iter, loff_t pos)
72474451e66SDaniel Borkmann {
72574451e66SDaniel Borkmann iter->pos = pos;
72674451e66SDaniel Borkmann
727b9667942SAdrian Hunter if ((!iter->pos_mod_end || iter->pos_mod_end > pos) &&
728b9667942SAdrian Hunter get_ksymbol_mod(iter))
7296171a031SSteven Rostedt (VMware) return 1;
7306171a031SSteven Rostedt (VMware)
731b9667942SAdrian Hunter if ((!iter->pos_ftrace_mod_end || iter->pos_ftrace_mod_end > pos) &&
732b9667942SAdrian Hunter get_ksymbol_ftrace_mod(iter))
73374451e66SDaniel Borkmann return 1;
734b9667942SAdrian Hunter
735d002b8bcSAdrian Hunter if ((!iter->pos_bpf_end || iter->pos_bpf_end > pos) &&
736d002b8bcSAdrian Hunter get_ksymbol_bpf(iter))
737d002b8bcSAdrian Hunter return 1;
738d002b8bcSAdrian Hunter
739d002b8bcSAdrian Hunter return get_ksymbol_kprobe(iter);
7401da177e4SLinus Torvalds }
7411da177e4SLinus Torvalds
7421da177e4SLinus Torvalds /* Returns false if pos at or past end of file. */
update_iter(struct kallsym_iter * iter,loff_t pos)7431da177e4SLinus Torvalds static int update_iter(struct kallsym_iter *iter, loff_t pos)
7441da177e4SLinus Torvalds {
7451da177e4SLinus Torvalds /* Module symbols can be accessed randomly. */
74674451e66SDaniel Borkmann if (pos >= kallsyms_num_syms)
74774451e66SDaniel Borkmann return update_iter_mod(iter, pos);
7481da177e4SLinus Torvalds
7491da177e4SLinus Torvalds /* If we're not on the desired position, reset to new position. */
7501da177e4SLinus Torvalds if (pos != iter->pos)
7511da177e4SLinus Torvalds reset_iter(iter, pos);
7521da177e4SLinus Torvalds
7531da177e4SLinus Torvalds iter->nameoff += get_ksymbol_core(iter);
7541da177e4SLinus Torvalds iter->pos++;
7551da177e4SLinus Torvalds
7561da177e4SLinus Torvalds return 1;
7571da177e4SLinus Torvalds }
7581da177e4SLinus Torvalds
s_next(struct seq_file * m,void * p,loff_t * pos)7591da177e4SLinus Torvalds static void *s_next(struct seq_file *m, void *p, loff_t *pos)
7601da177e4SLinus Torvalds {
7611da177e4SLinus Torvalds (*pos)++;
7621da177e4SLinus Torvalds
7631da177e4SLinus Torvalds if (!update_iter(m->private, *pos))
7641da177e4SLinus Torvalds return NULL;
7651da177e4SLinus Torvalds return p;
7661da177e4SLinus Torvalds }
7671da177e4SLinus Torvalds
s_start(struct seq_file * m,loff_t * pos)7681da177e4SLinus Torvalds static void *s_start(struct seq_file *m, loff_t *pos)
7691da177e4SLinus Torvalds {
7701da177e4SLinus Torvalds if (!update_iter(m->private, *pos))
7711da177e4SLinus Torvalds return NULL;
7721da177e4SLinus Torvalds return m->private;
7731da177e4SLinus Torvalds }
7741da177e4SLinus Torvalds
s_stop(struct seq_file * m,void * p)7751da177e4SLinus Torvalds static void s_stop(struct seq_file *m, void *p)
7761da177e4SLinus Torvalds {
7771da177e4SLinus Torvalds }
7781da177e4SLinus Torvalds
s_show(struct seq_file * m,void * p)7791da177e4SLinus Torvalds static int s_show(struct seq_file *m, void *p)
7801da177e4SLinus Torvalds {
781668533dcSLinus Torvalds void *value;
7821da177e4SLinus Torvalds struct kallsym_iter *iter = m->private;
7831da177e4SLinus Torvalds
7841da177e4SLinus Torvalds /* Some debugging symbols have no name. Ignore them. */
7851da177e4SLinus Torvalds if (!iter->name[0])
7861da177e4SLinus Torvalds return 0;
7871da177e4SLinus Torvalds
788668533dcSLinus Torvalds value = iter->show_value ? (void *)iter->value : NULL;
789c0f3ea15SLinus Torvalds
790ea07890aSAlexey Dobriyan if (iter->module_name[0]) {
791ea07890aSAlexey Dobriyan char type;
792ea07890aSAlexey Dobriyan
793ad6ccfadSManish Katiyar /*
794ad6ccfadSManish Katiyar * Label it "global" if it is exported,
795ad6ccfadSManish Katiyar * "local" if not exported.
796ad6ccfadSManish Katiyar */
797ea07890aSAlexey Dobriyan type = iter->exported ? toupper(iter->type) :
798ea07890aSAlexey Dobriyan tolower(iter->type);
799668533dcSLinus Torvalds seq_printf(m, "%px %c %s\t[%s]\n", value,
8009f36e2c4SKees Cook type, iter->name, iter->module_name);
801ea07890aSAlexey Dobriyan } else
802668533dcSLinus Torvalds seq_printf(m, "%px %c %s\n", value,
8039f36e2c4SKees Cook iter->type, iter->name);
8041da177e4SLinus Torvalds return 0;
8051da177e4SLinus Torvalds }
8061da177e4SLinus Torvalds
80715ad7cdcSHelge Deller static const struct seq_operations kallsyms_op = {
8081da177e4SLinus Torvalds .start = s_start,
8091da177e4SLinus Torvalds .next = s_next,
8101da177e4SLinus Torvalds .stop = s_stop,
8111da177e4SLinus Torvalds .show = s_show
8121da177e4SLinus Torvalds };
8131da177e4SLinus Torvalds
814647cafa2SAlan Maguire #ifdef CONFIG_BPF_SYSCALL
815647cafa2SAlan Maguire
816647cafa2SAlan Maguire struct bpf_iter__ksym {
817647cafa2SAlan Maguire __bpf_md_ptr(struct bpf_iter_meta *, meta);
818647cafa2SAlan Maguire __bpf_md_ptr(struct kallsym_iter *, ksym);
819647cafa2SAlan Maguire };
820647cafa2SAlan Maguire
ksym_prog_seq_show(struct seq_file * m,bool in_stop)821647cafa2SAlan Maguire static int ksym_prog_seq_show(struct seq_file *m, bool in_stop)
822647cafa2SAlan Maguire {
823647cafa2SAlan Maguire struct bpf_iter__ksym ctx;
824647cafa2SAlan Maguire struct bpf_iter_meta meta;
825647cafa2SAlan Maguire struct bpf_prog *prog;
826647cafa2SAlan Maguire
827647cafa2SAlan Maguire meta.seq = m;
828647cafa2SAlan Maguire prog = bpf_iter_get_info(&meta, in_stop);
829647cafa2SAlan Maguire if (!prog)
830647cafa2SAlan Maguire return 0;
831647cafa2SAlan Maguire
832647cafa2SAlan Maguire ctx.meta = &meta;
833647cafa2SAlan Maguire ctx.ksym = m ? m->private : NULL;
834647cafa2SAlan Maguire return bpf_iter_run_prog(prog, &ctx);
835647cafa2SAlan Maguire }
836647cafa2SAlan Maguire
bpf_iter_ksym_seq_show(struct seq_file * m,void * p)837647cafa2SAlan Maguire static int bpf_iter_ksym_seq_show(struct seq_file *m, void *p)
838647cafa2SAlan Maguire {
839647cafa2SAlan Maguire return ksym_prog_seq_show(m, false);
840647cafa2SAlan Maguire }
841647cafa2SAlan Maguire
bpf_iter_ksym_seq_stop(struct seq_file * m,void * p)842647cafa2SAlan Maguire static void bpf_iter_ksym_seq_stop(struct seq_file *m, void *p)
843647cafa2SAlan Maguire {
844647cafa2SAlan Maguire if (!p)
845647cafa2SAlan Maguire (void) ksym_prog_seq_show(m, true);
846647cafa2SAlan Maguire else
847647cafa2SAlan Maguire s_stop(m, p);
848647cafa2SAlan Maguire }
849647cafa2SAlan Maguire
850647cafa2SAlan Maguire static const struct seq_operations bpf_iter_ksym_ops = {
851647cafa2SAlan Maguire .start = s_start,
852647cafa2SAlan Maguire .next = s_next,
853647cafa2SAlan Maguire .stop = bpf_iter_ksym_seq_stop,
854647cafa2SAlan Maguire .show = bpf_iter_ksym_seq_show,
855647cafa2SAlan Maguire };
856647cafa2SAlan Maguire
bpf_iter_ksym_init(void * priv_data,struct bpf_iter_aux_info * aux)857647cafa2SAlan Maguire static int bpf_iter_ksym_init(void *priv_data, struct bpf_iter_aux_info *aux)
858647cafa2SAlan Maguire {
859647cafa2SAlan Maguire struct kallsym_iter *iter = priv_data;
860647cafa2SAlan Maguire
861647cafa2SAlan Maguire reset_iter(iter, 0);
862647cafa2SAlan Maguire
863647cafa2SAlan Maguire /* cache here as in kallsyms_open() case; use current process
864647cafa2SAlan Maguire * credentials to tell BPF iterators if values should be shown.
865647cafa2SAlan Maguire */
866647cafa2SAlan Maguire iter->show_value = kallsyms_show_value(current_cred());
867647cafa2SAlan Maguire
868647cafa2SAlan Maguire return 0;
869647cafa2SAlan Maguire }
870647cafa2SAlan Maguire
871647cafa2SAlan Maguire DEFINE_BPF_ITER_FUNC(ksym, struct bpf_iter_meta *meta, struct kallsym_iter *ksym)
872647cafa2SAlan Maguire
873647cafa2SAlan Maguire static const struct bpf_iter_seq_info ksym_iter_seq_info = {
874647cafa2SAlan Maguire .seq_ops = &bpf_iter_ksym_ops,
875647cafa2SAlan Maguire .init_seq_private = bpf_iter_ksym_init,
876647cafa2SAlan Maguire .fini_seq_private = NULL,
877647cafa2SAlan Maguire .seq_priv_size = sizeof(struct kallsym_iter),
878647cafa2SAlan Maguire };
879647cafa2SAlan Maguire
880647cafa2SAlan Maguire static struct bpf_iter_reg ksym_iter_reg_info = {
881647cafa2SAlan Maguire .target = "ksym",
882647cafa2SAlan Maguire .feature = BPF_ITER_RESCHED,
883647cafa2SAlan Maguire .ctx_arg_info_size = 1,
884647cafa2SAlan Maguire .ctx_arg_info = {
885647cafa2SAlan Maguire { offsetof(struct bpf_iter__ksym, ksym),
886647cafa2SAlan Maguire PTR_TO_BTF_ID_OR_NULL },
887647cafa2SAlan Maguire },
888647cafa2SAlan Maguire .seq_info = &ksym_iter_seq_info,
889647cafa2SAlan Maguire };
890647cafa2SAlan Maguire
891647cafa2SAlan Maguire BTF_ID_LIST(btf_ksym_iter_id)
BTF_ID(struct,kallsym_iter)892647cafa2SAlan Maguire BTF_ID(struct, kallsym_iter)
893647cafa2SAlan Maguire
894647cafa2SAlan Maguire static int __init bpf_ksym_iter_register(void)
895647cafa2SAlan Maguire {
896647cafa2SAlan Maguire ksym_iter_reg_info.ctx_arg_info[0].btf_id = *btf_ksym_iter_id;
897647cafa2SAlan Maguire return bpf_iter_reg_target(&ksym_iter_reg_info);
898647cafa2SAlan Maguire }
899647cafa2SAlan Maguire
900647cafa2SAlan Maguire late_initcall(bpf_ksym_iter_register);
901647cafa2SAlan Maguire
902647cafa2SAlan Maguire #endif /* CONFIG_BPF_SYSCALL */
903647cafa2SAlan Maguire
kallsyms_open(struct inode * inode,struct file * file)9041da177e4SLinus Torvalds static int kallsyms_open(struct inode *inode, struct file *file)
9051da177e4SLinus Torvalds {
906ad6ccfadSManish Katiyar /*
907ad6ccfadSManish Katiyar * We keep iterator in m->private, since normal case is to
9081da177e4SLinus Torvalds * s_start from where we left off, so we avoid doing
909ad6ccfadSManish Katiyar * using get_symbol_offset for every symbol.
910ad6ccfadSManish Katiyar */
9111da177e4SLinus Torvalds struct kallsym_iter *iter;
9120049f26aSRob Jones iter = __seq_open_private(file, &kallsyms_op, sizeof(*iter));
9131da177e4SLinus Torvalds if (!iter)
9141da177e4SLinus Torvalds return -ENOMEM;
9151da177e4SLinus Torvalds reset_iter(iter, 0);
9161da177e4SLinus Torvalds
91716025184SKees Cook /*
91816025184SKees Cook * Instead of checking this on every s_show() call, cache
91916025184SKees Cook * the result here at open time.
92016025184SKees Cook */
92116025184SKees Cook iter->show_value = kallsyms_show_value(file->f_cred);
9220049f26aSRob Jones return 0;
9231da177e4SLinus Torvalds }
9241da177e4SLinus Torvalds
92567fc4e0cSJason Wessel #ifdef CONFIG_KGDB_KDB
kdb_walk_kallsyms(loff_t * pos)92667fc4e0cSJason Wessel const char *kdb_walk_kallsyms(loff_t *pos)
92767fc4e0cSJason Wessel {
92867fc4e0cSJason Wessel static struct kallsym_iter kdb_walk_kallsyms_iter;
92967fc4e0cSJason Wessel if (*pos == 0) {
93067fc4e0cSJason Wessel memset(&kdb_walk_kallsyms_iter, 0,
93167fc4e0cSJason Wessel sizeof(kdb_walk_kallsyms_iter));
93267fc4e0cSJason Wessel reset_iter(&kdb_walk_kallsyms_iter, 0);
93367fc4e0cSJason Wessel }
93467fc4e0cSJason Wessel while (1) {
93567fc4e0cSJason Wessel if (!update_iter(&kdb_walk_kallsyms_iter, *pos))
93667fc4e0cSJason Wessel return NULL;
93767fc4e0cSJason Wessel ++*pos;
93867fc4e0cSJason Wessel /* Some debugging symbols have no name. Ignore them. */
93967fc4e0cSJason Wessel if (kdb_walk_kallsyms_iter.name[0])
94067fc4e0cSJason Wessel return kdb_walk_kallsyms_iter.name;
94167fc4e0cSJason Wessel }
94267fc4e0cSJason Wessel }
94367fc4e0cSJason Wessel #endif /* CONFIG_KGDB_KDB */
94467fc4e0cSJason Wessel
94597a32539SAlexey Dobriyan static const struct proc_ops kallsyms_proc_ops = {
94697a32539SAlexey Dobriyan .proc_open = kallsyms_open,
94797a32539SAlexey Dobriyan .proc_read = seq_read,
94897a32539SAlexey Dobriyan .proc_lseek = seq_lseek,
94997a32539SAlexey Dobriyan .proc_release = seq_release_private,
9501da177e4SLinus Torvalds };
9511da177e4SLinus Torvalds
kallsyms_init(void)9521da177e4SLinus Torvalds static int __init kallsyms_init(void)
9531da177e4SLinus Torvalds {
95497a32539SAlexey Dobriyan proc_create("kallsyms", 0444, NULL, &kallsyms_proc_ops);
9551da177e4SLinus Torvalds return 0;
9561da177e4SLinus Torvalds }
957ad6ccfadSManish Katiyar device_initcall(kallsyms_init);
958