cregit-Linux how code gets into the kernel

Release 4.15 kernel/kallsyms.c

Directory: kernel
/*
 * kallsyms.c: in-kernel printing of symbolic oopses and stack traces.
 *
 * Rewritten and vastly simplified by Rusty Russell for in-kernel
 * module loader:
 *   Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
 *
 * ChangeLog:
 *
 * (25/Aug/2004) Paulo Marques <pmarques@grupopie.com>
 *      Changed the compression method from stem compression to "table lookup"
 *      compression (see scripts/kallsyms.c for a more complete description)
 */
#include <linux/kallsyms.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/seq_file.h>
#include <linux/fs.h>
#include <linux/kdb.h>
#include <linux/err.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>	/* for cond_resched */
#include <linux/mm.h>
#include <linux/ctype.h>
#include <linux/slab.h>
#include <linux/filter.h>
#include <linux/ftrace.h>
#include <linux/compiler.h>

#include <asm/sections.h>

/*
 * These will be re-linked against their real values
 * during the second link stage.
 */
extern const unsigned long kallsyms_addresses[] __weak;
extern const int kallsyms_offsets[] __weak;
extern const u8 kallsyms_names[] __weak;

/*
 * Tell the compiler that the count isn't in the small data section if the arch
 * has one (eg: FRV).
 */
extern const unsigned long kallsyms_num_syms
__attribute__((weak, section(".rodata")));

extern const unsigned long kallsyms_relative_base
__attribute__((weak, section(".rodata")));

extern const u8 kallsyms_token_table[] __weak;
extern const u16 kallsyms_token_index[] __weak;

extern const unsigned long kallsyms_markers[] __weak;


static inline int is_kernel_inittext(unsigned long addr) { if (addr >= (unsigned long)_sinittext && addr <= (unsigned long)_einittext) return 1; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Andrew Morton35100.00%1100.00%
Total35100.00%1100.00%


static inline int is_kernel_text(unsigned long addr) { if ((addr >= (unsigned long)_stext && addr <= (unsigned long)_etext) || arch_is_kernel_text(addr)) return 1; return in_gate_area_no_mm(addr); }

Contributors

PersonTokensPropCommitsCommitProp
Andrew Morton3475.56%125.00%
Mike Frysinger715.56%125.00%
Keith Owens36.67%125.00%
Stephen Wilson12.22%125.00%
Total45100.00%4100.00%


static inline int is_kernel(unsigned long addr) { if (addr >= (unsigned long)_stext && addr <= (unsigned long)_end) return 1; return in_gate_area_no_mm(addr); }

Contributors

PersonTokensPropCommitsCommitProp
Keith Owens3797.37%150.00%
Stephen Wilson12.63%150.00%
Total38100.00%2100.00%


static int is_ksym_addr(unsigned long addr) { if (IS_ENABLED(CONFIG_KALLSYMS_ALL)) return is_kernel(addr); return is_kernel_text(addr) || is_kernel_inittext(addr); }

Contributors

PersonTokensPropCommitsCommitProp
Franck Bui-Huu3088.24%150.00%
Masahiro Yamada411.76%150.00%
Total34100.00%2100.00%

/* * Expand a compressed symbol data into the resulting uncompressed string, * if uncompressed string is too long (>= maxlen), it will be truncated, * given the offset to where the symbol is in the compressed stream. */
static unsigned int kallsyms_expand_symbol(unsigned int off, char *result, size_t maxlen) { int len, skipped_first = 0; const u8 *tptr, *data; /* Get the compressed symbol length from the first symbol byte. */ data = &kallsyms_names[off]; len = *data; data++; /* * Update the offset to return the offset for the next symbol on * the compressed stream. */ off += len + 1; /* * For every byte on the compressed symbol data, copy the table * entry for that byte. */ while (len) { tptr = &kallsyms_token_table[kallsyms_token_index[*data]]; data++; len--; while (*tptr) { if (skipped_first) { if (maxlen <= 1) goto tail; *result = *tptr; result++; maxlen--; } else skipped_first = 1; tptr++; } } tail: if (maxlen) *result = '\0'; /* Return to offset to the next symbol. */ return off; }

Contributors

PersonTokensPropCommitsCommitProp
Paulo Marques11381.29%125.00%
Chen Gang S2115.11%125.00%
Manish Katiyar42.88%125.00%
Jan Beulich10.72%125.00%
Total139100.00%4100.00%

/* * Get symbol type information. This is encoded as a single char at the * beginning of the symbol name. */
static char kallsyms_get_symbol_type(unsigned int off) { /* * Get just the first code, look it up in the token table, * and return the first char from this token. */ return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]]; }

