cregit-Linux how code gets into the kernel

Release 4.8 fs/binfmt_misc.c

Directory: fs
/*
 * binfmt_misc.c
 *
 * Copyright (C) 1997 Richard Günther
 *
 * binfmt_misc detects binaries via a magic or filename extension and invokes
 * a specified wrapper. See Documentation/binfmt_misc.txt for more details.
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/magic.h>
#include <linux/binfmts.h>
#include <linux/slab.h>
#include <linux/ctype.h>
#include <linux/string_helpers.h>
#include <linux/file.h>
#include <linux/pagemap.h>
#include <linux/namei.h>
#include <linux/mount.h>
#include <linux/syscalls.h>
#include <linux/fs.h>
#include <linux/uaccess.h>

#include "internal.h"

#ifdef DEBUG

# define USE_DEBUG 1
#else

# define USE_DEBUG 0
#endif

enum {
	
VERBOSE_STATUS = 1 /* make it zero to save 400 bytes kernel memory */
};

static LIST_HEAD(entries);

static int enabled = 1;



enum {Enabled, Magic};

#define MISC_FMT_PRESERVE_ARGV0 (1 << 31)

#define MISC_FMT_OPEN_BINARY (1 << 30)

#define MISC_FMT_CREDENTIALS (1 << 29)

#define MISC_FMT_OPEN_FILE (1 << 28)

typedef struct {
	
struct list_head list;
	
unsigned long flags;		/* type, status, etc. */
	
int offset;			/* offset of magic */
	
int size;			/* size of magic/mask */
	
char *magic;			/* magic or filename extension */
	
char *mask;			/* mask, NULL for exact match */
	
char *interpreter;		/* filename of interpreter */
	
char *name;
	
struct dentry *dentry;
	
struct file *interp_file;
} 
Node;

static DEFINE_RWLOCK(entries_lock);

static struct file_system_type bm_fs_type;

static struct vfsmount *bm_mnt;

static int entry_count;

/*
 * Max length of the register string.  Determined by:
 *  - 7 delimiters
 *  - name:   ~50 bytes
 *  - type:   1 byte
 *  - offset: 3 bytes (has to be smaller than BINPRM_BUF_SIZE)
 *  - magic:  128 bytes (512 in escaped form)
 *  - mask:   128 bytes (512 in escaped form)
 *  - interp: ~50 bytes
 *  - flags:  5 bytes
 * Round that up a bit, and then back off to hold the internal data
 * (like struct Node).
 */

#define MAX_REGISTER_LENGTH 1920

/*
 * Check if we support the binfmt
 * if we do, return the node, else NULL
 * locking is done in load_misc_binary
 */

