Release 4.10 fs/proc/inode.c

Directory: fs/proc
/*
 *  linux/fs/proc/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/time.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/pid_namespace.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/completion.h>
#include <linux/poll.h>
#include <linux/printk.h>
#include <linux/file.h>
#include <linux/limits.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/sysctl.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/mount.h>
#include <linux/magic.h>

#include <linux/uaccess.h>

#include "internal.h"



static void proc_evict_inode(struct inode *inode)
{
	struct proc_dir_entry *de;
	struct ctl_table_header *head;

	truncate_inode_pages_final(&inode->i_data);
	clear_inode(inode);

	/* Stop tracking associated processes */
	put_pid(PROC_I(inode)->pid);

	/* Let go of any associated proc directory entry */
	de = PDE(inode);
	if (de)
		pde_put(de);
	head = PROC_I(inode)->sysctl;
	if (head) {
		RCU_INIT_POINTER(PROC_I(inode)->sysctl, NULL);
		sysctl_head_put(head);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 41 43.62% 3 16.67%
pre-git pre-git 29 30.85% 6 33.33%
linus torvalds linus torvalds 8 8.51% 1 5.56%
mark fasheh mark fasheh 7 7.45% 1 5.56%
eric w. biederman eric w. biederman 4 4.26% 2 11.11%
jan kara jan kara 1 1.06% 1 5.56%
alexey dobriyan alexey dobriyan 1 1.06% 1 5.56%
monam agarwal monam agarwal 1 1.06% 1 5.56%
alexander kuleshov alexander kuleshov 1 1.06% 1 5.56%
johannes weiner johannes weiner 1 1.06% 1 5.56%
Total 94 100.00% 18 100.00%


static struct kmem_cache * proc_inode_cachep;



static struct inode *proc_alloc_inode(struct super_block *sb)
{
	struct proc_inode *ei;
	struct inode *inode;

	ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
	if (!ei)
		return NULL;
	ei->pid = NULL;
	ei->fd = 0;
	ei->op.proc_get_link = NULL;
	ei->pde = NULL;
	ei->sysctl = NULL;
	ei->sysctl_entry = NULL;
	ei->ns_ops = NULL;
	inode = &ei->vfs_inode;
	return inode;
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 56 56.57% 2 28.57%
linus torvalds linus torvalds 34 34.34% 1 14.29%
eric w. biederman eric w. biederman 8 8.08% 3 42.86%
christoph lameter christoph lameter 1 1.01% 1 14.29%
Total 99 100.00% 7 100.00%



static void proc_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	kmem_cache_free(proc_inode_cachep, PROC_I(inode));
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 18 50.00% 1 50.00%
nick piggin nick piggin 18 50.00% 1 50.00%
Total 36 100.00% 2 100.00%



static void proc_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, proc_i_callback);
}

Contributors
Person Tokens Prop Commits CommitProp
nick piggin nick piggin 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static void init_once(void *foo)
{
	struct proc_inode *ei = (struct proc_inode *) foo;

	inode_init_once(&ei->vfs_inode);
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 27 90.00% 1 50.00%
christoph lameter christoph lameter 3 10.00% 1 50.00%
Total 30 100.00% 2 100.00%



void __init proc_init_inodecache(void)
{
	proc_inode_cachep = kmem_cache_create("proc_inode_cache",
					     sizeof(struct proc_inode),
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD|SLAB_ACCOUNT|
						SLAB_PANIC),
					     init_once);
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 25 71.43% 1 14.29%
paul jackson paul jackson 4 11.43% 2 28.57%
alexey dobriyan alexey dobriyan 3 8.57% 2 28.57%
vladimir davydov vladimir davydov 2 5.71% 1 14.29%
andrew morton andrew morton 1 2.86% 1 14.29%
Total 35 100.00% 7 100.00%



static int proc_show_options(struct seq_file *seq, struct dentry *root)
{
	struct super_block *sb = root->d_sb;
	struct pid_namespace *pid = sb->s_fs_info;

	if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID))
		seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, pid->pid_gid));
	if (pid->hide_pid != 0)
		seq_printf(seq, ",hidepid=%u", pid->hide_pid);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
vasiliy kulikov vasiliy kulikov 72 84.71% 2 66.67%
eric w. biederman eric w. biederman 13 15.29% 1 33.33%
Total 85 100.00% 3 100.00%


static const struct super_operations proc_sops = {
	.alloc_inode	= proc_alloc_inode,
	.destroy_inode	= proc_destroy_inode,
	.drop_inode	= generic_delete_inode,
	.evict_inode	= proc_evict_inode,
	.statfs		= simple_statfs,
	.remount_fs	= proc_remount,
	.show_options	= proc_show_options,
};