Contributors

PersonTokensPropCommitsCommitProp
Paulo Marques2496.00%150.00%
Manish Katiyar14.00%150.00%
Total25100.00%2100.00%

/* * Find the offset on the compressed stream given and index in the * kallsyms array. */
static unsigned int get_symbol_offset(unsigned long pos) { const u8 *name; int i; /* * Use the closest marker we have. We have markers every 256 positions, * so that should be close enough. */ name = &kallsyms_names[kallsyms_markers[pos >> 8]]; /* * Sequentially scan all the symbols up to the point we're searching * for. Every symbol is stored in a [<len>][<len> bytes of data] format, * so we just need to add the len to the current pointer for every * symbol we wish to skip. */ for (i = 0; i < (pos & 0xFF); i++) name = name + (*name) + 1; return name - kallsyms_names; }

Contributors

PersonTokensPropCommitsCommitProp
Paulo Marques6495.52%133.33%
Manish Katiyar22.99%133.33%
Jan Beulich11.49%133.33%
Total67100.00%3100.00%


static unsigned long kallsyms_sym_address(int idx) { if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE)) return kallsyms_addresses[idx]; /* values are unsigned offsets if --absolute-percpu is not in effect */ if (!IS_ENABLED(CONFIG_KALLSYMS_ABSOLUTE_PERCPU)) return kallsyms_relative_base + (u32)kallsyms_offsets[idx]; /* ...otherwise, positive offsets are absolute values */ if (kallsyms_offsets[idx] >= 0) return kallsyms_offsets[idx]; /* ...and negative offsets are relative to kallsyms_relative_base - 1 */ return kallsyms_relative_base - 1 - kallsyms_offsets[idx]; }

Contributors

PersonTokensPropCommitsCommitProp
Ard Biesheuvel71100.00%1100.00%
Total71100.00%1100.00%

/* Lookup the address for this symbol. Returns 0 if not found. */
unsigned long kallsyms_lookup_name(const char *name) { char namebuf[KSYM_NAME_LEN]; unsigned long i; unsigned int off; for (i = 0, off = 0; i < kallsyms_num_syms; i++) { off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf)); if (strcmp(namebuf, name) == 0) return kallsyms_sym_address(i); } return module_kallsyms_lookup_name(name); }

Contributors

PersonTokensPropCommitsCommitProp
Andrew Morton6276.54%120.00%
Paulo Marques1012.35%120.00%
Chen Gang S56.17%120.00%
Ard Biesheuvel33.70%120.00%
Mika Kukkonen11.23%120.00%
Total81100.00%5100.00%

EXPORT_SYMBOL_GPL(kallsyms_lookup_name);
int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *, unsigned long), void *data) { char namebuf[KSYM_NAME_LEN]; unsigned long i; unsigned int off; int ret; for (i = 0, off = 0; i < kallsyms_num_syms; i++) { off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf)); ret = fn(data, namebuf, NULL, kallsyms_sym_address(i)); if (ret != 0) return ret; } return module_kallsyms_on_each_symbol(fn, data); }

Contributors

PersonTokensPropCommitsCommitProp
Anders H Kaseorg10592.92%133.33%
Chen Gang S54.42%133.33%
Ard Biesheuvel32.65%133.33%
Total113100.00%3100.00%