static Node *check_file(struct linux_binprm *bprm) { char *p = strrchr(bprm->interp, '.'); struct list_head *l; /* Walk all the registered handlers. */ list_for_each(l, &entries) { Node *e = list_entry(l, Node, list); char *s; int j; /* Make sure this one is currently enabled. */ if (!test_bit(Enabled, &e->flags)) continue; /* Do matching based on extension if applicable. */ if (!test_bit(Magic, &e->flags)) { if (p && !strcmp(e->magic, p + 1)) return e; continue; } /* Do matching based on magic & mask. */ s = bprm->buf + e->offset; if (e->mask) { for (j = 0; j < e->size; j++) if ((*s++ ^ e->magic[j]) & e->mask[j]) break; } else { for (j = 0; j < e->size; j++) if ((*s++ ^ e->magic[j])) break; } if (j == e->size) return e; } return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds15572.09%116.67%
pre-gitpre-git4922.79%233.33%
dave jonesdave jones62.79%116.67%
mike frysingermike frysinger41.86%116.67%
andrew mortonandrew morton10.47%116.67%
Total215100.00%6100.00%

/* * the loader itself */
static int load_misc_binary(struct linux_binprm *bprm) { Node *fmt; struct file *interp_file = NULL; char iname[BINPRM_BUF_SIZE]; const char *iname_addr = iname; int retval; int fd_binary = -1; retval = -ENOEXEC; if (!enabled) goto ret; /* to keep locking time low, we copy the interpreter string */ read_lock(&entries_lock); fmt = check_file(bprm); if (fmt) strlcpy(iname, fmt->interpreter, BINPRM_BUF_SIZE); read_unlock(&entries_lock); if (!fmt) goto ret; /* Need to be able to load the file after exec */ if (bprm->interp_flags & BINPRM_FLAGS_PATH_INACCESSIBLE) return -ENOENT; if (!(fmt->flags & MISC_FMT_PRESERVE_ARGV0)) { retval = remove_arg_zero(bprm); if (retval) goto ret; } if (fmt->flags & MISC_FMT_OPEN_BINARY) { /* if the binary should be opened on behalf of the * interpreter than keep it open and assign descriptor * to it */ fd_binary = get_unused_fd_flags(0); if (fd_binary < 0) { retval = fd_binary; goto ret; } fd_install(fd_binary, bprm->file); /* if the binary is not readable than enforce mm->dumpable=0 regardless of the interpreter's permissions */ would_dump(bprm, bprm->file); allow_write_access(bprm->file); bprm->file = NULL; /* mark the bprm that fd should be passed to interp */ bprm->interp_flags |= BINPRM_FLAGS_EXECFD; bprm->interp_data = fd_binary; } else { allow_write_access(bprm->file); fput(bprm->file); bprm->file = NULL; } /* make argv[1] be the path to the binary */ retval = copy_strings_kernel(1, &bprm->interp, bprm); if (retval < 0) goto error; bprm->argc++; /* add the interp as argv[0] */ retval = copy_strings_kernel(1, &iname_addr, bprm); if (retval < 0) goto error; bprm->argc++; /* Update interp in case binfmt_script needs it. */ retval = bprm_change_interp(iname, bprm); if (retval < 0) goto error; if (fmt->flags & MISC_FMT_OPEN_FILE && fmt->interp_file) { interp_file = filp_clone_open(fmt->interp_file); if (!IS_ERR(interp_file)) deny_write_access(interp_file); } else { interp_file = open_exec(iname); } retval = PTR_ERR(interp_file); if (IS_ERR(interp_file)) goto error; bprm->file = interp_file; if (fmt->flags & MISC_FMT_CREDENTIALS) { /* * No need to call prepare_binprm(), it's already been * done. bprm->buf is stale, update from interp_file. */ memset(bprm->buf, 0, BINPRM_BUF_SIZE); retval = kernel_read(bprm->file, 0, bprm->buf, BINPRM_BUF_SIZE); } else retval = prepare_binprm(bprm); if (retval < 0) goto error; retval = search_binary_handler(bprm); if (retval < 0) goto error; ret: return retval; error: if (fd_binary > 0) sys_close(fd_binary); bprm->interp_flags = 0; bprm->interp_data = 0; goto ret; }

Contributors

PersonTokensPropCommitsCommitProp
yoav zachyoav zach18938.57%313.64%
pre-gitpre-git18437.55%836.36%
james bottomleyjames bottomley397.96%14.55%
linus torvaldslinus torvalds183.67%14.55%
kees cookkees cook153.06%14.55%
mike frysingermike frysinger142.86%14.55%
david drysdaledavid drysdale132.65%14.55%
ollie wildollie wild81.63%14.55%
yann droneaudyann droneaud40.82%14.55%
al viroal viro30.61%14.55%
andrew mortonandrew morton10.20%14.55%
ben collinsben collins10.20%14.55%
david howellsdavid howells10.20%14.55%
Total490100.00%22100.00%

/* Command parsers */ /* * parses and copies one argument enclosed in del from *sp to *dp, * recognising the \x special. * returns pointer to the copied argument or NULL in case of an * error (and sets err) or null argument length. */
static char *scanarg(char *s, char del) { char c; while ((c = *s++) != del) { if (c == '\\' && *s == 'x') { s++; if (!isxdigit(*s++)) return NULL; if (!isxdigit(*s++)) return NULL; } } s[-1] ='\0'; return s; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git5160.71%133.33%
linus torvaldslinus torvalds2529.76%133.33%
al viroal viro89.52%133.33%
Total84100.00%3100.00%


static char *check_special_flags(char *sfs, Node *e) { char *p = sfs; int cont = 1; /* special flags */ while (cont) { switch (*p) { case 'P': pr_debug("register: flag: P (preserve argv0)\n"); p++; e->flags |= MISC_FMT_PRESERVE_ARGV0; break; case 'O': pr_debug("register: flag: O (open binary)\n"); p++; e->flags |= MISC_FMT_OPEN_BINARY; break; case 'C': pr_debug("register: flag: C (preserve creds)\n"); p++; /* this flags also implies the open-binary flag */ e->flags |= (MISC_FMT_CREDENTIALS | MISC_FMT_OPEN_BINARY); break; case 'F': pr_debug("register: flag: F: open interpreter file now\n"); p++; e->flags |= MISC_FMT_OPEN_FILE; break; default: cont = 0; } } return p; }

Contributors

PersonTokensPropCommitsCommitProp
yoav zachyoav zach9172.80%240.00%
james bottomleyjames bottomley1814.40%120.00%
mike frysingermike frysinger1612.80%240.00%
Total125100.00%5100.00%

/* * This registers a new binary format, it recognises the syntax * ':name:type:offset:magic:mask:interpreter:flags' * where the ':' is the IFS, that can be chosen with the first char */
static Node *create_entry(const char __user *buffer, size_t count) { Node *e; int memsize, err; char *buf, *p; char del; pr_debug("register: received %zu bytes\n", count); /* some sanity checks */ err = -EINVAL; if ((count < 11) || (count > MAX_REGISTER_LENGTH)) goto out; err = -ENOMEM; memsize = sizeof(Node) + count + 8; e = kmalloc(memsize, GFP_KERNEL); if (!e) goto out; p = buf = (char *)e + sizeof(Node); memset(e, 0, sizeof(Node)); if (copy_from_user(buf, buffer, count)) goto efault; del = *p++; /* delimeter */ pr_debug("register: delim: %#x {%c}\n", del, del); /* Pad the buffer with the delim to simplify parsing below. */ memset(buf + count, del, 8); /* Parse the 'name' field. */ e->name = p; p = strchr(p, del); if (!p) goto einval; *p++ = '\0'; if (!e->name[0] || !strcmp(e->name, ".") || !strcmp(e->name, "..") || strchr(e->name, '/')) goto einval; pr_debug("register: name: {%s}\n", e->name); /* Parse the 'type' field. */ switch (*p++) { case 'E': pr_debug("register: type: E (extension)\n"); e->flags = 1 << Enabled; break; case 'M': pr_debug("register: type: M (magic)\n"); e->flags = (1 << Enabled) | (1 << Magic); break; default: goto einval; } if (*p++ != del) goto einval; if (test_bit(Magic, &e->flags)) { /* Handle the 'M' (magic) format. */ char *s; /* Parse the 'offset' field. */ s = strchr(p, del); if (!s) goto einval; *s++ = '\0'; e->offset = simple_strtoul(p, &p, 10); if (*p++) goto einval; pr_debug("register: offset: %#x\n", e->offset); /* Parse the 'magic' field. */ e->magic = p; p = scanarg(p, del); if (!p) goto einval; if (!e->magic[0]) goto einval; if (USE_DEBUG) print_hex_dump_bytes( KBUILD_MODNAME ": register: magic[raw]: ", DUMP_PREFIX_NONE, e->magic, p - e->magic); /* Parse the 'mask' field. */ e->mask = p; p = scanarg(p, del); if (!p) goto einval; if (!e->mask[0]) { e->mask = NULL; pr_debug("register: mask[raw]: none\n"); } else if (USE_DEBUG) print_hex_dump_bytes( KBUILD_MODNAME ": register: mask[raw]: ", DUMP_PREFIX_NONE, e->mask, p - e->mask); /* * Decode the magic & mask fields. * Note: while we might have accepted embedded NUL bytes from * above, the unescape helpers here will stop at the first one * it encounters. */ e->size = string_unescape_inplace(e->magic, UNESCAPE_HEX); if (e->mask && string_unescape_inplace(e->mask, UNESCAPE_HEX) != e->size) goto einval; if (e->size + e->offset > BINPRM_BUF_SIZE) goto einval; pr_debug("register: magic/mask length: %i\n", e->size); if (USE_DEBUG) { print_hex_dump_bytes( KBUILD_MODNAME ": register: magic[decoded]: ", DUMP_PREFIX_NONE, e->magic, e->size); if (e->mask) { int i; char *masked = kmalloc(e->size, GFP_KERNEL); print_hex_dump_bytes( KBUILD_MODNAME ": register: mask[decoded]: ", DUMP_PREFIX_NONE, e->mask, e->size); if (masked) { for (i = 0; i < e->size; ++i) masked[i] = e->magic[i] & e->mask[i]; print_hex_dump_bytes( KBUILD_MODNAME ": register: magic[masked]: ", DUMP_PREFIX_NONE, masked, e->size); kfree(masked); } } } } else { /* Handle the 'E' (extension) format. */ /* Skip the 'offset' field. */ p = strchr(p, del); if (!p) goto einval; *p++ = '\0'; /* Parse the 'magic' field. */ e->magic = p; p = strchr(p, del); if (!p) goto einval; *p++ = '\0'; if (!e->magic[0] || strchr(e->magic, '/')) goto einval; pr_debug("register: extension: {%s}\n", e->magic); /* Skip the 'mask' field. */ p = strchr(p, del); if (!p) goto einval; *p++ = '\0'; } /* Parse the 'interpreter' field. */ e->interpreter = p; p = strchr(p, del); if (!p) goto einval; *p++ = '\0'; if (!e->interpreter[0]) goto einval; pr_debug("register: interpreter: {%s}\n", e->interpreter); /* Parse the 'flags' field. */ p = check_special_flags(p, e); if (*p == '\n') p++; if (p != buf + count) goto einval; return e; out: return ERR_PTR(err); efault: kfree(e); return ERR_PTR(-EFAULT); einval: kfree(e); return ERR_PTR(-EINVAL); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds43446.47%17.14%
mike frysingermike frysinger28330.30%321.43%
pre-gitpre-git18720.02%428.57%
al viroal viro90.96%214.29%
david mosbergerdavid mosberger80.86%17.14%
andy shevchenkoandy shevchenko60.64%17.14%
yoav zachyoav zach50.54%17.14%
andrew mortonandrew morton20.21%17.14%
Total934100.00%14100.00%

/* * Set status of entry/binfmt_misc: * '1' enables, '0' disables and '-1' clears entry/binfmt_misc */
static int parse_command(const char __user *buffer, size_t count) { char s[4]; if (count > 3) return -EINVAL; if (copy_from_user(s, buffer, count)) return -EFAULT; if (!count) return 0; if (s[count - 1] == '\n') count--; if (count == 1 && s[0] == '0') return 1; if (count == 1 && s[0] == '1') return 2; if (count == 2 && s[0] == '-' && s[1] == '1') return 3; return -EINVAL; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds11892.91%133.33%
arnd bergmannarnd bergmann86.30%133.33%
al viroal viro10.79%133.33%
Total127100.00%3100.00%

/* generic stuff */
static void entry_status(Node *e, char *page) { char *dp = page; const char *status = "disabled"; if (test_bit(Enabled, &e->flags)) status = "enabled"; if (!VERBOSE_STATUS) { sprintf(page, "%s\n", status); return; } dp += sprintf(dp, "%s\ninterpreter %s\n", status, e->interpreter); /* print the special flags */ dp += sprintf(dp, "flags: "); if (e->flags & MISC_FMT_PRESERVE_ARGV0) *dp++ = 'P'; if (e->flags & MISC_FMT_OPEN_BINARY) *dp++ = 'O'; if (e->flags & MISC_FMT_CREDENTIALS) *dp++ = 'C'; if (e->flags & MISC_FMT_OPEN_FILE) *dp++ = 'F'; *dp++ = '\n'; if (!test_bit(Magic, &e->flags)) { sprintf(dp, "extension .%s\n", e->magic); } else { dp += sprintf(dp, "offset %i\nmagic ", e->offset); dp = bin2hex(dp, e->magic, e->size); if (e->mask) { dp += sprintf(dp, "\nmask "); dp = bin2hex(dp, e->mask, e->size); } *dp++ = '\n'; *dp = '\0'; } }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds15060.73%120.00%
yoav zachyoav zach6024.29%240.00%
rasmus villemoesrasmus villemoes239.31%120.00%
james bottomleyjames bottomley145.67%120.00%
Total247100.00%5100.00%


static struct inode *bm_get_inode(struct super_block *sb, int mode) { struct inode *inode = new_inode(sb); if (inode) { inode->i_ino = get_next_ino(); inode->i_mode = mode; inode->i_atime = inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb); } return inode; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds5480.60%133.33%
christoph hellwigchristoph hellwig710.45%133.33%
andi kleenandi kleen68.96%133.33%
Total67100.00%3100.00%


static void bm_evict_inode(struct inode *inode) { clear_inode(inode); kfree(inode->i_private); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds1460.87%233.33%
al viroal viro730.43%233.33%
theodore tsotheodore tso14.35%116.67%
jan karajan kara14.35%116.67%
Total23100.00%6100.00%


static void kill_node(Node *e) { struct dentry *dentry; write_lock(&entries_lock); dentry = e->dentry; if (dentry) { list_del_init(&e->list); e->dentry = NULL; } write_unlock(&entries_lock); if ((e->flags & MISC_FMT_OPEN_FILE) && e->interp_file) { filp_close(e->interp_file, NULL); e->interp_file = NULL; } if (dentry) { drop_nlink(d_inode(dentry)); d_drop(dentry); dput(dentry); simple_release_fs(&bm_mnt, &entry_count); } }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds7160.68%233.33%
james bottomleyjames bottomley3126.50%116.67%
al viroal viro97.69%116.67%
miklos szeredimiklos szeredi32.56%116.67%
david howellsdavid howells32.56%116.67%
Total117100.00%6100.00%

/* /<entry> */
static ssize_t bm_entry_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) { Node *e = file_inode(file)->i_private; ssize_t res; char *page; page = (char *) __get_free_page(GFP_KERNEL); if (!page) return -ENOMEM; entry_status(e, page); res = simple_read_from_buffer(buf, nbytes, ppos, page, strlen(page)); free_page((unsigned long) page); return res; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds7980.61%116.67%
akinobu mitaakinobu mita99.18%116.67%
mike frysingermike frysinger55.10%116.67%
al viroal viro44.08%233.33%
theodore tsotheodore tso11.02%116.67%
Total98100.00%6100.00%


static ssize_t bm_entry_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) { struct dentry *root; Node *e = file_inode(file)->i_private; int res = parse_command(buffer, count); switch (res) { case 1: /* Disable this handler. */ clear_bit(Enabled, &e->flags); break; case 2: /* Enable this handler. */ set_bit(Enabled, &e->flags); break; case 3: /* Delete this handler. */ root = file_inode(file)->i_sb->s_root; inode_lock(d_inode(root)); kill_node(e); inode_unlock(d_inode(root)); break; default: return res; } return count; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds11185.38%112.50%
al viroal viro96.92%450.00%
david howellsdavid howells64.62%112.50%
mike frysingermike frysinger32.31%112.50%
theodore tsotheodore tso10.77%112.50%
Total130100.00%8100.00%

static const struct file_operations bm_entry_operations = { .read = bm_entry_read, .write = bm_entry_write, .llseek = default_llseek, }; /* /register */
static ssize_t bm_register_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) { Node *e; struct inode *inode; struct super_block *sb = file_inode(file)->i_sb; struct dentry *root = sb->s_root, *dentry; int err = 0; e = create_entry(buffer, count); if (IS_ERR(e)) return PTR_ERR(e); inode_lock(d_inode(root)); dentry = lookup_one_len(e->name, root, strlen(e->name)); err = PTR_ERR(dentry); if (IS_ERR(dentry)) goto out; err = -EEXIST; if (d_really_is_positive(dentry)) goto out2; inode = bm_get_inode(sb, S_IFREG | 0644); err = -ENOMEM; if (!inode) goto out2; err = simple_pin_fs(&bm_fs_type, &bm_mnt, &entry_count); if (err) { iput(inode); inode = NULL; goto out2; } if (e->flags & MISC_FMT_OPEN_FILE) { struct file *f; f = open_exec(e->interpreter); if (IS_ERR(f)) { err = PTR_ERR(f); pr_notice("register: failed to install interpreter file %s\n", e->interpreter); simple_release_fs(&bm_mnt, &entry_count); iput(inode); inode = NULL; goto out2; } e->interp_file = f; } e->dentry = dget(dentry); inode->i_private = e; inode->i_fop = &bm_entry_operations; d_instantiate(dentry, inode); write_lock(&entries_lock); list_add(&e->list, &entries); write_unlock(&entries_lock); err = 0; out2: dput(dentry); out: inode_unlock(d_inode(root)); if (err) { kfree(e); return err; } return count; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds24467.03%216.67%
james bottomleyjames bottomley7721.15%18.33%
al viroal viro256.87%541.67%
david howellsdavid howells92.47%18.33%
andrew mortonandrew morton61.65%18.33%
trond myklebusttrond myklebust20.55%18.33%
theodore tsotheodore tso10.27%18.33%
Total364100.00%12100.00%

static const struct file_operations bm_register_operations = { .write = bm_register_write, .llseek = noop_llseek, }; /* /status */
static ssize_t bm_status_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) { char *s = enabled ? "enabled\n" : "disabled\n"; return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s)); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds2448.00%120.00%
pre-gitpre-git1428.00%120.00%
akinobu mitaakinobu mita918.00%120.00%
qinghuang fengqinghuang feng24.00%120.00%
al viroal viro12.00%120.00%
Total50100.00%5100.00%


static ssize_t bm_status_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) { int res = parse_command(buffer, count); struct dentry *root; switch (res) { case 1: /* Disable all handlers. */ enabled = 0; break; case 2: /* Enable all handlers. */ enabled = 1; break; case 3: /* Delete all handlers. */ root = file_inode(file)->i_sb->s_root; inode_lock(d_inode(root)); while (!list_empty(&entries)) kill_node(list_entry(entries.next, Node, list)); inode_unlock(d_inode(root)); break; default: return res; } return count; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds8971.20%112.50%
pre-gitpre-git2016.00%112.50%
david howellsdavid howells64.80%112.50%
al viroal viro64.80%337.50%
mike frysingermike frysinger32.40%112.50%
luis henriquesluis henriques10.80%112.50%
Total125100.00%8100.00%

static const struct file_operations bm_status_operations = { .read = bm_status_read, .write = bm_status_write, .llseek = default_llseek, }; /* Superblock handling */ static const struct super_operations s_ops = { .statfs = simple_statfs, .evict_inode = bm_evict_inode, };
static int bm_fill_super(struct super_block *sb, void *data, int silent) { int err; static struct tree_descr bm_files[] = { [2] = {"status", &bm_status_operations, S_IWUSR|S_IRUGO}, [3] = {"register", &bm_register_operations, S_IWUSR}, /* last one */ {""} }; err = simple_fill_super(sb, BINFMTFS_MAGIC, bm_files); if (!err) sb->s_op = &s_ops; return err; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro3742.05%228.57%
linus torvaldslinus torvalds3539.77%114.29%
pre-gitpre-git89.09%114.29%
mike frysingermike frysinger55.68%114.29%
jeff laytonjeff layton22.27%114.29%
muthu kumarmuthu kumar11.14%114.29%
Total88100.00%7100.00%


static struct dentry *bm_mount(struct file_system_type *fs_type, int flags, const char *dev_name, void *data) { return mount_single(fs_type, flags, data, bm_fill_super); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro3491.89%250.00%
pre-gitpre-git25.41%125.00%
andries brouwerandries brouwer12.70%125.00%
Total37100.00%4100.00%

static struct linux_binfmt misc_format = { .module = THIS_MODULE, .load_binary = load_misc_binary, }; static struct file_system_type bm_fs_type = { .owner = THIS_MODULE, .name = "binfmt_misc", .mount = bm_mount, .kill_sb = kill_litter_super, }; MODULE_ALIAS_FS("binfmt_misc");
static int __init init_misc_binfmt(void) { int err = register_filesystem(&bm_fs_type); if (!err) insert_binfmt(&misc_format); return err; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git2268.75%571.43%
linus torvaldslinus torvalds928.12%114.29%
jan semberajan sembera13.12%114.29%
Total32100.00%7100.00%


static void __exit exit_misc_binfmt(void) { unregister_binfmt(&misc_format); unregister_filesystem(&bm_fs_type); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git1885.71%266.67%
linus torvaldslinus torvalds314.29%133.33%
Total21100.00%3100.00%

core_initcall(init_misc_binfmt); module_exit(exit_misc_binfmt); MODULE_LICENSE("GPL");

Overall Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds175247.02%33.80%
pre-gitpre-git62716.83%1518.99%
mike frysingermike frysinger3669.82%33.80%
yoav zachyoav zach3529.45%33.80%
james bottomleyjames bottomley1915.13%11.27%
al viroal viro1754.70%1417.72%
rasmus villemoesrasmus villemoes260.70%11.27%
art haasart haas260.70%11.27%
david howellsdavid howells250.67%22.53%
arnd bergmannarnd bergmann230.62%22.53%
akinobu mitaakinobu mita210.56%22.53%
kees cookkees cook150.40%11.27%
andrew mortonandrew morton140.38%56.33%
david drysdaledavid drysdale130.35%11.27%
christoph hellwigchristoph hellwig130.35%33.80%
david mosbergerdavid mosberger110.30%11.27%
andy shevchenkoandy shevchenko90.24%11.27%
ollie wildollie wild80.21%11.27%
trond myklebusttrond myklebust70.19%11.27%
andi kleenandi kleen60.16%11.27%
dave jonesdave jones60.16%11.27%
eric w. biedermaneric w. biederman50.13%11.27%
theodore tsotheodore tso40.11%11.27%
yann droneaudyann droneaud40.11%11.27%
thomas gleixnerthomas gleixner40.11%11.27%
muthu kumarmuthu kumar40.11%11.27%
alexey dobriyanalexey dobriyan30.08%11.27%
miklos szeredimiklos szeredi30.08%11.27%
arjan van de venarjan van de ven30.08%11.27%
qinghuang fengqinghuang feng20.05%11.27%
jeff laytonjeff layton20.05%11.27%
josef 'jeff' sipekjosef 'jeff' sipek10.03%11.27%
jan semberajan sembera10.03%11.27%
luis henriquesluis henriques10.03%11.27%
andries brouwerandries brouwer10.03%11.27%
ben collinsben collins10.03%11.27%
jan karajan kara10.03%11.27%
Total3726100.00%79100.00%
Directory: fs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.