cregit-Linux how code gets into the kernel

Release 4.10 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/compiler.h>

#include <asm/sections.h>

#ifdef CONFIG_KALLSYMS_ALL

#define all_var 1
#else

#define all_var 0
#endif

/*
 * 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 mortonandrew 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 mortonandrew morton3475.56%240.00%
mike frysingermike frysinger715.56%120.00%
keith owenskeith owens36.67%120.00%
stephen wilsonstephen wilson12.22%120.00%
Total45100.00%5100.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 owenskeith owens3797.37%150.00%
stephen wilsonstephen wilson12.63%150.00%
Total38100.00%2100.00%


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

Contributors

PersonTokensPropCommitsCommitProp
franck bui-huufranck bui-huu31100.00%1100.00%
Total31100.00%1100.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 marquespaulo marques11381.29%125.00%
chen gangchen gang2115.11%125.00%
manish katiyarmanish katiyar42.88%125.00%
jan beulichjan 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 marquespaulo marques2496.00%150.00%
manish katiyarmanish 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 marquespaulo marques6495.52%133.33%
manish katiyarmanish katiyar22.99%133.33%
jan beulichjan 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 biesheuvelard 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 mortonandrew morton6276.54%233.33%
paulo marquespaulo marques1012.35%116.67%
chen gangchen gang56.17%116.67%
ard biesheuvelard biesheuvel33.70%116.67%
mika kukkonenmika kukkonen11.23%116.67%
Total81100.00%6100.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 kaseorganders kaseorg10592.92%133.33%
chen gangchen gang54.42%133.33%
ard biesheuvelard 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 (all_var) 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 marquespaulo marques8534.55%18.33%
ard biesheuvelard biesheuvel3313.41%18.33%
franck bui-huufranck bui-huu3213.01%18.33%
andrew mortonandrew morton2811.38%18.33%
ingo molnaringo molnar218.54%18.33%
rusty russellrusty russell197.72%18.33%
alexey dobriyanalexey dobriyan83.25%18.33%
sam ravnborgsam ravnborg72.85%18.33%
keith owenskeith owens52.03%18.33%
manish katiyarmanish katiyar41.63%18.33%
vegard nossumvegard nossum31.22%18.33%
kai germaschewskikai germaschewski10.41%18.33%
Total246100.00%12100.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); }

Contributors

PersonTokensPropCommitsCommitProp
franck bui-huufranck bui-huu5286.67%150.00%
rusty russellrusty russell813.33%150.00%
Total60100.00%2100.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) { 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. */ return module_address_lookup(addr, symbolsize, offset, modname, namebuf); }

Contributors

PersonTokensPropCommitsCommitProp
franck bui-huufranck bui-huu8072.73%110.00%
rusty russellrusty russell1412.73%220.00%
kyle mcmartinkyle mcmartin43.64%110.00%
ingo molnaringo molnar32.73%110.00%
david howellsdavid howells32.73%110.00%
tejun heotejun heo21.82%110.00%
chen gangchen gang21.82%110.00%
manish katiyarmanish katiyar10.91%110.00%
andi kleenandi kleen10.91%110.00%
Total110100.00%10100.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 dobriyanalexey dobriyan7393.59%125.00%
chen gangchen gang22.56%125.00%
tejun heotejun heo22.56%125.00%
manish katiyarmanish 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 dobriyanalexey dobriyan10095.24%125.00%
chen gangchen gang21.90%125.00%
tejun heotejun heo21.90%125.00%
manish katiyarmanish 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 russellrusty russell5438.57%111.11%
hugh dickinshugh dickins3122.14%111.11%
ingo molnaringo molnar1611.43%111.11%
namhyung kimnamhyung kim1510.71%222.22%
stephen boydstephen boyd1510.71%111.11%
robert s. petersonrobert s. peterson64.29%111.11%
mika kukkonenmika kukkonen21.43%111.11%
andi kleenandi 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 kimnamhyung kim2392.00%150.00%
stephen boydstephen 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 boydstephen 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 kimnamhyung kim2492.31%150.00%
stephen boydstephen 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. petersonrobert s. peterson2676.47%133.33%
rusty russellrusty russell514.71%133.33%
ingo molnaringo 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; 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; };
static int get_ksymbol_mod(struct kallsym_iter *iter) { if (module_get_kallsym(iter->pos - kallsyms_num_syms, &iter->value, &iter->type, iter->name, iter->module_name, &iter->exported) < 0) return 0; return 1; }

Contributors