EXPORT_SYMBOL_GPL(kallsyms_on_each_symbol);
static unsigned long get_symbol_pos(unsigned long addr, unsigned long *symbolsize, unsigned long *offset) { unsigned long symbol_start = 0, symbol_end = 0; unsigned long i, low, high, mid; /* This kernel should never had been booted. */ if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE)) BUG_ON(!kallsyms_addresses); else BUG_ON(!kallsyms_offsets); /* Do a binary search on the sorted kallsyms_addresses array. */ low = 0; high = kallsyms_num_syms; while (high - low > 1) { mid = low + (high - low) / 2; if (kallsyms_sym_address(mid) <= addr) low = mid; else high = mid; } /* * Search for the first aliased symbol. Aliased * symbols are symbols with the same address. */ while (low && kallsyms_sym_address(low-1) == kallsyms_sym_address(low)) --low; symbol_start = kallsyms_sym_address(low); /* Search for next non-aliased symbol. */ for (i = low + 1; i < kallsyms_num_syms; i++) { if (kallsyms_sym_address(i) > symbol_start) { symbol_end = kallsyms_sym_address(i); break; } } /* If we found no next symbol, we use the end of the section. */ if (!symbol_end) { if (is_kernel_inittext(addr)) symbol_end = (unsigned long)_einittext; else if (IS_ENABLED(CONFIG_KALLSYMS_ALL)) symbol_end = (unsigned long)_end; else symbol_end = (unsigned long)_etext; } if (symbolsize) *symbolsize = symbol_end - symbol_start; if (offset) *offset = addr - symbol_start; return low; }

Contributors

PersonTokensPropCommitsCommitProp
Paulo Marques8534.14%17.69%
Ard Biesheuvel3313.25%17.69%
Franck Bui-Huu3112.45%17.69%
Andrew Morton2811.24%17.69%
Ingo Molnar218.43%17.69%
Rusty Russell197.63%17.69%
Alexey Dobriyan83.21%17.69%
Sam Ravnborg72.81%17.69%
Keith Owens52.01%17.69%
Masahiro Yamada41.61%17.69%
Manish Katiyar41.61%17.69%
Vegard Nossum31.20%17.69%
Kai Germaschewski10.40%17.69%
Total249100.00%13100.00%

/* * Lookup an address but don't bother to find any names. */
int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize, unsigned long *offset) { char namebuf[KSYM_NAME_LEN]; if (is_ksym_addr(addr)) return !!get_symbol_pos(addr, symbolsize, offset); return !!module_address_lookup(addr, symbolsize, offset, NULL, namebuf) || !!__bpf_address_lookup(addr, symbolsize, offset, namebuf); }

Contributors

PersonTokensPropCommitsCommitProp
Franck Bui-Huu5271.23%133.33%
Daniel Borkmann1317.81%133.33%
Rusty Russell810.96%133.33%
Total73100.00%3100.00%