enum {BIAS = -1U<<31};



static inline int use_pde(struct proc_dir_entry *pde)
{
	return atomic_inc_unless_negative(&pde->in_use);
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 13 61.90% 2 50.00%
alexey dobriyan alexey dobriyan 6 28.57% 1 25.00%
pre-git pre-git 2 9.52% 1 25.00%
Total 21 100.00% 4 100.00%



static void unuse_pde(struct proc_dir_entry *pde)
{
	if (atomic_dec_return(&pde->in_use) == BIAS)
		complete(pde->pde_unload_completion);
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 18 60.00% 2 50.00%
alexey dobriyan alexey dobriyan 12 40.00% 2 50.00%
Total 30 100.00% 4 100.00%

/* pde is locked */


static void close_pdeo(struct proc_dir_entry *pde, struct pde_opener *pdeo)
{
	/*
         * close() (proc_reg_release()) can't delete an entry and proceed:
         * ->release hook needs to be available at the right moment.
         *
         * rmmod (remove_proc_entry() et al) can't delete an entry and proceed:
         * "struct file" needs to be available at the right moment.
         *
         * Therefore, first process to enter this function does ->release() and
         * signals its completion to the other process which does nothing.
         */
	if (pdeo->closing) {
		/* somebody else is doing that, just wait */
		DECLARE_COMPLETION_ONSTACK(c);
		pdeo->c = &c;
		spin_unlock(&pde->pde_unload_lock);
		wait_for_completion(&c);
		spin_lock(&pde->pde_unload_lock);
	} else {
		struct file *file;
		pdeo->closing = true;
		spin_unlock(&pde->pde_unload_lock);
		file = pdeo->file;
		pde->proc_fops->release(file_inode(file), file);
		spin_lock(&pde->pde_unload_lock);
		/* After ->release. */
		list_del(&pdeo->lh);
		if (pdeo->c)
			complete(pdeo->c);
		kfree(pdeo);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 133 97.08% 2 40.00%
alexey dobriyan alexey dobriyan 4 2.92% 3 60.00%
Total 137 100.00% 5 100.00%



void proc_entry_rundown(struct proc_dir_entry *de)
{
	DECLARE_COMPLETION_ONSTACK(c);
	/* Wait until all existing callers into module are done. */
	de->pde_unload_completion = &c;
	if (atomic_add_return(BIAS, &de->in_use) != BIAS)
		wait_for_completion(&c);

	/* ->pde_openers list can't grow from now on. */

	spin_lock(&de->pde_unload_lock);
	while (!list_empty(&de->pde_openers)) {
		struct pde_opener *pdeo;
		pdeo = list_first_entry(&de->pde_openers, struct pde_opener, lh);
		close_pdeo(de, pdeo);
	}
	spin_unlock(&de->pde_unload_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 99 99.00% 3 75.00%
alexey dobriyan alexey dobriyan 1 1.00% 1 25.00%
Total 100 100.00% 4 100.00%



static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
{
	struct proc_dir_entry *pde = PDE(file_inode(file));
	loff_t rv = -EINVAL;
	if (use_pde(pde)) {
		loff_t (*llseek)(struct file *, loff_t, int);
		llseek = pde->proc_fops->llseek;
		if (!llseek)
			llseek = default_llseek;
		rv = llseek(file, offset, whence);
		unuse_pde(pde);
	}
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 61 63.54% 1 16.67%
pre-git pre-git 18 18.75% 1 16.67%
al viro al viro 13 13.54% 2 33.33%
eric w. biederman eric w. biederman 2 2.08% 1 16.67%
kirill korotaev kirill korotaev 2 2.08% 1 16.67%
Total 96 100.00% 6 100.00%



static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
	struct proc_dir_entry *pde = PDE(file_inode(file));
	ssize_t rv = -EIO;
	if (use_pde(pde)) {
		read = pde->proc_fops->read;
		if (read)
			rv = read(file, buf, count, ppos);
		unuse_pde(pde);
	}
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 76 73.08% 1 33.33%
al viro al viro 22 21.15% 1 33.33%
pre-git pre-git 6 5.77% 1 33.33%
Total 104 100.00% 3 100.00%



static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
	ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
	struct proc_dir_entry *pde = PDE(file_inode(file));
	ssize_t rv = -EIO;
	if (use_pde(pde)) {
		write = pde->proc_fops->write;
		if (write)
			rv = write(file, buf, count, ppos);
		unuse_pde(pde);
	}
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 84 79.25% 1 50.00%
al viro al viro 22 20.75% 1 50.00%
Total 106 100.00% 2 100.00%



static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
{
	struct proc_dir_entry *pde = PDE(file_inode(file));
	unsigned int rv = DEFAULT_POLLMASK;
	unsigned int (*poll)(struct file *, struct poll_table_struct *);
	if (use_pde(pde)) {
		poll = pde->proc_fops->poll;
		if (poll)
			rv = poll(file, pts);
		unuse_pde(pde);
	}
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 82 91.11% 2 50.00%
al viro al viro 8 8.89% 2 50.00%
Total 90 100.00% 4 100.00%



static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct proc_dir_entry *pde = PDE(file_inode(file));
	long rv = -ENOTTY;
	long (*ioctl)(struct file *, unsigned int, unsigned long);
	if (use_pde(pde)) {
		ioctl = pde->proc_fops->unlocked_ioctl;
		if (ioctl)
			rv = ioctl(file, cmd, arg);
		unuse_pde(pde);
	}
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 86 90.53% 1 25.00%
al viro al viro 8 8.42% 2 50.00%
arnd bergmann arnd bergmann 1 1.05% 1 25.00%
Total 95 100.00% 4 100.00%

#ifdef CONFIG_COMPAT


static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct proc_dir_entry *pde = PDE(file_inode(file));
	long rv = -ENOTTY;
	long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
	if (use_pde(pde)) {
		compat_ioctl = pde->proc_fops->compat_ioctl;
		if (compat_ioctl)
			rv = compat_ioctl(file, cmd, arg);
		unuse_pde(pde);
	}
	return rv;
}
Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 87 91.58% 1 33.33%
al viro al viro 8 8.42% 2 66.67%
Total 95 100.00% 3 100.00%

#endif



static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct proc_dir_entry *pde = PDE(file_inode(file));
	int rv = -EIO;
	int (*mmap)(struct file *, struct vm_area_struct *);
	if (use_pde(pde)) {
		mmap = pde->proc_fops->mmap;
		if (mmap)
			rv = mmap(file, vma);
		unuse_pde(pde);
	}
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 80 90.91% 1 33.33%
al viro al viro 8 9.09% 2 66.67%
Total 88 100.00% 3 100.00%


static unsigned long

proc_reg_get_unmapped_area(struct file *file, unsigned long orig_addr,
			   unsigned long len, unsigned long pgoff,
			   unsigned long flags)
{
	struct proc_dir_entry *pde = PDE(file_inode(file));
	unsigned long rv = -EIO;

	if (use_pde(pde)) {
		typeof(proc_reg_get_unmapped_area) *get_area;

		get_area = pde->proc_fops->get_unmapped_area;
#ifdef CONFIG_MMU
		if (!get_area)
			get_area = current->mm->get_unmapped_area;
#endif

		if (get_area)
			rv = get_area(file, orig_addr, len, pgoff, flags);
		else
			rv = orig_addr;
		unuse_pde(pde);
	}
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 85 69.67% 1 20.00%
jan beulich jan beulich 23 18.85% 1 20.00%
daisuke hatayama daisuke hatayama 14 11.48% 3 60.00%
Total 122 100.00% 5 100.00%



static int proc_reg_open(struct inode *inode, struct file *file)
{
	struct proc_dir_entry *pde = PDE(inode);
	int rv = 0;
	int (*open)(struct inode *, struct file *);
	int (*release)(struct inode *, struct file *);
	struct pde_opener *pdeo;

	/*
         * Ensure that
         * 1) PDE's ->release hook will be called no matter what
         *    either normally by close()/->release, or forcefully by
         *    rmmod/remove_proc_entry.
         *
         * 2) rmmod isn't blocked by opening file in /proc and sitting on
         *    the descriptor (including "rmmod foo </proc/foo" scenario).
         *
         * Save every "struct file" with custom ->release hook.
         */
	pdeo = kmalloc(sizeof(struct pde_opener), GFP_KERNEL);
	if (!pdeo)
		return -ENOMEM;

	if (!use_pde(pde)) {
		kfree(pdeo);
		return -ENOENT;
	}
	open = pde->proc_fops->open;
	release = pde->proc_fops->release;

	if (open)
		rv = open(inode, file);

	if (rv == 0 && release) {
		/* To know what to release. */
		pdeo->file = file;
		pdeo->closing = false;
		pdeo->c = NULL;
		spin_lock(&pde->pde_unload_lock);
		list_add(&pdeo->lh, &pde->pde_openers);
		spin_unlock(&pde->pde_unload_lock);
	} else
		kfree(pdeo);

	unuse_pde(pde);
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 188 89.95% 5 62.50%
al viro al viro 20 9.57% 2 25.00%
daisuke ogino daisuke ogino 1 0.48% 1 12.50%
Total 209 100.00% 8 100.00%



static int proc_reg_release(struct inode *inode, struct file *file)
{
	struct proc_dir_entry *pde = PDE(inode);
	struct pde_opener *pdeo;
	spin_lock(&pde->pde_unload_lock);
	list_for_each_entry(pdeo, &pde->pde_openers, lh) {
		if (pdeo->file == file) {
			close_pdeo(pde, pdeo);
			break;
		}
	}
	spin_unlock(&pde->pde_unload_lock);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 66 84.62% 2 66.67%
al viro al viro 12 15.38% 1 33.33%
Total 78 100.00% 3 100.00%


static const struct file_operations proc_reg_file_ops = {
	.llseek		= proc_reg_llseek,
	.read		= proc_reg_read,
	.write		= proc_reg_write,
	.poll		= proc_reg_poll,
	.unlocked_ioctl	= proc_reg_unlocked_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= proc_reg_compat_ioctl,
#endif
	.mmap		= proc_reg_mmap,
	.get_unmapped_area = proc_reg_get_unmapped_area,
	.open		= proc_reg_open,
	.release	= proc_reg_release,
};

#ifdef CONFIG_COMPAT

static const struct file_operations proc_reg_file_ops_no_compat = {
	.llseek		= proc_reg_llseek,
	.read		= proc_reg_read,
	.write		= proc_reg_write,
	.poll		= proc_reg_poll,
	.unlocked_ioctl	= proc_reg_unlocked_ioctl,
	.mmap		= proc_reg_mmap,
	.get_unmapped_area = proc_reg_get_unmapped_area,
	.open		= proc_reg_open,
	.release	= proc_reg_release,
};
#endif



static void proc_put_link(void *p)
{
	unuse_pde(p);
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static const char *proc_get_link(struct dentry *dentry,
				 struct inode *inode,
				 struct delayed_call *done)
{
	struct proc_dir_entry *pde = PDE(inode);
	if (unlikely(!use_pde(pde)))
		return ERR_PTR(-EINVAL);
	set_delayed_call(done, proc_put_link, pde);
	return pde->data;
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 65 100.00% 4 100.00%
Total 65 100.00% 4 100.00%


const struct inode_operations proc_link_inode_operations = {
	.get_link	= proc_get_link,
};



struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
{
	struct inode *inode = new_inode_pseudo(sb);

	if (inode) {
		inode->i_ino = de->low_ino;
		inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
		PROC_I(inode)->pde = de;

		if (is_empty_pde(de)) {
			make_empty_dir_inode(inode);
			return inode;
		}
		if (de->mode) {
			inode->i_mode = de->mode;
			inode->i_uid = de->uid;
			inode->i_gid = de->gid;
		}
		if (de->size)
			inode->i_size = de->size;
		if (de->nlink)
			set_nlink(inode, de->nlink);
		WARN_ON(!de->proc_iops);
		inode->i_op = de->proc_iops;
		if (de->proc_fops) {
			if (S_ISREG(inode->i_mode)) {
#ifdef CONFIG_COMPAT
				if (!de->proc_fops->compat_ioctl)
					inode->i_fop =
						&proc_reg_file_ops_no_compat;
				else
#endif
					inode->i_fop = &proc_reg_file_ops;
			} else {
				inode->i_fop = de->proc_fops;
			}
		}
	} else
	       pde_put(de);
	return inode;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 113 49.34% 2 13.33%
linus torvalds linus torvalds 33 14.41% 2 13.33%
david s. miller david s. miller 24 10.48% 1 6.67%
eric w. biederman eric w. biederman 17 7.42% 1 6.67%
david howells david howells 17 7.42% 1 6.67%
al viro al viro 7 3.06% 2 13.33%
pre-git pre-git 5 2.18% 2 13.33%
krzysztof sachanowicz krzysztof sachanowicz 4 1.75% 1 6.67%
deepa dinamani deepa dinamani 4 1.75% 1 6.67%
miklos szeredi miklos szeredi 4 1.75% 1 6.67%
denis v. lunev denis v. lunev 1 0.44% 1 6.67%
Total 229 100.00% 15 100.00%



int proc_fill_super(struct super_block *s, void *data, int silent)
{
	struct pid_namespace *ns = get_pid_ns(s->s_fs_info);
	struct inode *root_inode;
	int ret;

	if (!proc_parse_options(data, ns))
		return -EINVAL;

	/* User space would break if executables or devices appear on proc */
	s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;
	s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
	s->s_blocksize = 1024;
	s->s_blocksize_bits = 10;
	s->s_magic = PROC_SUPER_MAGIC;
	s->s_op = &proc_sops;
	s->s_time_gran = 1;

	/*
         * procfs isn't actually a stacking filesystem; however, there is
         * too much magic going on inside it to permit stacking things on
         * top of it
         */
	s->s_stack_depth = FILESYSTEM_MAX_STACK_DEPTH;
	
	pde_get(&proc_root);
	root_inode = proc_get_inode(s, &proc_root);
	if (!root_inode) {
		pr_err("proc_fill_super: get root inode failed\n");
		return -ENOMEM;
	}

	s->s_root = d_make_root(root_inode);
	if (!s->s_root) {
		pr_err("proc_fill_super: allocate dentry failed\n");
		return -ENOMEM;
	}

	ret = proc_setup_self(s);
	if (ret) {
		return ret;
	}
	return proc_setup_thread_self(s);
}
Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 62 32.46% 4 21.05%
pre-git pre-git 52 27.23% 5 26.32%
maxim patlasov maxim patlasov 38 19.90% 1 5.26%
linus torvalds linus torvalds 11 5.76% 2 10.53%
andrew morton andrew morton 8 4.19% 2 10.53%
al viro al viro 8 4.19% 2 10.53%
alexey dobriyan alexey dobriyan 6 3.14% 2 10.53%
andi kleen andi kleen 6 3.14% 1 5.26%
Total 191 100.00% 19 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 1120 44.22% 13 12.87%
al viro al viro 685 27.04% 17 16.83%
pre-git pre-git 152 6.00% 14 13.86%
eric w. biederman eric w. biederman 106 4.18% 11 10.89%
vasiliy kulikov vasiliy kulikov 91 3.59% 2 1.98%
linus torvalds linus torvalds 89 3.51% 7 6.93%
david s. miller david s. miller 77 3.04% 1 0.99%
nick piggin nick piggin 39 1.54% 1 0.99%
maxim patlasov maxim patlasov 38 1.50% 1 0.99%
jan beulich jan beulich 23 0.91% 1 0.99%
david howells david howells 20 0.79% 2 1.98%
daisuke hatayama daisuke hatayama 14 0.55% 3 2.97%
andrew morton andrew morton 12 0.47% 3 2.97%
art haas art haas 10 0.39% 1 0.99%
andi kleen andi kleen 9 0.36% 2 1.98%
mark fasheh mark fasheh 7 0.28% 1 0.99%
christoph lameter christoph lameter 6 0.24% 3 2.97%
miklos szeredi miklos szeredi 4 0.16% 1 0.99%
krzysztof sachanowicz krzysztof sachanowicz 4 0.16% 1 0.99%
deepa dinamani deepa dinamani 4 0.16% 1 0.99%
paul jackson paul jackson 4 0.16% 2 1.98%
tejun heo tejun heo 3 0.12% 1 0.99%
adrian bunk adrian bunk 3 0.12% 1 0.99%
kirill korotaev kirill korotaev 2 0.08% 1 0.99%
vladimir davydov vladimir davydov 2 0.08% 1 0.99%
jan kara jan kara 1 0.04% 1 0.99%
josef 'jeff' sipek josef 'jeff' sipek 1 0.04% 1 0.99%
johannes weiner johannes weiner 1 0.04% 1 0.99%
daisuke ogino daisuke ogino 1 0.04% 1 0.99%
arnd bergmann arnd bergmann 1 0.04% 1 0.99%
monam agarwal monam agarwal 1 0.04% 1 0.99%
dave jones dave jones 1 0.04% 1 0.99%
denis v. lunev denis v. lunev 1 0.04% 1 0.99%
alexander kuleshov alexander kuleshov 1 0.04% 1 0.99%
Total 2533 100.00% 101 100.00%
Directory: fs/proc

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
al viro	al viro	41	43.62%	3	16.67%
pre-git	pre-git	29	30.85%	6	33.33%
linus torvalds	linus torvalds	8	8.51%	1	5.56%
mark fasheh	mark fasheh	7	7.45%	1	5.56%
eric w. biederman	eric w. biederman	4	4.26%	2	11.11%
jan kara	jan kara	1	1.06%	1	5.56%
alexey dobriyan	alexey dobriyan	1	1.06%	1	5.56%
monam agarwal	monam agarwal	1	1.06%	1	5.56%
alexander kuleshov	alexander kuleshov	1	1.06%	1	5.56%
johannes weiner	johannes weiner	1	1.06%	1	5.56%
	Total	94	100.00%	18	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/proc/inode.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