PersonTokensPropCommitsCommitProp
rusty russellrusty russell3667.92%133.33%
alexey dobriyanalexey dobriyan1222.64%133.33%
adam b. jeromeadam b. jerome59.43%133.33%
Total53100.00%3100.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 russellrusty russell3345.21%114.29%
andrew mortonandrew morton1520.55%228.57%
paulo marquespaulo marques1013.70%114.29%
chen gangchen gang79.59%114.29%
alexey dobriyanalexey dobriyan56.85%114.29%
ard biesheuvelard 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; }

Contributors

PersonTokensPropCommitsCommitProp
rusty russellrusty russell3078.95%150.00%
paulo marquespaulo marques821.05%150.00%
Total38100.00%2100.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) { iter->pos = pos; return get_ksymbol_mod(iter); } /* 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 russellrusty russell5580.88%133.33%
paulo marquespaulo marques710.29%133.33%
andrew mortonandrew morton68.82%133.33%
Total68100.00%3100.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 russellrusty 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 russellrusty russell37100.00%1100.00%
Total37100.00%1100.00%


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

Contributors

PersonTokensPropCommitsCommitProp
rusty russellrusty russell14100.00%1100.00%
Total14100.00%1100.00%


static int s_show(struct seq_file *m, void *p) { struct kallsym_iter *iter = m->private; /* Some debugging symbols have no name. Ignore them. */ if (!iter->name[0]) return 0; 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, "%pK %c %s\t[%s]\n", (void *)iter->value, type, iter->name, iter->module_name); } else seq_printf(m, "%pK %c %s\n", (void *)iter->value, iter->type, iter->name); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
rusty russellrusty russell8870.40%125.00%
alexey dobriyanalexey dobriyan3024.00%125.00%
kees cookkees cook64.80%125.00%
manish katiyarmanish katiyar10.80%125.00%
Total125100.00%4100.00%

static const struct seq_operations kallsyms_op = { .start = s_start, .next = s_next, .stop = s_stop, .show = s_show };
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); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
rusty russellrusty russell4782.46%240.00%
rob jonesrob jones712.28%120.00%
paulo marquespaulo marques23.51%120.00%
manish katiyarmanish katiyar11.75%120.00%
Total57100.00%5100.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 wesseljason 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 russellrusty russell1979.17%125.00%
denis v. lunevdenis v. lunev312.50%125.00%
linus torvaldslinus torvalds14.17%125.00%
adrian bunkadrian bunk14.17%125.00%
Total24100.00%4100.00%

device_initcall(kallsyms_init);

Overall Contributors

PersonTokensPropCommitsCommitProp
rusty russellrusty russell61325.61%47.41%
paulo marquespaulo marques34114.24%11.85%
alexey dobriyanalexey dobriyan2379.90%47.41%
franck bui-huufranck bui-huu1968.19%11.85%
andrew mortonandrew morton1827.60%59.26%
ard biesheuvelard biesheuvel1375.72%11.85%
anders kaseorganders kaseorg1104.59%11.85%
jason wesseljason wessel953.97%11.85%
namhyung kimnamhyung kim642.67%23.70%
keith owenskeith owens632.63%23.70%
stephen boydstephen boyd502.09%11.85%
ingo molnaringo molnar502.09%11.85%
chen gangchen gang451.88%11.85%
robert s. petersonrobert s. peterson341.42%11.85%
manish katiyarmanish katiyar331.38%11.85%
hugh dickinshugh dickins311.29%11.85%
david howellsdavid howells150.63%35.56%
sam ravnborgsam ravnborg100.42%11.85%
tejun heotejun heo90.38%23.70%
adam b. jeromeadam b. jerome80.33%11.85%
gideon israel dsouzagideon israel dsouza80.33%11.85%
jan beulichjan beulich80.33%11.85%
mike frysingermike frysinger70.29%11.85%
rob jonesrob jones70.29%11.85%
kees cookkees cook60.25%11.85%
frederic weisbeckerfrederic weisbecker50.21%11.85%
mika kukkonenmika kukkonen40.17%11.85%
tim schmielautim schmielau40.17%11.85%
kyle mcmartinkyle mcmartin40.17%11.85%
vegard nossumvegard nossum30.13%11.85%
denis v. lunevdenis v. lunev30.13%11.85%
stephen wilsonstephen wilson20.08%11.85%
andi kleenandi kleen20.08%11.85%
kai germaschewskikai germaschewski20.08%23.70%
adrian bunkadrian bunk20.08%11.85%
helge dellerhelge deller20.08%11.85%
martin peschkemartin peschke10.04%11.85%
linus torvaldslinus torvalds10.04%11.85%
Total2394100.00%54100.00%
Directory: kernel
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.