/* * Lookup an address * - modname is set to NULL if it's in the kernel. * - We guarantee that the returned name is valid until we reschedule even if. * It resides in a module. * - We also guarantee that modname will be valid until rescheduled. */
const char *kallsyms_lookup(unsigned long addr, unsigned long *symbolsize, unsigned long *offset, char **modname, char *namebuf) { const char *ret; namebuf[KSYM_NAME_LEN - 1] = 0; namebuf[0] = 0; if (is_ksym_addr(addr)) { unsigned long pos; pos = get_symbol_pos(addr, symbolsize, offset); /* Grab name */ kallsyms_expand_symbol(get_symbol_offset(pos), namebuf, KSYM_NAME_LEN); if (modname) *modname = NULL; return namebuf; } /* See if it's in a module or a BPF JITed image. */ ret = module_address_lookup(addr, symbolsize, offset, modname, namebuf); if (!ret) ret = bpf_address_lookup(addr, symbolsize, offset, modname, namebuf); if (!ret) ret = ftrace_mod_address_lookup(addr, symbolsize, offset, modname, namebuf); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Franck Bui-Huu8050.31%19.09%
Daniel Borkmann3119.50%19.09%
Steven Rostedt2012.58%19.09%
Rusty Russell138.18%218.18%
Kyle McMartin42.52%19.09%
Ingo Molnar31.89%19.09%
David Howells31.89%19.09%
Chen Gang S21.26%19.09%
Tejun Heo21.26%19.09%
Andi Kleen10.63%19.09%
Total159100.00%11100.00%


int lookup_symbol_name(unsigned long addr, char *symname) { symname[0] = '\0'; symname[KSYM_NAME_LEN - 1] = '\0'; if (is_ksym_addr(addr)) { unsigned long pos; pos = get_symbol_pos(addr, NULL, NULL); /* Grab name */ kallsyms_expand_symbol(get_symbol_offset(pos), symname, KSYM_NAME_LEN); return 0; } /* See if it's in a module. */ return lookup_module_symbol_name(addr, symname); }

Contributors

PersonTokensPropCommitsCommitProp
Alexey Dobriyan7393.59%125.00%
Chen Gang S22.56%125.00%
Tejun Heo22.56%125.00%
Manish Katiyar11.28%125.00%
Total78100.00%4100.00%


int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name) { name[0] = '\0'; name[KSYM_NAME_LEN - 1] = '\0'; if (is_ksym_addr(addr)) { unsigned long pos; pos = get_symbol_pos(addr, size, offset); /* Grab name */ kallsyms_expand_symbol(get_symbol_offset(pos), name, KSYM_NAME_LEN); modname[0] = '\0'; return 0; } /* See if it's in a module. */ return lookup_module_symbol_attrs(addr, size, offset, modname, name); }

Contributors

PersonTokensPropCommitsCommitProp
Alexey Dobriyan10095.24%125.00%
Tejun Heo21.90%125.00%
Chen Gang S21.90%125.00%
Manish Katiyar10.95%125.00%
Total105100.00%4100.00%

/* Look up a kernel symbol and return it in a text buffer. */
static int __sprint_symbol(char *buffer, unsigned long address, int symbol_offset, int add_offset) { char *modname; const char *name; unsigned long offset, size; int len; address += symbol_offset; name = kallsyms_lookup(address, &size, &offset, &modname, buffer); if (!name) return sprintf(buffer, "0x%lx", address - symbol_offset); if (name != buffer) strcpy(buffer, name); len = strlen(buffer); offset -= symbol_offset; if (add_offset) len += sprintf(buffer + len, "+%#lx/%#lx", offset, size); if (modname) len += sprintf(buffer + len, " [%s]", modname); return len; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell5438.57%111.11%
Hugh Dickins3122.14%111.11%
Ingo Molnar1611.43%111.11%
Stephen Boyd1510.71%111.11%
Namhyung Kim1510.71%222.22%
Robert S Peterson64.29%111.11%
Mika Kukkonen21.43%111.11%
Andi Kleen10.71%111.11%
Total140100.00%9100.00%

/** * sprint_symbol - Look up a kernel symbol and return it in a text buffer * @buffer: buffer to be stored * @address: address to lookup * * This function looks up a kernel symbol with @address and stores its name, * offset, size and module name to @buffer if possible. If no symbol was found, * just saves its @address as is. * * This function returns the number of bytes stored in @buffer. */
int sprint_symbol(char *buffer, unsigned long address) { return __sprint_symbol(buffer, address, 0, 1); }

Contributors

PersonTokensPropCommitsCommitProp
Namhyung Kim2392.00%150.00%
Stephen Boyd28.00%150.00%
Total25100.00%2100.00%

EXPORT_SYMBOL_GPL(sprint_symbol); /** * sprint_symbol_no_offset - Look up a kernel symbol and return it in a text buffer * @buffer: buffer to be stored * @address: address to lookup * * This function looks up a kernel symbol with @address and stores its name * and module name to @buffer if possible. If no symbol was found, just saves * its @address as is. * * This function returns the number of bytes stored in @buffer. */
int sprint_symbol_no_offset(char *buffer, unsigned long address) { return __sprint_symbol(buffer, address, 0, 0); }

Contributors

PersonTokensPropCommitsCommitProp
Stephen Boyd25100.00%1100.00%
Total25100.00%1100.00%

EXPORT_SYMBOL_GPL(sprint_symbol_no_offset); /** * sprint_backtrace - Look up a backtrace symbol and return it in a text buffer * @buffer: buffer to be stored * @address: address to lookup * * This function is for stack backtrace and does the same thing as * sprint_symbol() but with modified/decreased @address. If there is a * tail-call to the function marked "noreturn", gcc optimized out code after * the call so that the stack-saved return address could point outside of the * caller. This function ensures that kallsyms will find the original caller * by decreasing @address. * * This function returns the number of bytes stored in @buffer. */
int sprint_backtrace(char *buffer, unsigned long address) { return __sprint_symbol(buffer, address, -1, 1); }

Contributors

PersonTokensPropCommitsCommitProp
Namhyung Kim2492.31%150.00%
Stephen Boyd27.69%150.00%
Total26100.00%2100.00%

/* Look up a kernel symbol and print it to the kernel messages. */
void __print_symbol(const char *fmt, unsigned long address) { char buffer[KSYM_SYMBOL_LEN]; sprint_symbol(buffer, address); printk(fmt, buffer); }

Contributors

PersonTokensPropCommitsCommitProp
Robert S Peterson2676.47%133.33%
Rusty Russell514.71%133.33%
Ingo Molnar38.82%133.33%
Total34100.00%3100.00%

EXPORT_SYMBOL(__print_symbol); /* To avoid using get_symbol_offset for every symbol, we carry prefix along. */ struct kallsym_iter { loff_t pos; loff_t pos_mod_end; loff_t pos_ftrace_mod_end; unsigned long value; unsigned int nameoff; /* If iterating in core kernel symbols. */ char type; char name[KSYM_NAME_LEN]; char module_name[MODULE_NAME_LEN]; int exported; int show_value; };
static int get_ksymbol_mod(struct kallsym_iter *iter) { int ret = module_get_kallsym(iter->pos - kallsyms_num_syms, &iter->value, &iter->type, iter->name, iter->module_name, &iter->exported); if (ret < 0) { iter->pos_mod_end = iter->pos; return 0; } return 1; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell3652.94%125.00%
Daniel Borkmann1725.00%125.00%
Alexey Dobriyan1014.71%125.00%
Adam B. Jerome57.35%125.00%
Total68100.00%4100.00%


static int get_ksymbol_ftrace_mod(struct kallsym_iter *iter) { int ret = ftrace_mod_get_kallsym(iter->pos - iter->pos_mod_end, &iter->value, &iter->type, iter->name, iter->module_name, &iter->exported); if (ret < 0) { iter->pos_ftrace_mod_end = iter->pos; return 0; } return 1; }

Contributors

PersonTokensPropCommitsCommitProp
Steven Rostedt70100.00%1100.00%
Total70100.00%1100.00%


static int get_ksymbol_bpf(struct kallsym_iter *iter) { iter->module_name[0] = '\0'; iter->exported = 0; return bpf_get_kallsym(iter->pos - iter->pos_ftrace_mod_end, &iter->value, &iter->type, iter->name) < 0 ? 0 : 1; }

Contributors

PersonTokensPropCommitsCommitProp
Daniel Borkmann5798.28%150.00%
Steven Rostedt11.72%150.00%
Total58100.00%2100.00%

/* Returns space to next name. */
static unsigned long get_ksymbol_core(struct kallsym_iter *iter) { unsigned off = iter->nameoff; iter->module_name[0] = '\0'; iter->value = kallsyms_sym_address(iter->pos); iter->type = kallsyms_get_symbol_type(off); off = kallsyms_expand_symbol(off, iter->name, ARRAY_SIZE(iter->name)); return off - iter->nameoff; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell3345.21%114.29%
Andrew Morton1520.55%228.57%
Paulo Marques1013.70%114.29%
Chen Gang S79.59%114.29%
Alexey Dobriyan56.85%114.29%
Ard Biesheuvel34.11%114.29%
Total73100.00%7100.00%


static void reset_iter(struct kallsym_iter *iter, loff_t new_pos) { iter->name[0] = '\0'; iter->nameoff = get_symbol_offset(new_pos); iter->pos = new_pos; if (new_pos == 0) { iter->pos_mod_end = 0; iter->pos_ftrace_mod_end = 0; } }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell2950.00%125.00%
Daniel Borkmann1322.41%125.00%
Steven Rostedt813.79%125.00%
Paulo Marques813.79%125.00%
Total58100.00%4100.00%


static int update_iter_mod(struct kallsym_iter *iter, loff_t pos) { iter->pos = pos; if (iter->pos_ftrace_mod_end > 0 && iter->pos_ftrace_mod_end < iter->pos) return get_ksymbol_bpf(iter); if (iter->pos_mod_end > 0 && iter->pos_mod_end < iter->pos) { if (!get_ksymbol_ftrace_mod(iter)) return get_ksymbol_bpf(iter); return 1; } if (!get_ksymbol_mod(iter)) { if (!get_ksymbol_ftrace_mod(iter)) return get_ksymbol_bpf(iter); } return 1; }

Contributors

PersonTokensPropCommitsCommitProp
Daniel Borkmann5855.77%133.33%
Steven Rostedt4543.27%133.33%
Rusty Russell10.96%133.33%
Total104100.00%3100.00%

/* Returns false if pos at or past end of file. */
static int update_iter(struct kallsym_iter *iter, loff_t pos) { /* Module symbols can be accessed randomly. */ if (pos >= kallsyms_num_syms) return update_iter_mod(iter, pos); /* If we're not on the desired position, reset to new position. */ if (pos != iter->pos) reset_iter(iter, pos); iter->nameoff += get_ksymbol_core(iter); iter->pos++; return 1; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell4674.19%125.00%
Paulo Marques711.29%125.00%
Andrew Morton69.68%125.00%
Daniel Borkmann34.84%125.00%
Total62100.00%4100.00%


static void *s_next(struct seq_file *m, void *p, loff_t *pos) { (*pos)++; if (!update_iter(m->private, *pos)) return NULL; return p; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell45100.00%1100.00%
Total45100.00%1100.00%


static void *s_start(struct seq_file *m, loff_t *pos) { if (!update_iter(m->private, *pos)) return NULL; return m->private; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell37100.00%1100.00%
Total37100.00%1100.00%


static void s_stop(struct seq_file *m, void *p) { }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell14100.00%1100.00%
Total14100.00%1100.00%


static int s_show(struct seq_file *m, void *p) { void *value; struct kallsym_iter *iter = m->private; /* Some debugging symbols have no name. Ignore them. */ if (!iter->name[0]) return 0; value = iter->show_value ? (void *)iter->value : NULL; if (iter->module_name[0]) { char type; /* * Label it "global" if it is exported, * "local" if not exported. */ type = iter->exported ? toupper(iter->type) : tolower(iter->type); seq_printf(m, "%px %c %s\t[%s]\n", value, type, iter->name, iter->module_name); } else seq_printf(m, "%px %c %s\n", value, iter->type, iter->name); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell8060.15%120.00%
Alexey Dobriyan3022.56%120.00%
Linus Torvalds2216.54%240.00%
Manish Katiyar10.75%120.00%
Total133100.00%5100.00%

static const struct seq_operations kallsyms_op = { .start = s_start, .next = s_next, .stop = s_stop, .show = s_show };
static inline int kallsyms_for_perf(void) { #ifdef CONFIG_PERF_EVENTS extern int sysctl_perf_event_paranoid; if (sysctl_perf_event_paranoid <= 1) return 1; #endif return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds30100.00%1100.00%
Total30100.00%1100.00%

/* * We show kallsyms information even to normal users if we've enabled * kernel profiling and are explicitly not paranoid (so kptr_restrict * is clear, and sysctl_perf_event_paranoid isn't set). * * Otherwise, require CAP_SYSLOG (assuming kptr_restrict isn't set to * block even that). */
int kallsyms_show_value(void) { switch (kptr_restrict) { case 0: if (kallsyms_for_perf()) return 1; /* fallthrough */ case 1: if (has_capability_noaudit(current, CAP_SYSLOG)) return 1; /* fallthrough */ default: return 0; } }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds45100.00%1100.00%
Total45100.00%1100.00%


static int kallsyms_open(struct inode *inode, struct file *file) { /* * We keep iterator in m->private, since normal case is to * s_start from where we left off, so we avoid doing * using get_symbol_offset for every symbol. */ struct kallsym_iter *iter; iter = __seq_open_private(file, &kallsyms_op, sizeof(*iter)); if (!iter) return -ENOMEM; reset_iter(iter, 0); iter->show_value = kallsyms_show_value(); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell4773.44%233.33%
Linus Torvalds710.94%116.67%
Rob Jones710.94%116.67%
Paulo Marques23.12%116.67%
Manish Katiyar11.56%116.67%
Total64100.00%6100.00%

#ifdef CONFIG_KGDB_KDB
const char *kdb_walk_kallsyms(loff_t *pos) { static struct kallsym_iter kdb_walk_kallsyms_iter; if (*pos == 0) { memset(&kdb_walk_kallsyms_iter, 0, sizeof(kdb_walk_kallsyms_iter)); reset_iter(&kdb_walk_kallsyms_iter, 0); } while (1) { if (!update_iter(&kdb_walk_kallsyms_iter, *pos)) return NULL; ++*pos; /* Some debugging symbols have no name. Ignore them. */ if (kdb_walk_kallsyms_iter.name[0]) return kdb_walk_kallsyms_iter.name; } }

Contributors

PersonTokensPropCommitsCommitProp
Jason Wessel86100.00%1100.00%
Total86100.00%1100.00%

#endif /* CONFIG_KGDB_KDB */ static const struct file_operations kallsyms_operations = { .open = kallsyms_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private, };
static int __init kallsyms_init(void) { proc_create("kallsyms", 0444, NULL, &kallsyms_operations); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell1979.17%125.00%
Denis V. Lunev312.50%125.00%
Linus Torvalds14.17%125.00%
Adrian Bunk14.17%125.00%
Total24100.00%4100.00%

device_initcall(kallsyms_init);

Overall Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell59521.14%46.78%
Paulo Marques34112.12%11.69%
Alexey Dobriyan2358.35%46.78%
Daniel Borkmann1987.04%11.69%
Franck Bui-Huu1946.89%11.69%
Andrew Morton1826.47%58.47%
Steven Rostedt1505.33%23.39%
Ard Biesheuvel1374.87%11.69%
Anders H Kaseorg1103.91%11.69%
Linus Torvalds1093.87%35.08%
Jason Wessel953.38%11.69%
Namhyung Kim642.27%23.39%
Ingo Molnar501.78%11.69%
Stephen Boyd501.78%11.69%
Keith Owens481.71%23.39%
Chen Gang S451.60%11.69%
Robert S Peterson341.21%11.69%
Manish Katiyar321.14%11.69%
Hugh Dickins311.10%11.69%
David Howells150.53%35.08%
Sam Ravnborg100.36%11.69%
Tejun Heo90.32%23.39%
Adam B. Jerome80.28%11.69%
Jan Beulich80.28%11.69%
Gideon Israel Dsouza80.28%11.69%
Masahiro Yamada80.28%11.69%
Rob Jones70.25%11.69%
Mike Frysinger70.25%11.69%
Frédéric Weisbecker50.18%11.69%
Mika Kukkonen40.14%11.69%
Kyle McMartin40.14%11.69%
Tim Schmielau40.14%11.69%
Denis V. Lunev30.11%11.69%
Vegard Nossum30.11%11.69%
Stephen Wilson20.07%11.69%
Andi Kleen20.07%11.69%
Helge Deller20.07%11.69%
Kai Germaschewski20.07%23.39%
Adrian Bunk20.07%11.69%
Martin Peschke10.04%11.69%
Total2814100.00%59100.00%
Directory: kernel
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.