Release 4.10 fs/proc/base.c

Directory: fs/proc
/*
 *  linux/fs/proc/base.c
 *
 *  Copyright (C) 1991, 1992 Linus Torvalds
 *
 *  proc base directory handling functions
 *
 *  1999, Al Viro. Rewritten. Now it covers the whole per-process part.
 *  Instead of using magical inumbers to determine the kind of object
 *  we allocate and fill in-core inodes upon lookup. They don't even
 *  go into icache. We cache the reference to task_struct upon lookup too.
 *  Eventually it should become a filesystem in its own. We don't use the
 *  rest of procfs anymore.
 *
 *
 *  Changelog:
 *  17-Jan-2005
 *  Allan Bezerra
 *  Bruna Moreira <bruna.moreira@indt.org.br>
 *  Edjard Mota <edjard.mota@indt.org.br>
 *  Ilias Biris <ilias.biris@indt.org.br>
 *  Mauricio Lin <mauricio.lin@indt.org.br>
 *
 *  Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
 *
 *  A new process specific entry (smaps) included in /proc. It shows the
 *  size of rss for each memory area. The maps entry lacks information
 *  about physical memory size (rss) for each mapped file, i.e.,
 *  rss information for executables and library files.
 *  This additional information is useful for any tools that need to know
 *  about physical memory consumption for a process specific library.
 *
 *  Changelog:
 *  21-Feb-2005
 *  Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
 *  Pud inclusion in the page table walking.
 *
 *  ChangeLog:
 *  10-Mar-2005
 *  10LE Instituto Nokia de Tecnologia - INdT:
 *  A better way to walks through the page table as suggested by Hugh Dickins.
 *
 *  Simo Piiroinen <simo.piiroinen@nokia.com>:
 *  Smaps information related to shared, private, clean and dirty pages.
 *
 *  Paul Mundt <paul.mundt@nokia.com>:
 *  Overall revision about smaps.
 */

#include <linux/uaccess.h>

#include <linux/errno.h>
#include <linux/time.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/task_io_accounting_ops.h>
#include <linux/init.h>
#include <linux/capability.h>
#include <linux/file.h>
#include <linux/fdtable.h>
#include <linux/string.h>
#include <linux/seq_file.h>
#include <linux/namei.h>
#include <linux/mnt_namespace.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/rcupdate.h>
#include <linux/kallsyms.h>
#include <linux/stacktrace.h>
#include <linux/resource.h>
#include <linux/module.h>
#include <linux/mount.h>
#include <linux/security.h>
#include <linux/ptrace.h>
#include <linux/tracehook.h>
#include <linux/printk.h>
#include <linux/cgroup.h>
#include <linux/cpuset.h>
#include <linux/audit.h>
#include <linux/poll.h>
#include <linux/nsproxy.h>
#include <linux/oom.h>
#include <linux/elf.h>
#include <linux/pid_namespace.h>
#include <linux/user_namespace.h>
#include <linux/fs_struct.h>
#include <linux/slab.h>
#include <linux/flex_array.h>
#include <linux/posix-timers.h>
#ifdef CONFIG_HARDWALL
#include <asm/hardwall.h>
#endif
#include <trace/events/oom.h>
#include "internal.h"
#include "fd.h"

/* NOTE:
 *      Implementing inode permission operations in /proc is almost
 *      certainly an error.  Permission checks need to happen during
 *      each system call not at open time.  The reason is that most of
 *      what we wish to check for permissions in /proc varies at runtime.
 *
 *      The classic example of a problem is opening file descriptors
 *      in /proc for a task before it execs a suid executable.
 */


static u8 nlink_tid;

static u8 nlink_tgid;


struct pid_entry {
	
const char *name;
	
unsigned int len;
	
umode_t mode;
	
const struct inode_operations *iop;
	
const struct file_operations *fop;
	
union proc_op op;
};


#define NOD(NAME, MODE, IOP, FOP, OP) {                       \
        .name = (NAME),                                 \
        .len  = sizeof(NAME) - 1,                       \
        .mode = MODE,                                   \
        .iop  = IOP,                                    \
        .fop  = FOP,                                    \
        .op   = OP,                                     \
}


#define DIR(NAME, MODE, iops, fops)	\
	NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} )

#define LNK(NAME, get_link)					\
	NOD(NAME, (S_IFLNK|S_IRWXUGO),                          \
                &proc_pid_link_inode_operations, NULL,          \
                { .proc_get_link = get_link } )

#define REG(NAME, MODE, fops)				\
	NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {})

#define ONE(NAME, MODE, show)				\
	NOD(NAME, (S_IFREG|(MODE)),                     \
                NULL, &proc_single_file_operations,     \
                { .proc_show = show } )

/*
 * Count the number of hardlinks for the pid_entry table, excluding the .
 * and .. links.
 */


static unsigned int __init pid_entry_nlink(const struct pid_entry *entries,
	unsigned int n)
{
	unsigned int i;
	unsigned int count;

	count = 2;
	for (i = 0; i < n; ++i) {
		if (S_ISDIR(entries[i].mode))
			++count;
	}

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
vegard nossum vegard nossum 60 95.24% 1 50.00%
alexey dobriyan alexey dobriyan 3 4.76% 1 50.00%
Total 63 100.00% 2 100.00%



static int get_task_root(struct task_struct *task, struct path *root)
{
	int result = -ENOENT;

	task_lock(task);
	if (task->fs) {
		get_fs_root(task->fs, root);
		result = 0;
	}
	task_unlock(task);
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
hugh dickins hugh dickins 23 41.07% 1 25.00%
eric w. biederman eric w. biederman 20 35.71% 1 25.00%
albert cahalan albert cahalan 7 12.50% 1 25.00%
miklos szeredi miklos szeredi 6 10.71% 1 25.00%
Total 56 100.00% 4 100.00%



static int proc_cwd_link(struct dentry *dentry, struct path *path)
{
	struct task_struct *task = get_proc_task(d_inode(dentry));
	int result = -ENOENT;

	if (task) {
		task_lock(task);
		if (task->fs) {
			get_fs_pwd(task->fs, path);
			result = 0;
		}
		task_unlock(task);
		put_task_struct(task);
	}
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 39 48.75% 1 14.29%
miklos szeredi miklos szeredi 24 30.00% 1 14.29%
albert cahalan albert cahalan 6 7.50% 1 14.29%
hugh dickins hugh dickins 3 3.75% 1 14.29%
david howells david howells 3 3.75% 1 14.29%
cyrill gorcunov cyrill gorcunov 3 3.75% 1 14.29%
jan blunck jan blunck 2 2.50% 1 14.29%
Total 80 100.00% 7 100.00%



static int proc_root_link(struct dentry *dentry, struct path *path)
{
	struct task_struct *task = get_proc_task(d_inode(dentry));
	int result = -ENOENT;

	if (task) {
		result = get_task_root(task, path);
		put_task_struct(task);
	}
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 39 67.24% 1 12.50%
albert cahalan albert cahalan 5 8.62% 1 12.50%
cyrill gorcunov cyrill gorcunov 3 5.17% 1 12.50%
hugh dickins hugh dickins 3 5.17% 1 12.50%
david howells david howells 3 5.17% 1 12.50%
chuck lever chuck lever 2 3.45% 1 12.50%
jan blunck jan blunck 2 3.45% 1 12.50%
miklos szeredi miklos szeredi 1 1.72% 1 12.50%
Total 58 100.00% 8 100.00%



static ssize_t proc_pid_cmdline_read(struct file *file, char __user *buf,
				     size_t _count, loff_t *pos)
{
	struct task_struct *tsk;
	struct mm_struct *mm;
	char *page;
	unsigned long count = _count;
	unsigned long arg_start, arg_end, env_start, env_end;
	unsigned long len1, len2, len;
	unsigned long p;
	char c;
	ssize_t rv;

	BUG_ON(*pos < 0);

	tsk = get_proc_task(file_inode(file));
	if (!tsk)
		return -ESRCH;
	mm = get_task_mm(tsk);
	put_task_struct(tsk);
	if (!mm)
		return 0;
	/* Check if process spawned far enough to have cmdline. */
	if (!mm->env_end) {
		rv = 0;
		goto out_mmput;
	}

	page = (char *)__get_free_page(GFP_TEMPORARY);
	if (!page) {
		rv = -ENOMEM;
		goto out_mmput;
	}

	down_read(&mm->mmap_sem);
	arg_start = mm->arg_start;
	arg_end = mm->arg_end;
	env_start = mm->env_start;
	env_end = mm->env_end;
	up_read(&mm->mmap_sem);

	BUG_ON(arg_start > arg_end);
	BUG_ON(env_start > env_end);

	len1 = arg_end - arg_start;
	len2 = env_end - env_start;

	/* Empty ARGV. */
	if (len1 == 0) {
		rv = 0;
		goto out_free_page;
	}
	/*
         * Inherently racy -- command line shares address space
         * with code and data.
         */
	rv = access_remote_vm(mm, arg_end - 1, &c, 1, 0);
	if (rv <= 0)
		goto out_free_page;

	rv = 0;

	if (c == '\0') {
		/* Command line (set of strings) occupies whole ARGV. */
		if (len1 <= *pos)
			goto out_free_page;

		p = arg_start + *pos;
		len = len1 - *pos;
		while (count > 0 && len > 0) {
			unsigned int _count;
			int nr_read;

			_count = min3(count, len, PAGE_SIZE);
			nr_read = access_remote_vm(mm, p, page, _count, 0);
			if (nr_read < 0)
				rv = nr_read;
			if (nr_read <= 0)
				goto out_free_page;

			if (copy_to_user(buf, page, nr_read)) {
				rv = -EFAULT;
				goto out_free_page;
			}

			p	+= nr_read;
			len	-= nr_read;
			buf	+= nr_read;
			count	-= nr_read;
			rv	+= nr_read;
		}
	} else {
		/*
                 * Command line (1 string) occupies ARGV and maybe
                 * extends into ENVP.
                 */
		if (len1 + len2 <= *pos)
			goto skip_argv_envp;
		if (len1 <= *pos)
			goto skip_argv;

		p = arg_start + *pos;
		len = len1 - *pos;
		while (count > 0 && len > 0) {
			unsigned int _count, l;
			int nr_read;
			bool final;

			_count = min3(count, len, PAGE_SIZE);
			nr_read = access_remote_vm(mm, p, page, _count, 0);
			if (nr_read < 0)
				rv = nr_read;
			if (nr_read <= 0)
				goto out_free_page;

			/*
                         * Command line can be shorter than whole ARGV
                         * even if last "marker" byte says it is not.
                         */
			final = false;
			l = strnlen(page, nr_read);
			if (l < nr_read) {
				nr_read = l;
				final = true;
			}

			if (copy_to_user(buf, page, nr_read)) {
				rv = -EFAULT;
				goto out_free_page;
			}

			p	+= nr_read;
			len	-= nr_read;
			buf	+= nr_read;
			count	-= nr_read;
			rv	+= nr_read;

			if (final)
				goto out_free_page;
		}
skip_argv:
		/*
                 * Command line (1 string) occupies ARGV and
                 * extends into ENVP.
                 */
		if (len1 <= *pos) {
			p = env_start + *pos - len1;
			len = len1 + len2 - *pos;
		} else {
			p = env_start;
			len = len2;
		}
		while (count > 0 && len > 0) {
			unsigned int _count, l;
			int nr_read;
			bool final;

			_count = min3(count, len, PAGE_SIZE);
			nr_read = access_remote_vm(mm, p, page, _count, 0);
			if (nr_read < 0)
				rv = nr_read;
			if (nr_read <= 0)
				goto out_free_page;

			/* Find EOS. */
			final = false;
			l = strnlen(page, nr_read);
			if (l < nr_read) {
				nr_read = l;
				final = true;
			}

			if (copy_to_user(buf, page, nr_read)) {
				rv = -EFAULT;
				goto out_free_page;
			}

			p	+= nr_read;
			len	-= nr_read;
			buf	+= nr_read;
			count	-= nr_read;
			rv	+= nr_read;

			if (final)
				goto out_free_page;
		}
skip_argv_envp:
		;
	}

out_free_page:
	free_page((unsigned long)page);
out_mmput:
	mmput(mm);
	if (rv > 0)
		*pos += rv;
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 805 97.81% 3 37.50%
eric w. biederman eric w. biederman 10 1.22% 1 12.50%
linus torvalds linus torvalds 4 0.49% 1 12.50%
christoph lameter christoph lameter 2 0.24% 1 12.50%
andrea arcangeli andrea arcangeli 1 0.12% 1 12.50%
al viro al viro 1 0.12% 1 12.50%
Total 823 100.00% 8 100.00%


static const struct file_operations proc_pid_cmdline_ops = {
	.read	= proc_pid_cmdline_read,
	.llseek	= generic_file_llseek,
};

#ifdef CONFIG_KALLSYMS
/*
 * Provides a wchan file via kallsyms in a proper one-value-per-file format.
 * Returns the resolved symbol.  If that fails, simply return the address.
 */


static int proc_pid_wchan(struct seq_file *m, struct pid_namespace *ns,
			  struct pid *pid, struct task_struct *task)
{
	unsigned long wchan;
	char symname[KSYM_NAME_LEN];

	wchan = get_wchan(task);

	if (wchan && ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)
			&& !lookup_symbol_name(wchan, symname))
		seq_printf(m, "%s", symname);
	else
		seq_putc(m, '0');

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 28 34.15% 1 9.09%
alexey dobriyan alexey dobriyan 22 26.83% 2 18.18%
ingo molnar ingo molnar 11 13.41% 1 9.09%
jake edge jake edge 6 7.32% 1 9.09%
joe perches joe perches 4 4.88% 1 9.09%
rick lindsley rick lindsley 4 4.88% 1 9.09%
paul jackson paul jackson 3 3.66% 1 9.09%
robin humble robin humble 2 2.44% 1 9.09%
robert love robert love 1 1.22% 1 9.09%
jann horn jann horn 1 1.22% 1 9.09%
Total 82 100.00% 11 100.00%

#endif /* CONFIG_KALLSYMS */



static int lock_trace(struct task_struct *task)
{
	int err = mutex_lock_killable(&task->signal->cred_guard_mutex);
	if (err)
		return err;
	if (!ptrace_may_access(task, PTRACE_MODE_ATTACH_FSCREDS)) {
		mutex_unlock(&task->signal->cred_guard_mutex);
		return -EPERM;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 59 98.33% 1 50.00%
jann horn jann horn 1 1.67% 1 50.00%
Total 60 100.00% 2 100.00%



static void unlock_trace(struct task_struct *task)
{
	mutex_unlock(&task->signal->cred_guard_mutex);
}

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

#ifdef CONFIG_STACKTRACE


#define MAX_STACK_TRACE_DEPTH	64



static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,
			  struct pid *pid, struct task_struct *task)
{
	struct stack_trace trace;
	unsigned long *entries;
	int err;
	int i;

	entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL);
	if (!entries)
		return -ENOMEM;

	trace.nr_entries	= 0;
	trace.max_entries	= MAX_STACK_TRACE_DEPTH;
	trace.entries		= entries;
	trace.skip		= 0;

	err = lock_trace(task);
	if (!err) {
		save_stack_trace_tsk(task, &trace);

		for (i = 0; i < trace.nr_entries; i++) {
			seq_printf(m, "[<%pK>] %pB\n",
				   (void *)entries[i], (void *)entries[i]);
		}
		unlock_trace(task);
	}
	kfree(entries);

	return err;
}
Contributors
Person Tokens Prop Commits CommitProp
ken chen ken chen 142 85.54% 1 33.33%
al viro al viro 23 13.86% 1 33.33%
josh poimboeuf josh poimboeuf 1 0.60% 1 33.33%
Total 166 100.00% 3 100.00%

#endif

#ifdef CONFIG_SCHED_INFO
/*
 * Provides /proc/PID/schedstat
 */


static int proc_pid_schedstat(struct seq_file *m, struct pid_namespace *ns,
			      struct pid *pid, struct task_struct *task)
{
	if (unlikely(!sched_info_on()))
		seq_printf(m, "0 0 0\n");
	else
		seq_printf(m, "%llu %llu %lu\n",
		   (unsigned long long)task->se.sum_exec_runtime,
		   (unsigned long long)task->sched_info.run_delay,
		   task->sched_info.pcount);

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 21 25.93% 1 11.11%
alexey dobriyan alexey dobriyan 17 20.99% 1 11.11%
naveen n. rao naveen n. rao 17 20.99% 1 11.11%
ingo molnar ingo molnar 11 13.58% 2 22.22%
andrew morton andrew morton 9 11.11% 1 11.11%
joe perches joe perches 3 3.70% 1 11.11%
ken chen ken chen 2 2.47% 1 11.11%
balbir singh balbir singh 1 1.23% 1 11.11%
Total 81 100.00% 9 100.00%

#endif

#ifdef CONFIG_LATENCYTOP


static int lstats_show_proc(struct seq_file *m, void *v)
{
	int i;
	struct inode *inode = m->private;
	struct task_struct *task = get_proc_task(inode);

	if (!task)
		return -ESRCH;
	seq_puts(m, "Latency Top version : v0.1\n");
	for (i = 0; i < 32; i++) {
		struct latency_record *lr = &task->latency_record[i];
		if (lr->backtrace[0]) {
			int q;
			seq_printf(m, "%i %li %li",
				   lr->count, lr->time, lr->max);
			for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
				unsigned long bt = lr->backtrace[q];
				if (!bt)
					break;
				if (bt == ULONG_MAX)
					break;
				seq_printf(m, " %ps", (void *)bt);
			}
			seq_putc(m, '\n');
		}

	}
	put_task_struct(task);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arjan van de ven arjan van de ven 122 67.40% 1 25.00%
joe perches joe perches 31 17.13% 1 25.00%
hiroshi shimamoto hiroshi shimamoto 26 14.36% 1 25.00%
alexey dobriyan alexey dobriyan 2 1.10% 1 25.00%
Total 181 100.00% 4 100.00%



static int lstats_open(struct inode *inode, struct file *file)
{
	return single_open(file, lstats_show_proc, inode);
}

Contributors
Person Tokens Prop Commits CommitProp
arjan van de ven arjan van de ven 21 80.77% 1 33.33%
hiroshi shimamoto hiroshi shimamoto 5 19.23% 2 66.67%
Total 26 100.00% 3 100.00%



static ssize_t lstats_write(struct file *file, const char __user *buf,
			    size_t count, loff_t *offs)
{
	struct task_struct *task = get_proc_task(file_inode(file));

	if (!task)
		return -ESRCH;
	clear_all_latency_tracing(task);
	put_task_struct(task);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
arjan van de ven arjan van de ven 37 62.71% 1 33.33%
hiroshi shimamoto hiroshi shimamoto 19 32.20% 1 33.33%
al viro al viro 3 5.08% 1 33.33%
Total 59 100.00% 3 100.00%


static const struct file_operations proc_lstats_operations = {
	.open		= lstats_open,
	.read		= seq_read,
	.write		= lstats_write,
	.llseek		= seq_lseek,
	.release	= single_release,
};

#endif



static int proc_oom_score(struct seq_file *m, struct pid_namespace *ns,
			  struct pid *pid, struct task_struct *task)
{
	unsigned long totalpages = totalram_pages + total_swap_pages;
	unsigned long points = 0;

	points = oom_badness(task, NULL, NULL, totalpages) *
					1000 / totalpages;
	seq_printf(m, "%lu\n", points);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 21 30.43% 1 10.00%
alexey dobriyan alexey dobriyan 17 24.64% 1 10.00%
david rientjes david rientjes 14 20.29% 2 20.00%
eric paris eric paris 4 5.80% 1 10.00%
kosaki motohiro kosaki motohiro 4 5.80% 1 10.00%
joe perches joe perches 3 4.35% 1 10.00%
michael lemay michael lemay 3 4.35% 1 10.00%
oleg nesterov oleg nesterov 2 2.90% 1 10.00%
andrew morton andrew morton 1 1.45% 1 10.00%
Total 69 100.00% 10 100.00%


struct limit_names {
	
const char *name;
	
const char *unit;
};


static const struct limit_names lnames[RLIM_NLIMITS] = {
	[RLIMIT_CPU] = {"Max cpu time", "seconds"},
	[RLIMIT_FSIZE] = {"Max file size", "bytes"},
	[RLIMIT_DATA] = {"Max data size", "bytes"},
	[RLIMIT_STACK] = {"Max stack size", "bytes"},
	[RLIMIT_CORE] = {"Max core file size", "bytes"},
	[RLIMIT_RSS] = {"Max resident set", "bytes"},
	[RLIMIT_NPROC] = {"Max processes", "processes"},
	[RLIMIT_NOFILE] = {"Max open files", "files"},
	[RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"},
	[RLIMIT_AS] = {"Max address space", "bytes"},
	[RLIMIT_LOCKS] = {"Max file locks", "locks"},
	[RLIMIT_SIGPENDING] = {"Max pending signals", "signals"},
	[RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
	[RLIMIT_NICE] = {"Max nice priority", NULL},
	[RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
	[RLIMIT_RTTIME] = {"Max realtime timeout", "us"},
};

/* Display limits for a process */


static int proc_pid_limits(struct seq_file *m, struct pid_namespace *ns,
			   struct pid *pid, struct task_struct *task)
{
	unsigned int i;
	unsigned long flags;

	struct rlimit rlim[RLIM_NLIMITS];

	if (!lock_task_sighand(task, &flags))
		return 0;
	memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);
	unlock_task_sighand(task, &flags);

	/*
         * print the file header
         */
       seq_printf(m, "%-25s %-20s %-20s %-10s\n",
		  "Limit", "Soft Limit", "Hard Limit", "Units");

	for (i = 0; i < RLIM_NLIMITS; i++) {
		if (rlim[i].rlim_cur == RLIM_INFINITY)
			seq_printf(m, "%-25s %-20s ",
				   lnames[i].name, "unlimited");
		else
			seq_printf(m, "%-25s %-20lu ",
				   lnames[i].name, rlim[i].rlim_cur);

		if (rlim[i].rlim_max == RLIM_INFINITY)
			seq_printf(m, "%-20s ", "unlimited");
		else
			seq_printf(m, "%-20lu ", rlim[i].rlim_max);

		if (lnames[i].unit)
			seq_printf(m, "%-10s\n", lnames[i].unit);
		else
			seq_putc(m, '\n');
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
neil horman neil horman 200 86.58% 1 50.00%
alexey dobriyan alexey dobriyan 31 13.42% 1 50.00%
Total 231 100.00% 2 100.00%

#ifdef CONFIG_HAVE_ARCH_TRACEHOOK


static int proc_pid_syscall(struct seq_file *m, struct pid_namespace *ns,
			    struct pid *pid, struct task_struct *task)
{
	long nr;
	unsigned long args[6], sp, pc;
	int res;

	res = lock_trace(task);
	if (res)
		return res;

	if (task_current_syscall(task, &nr, args, 6, &sp, &pc))
		seq_puts(m, "running\n");
	else if (nr < 0)
		seq_printf(m, "%ld 0x%lx 0x%lx\n", nr, sp, pc);
	else
		seq_printf(m,
		       "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
		       nr,
		       args[0], args[1], args[2], args[3], args[4], args[5],
		       sp, pc);
	unlock_trace(task);

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
roland mcgrath roland mcgrath 106 67.95% 1 25.00%
al viro al viro 24 15.38% 1 25.00%
alexey dobriyan alexey dobriyan 21 13.46% 1 25.00%
joe perches joe perches 5 3.21% 1 25.00%
Total 156 100.00% 4 100.00%

#endif /* CONFIG_HAVE_ARCH_TRACEHOOK */

/************************************************************************/
/*                       Here the fs part begins                        */
/************************************************************************/

/* permission checks */


static int proc_fd_access_allowed(struct inode *inode)
{
	struct task_struct *task;
	int allowed = 0;
	/* Allow access to a task's file descriptors if it is us or we
         * may use ptrace attach to the process and find out that
         * information.
         */
	task = get_proc_task(inode);
	if (task) {
		allowed = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);
		put_task_struct(task);
	}
	return allowed;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 25 48.08% 2 18.18%
al viro al viro 14 26.92% 3 27.27%
pre-git pre-git 10 19.23% 4 36.36%
stephen d. smalley stephen d. smalley 2 3.85% 1 9.09%
jann horn jann horn 1 1.92% 1 9.09%
Total 52 100.00% 11 100.00%



int proc_setattr(struct dentry *dentry, struct iattr *attr)
{
	int error;
	struct inode *inode = d_inode(dentry);

	if (attr->ia_valid & ATTR_MODE)
		return -EPERM;

	error = setattr_prepare(dentry, attr);
	if (error)
		return error;

	setattr_copy(inode, attr);
	mark_inode_dirty(inode);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 36 50.70% 1 12.50%
christoph hellwig christoph hellwig 19 26.76% 1 12.50%
al viro al viro 9 12.68% 2 25.00%
david howells david howells 3 4.23% 1 12.50%
jan kara jan kara 2 2.82% 1 12.50%
dipankar sarma dipankar sarma 1 1.41% 1 12.50%
pre-git pre-git 1 1.41% 1 12.50%
Total 71 100.00% 8 100.00%

/*
 * May current process learn task's sched/cmdline info (for hide_pid_min=1)
 * or euid/egid (for hide_pid_min=2)?
 */


static bool has_pid_permissions(struct pid_namespace *pid,
				 struct task_struct *task,
				 int hide_pid_min)
{
	if (pid->hide_pid < hide_pid_min)
		return true;
	if (in_group_p(pid->pid_gid))
		return true;
	return ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS);
}


Contributors
Person Tokens Prop Commits CommitProp
vasiliy kulikov vasiliy kulikov 49 98.00% 1 50.00%
jann horn jann horn 1 2.00% 1 50.00%
Total 50 100.00% 2 100.00%



static int proc_pid_permission(struct inode *inode, int mask)
{
	struct pid_namespace *pid = inode->i_sb->s_fs_info;
	struct task_struct *task;
	bool has_perms;

	task = get_proc_task(inode);
	if (!task)
		return -ESRCH;
	has_perms = has_pid_permissions(pid, task, 1);
	put_task_struct(task);

	if (!has_perms) {
		if (pid->hide_pid == 2) {
			/*
                         * Let's make getdents(), stat(), and open()
                         * consistent with each other.  If a process
                         * may not stat() a file, it shouldn't be seen
                         * in procfs at all.
                         */
			return -ENOENT;
		}

		return -EPERM;
	}
	return generic_permission(inode, mask);
}



Contributors
Person Tokens Prop Commits CommitProp
vasiliy kulikov vasiliy kulikov 90 90.91% 1 50.00%
xiaotian feng xiaotian feng 9 9.09% 1 50.00%
Total 99 100.00% 2 100.00%


static const struct inode_operations proc_def_inode_operations = {
	.setattr	= proc_setattr,
};



static int proc_single_show(struct seq_file *m, void *v)
{
	struct inode *inode = m->private;
	struct pid_namespace *ns;
	struct pid *pid;
	struct task_struct *task;
	int ret;

	ns = inode->i_sb->s_fs_info;
	pid = proc_pid(inode);
	task = get_pid_task(pid, PIDTYPE_PID);
	if (!task)
		return -ESRCH;

	ret = PROC_I(inode)->op.proc_show(m, ns, pid, task);

	put_task_struct(task);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 103 100.00% 1 100.00%
Total 103 100.00% 1 100.00%



static int proc_single_open(struct inode *inode, struct file *filp)
{
	return single_open(filp, proc_single_show, inode);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 24 92.31% 1 50.00%
jovi zhang jovi zhang 2 7.69% 1 50.00%
Total 26 100.00% 2 100.00%


static const struct file_operations proc_single_file_operations = {
	.open		= proc_single_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};




struct mm_struct *proc_mem_open(struct inode *inode, unsigned int mode)
{
	struct task_struct *task = get_proc_task(inode);
	struct mm_struct *mm = ERR_PTR(-ESRCH);

	if (task) {
		mm = mm_access(task, mode | PTRACE_MODE_FSCREDS);
		put_task_struct(task);

		if (!IS_ERR_OR_NULL(mm)) {
			/* ensure this mm_struct can't be freed */
			atomic_inc(&mm->mm_count);
			/* but do not pin its memory */
			mmput(mm);
		}
	}

	return mm;
}

Contributors
Person Tokens Prop Commits CommitProp
oleg nesterov oleg nesterov 37 42.53% 2 25.00%
linus torvalds linus torvalds 35 40.23% 1 12.50%
robert love robert love 6 6.90% 1 12.50%
americo wang americo wang 4 4.60% 1 12.50%
jann horn jann horn 2 2.30% 1 12.50%
eric w. biederman eric w. biederman 2 2.30% 1 12.50%
rusty russell rusty russell 1 1.15% 1 12.50%
Total 87 100.00% 8 100.00%



static int __mem_open(struct inode *inode, struct file *file, unsigned int mode)
{
	struct mm_struct *mm = proc_mem_open(inode, mode);

	if (IS_ERR(mm))
		return PTR_ERR(mm);

	file->private_data = mm;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
oleg nesterov oleg nesterov 44 81.48% 1 25.00%
linus torvalds linus torvalds 6 11.11% 1 25.00%
robert love robert love 3 5.56% 1 25.00%
eric w. biederman eric w. biederman 1 1.85% 1 25.00%
Total 54 100.00% 4 100.00%



static int mem_open(struct inode *inode, struct file *file)
{
	int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH);

	/* OK to pass negative loff_t, we can catch out-of-range */
	file->f_mode |= FMODE_UNSIGNED_OFFSET;

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
americo wang americo wang 25 65.79% 1 50.00%
djalal harouni djalal harouni 13 34.21% 1 50.00%
Total 38 100.00% 2 100.00%



static ssize_t mem_rw(struct file *file, char __user *buf,
			size_t count, loff_t *ppos, int write)
{
	struct mm_struct *mm = file->private_data;
	unsigned long addr = *ppos;
	ssize_t copied;
	char *page;
	unsigned int flags;

	if (!mm)
		return 0;

	page = (char *)__get_free_page(GFP_TEMPORARY);
	if (!page)
		return -ENOMEM;

	copied = 0;
	if (!atomic_inc_not_zero(&mm->mm_users))
		goto free;

	/* Maybe we should limit FOLL_FORCE to actual ptrace users? */
	flags = FOLL_FORCE;
	if (write)
		flags |= FOLL_WRITE;

	while (count > 0) {
		int this_len = min_t(int, count, PAGE_SIZE);

		if (write && copy_from_user(page, buf, this_len)) {
			copied = -EFAULT;
			break;
		}

		this_len = access_remote_vm(mm, addr, page, this_len, flags);
		if (!this_len) {
			if (!copied)
				copied = -EIO;
			break;
		}

		if (!write && copy_to_user(buf, page, this_len)) {
			copied = -EFAULT;
			break;
		}

		buf += this_len;
		addr += this_len;
		copied += this_len;
		count -= this_len;
	}
	*ppos = addr;

	mmput(mm);
free:
	free_page((unsigned long) page);
	return copied;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 104 41.94% 2 15.38%
oleg nesterov oleg nesterov 85 34.27% 2 15.38%
linus torvalds linus torvalds 27 10.89% 3 23.08%
lorenzo stoakes lorenzo stoakes 13 5.24% 1 7.69%
rick lindsley rick lindsley 7 2.82% 1 7.69%
andrea arcangeli andrea arcangeli 6 2.42% 1 7.69%
pre-git pre-git 3 1.21% 1 7.69%
stephen wilson stephen wilson 2 0.81% 1 7.69%
mel gorman mel gorman 1 0.40% 1 7.69%
Total 248 100.00% 13 100.00%



static ssize_t mem_read(struct file *file, char __user *buf,
			size_t count, loff_t *ppos)
{
	return mem_rw(file, buf, count, ppos, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 17 45.95% 1 16.67%
linus torvalds linus torvalds 10 27.03% 2 33.33%
oleg nesterov oleg nesterov 7 18.92% 1 16.67%
al viro al viro 2 5.41% 1 16.67%
glauber de oliveira costa glauber de oliveira costa 1 2.70% 1 16.67%
Total 37 100.00% 6 100.00%



static ssize_t mem_write(struct file *file, const char __user *buf,
			 size_t count, loff_t *ppos)
{
	return mem_rw(file, (char __user*)buf, count, ppos, 1);
}

Contributors
Person Tokens Prop Commits CommitProp
oleg nesterov oleg nesterov 34 79.07% 1 25.00%
eric w. biederman eric w. biederman 5 11.63% 1 25.00%
al viro al viro 2 4.65% 1 25.00%
linus torvalds linus torvalds 2 4.65% 1 25.00%
Total 43 100.00% 4 100.00%



loff_t mem_lseek(struct file *file, loff_t offset, int orig)
{
	switch (orig) {
	case 0:
		file->f_pos = offset;
		break;
	case 1:
		file->f_pos += offset;
		break;
	default:
		return -EINVAL;
	}
	force_successful_syscall_return();
	return file->f_pos;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 40 72.73% 1 50.00%
linus torvalds linus torvalds 15 27.27% 1 50.00%
Total 55 100.00% 2 100.00%



static int mem_release(struct inode *inode, struct file *file)
{
	struct mm_struct *mm = file->private_data;
	if (mm)
		mmdrop(mm);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 32 86.49% 1 33.33%
oleg nesterov oleg nesterov 5 13.51% 2 66.67%
Total 37 100.00% 3 100.00%


static const struct file_operations proc_mem_operations = {
	.llseek		= mem_lseek,
	.read		= mem_read,
	.write		= mem_write,
	.open		= mem_open,
	.release	= mem_release,
};



static int environ_open(struct inode *inode, struct file *file)
{
	return __mem_open(inode, file, PTRACE_MODE_READ);
}

Contributors
Person Tokens Prop Commits CommitProp
americo wang americo wang 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static ssize_t environ_read(struct file *file, char __user *buf,
			size_t count, loff_t *ppos)
{
	char *page;
	unsigned long src = *ppos;
	int ret = 0;
	struct mm_struct *mm = file->private_data;
	unsigned long env_start, env_end;

	/* Ensure the process spawned far enough to have an environment. */
	if (!mm || !mm->env_end)
		return 0;

	page = (char *)__get_free_page(GFP_TEMPORARY);
	if (!page)
		return -ENOMEM;

	ret = 0;
	if (!atomic_inc_not_zero(&mm->mm_users))
		goto free;

	down_read(&mm->mmap_sem);
	env_start = mm->env_start;
	env_end = mm->env_end;
	up_read(&mm->mmap_sem);

	while (count > 0) {
		size_t this_len, max_len;
		int retval;

		if (src >= (env_end - env_start))
			break;

		this_len = env_end - (env_start + src);

		max_len = min_t(size_t, PAGE_SIZE, count);
		this_len = min(max_len, this_len);

		retval = access_remote_vm(mm, (env_start + src), page, this_len, 0);

		if (retval <= 0) {
			ret = retval;
			break;
		}

		if (copy_to_user(buf, page, retval)) {
			ret = -EFAULT;
			break;
		}

		ret += retval;
		src += retval;
		buf += retval;
		count -= retval;
	}
	*ppos = src;
	mmput(mm);

free:
	free_page((unsigned long) page);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
james pearson james pearson 188 66.67% 1 14.29%
mateusz guzik mateusz guzik 34 12.06% 1 14.29%
djalal harouni djalal harouni 25 8.87% 1 14.29%
americo wang americo wang 22 7.80% 1 14.29%
mathias krause mathias krause 6 2.13% 1 14.29%
al viro al viro 6 2.13% 1 14.29%
linus torvalds linus torvalds 1 0.35% 1 14.29%
Total 282 100.00% 7 100.00%


static const struct file_operations proc_environ_operations = {
	.open		= environ_open,
	.read		= environ_read,
	.llseek		= generic_file_llseek,
	.release	= mem_release,
};



static int auxv_open(struct inode *inode, struct file *file)
{
	return __mem_open(inode, file, PTRACE_MODE_READ_FSCREDS);
}

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



static ssize_t auxv_read(struct file *file, char __user *buf,
			size_t count, loff_t *ppos)
{
	struct mm_struct *mm = file->private_data;
	unsigned int nwords = 0;

	if (!mm)
		return 0;
	do {
		nwords += 2;
	} while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
	return simple_read_from_buffer(buf, count, ppos, mm->saved_auxv,
				       nwords * sizeof(mm->saved_auxv[0]));
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 86 91.49% 1 50.00%
leon yu leon yu 8 8.51% 1 50.00%
Total 94 100.00% 2 100.00%


static const struct file_operations proc_auxv_operations = {
	.open		= auxv_open,
	.read		= auxv_read,
	.llseek		= generic_file_llseek,
	.release	= mem_release,
};



static ssize_t oom_adj_read(struct file *file, char __user *buf, size_t count,
			    loff_t *ppos)
{
	struct task_struct *task = get_proc_task(file_inode(file));
	char buffer[PROC_NUMBUF];
	int oom_adj = OOM_ADJUST_MIN;
	size_t len;

	if (!task)
		return -ESRCH;
	if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MAX)
		oom_adj = OOM_ADJUST_MAX;
	else
		oom_adj = (task->signal->oom_score_adj * -OOM_DISABLE) /
			  OOM_SCORE_ADJ_MAX;
	put_task_struct(task);
	len = snprintf(buffer, sizeof(buffer), "%d\n", oom_adj);
	return simple_read_from_buffer(buf, count, ppos, buffer, len);
}

Contributors
Person Tokens Prop Commits CommitProp
david rientjes david rientjes 121 97.58% 1 50.00%
al viro al viro 3 2.42% 1 50.00%
Total 124 100.00% 2 100.00%



static int __set_oom_adj(struct file *file, int oom_adj, bool legacy)
{
	static DEFINE_MUTEX(oom_adj_mutex);
	struct mm_struct *mm = NULL;
	struct task_struct *task;
	int err = 0;

	task = get_proc_task(file_inode(file));
	if (!task)
		return -ESRCH;

	mutex_lock(&oom_adj_mutex);
	if (legacy) {
		if (oom_adj < task->signal->oom_score_adj &&
				!capable(CAP_SYS_RESOURCE)) {
			err = -EACCES;
			goto err_unlock;
		}
		/*
                 * /proc/pid/oom_adj is provided for legacy purposes, ask users to use
                 * /proc/pid/oom_score_adj instead.
                 */
		pr_warn_once("%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
			  current->comm, task_pid_nr(current), task_pid_nr(task),
			  task_pid_nr(task));
	} else {
		if ((short)oom_adj < task->signal->oom_score_adj_min &&
				!capable(CAP_SYS_RESOURCE)) {
			err = -EACCES;
			goto err_unlock;
		}
	}

	/*
         * Make sure we will check other processes sharing the mm if this is
         * not vfrok which wants its own oom_score_adj.
         * pin the mm so it doesn't go away and get reused after task_unlock
         */
	if (!task->vfork_done) {
		struct task_struct *p = find_lock_task_mm(task);

		if (p) {
			if (atomic_read(&p->mm->mm_users) > 1) {
				mm = p->mm;
				atomic_inc(&mm->mm_count);
			}
			task_unlock(p);
		}
	}

	task->signal->oom_score_adj = oom_adj;
	if (!legacy && has_capability_noaudit(current, CAP_SYS_RESOURCE))
		task->signal->oom_score_adj_min = (short)oom_adj;
	trace_oom_score_adj_update(task);

	if (mm) {
		struct task_struct *p;

		rcu_read_lock();
		for_each_process(p) {
			if (same_thread_group(task, p))
				continue;

			/* do not touch kernel threads or the global init */
			if (p->flags & PF_KTHREAD || is_global_init(p))
				continue;

			task_lock(p);
			if (!p->vfork_done && process_shares_mm(p, mm)) {
				pr_info("updating oom_score_adj for %d (%s) from %d to %d because it shares mm with %d (%s). Report if this is unexpected.\n",
						task_pid_nr(p), p->comm,
						p->signal->oom_score_adj, oom_adj,
						task_pid_nr(task), task->comm);
				p->signal->oom_score_adj = oom_adj;
				if (!legacy && has_capability_noaudit(current, CAP_SYS_RESOURCE))
					p->signal->oom_score_adj_min = (short)oom_adj;
			}
			task_unlock(p);
		}
		rcu_read_unlock();
		mmdrop(mm);
	}
err_unlock:
	mutex_unlock(&oom_adj_mutex);
	put_task_struct(task);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
michal hocko michal hocko 408 100.00% 3 100.00%
Total 408 100.00% 3 100.00%

/*
 * /proc/pid/oom_adj exists solely for backwards compatibility with previous
 * kernels.  The effective policy is defined by oom_score_adj, which has a
 * different scale: oom_adj grew exponentially and oom_score_adj grows linearly.
 * Values written to oom_adj are simply mapped linearly to oom_score_adj.
 * Processes that become oom disabled via oom_adj will still be oom disabled
 * with this implementation.
 *
 * oom_adj cannot be removed since existing userspace binaries use it.
 */


static ssize_t oom_adj_write(struct file *file, const char __user *buf,
			     size_t count, loff_t *ppos)
{
	char buffer[PROC_NUMBUF];
	int oom_adj;
	int err;

	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
	if (copy_from_user(buffer, buf, count)) {
		err = -EFAULT;
		goto out;
	}

	err = kstrtoint(strstrip(buffer), 0, &oom_adj);
	if (err)
		goto out;
	if ((oom_adj < OOM_ADJUST_MIN || oom_adj > OOM_ADJUST_MAX) &&
	     oom_adj != OOM_DISABLE) {
		err = -EINVAL;
		goto out;
	}

	/*
         * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
         * value is always attainable.
         */
	if (oom_adj == OOM_ADJUST_MAX)
		oom_adj = OOM_SCORE_ADJ_MAX;
	else
		oom_adj = (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;

	err = __set_oom_adj(file, oom_adj, true);
out:
	return err < 0 ? err : count;
}

Contributors
Person Tokens Prop Commits CommitProp
david rientjes david rientjes 178 97.80% 1 50.00%
michal hocko michal hocko 4 2.20% 1 50.00%
Total 182 100.00% 2 100.00%


static const struct file_operations proc_oom_adj_operations = {
	.read		= oom_adj_read,
	.write		= oom_adj_write,
	.llseek		= generic_file_llseek,
};



static ssize_t oom_score_adj_read(struct file *file, char __user *buf,
					size_t count, loff_t *ppos)
{
	struct task_struct *task = get_proc_task(file_inode(file));
	char buffer[PROC_NUMBUF];
	short oom_score_adj = OOM_SCORE_ADJ_MIN;
	size_t len;

	if (!task)
		return -ESRCH;
	oom_score_adj = task->signal->oom_score_adj;
	put_task_struct(task);
	len = snprintf(buffer, sizeof(buffer), "%hd\n", oom_score_adj);
	return simple_read_from_buffer(buf, count, ppos, buffer, len);
}

Contributors
Person Tokens Prop Commits CommitProp
david rientjes david rientjes 99 97.06% 2 66.67%
al viro al viro 3 2.94% 1 33.33%
Total 102 100.00% 3 100.00%



static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
					size_t count, loff_t *ppos)
{
	char buffer[PROC_NUMBUF];
	int oom_score_adj;
	int err;

	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
	if (copy_from_user(buffer, buf, count)) {
		err = -EFAULT;
		goto out;
	}

	err = kstrtoint(strstrip(buffer), 0, &oom_score_adj);
	if (err)
		goto out;
	if (oom_score_adj < OOM_SCORE_ADJ_MIN ||
			oom_score_adj > OOM_SCORE_ADJ_MAX) {
		err = -EINVAL;
		goto out;
	}

	err = __set_oom_adj(file, oom_score_adj, false);
out:
	return err < 0 ? err : count;
}

Contributors
Person Tokens Prop Commits CommitProp
david rientjes david rientjes 144 94.12% 2 40.00%
michal hocko michal hocko 4 2.61% 1 20.00%
mandeep singh baines mandeep singh baines 3 1.96% 1 20.00%
alexey dobriyan alexey dobriyan 2 1.31% 1 20.00%
Total 153 100.00% 5 100.00%


static const struct file_operations proc_oom_score_adj_operations = {
	.read		= oom_score_adj_read,
	.write		= oom_score_adj_write,
	.llseek		= default_llseek,
};

#ifdef CONFIG_AUDITSYSCALL

#define TMPBUFLEN 11


static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
				  size_t count, loff_t *ppos)
{
	struct inode * inode = file_inode(file);
	struct task_struct *task = get_proc_task(inode);
	ssize_t length;
	char tmpbuf[TMPBUFLEN];

	if (!task)
		return -ESRCH;
	length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
			   from_kuid(file->f_cred->user_ns,
				     audit_get_loginuid(task)));
	put_task_struct(task);
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 49 46.67% 3 30.00%
pre-git pre-git 42 40.00% 2 20.00%
chris wright chris wright 6 5.71% 1 10.00%
al viro al viro 6 5.71% 3 30.00%
linus torvalds linus torvalds 2 1.90% 1 10.00%
Total 105 100.00% 10 100.00%



static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
				   size_t count, loff_t *ppos)
{
	struct inode * inode = file_inode(file);
	uid_t loginuid;
	kuid_t kloginuid;
	int rv;

	rcu_read_lock();
	if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) {
		rcu_read_unlock();
		return -EPERM;
	}
	rcu_read_unlock();

	if (*ppos != 0) {
		/* No partial writes. */
		return -EINVAL;
	}

	rv = kstrtou32_from_user(buf, count, 10, &loginuid);
	if (rv < 0)
		return rv;

	/* is userspace tring to explicitly UNSET the loginuid? */
	if (loginuid == AUDIT_UID_UNSET) {
		kloginuid = INVALID_UID;
	} else {
		kloginuid = make_kuid(file->f_cred->user_ns, loginuid);
		if (!uid_valid(kloginuid))
			return -EINVAL;
	}

	rv = audit_set_loginuid(kloginuid);
	if (rv < 0)
		return rv;
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 70 41.42% 3 25.00%
pre-git pre-git 36 21.30% 1 8.33%
alexey dobriyan alexey dobriyan 23 13.61% 1 8.33%
eric paris eric paris 16 9.47% 1 8.33%
paul e. mckenney paul e. mckenney 11 6.51% 1 8.33%
linus torvalds linus torvalds 6 3.55% 2 16.67%
al viro al viro 4 2.37% 2 16.67%
andrew morton andrew morton 3 1.78% 1 8.33%
Total 169 100.00% 12 100.00%


static const struct file_operations proc_loginuid_operations = {
	.read		= proc_loginuid_read,
	.write		= proc_loginuid_write,
	.llseek		= generic_file_llseek,
};



static ssize_t proc_sessionid_read(struct file * file, char __user * buf,
				  size_t count, loff_t *ppos)
{
	struct inode * inode = file_inode(file);
	struct task_struct *task = get_proc_task(inode);
	ssize_t length;
	char tmpbuf[TMPBUFLEN];

	if (!task)
		return -ESRCH;
	length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
				audit_get_sessionid(task));
	put_task_struct(task);
	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
}

Contributors
Person Tokens Prop Commits CommitProp
eric paris eric paris 93 96.88% 1 50.00%
al viro al viro 3 3.12% 1 50.00%
Total 96 100.00% 2 100.00%


static const struct file_operations proc_sessionid_operations = {
	.read		= proc_sessionid_read,
	.llseek		= generic_file_llseek,
};
#endif

#ifdef CONFIG_FAULT_INJECTION


static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
				      size_t count, loff_t *ppos)
{
	struct task_struct *task = get_proc_task(file_inode(file));
	char buffer[PROC_NUMBUF];
	size_t len;
	int make_it_fail;

	if (!task)
		return -ESRCH;
	make_it_fail = task->make_it_fail;
	put_task_struct(task);

	len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);

	return simple_read_from_buffer(buf, count, ppos, buffer, len);
}

Contributors
Person Tokens Prop Commits CommitProp
akinobu mita akinobu mita 95 96.94% 2 66.67%
al viro al viro 3 3.06% 1 33.33%
Total 98 100.00% 3 100.00%



static ssize_t proc_fault_inject_write(struct file * file,
			const char __user * buf, size_t count, loff_t *ppos)
{
	struct task_struct *task;
	char buffer[PROC_NUMBUF];
	int make_it_fail;
	int rv;

	if (!capable(CAP_SYS_RESOURCE))
		return -EPERM;
	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
	if (copy_from_user(buffer, buf, count))
		return -EFAULT;
	rv = kstrtoint(strstrip(buffer), 0, &make_it_fail);
	if (rv < 0)
		return rv;
	if (make_it_fail < 0 || make_it_fail > 1)
		return -EINVAL;

	task = get_proc_task(file_inode(file));
	if (!task)
		return -ESRCH;
	task->make_it_fail = make_it_fail;
	put_task_struct(task);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
akinobu mita akinobu mita 136 79.53% 1 20.00%
dave jones dave jones 14 8.19% 1 20.00%
alexey dobriyan alexey dobriyan 12 7.02% 1 20.00%
vincent li vincent li 6 3.51% 1 20.00%
al viro al viro 3 1.75% 1 20.00%
Total 171 100.00% 5 100.00%


static const struct file_operations proc_fault_inject_operations = {
	.read		= proc_fault_inject_read,
	.write		= proc_fault_inject_write,
	.llseek		= generic_file_llseek,
};
#endif


#ifdef CONFIG_SCHED_DEBUG
/*
 * Print out various scheduling related per-task fields:
 */


static int sched_show(struct seq_file *m, void *v)
{
	struct inode *inode = m->private;
	struct task_struct *p;

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;
	proc_sched_show_task(p, m);

	put_task_struct(p);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 60 100.00% 1 100.00%
Total 60 100.00% 1 100.00%


static ssize_t

sched_write(struct file *file, const char __user *buf,
	    size_t count, loff_t *offset)
{
	struct inode *inode = file_inode(file);
	struct task_struct *p;

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;
	proc_sched_set_task(p);

	put_task_struct(p);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 65 95.59% 1 50.00%
al viro al viro 3 4.41% 1 50.00%
Total 68 100.00% 2 100.00%



static int sched_open(struct inode *inode, struct file *filp)
{
	return single_open(filp, sched_show, inode);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 24 92.31% 1 50.00%
jovi zhang jovi zhang 2 7.69% 1 50.00%
Total 26 100.00% 2 100.00%


static const struct file_operations proc_pid_sched_operations = {
	.open		= sched_open,
	.read		= seq_read,
	.write		= sched_write,
	.llseek		= seq_lseek,
	.release	= single_release,
};

#endif

#ifdef CONFIG_SCHED_AUTOGROUP
/*
 * Print out autogroup related information:
 */


static int sched_autogroup_show(struct seq_file *m, void *v)
{
	struct inode *inode = m->private;
	struct task_struct *p;

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;
	proc_sched_autogroup_show_task(p, m);

	put_task_struct(p);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
mike galbraith mike galbraith 60 100.00% 1 100.00%
Total 60 100.00% 1 100.00%


static ssize_t

sched_autogroup_write(struct file *file, const char __user *buf,
	    size_t count, loff_t *offset)
{
	struct inode *inode = file_inode(file);
	struct task_struct *p;
	char buffer[PROC_NUMBUF];
	int nice;
	int err;

	memset(buffer, 0, sizeof(buffer));
	if (count > sizeof(buffer) - 1)
		count = sizeof(buffer) - 1;
	if (copy_from_user(buffer, buf, count))
		return -EFAULT;

	err = kstrtoint(strstrip(buffer), 0, &nice);
	if (err < 0)
		return err;

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;

	err = proc_sched_autogroup_set_nice(p, nice);
	if (err)
		count = err;

	put_task_struct(p);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
mike galbraith mike galbraith 154 94.48% 1 25.00%
alexey dobriyan alexey dobriyan 5 3.07% 1 25.00%
al viro al viro 3 1.84% 1 25.00%
hiroshi shimamoto hiroshi shimamoto 1 0.61% 1 25.00%
Total 163 100.00% 4 100.00%



static int sched_autogroup_open(struct inode *inode, struct file *filp)
{
	int ret;

	ret = single_open(filp, sched_autogroup_show, NULL);
	if (!ret) {
		struct seq_file *m = filp->private_data;

		m->private = inode;
	}
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
mike galbraith mike galbraith 55 100.00% 1 100.00%
Total 55 100.00% 1 100.00%


static const struct file_operations proc_pid_sched_autogroup_operations = {
	.open		= sched_autogroup_open,
	.read		= seq_read,
	.write		= sched_autogroup_write,
	.llseek		= seq_lseek,
	.release	= single_release,
};

#endif /* CONFIG_SCHED_AUTOGROUP */



static ssize_t comm_write(struct file *file, const char __user *buf,
				size_t count, loff_t *offset)
{
	struct inode *inode = file_inode(file);
	struct task_struct *p;
	char buffer[TASK_COMM_LEN];
	const size_t maxlen = sizeof(buffer) - 1;

	memset(buffer, 0, sizeof(buffer));
	if (copy_from_user(buffer, buf, count > maxlen ? maxlen : count))
		return -EFAULT;

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;

	if (same_thread_group(current, p))
		set_task_comm(p, buffer);
	else
		count = -EINVAL;

	put_task_struct(p);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
john stultz john stultz 115 85.19% 1 33.33%
david rientjes david rientjes 17 12.59% 1 33.33%
al viro al viro 3 2.22% 1 33.33%
Total 135 100.00% 3 100.00%



static int comm_show(struct seq_file *m, void *v)
{
	struct inode *inode = m->private;
	struct task_struct *p;

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;

	task_lock(p);
	seq_printf(m, "%s\n", p->comm);
	task_unlock(p);

	put_task_struct(p);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
john stultz john stultz 74 100.00% 1 100.00%
Total 74 100.00% 1 100.00%



static int comm_open(struct inode *inode, struct file *filp)
{
	return single_open(filp, comm_show, inode);
}

Contributors
Person Tokens Prop Commits CommitProp
john stultz john stultz 24 92.31% 1 50.00%
jovi zhang jovi zhang 2 7.69% 1 50.00%
Total 26 100.00% 2 100.00%


static const struct file_operations proc_pid_set_comm_operations = {
	.open		= comm_open,
	.read		= seq_read,
	.write		= comm_write,
	.llseek		= seq_lseek,
	.release	= single_release,
};



static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
{
	struct task_struct *task;
	struct file *exe_file;

	task = get_proc_task(d_inode(dentry));
	if (!task)
		return -ENOENT;
	exe_file = get_task_exe_file(task);
	put_task_struct(task);
	if (exe_file) {
		*exe_path = exe_file->f_path;
		path_get(&exe_file->f_path);
		fput(exe_file);
		return 0;
	} else
		return -ENOENT;
}

Contributors
Person Tokens Prop Commits CommitProp
matt helsley matt helsley 83 91.21% 1 25.00%
david howells david howells 3 3.30% 1 25.00%
cyrill gorcunov cyrill gorcunov 3 3.30% 1 25.00%
mateusz guzik mateusz guzik 2 2.20% 1 25.00%
Total 91 100.00% 4 100.00%



static const char *proc_pid_get_link(struct dentry *dentry,
				     struct inode *inode,
				     struct delayed_call *done)
{
	struct path path;
	int error = -EACCES;

	if (!dentry)
		return ERR_PTR(-ECHILD);

	/* Are we allowed to snoop on the tasks file descriptors? */
	if (!proc_fd_access_allowed(inode))
		goto out;

	error = PROC_I(inode)->op.proc_get_link(dentry, &path);
	if (error)
		goto out;

	nd_jump_link(&path);
	return NULL;
out:
	return ERR_PTR(error);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 34 34.69% 2 20.00%
serge hallyn serge hallyn 22 22.45% 1 10.00%
al viro al viro 20 20.41% 3 30.00%
christoph hellwig christoph hellwig 20 20.41% 2 20.00%
cyrill gorcunov cyrill gorcunov 1 1.02% 1 10.00%
jan blunck jan blunck 1 1.02% 1 10.00%
Total 98 100.00% 10 100.00%



static int do_proc_readlink(struct path *path, char __user *buffer, int buflen)
{
	char *tmp = (char*)__get_free_page(GFP_TEMPORARY);
	char *pathname;
	int len;

	if (!tmp)
		return -ENOMEM;

	pathname = d_path(path, tmp, PAGE_SIZE);
	len = PTR_ERR(pathname);
	if (IS_ERR(pathname))
		goto out;
	len = tmp + PAGE_SIZE - 1 - pathname;

	if (len > buflen)
		len = buflen;
	if (copy_to_user(buffer, pathname, len))
		len = -EFAULT;
 out:
	free_page((unsigned long)tmp);
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
serge hallyn serge hallyn 62 49.21% 1 20.00%
eric w. biederman eric w. biederman 52 41.27% 2 40.00%
jan blunck jan blunck 9 7.14% 1 20.00%
mel gorman mel gorman 3 2.38% 1 20.00%
Total 126 100.00% 5 100.00%



static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
{
	int error = -EACCES;
	struct inode *inode = d_inode(dentry);
	struct path path;

	/* Are we allowed to snoop on the tasks file descriptors? */
	if (!proc_fd_access_allowed(inode))
		goto out;

	error = PROC_I(inode)->op.proc_get_link(dentry, &path);
	if (error)
		goto out;

	error = do_proc_readlink(&path, buffer, buflen);
	path_put(&path);
out:
	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 60 61.22% 2 33.33%
andrea arcangeli andrea arcangeli 26 26.53% 1 16.67%
jan blunck jan blunck 8 8.16% 1 16.67%
david howells david howells 3 3.06% 1 16.67%
cyrill gorcunov cyrill gorcunov 1 1.02% 1 16.67%
Total 98 100.00% 6 100.00%


const struct inode_operations proc_pid_link_inode_operations = {
	.readlink	= proc_pid_readlink,
	.get_link	= proc_pid_get_link,
	.setattr	= proc_setattr,
};


/* building an inode */



struct inode *proc_pid_make_inode(struct super_block * sb,
				  struct task_struct *task, umode_t mode)
{
	struct inode * inode;
	struct proc_inode *ei;
	const struct cred *cred;

	/* We need a new inode */

	inode = new_inode(sb);
	if (!inode)
		goto out;

	/* Common stuff */
	ei = PROC_I(inode);
	inode->i_mode = mode;
	inode->i_ino = get_next_ino();
	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
	inode->i_op = &proc_def_inode_operations;

	/*
         * grab the reference to task.
         */
	ei->pid = get_task_pid(task, PIDTYPE_PID);
	if (!ei->pid)
		goto out_unlock;

	if (task_dumpable(task)) {
		rcu_read_lock();
		cred = __task_cred(task);
		inode->i_uid = cred->euid;
		inode->i_gid = cred->egid;
		rcu_read_unlock();
	}
	security_task_to_inode(task, inode);

out:
	return inode;

out_unlock:
	iput(inode);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 105 58.66% 3 30.00%
andrea arcangeli andrea arcangeli 30 16.76% 1 10.00%
david howells david howells 21 11.73% 2 20.00%
andreas gruenbacher andreas gruenbacher 9 5.03% 1 10.00%
christoph hellwig christoph hellwig 7 3.91% 1 10.00%
deepa dinamani deepa dinamani 4 2.23% 1 10.00%
oleg nesterov oleg nesterov 3 1.68% 1 10.00%
Total 179 100.00% 10 100.00%



int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = d_inode(dentry);
	struct task_struct *task;
	const struct cred *cred;
	struct pid_namespace *pid = dentry->d_sb->s_fs_info;

	generic_fillattr(inode, stat);

	rcu_read_lock();
	stat->uid = GLOBAL_ROOT_UID;
	stat->gid = GLOBAL_ROOT_GID;
	task = pid_task(proc_pid(inode), PIDTYPE_PID);
	if (task) {
		if (!has_pid_permissions(pid, task, 2)) {
			rcu_read_unlock();
			/*
                         * This doesn't prevent learning whether PID exists,
                         * it only makes getattr() consistent with readdir().
                         */
			return -ENOENT;
		}
		if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
		    task_dumpable(task)) {
			cred = __task_cred(task);
			stat->uid = cred->euid;
			stat->gid = cred->egid;
		}
	}
	rcu_read_unlock();
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 69 41.57% 3 23.08%
pre-git pre-git 39 23.49% 4 30.77%
vasiliy kulikov vasiliy kulikov 33 19.88% 1 7.69%
david howells david howells 18 10.84% 3 23.08%
andrew morton andrew morton 4 2.41% 1 7.69%
andries brouwer andries brouwer 3 1.81% 1 7.69%
Total 166 100.00% 13 100.00%

/* dentry stuff */

/*
 *      Exceptional case: normally we are not allowed to unhash a busy
 * directory. In this case, however, we can do it - no aliasing problems
 * due to the way we treat inodes.
 *
 * Rewrite the inode's ownerships here because the owning task may have
 * performed a setuid(), etc.
 *
 * Before the /proc/pid/status file was created the only way to read
 * the effective uid of a /process was to stat /proc/pid.  Reading
 * /proc/pid/status is slow enough that procps and other packages
 * kept stating /proc/pid.  To keep the rules in /proc simple I have
 * made this apply to all per process world readable and executable
 * directories.
 */


int pid_revalidate(struct dentry *dentry, unsigned int flags)
{
	struct inode *inode;
	struct task_struct *task;
	const struct cred *cred;

	if (flags & LOOKUP_RCU)
		return -ECHILD;

	inode = d_inode(dentry);
	task = get_proc_task(inode);

	if (task) {
		if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
		    task_dumpable(task)) {
			rcu_read_lock();
			cred = __task_cred(task);
			inode->i_uid = cred->euid;
			inode->i_gid = cred->egid;
			rcu_read_unlock();
		} else {
			inode->i_uid = GLOBAL_ROOT_UID;
			inode->i_gid = GLOBAL_ROOT_GID;
		}
		inode->i_mode &= ~(S_ISUID | S_ISGID);
		security_task_to_inode(task, inode);
		put_task_struct(task);
		return 1;
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 80 51.28% 3 30.00%
al viro al viro 25 16.03% 2 20.00%
david howells david howells 24 15.38% 3 30.00%
nick piggin nick piggin 21 13.46% 1 10.00%
pre-git pre-git 6 3.85% 1 10.00%
Total 156 100.00% 10 100.00%



static inline bool proc_inode_is_dead(struct inode *inode)
{
	return !proc_pid(inode)->tasks[PIDTYPE_PID].first;
}

Contributors
Person Tokens Prop Commits CommitProp
oleg nesterov oleg nesterov 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



int pid_delete_dentry(const struct dentry *dentry)
{
	/* Is the task we represent dead?
         * If so, then don't put the dentry on the lru list,
         * kill it immediately.
         */
	return proc_inode_is_dead(d_inode(dentry));
}

Contributors
Person Tokens Prop Commits CommitProp
david howells david howells 20 95.24% 2 66.67%
oleg nesterov oleg nesterov 1 4.76% 1 33.33%
Total 21 100.00% 3 100.00%


const struct dentry_operations pid_dentry_operations =
{
	.d_revalidate	= pid_revalidate,
	.d_delete	= pid_delete_dentry,
};

/* Lookups */

/*
 * Fill a directory entry.
 *
 * If possible create the dcache entry and derive our inode number and
 * file type from dcache entry.
 *
 * Since all of the proc inode numbers are dynamically generated, the inode
 * numbers do not exist until the inode is cache.  This means creating the
 * the dcache entry in readdir is necessary to keep the inode numbers
 * reported by readdir in sync with the inode numbers reported
 * by stat.
 */


bool proc_fill_cache(struct file *file, struct dir_context *ctx,
	const char *name, int len,
	instantiate_t instantiate, struct task_struct *task, const void *ptr)
{
	struct dentry *child, *dir = file->f_path.dentry;
	struct qstr qname = QSTR_INIT(name, len);
	struct inode *inode;
	unsigned type;
	ino_t ino;

	child = d_hash_and_lookup(dir, &qname);
	if (!child) {
		DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
		child = d_alloc_parallel(dir, &qname, &wq);
		if (IS_ERR(child))
			goto end_instantiate;
		if (d_in_lookup(child)) {
			int err = instantiate(d_inode(dir), child, task, ptr);
			d_lookup_done(child);
			if (err < 0) {
				dput(child);
				goto end_instantiate;
			}
		}
	}
	inode = d_inode(child);
	ino = inode->i_ino;
	type = inode->i_mode >> 12;
	dput(child);
	return dir_emit(ctx, name, len, ino, type);

end_instantiate:
	return dir_emit(ctx, name, len, 1, DT_UNKNOWN);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 125 56.82% 4 36.36%
al viro al viro 82 37.27% 3 27.27%
david howells david howells 6 2.73% 1 9.09%
josef 'jeff' sipek josef 'jeff' sipek 3 1.36% 1 9.09%
pre-git pre-git 3 1.36% 1 9.09%
eric dumazet eric dumazet 1 0.45% 1 9.09%
Total 220 100.00% 11 100.00%

/*
 * dname_to_vma_addr - maps a dentry name into two unsigned longs
 * which represent vma start and end addresses.
 */


static int dname_to_vma_addr(struct dentry *dentry,
			     unsigned long *start, unsigned long *end)
{
	if (sscanf(dentry->d_name.name, "%lx-%lx", start, end) != 2)
		return -EINVAL;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
cyrill gorcunov cyrill gorcunov 28 59.57% 1 25.00%
eric w. biederman eric w. biederman 18 38.30% 2 50.00%
pre-git pre-git 1 2.13% 1 25.00%
Total 47 100.00% 4 100.00%



static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
{
	unsigned long vm_start, vm_end;
	bool exact_vma_exists = false;
	struct mm_struct *mm = NULL;
	struct task_struct *task;
	const struct cred *cred;
	struct inode *inode;
	int status = 0;

	if (flags & LOOKUP_RCU)
		return -ECHILD;

	inode = d_inode(dentry);
	task = get_proc_task(inode);
	if (!task)
		goto out_notask;

	mm = mm_access(task, PTRACE_MODE_READ_FSCREDS);
	if (IS_ERR_OR_NULL(mm))
		goto out;

	if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) {
		down_read(&mm->mmap_sem);
		exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end);
		up_read(&mm->mmap_sem);
	}

	mmput(mm);

	if (exact_vma_exists) {
		if (task_dumpable(task)) {
			rcu_read_lock();
			cred = __task_cred(task);
			inode->i_uid = cred->euid;
			inode->i_gid = cred->egid;
			rcu_read_unlock();
		} else {
			inode->i_uid = GLOBAL_ROOT_UID;
			inode->i_gid = GLOBAL_ROOT_GID;
		}
		security_task_to_inode(task, inode);
		status = 1;
	}

out:
	put_task_struct(task);

out_notask:
	return status;
}

Contributors
Person Tokens Prop Commits CommitProp
cyrill gorcunov cyrill gorcunov 154 64.98% 1 7.69%
eric w. biederman eric w. biederman 36 15.19% 2 15.38%
pre-git pre-git 21 8.86% 2 15.38%
linus torvalds linus torvalds 10 4.22% 2 15.38%
miklos szeredi miklos szeredi 6 2.53% 1 7.69%
david howells david howells 3 1.27% 1 7.69%
dipankar sarma dipankar sarma 3 1.27% 1 7.69%
jan blunck jan blunck 2 0.84% 1 7.69%
jann horn jann horn 1 0.42% 1 7.69%
al viro al viro 1 0.42% 1 7.69%
Total 237 100.00% 13 100.00%


static const struct dentry_operations tid_map_files_dentry_operations = {
	.d_revalidate	= map_files_d_revalidate,
	.d_delete	= pid_delete_dentry,
};



static int map_files_get_link(struct dentry *dentry, struct path *path)
{
	unsigned long vm_start, vm_end;
	struct vm_area_struct *vma;
	struct task_struct *task;
	struct mm_struct *mm;
	int rc;

	rc = -ENOENT;
	task = get_proc_task(d_inode(dentry));
	if (!task)
		goto out;

	mm = get_task_mm(task);
	put_task_struct(task);
	if (!mm)
		goto out;

	rc = dname_to_vma_addr(dentry, &vm_start, &vm_end);
	if (rc)
		goto out_mmput;

	rc = -ENOENT;
	down_read(&mm->mmap_sem);
	vma = find_exact_vma(mm, vm_start, vm_end);
	if (vma && vma->vm_file) {
		*path = vma->vm_file->f_path;
		path_get(path);
		rc = 0;
	}
	up_read(&mm->mmap_sem);

out_mmput:
	mmput(mm);
out:
	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
cyrill gorcunov cyrill gorcunov 89 50.86% 1 6.67%
pre-git pre-git 26 14.86% 2 13.33%
eric w. biederman eric w. biederman 20 11.43% 2 13.33%
nick piggin nick piggin 10 5.71% 1 6.67%
andrew morton andrew morton 7 4.00% 2 13.33%
linus torvalds linus torvalds 7 4.00% 2 13.33%
david howells david howells 5 2.86% 2 13.33%
dave hansen dave hansen 5 2.86% 1 6.67%
artem fetishev artem fetishev 5 2.86% 1 6.67%
al viro al viro 1 0.57% 1 6.67%
Total 175 100.00% 15 100.00%


struct map_files_info {
	
fmode_t		mode;
	
unsigned int	len;
	
unsigned char	name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */
};

/*
 * Only allow CAP_SYS_ADMIN to follow the links, due to concerns about how the
 * symlinks may be used to bypass permissions on ancestor directories in the
 * path to the file in question.
 */

static const char *

proc_map_files_get_link(struct dentry *dentry,
			struct inode *inode,
		        struct delayed_call *done)
{
	if (!capable(CAP_SYS_ADMIN))
		return ERR_PTR(-EPERM);

	return proc_pid_get_link(dentry, inode, done);
}

Contributors
Person Tokens Prop Commits CommitProp
calvin owens calvin owens 36 75.00% 1 33.33%
al viro al viro 12 25.00% 2 66.67%
Total 48 100.00% 3 100.00%

/*
 * Identical to proc_pid_link_inode_operations except for get_link()
 */

static const struct inode_operations proc_map_files_link_inode_operations = {
	.readlink	= proc_pid_readlink,
	.get_link	= proc_map_files_get_link,
	.setattr	= proc_setattr,
};


static int

proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
			   struct task_struct *task, const void *ptr)
{
	fmode_t mode = (fmode_t)(unsigned long)ptr;
	struct proc_inode *ei;
	struct inode *inode;

	inode = proc_pid_make_inode(dir->i_sb, task, S_IFLNK |
				    ((mode & FMODE_READ ) ? S_IRUSR : 0) |
				    ((mode & FMODE_WRITE) ? S_IWUSR : 0));
	if (!inode)
		return -ENOENT;

	ei = PROC_I(inode);
	ei->op.proc_get_link = map_files_get_link;

	inode->i_op = &proc_map_files_link_inode_operations;
	inode->i_size = 64;

	d_set_d_op(dentry, &tid_map_files_dentry_operations);
	d_add(dentry, inode);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 45 32.14% 2 10.53%
andreas gruenbacher andreas gruenbacher 26 18.57% 1 5.26%
pre-git pre-git 17 12.14% 2 10.53%
al viro al viro 15 10.71% 4 21.05%
cyrill gorcunov cyrill gorcunov 11 7.86% 1 5.26%
albert cahalan albert cahalan 7 5.00% 1 5.26%
linus torvalds linus torvalds 6 4.29% 2 10.53%
andrew morton andrew morton 6 4.29% 2 10.53%
nick piggin nick piggin 4 2.86% 1 5.26%
alexey dobriyan alexey dobriyan 1 0.71% 1 5.26%
calvin owens calvin owens 1 0.71% 1 5.26%
eric dumazet eric dumazet 1 0.71% 1 5.26%
Total 140 100.00% 19 100.00%



static struct dentry *proc_map_files_lookup(struct inode *dir,
		struct dentry *dentry, unsigned int flags)
{
	unsigned long vm_start, vm_end;
	struct vm_area_struct *vma;
	struct task_struct *task;
	int result;
	struct mm_struct *mm;

	result = -ENOENT;
	task = get_proc_task(dir);
	if (!task)
		goto out;

	result = -EACCES;
	if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
		goto out_put_task;

	result = -ENOENT;
	if (dname_to_vma_addr(dentry, &vm_start, &vm_end))
		goto out_put_task;

	mm = get_task_mm(task);
	if (!mm)
		goto out_put_task;

	down_read(&mm->mmap_sem);
	vma = find_exact_vma(mm, vm_start, vm_end);
	if (!vma)
		goto out_no_vma;

	if (vma->vm_file)
		result = proc_map_files_instantiate(dir, dentry, task,
				(void *)(unsigned long)vma->vm_file->f_mode);

out_no_vma:
	up_read(&mm->mmap_sem);
	mmput(mm);
out_put_task:
	put_task_struct(task);
out:
	return ERR_PTR(result);
}

Contributors
Person Tokens Prop Commits CommitProp
cyrill gorcunov cyrill gorcunov 137 65.87% 1 16.67%
eric w. biederman eric w. biederman 50 24.04% 1 16.67%
al viro al viro 14 6.73% 2 33.33%
stanislav kinsbursky stanislav kinsbursky 6 2.88% 1 16.67%
jann horn jann horn 1 0.48% 1 16.67%
Total 208 100.00% 6 100.00%


static const struct inode_operations proc_map_files_inode_operations = {
	.lookup		= proc_map_files_lookup,
	.permission	= proc_fd_permission,
	.setattr	= proc_setattr,
};


static int

proc_map_files_readdir(struct file *file, struct dir_context *ctx)
{
	struct vm_area_struct *vma;
	struct task_struct *task;
	struct mm_struct *mm;
	unsigned long nr_files, pos, i;
	struct flex_array *fa = NULL;
	struct map_files_info info;
	struct map_files_info *p;
	int ret;

	ret = -ENOENT;
	task = get_proc_task(file_inode(file));
	if (!task)
		goto out;

	ret = -EACCES;
	if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS))
		goto out_put_task;

	ret = 0;
	if (!dir_emit_dots(file, ctx))
		goto out_put_task;

	mm = get_task_mm(task);
	if (!mm)
		goto out_put_task;
	down_read(&mm->mmap_sem);

	nr_files = 0;

	/*
         * We need two passes here:
         *
         *  1) Collect vmas of mapped files with mmap_sem taken
         *  2) Release mmap_sem and instantiate entries
         *
         * otherwise we get lockdep complained, since filldir()
         * routine might require mmap_sem taken in might_fault().
         */

	for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) {
		if (vma->vm_file && ++pos > ctx->pos)
			nr_files++;
	}

	if (nr_files) {
		fa = flex_array_alloc(sizeof(info), nr_files,
					GFP_KERNEL);
		if (!fa || flex_array_prealloc(fa, 0, nr_files,
						GFP_KERNEL)) {
			ret = -ENOMEM;
			if (fa)
				flex_array_free(fa);
			up_read(&mm->mmap_sem);
			mmput(mm);
			goto out_put_task;
		}
		for (i = 0, vma = mm->mmap, pos = 2; vma;
				vma = vma->vm_next) {
			if (!vma->vm_file)
				continue;
			if (++pos <= ctx->pos)
				continue;

			info.mode = vma->vm_file->f_mode;
			info.len = snprintf(info.name,
					sizeof(info.name), "%lx-%lx",
					vma->vm_start, vma->vm_end);
			if (flex_array_put(fa, i++, &info, GFP_KERNEL))
				BUG();
		}
	}
	up_read(&mm->mmap_sem);

	for (i = 0; i < nr_files; i++) {
		p = flex_array_get(fa, i);
		if (!proc_fill_cache(file, ctx,
				      p->name, p->len,
				      proc_map_files_instantiate,
				      task,
				      (void *)(unsigned long)p->mode))
			break;
		ctx->pos++;
	}
	if (fa)
		flex_array_free(fa);
	mmput(mm);

out_put_task:
	put_task_struct(task);
out:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
cyrill gorcunov cyrill gorcunov 253 56.47% 1 6.67%
al viro al viro 59 13.17% 3 20.00%
miklos szeredi miklos szeredi 43 9.60% 1 6.67%
pavel emelianov pavel emelianov 39 8.71% 1 6.67%
eric w. biederman eric w. biederman 27 6.03% 3 20.00%
alexey dobriyan alexey dobriyan 12 2.68% 2 13.33%
andrew morton andrew morton 11 2.46% 2 13.33%
pre-git pre-git 3 0.67% 1 6.67%
jann horn jann horn 1 0.22% 1 6.67%
Total 448 100.00% 15 100.00%


static const struct file_operations proc_map_files_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= proc_map_files_readdir,
	.llseek		= generic_file_llseek,
};

#ifdef CONFIG_CHECKPOINT_RESTORE

struct timers_private {
	
struct pid *pid;
	
struct task_struct *task;
	
struct sighand_struct *sighand;
	
struct pid_namespace *ns;
	
unsigned long flags;
};



static void *timers_start(struct seq_file *m, loff_t *pos)
{
	struct timers_private *tp = m->private;

	tp->task = get_pid_task(tp->pid, PIDTYPE_PID);
	if (!tp->task)
		return ERR_PTR(-ESRCH);

	tp->sighand = lock_task_sighand(tp->task, &tp->flags);
	if (!tp->sighand)
		return ERR_PTR(-ESRCH);

	return seq_list_start(&tp->task->signal->posix_timers, *pos);
}

Contributors
Person Tokens Prop Commits CommitProp
pavel emelianov pavel emelianov 98 100.00% 1 100.00%
Total 98 100.00% 1 100.00%



static void *timers_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct timers_private *tp = m->private;
	return seq_list_next(v, &tp->task->signal->posix_timers, pos);
}

Contributors
Person Tokens Prop Commits CommitProp
pavel emelianov pavel emelianov 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%



static void timers_stop(struct seq_file *m, void *v)
{
	struct timers_private *tp = m->private;

	if (tp->sighand) {
		unlock_task_sighand(tp->task, &tp->flags);
		tp->sighand = NULL;
	}

	if (tp->task) {
		put_task_struct(tp->task);
		tp->task = NULL;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pavel emelianov pavel emelianov 71 100.00% 1 100.00%
Total 71 100.00% 1 100.00%



static int show_timer(struct seq_file *m, void *v)
{
	struct k_itimer *timer;
	struct timers_private *tp = m->private;
	int notify;
	static const char * const nstr[] = {
		[SIGEV_SIGNAL] = "signal",
		[SIGEV_NONE] = "none",
		[SIGEV_THREAD] = "thread",
        };

	timer = list_entry((struct list_head *)v, struct k_itimer, list);
	notify = timer->it_sigev_notify;

	seq_printf(m, "ID: %d\n", timer->it_id);
	seq_printf(m, "signal: %d/%p\n",
		   timer->sigq->info.si_signo,
		   timer->sigq->info.si_value.sival_ptr);
	seq_printf(m, "notify: %s/%s.%d\n",
		   nstr[notify & ~SIGEV_THREAD_ID],
		   (notify & SIGEV_THREAD_ID) ? "tid" : "pid",
		   pid_nr_ns(timer->it_pid, tp->ns));
	seq_printf(m, "ClockID: %d\n", timer->it_clock);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pavel emelianov pavel emelianov 156 92.31% 2 50.00%
pavel tikhomirov pavel tikhomirov 11 6.51% 1 25.00%
alexey dobriyan alexey dobriyan 2 1.18% 1 25.00%
Total 169 100.00% 4 100.00%


static const struct seq_operations proc_timers_seq_ops = {
	.start	= timers_start,
	.next	= timers_next,
	.stop	= timers_stop,
	.show	= show_timer,
};



static int proc_timers_open(struct inode *inode, struct file *file)
{
	struct timers_private *tp;

	tp = __seq_open_private(file, &proc_timers_seq_ops,
			sizeof(struct timers_private));
	if (!tp)
		return -ENOMEM;

	tp->pid = proc_pid(inode);
	tp->ns = inode->i_sb->s_fs_info;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pavel emelianov pavel emelianov 68 100.00% 2 100.00%
Total 68 100.00% 2 100.00%


static const struct file_operations proc_timers_operations = {
	.open		= proc_timers_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release_private,
};
#endif



static ssize_t timerslack_ns_write(struct file *file, const char __user *buf,
					size_t count, loff_t *offset)
{
	struct inode *inode = file_inode(file);
	struct task_struct *p;
	u64 slack_ns;
	int err;

	err = kstrtoull_from_user(buf, count, 10, &slack_ns);
	if (err < 0)
		return err;

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;

	if (p != current) {
		if (!capable(CAP_SYS_NICE)) {
			count = -EPERM;
			goto out;
		}

		err = security_task_setscheduler(p);
		if (err) {
			count = err;
			goto out;
		}
	}

	task_lock(p);
	if (slack_ns == 0)
		p->timer_slack_ns = p->default_timer_slack_ns;
	else
		p->timer_slack_ns = slack_ns;
	task_unlock(p);

out:
	put_task_struct(p);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
john stultz john stultz 171 100.00% 4 100.00%
Total 171 100.00% 4 100.00%



static int timerslack_ns_show(struct seq_file *m, void *v)
{
	struct inode *inode = m->private;
	struct task_struct *p;
	int err = 0;

	p = get_proc_task(inode);
	if (!p)
		return -ESRCH;

	if (p != current) {

		if (!capable(CAP_SYS_NICE)) {
			err = -EPERM;
			goto out;
		}
		err = security_task_getscheduler(p);
		if (err)
			goto out;
	}

	task_lock(p);
	seq_printf(m, "%llu\n", p->timer_slack_ns);
	task_unlock(p);

out:
	put_task_struct(p);

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
john stultz john stultz 121 100.00% 4 100.00%
Total 121 100.00% 4 100.00%



static int timerslack_ns_open(struct inode *inode, struct file *filp)
{
	return single_open(filp, timerslack_ns_show, inode);
}

Contributors
Person Tokens Prop Commits CommitProp
john stultz john stultz 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%


static const struct file_operations proc_pid_set_timerslack_ns_operations = {
	.open		= timerslack_ns_open,
	.read		= seq_read,
	.write		= timerslack_ns_write,
	.llseek		= seq_lseek,
	.release	= single_release,
};



static int proc_pident_instantiate(struct inode *dir,
	struct dentry *dentry, struct task_struct *task, const void *ptr)
{
	const struct pid_entry *p = ptr;
	struct inode *inode;
	struct proc_inode *ei;

	inode = proc_pid_make_inode(dir->i_sb, task, p->mode);
	if (!inode)
		goto out;

	ei = PROC_I(inode);
	if (S_ISDIR(inode->i_mode))
		set_nlink(inode, 2);	/* Use getattr to fix if necessary */
	if (p->iop)
		inode->i_op = p->iop;
	if (p->fop)
		inode->i_fop = p->fop;
	ei->op = p->op;
	d_set_d_op(dentry, &pid_dentry_operations);
	d_add(dentry, inode);
	/* Close the race of the process dying before we return the dentry */
	if (pid_revalidate(dentry, 0))
		return 0;
out:
	return -ENOENT;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 78 48.45% 5 26.32%
al viro al viro 40 24.84% 5 26.32%
pre-git pre-git 23 14.29% 2 10.53%
miklos szeredi miklos szeredi 4 2.48% 1 5.26%
andreas gruenbacher andreas gruenbacher 4 2.48% 1 5.26%
nick piggin nick piggin 4 2.48% 1 5.26%
trond myklebust trond myklebust 3 1.86% 1 5.26%
eric dumazet eric dumazet 2 1.24% 1 5.26%
dipankar sarma dipankar sarma 2 1.24% 1 5.26%
andrew morton andrew morton 1 0.62% 1 5.26%
Total 161 100.00% 19 100.00%



static struct dentry *proc_pident_lookup(struct inode *dir, 
					 struct dentry *dentry,
					 const struct pid_entry *ents,
					 unsigned int nents)
{
	int error;
	struct task_struct *task = get_proc_task(dir);
	const struct pid_entry *p, *last;

	error = -ENOENT;

	if (!task)
		goto out_no_task;

	/*
         * Yes, it does not scale. And it should not. Don't add
         * new entries into /proc/<tgid>/ without very good reasons.
         */
	last = &ents[nents];
	for (p = ents; p < last; p++) {
		if (p->len != dentry->d_name.len)
			continue;
		if (!memcmp(dentry->d_name.name, p->name, p->len))
			break;
	}
	if (p >= last)
		goto out;

	error = proc_pident_instantiate(dir, dentry, task, p);
out:
	put_task_struct(task);
out_no_task:
	return ERR_PTR(error);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 150 94.94% 3 50.00%
al viro al viro 4 2.53% 1 16.67%
alexey dobriyan alexey dobriyan 2 1.27% 1 16.67%
eric dumazet eric dumazet 2 1.27% 1 16.67%
Total 158 100.00% 6 100.00%



static int proc_pident_readdir(struct file *file, struct dir_context *ctx,
		const struct pid_entry *ents, unsigned int nents)
{
	struct task_struct *task = get_proc_task(file_inode(file));
	const struct pid_entry *p;

	if (!task)
		return -ENOENT;

	if (!dir_emit_dots(file, ctx))
		goto out;

	if (ctx->pos >= nents + 2)
		goto out;

	for (p = ents + (ctx->pos - 2); p < ents + nents; p++) {
		if (!proc_fill_cache(file, ctx, p->name, p->len,
				proc_pident_instantiate, task, p))
			break;
		ctx->pos++;
	}
out:
	put_task_struct(task);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
al viro al viro 58 40.00% 1 10.00%
eric w. biederman eric w. biederman 47 32.41% 3 30.00%
andrew morton andrew morton 25 17.24% 2 20.00%
pre-git pre-git 13 8.97% 2 20.00%
eric dumazet eric dumazet 1 0.69% 1 10.00%
alexey dobriyan alexey dobriyan 1 0.69% 1 10.00%
Total 145 100.00% 10 100.00%

#ifdef CONFIG_SECURITY


static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
				  size_t count, loff_t *ppos)
{
	struct inode * inode = file_inode(file);
	char *p = NULL;
	ssize_t length;
	struct task_struct *task = get_proc_task(inode);

	if (!task)
		return -ESRCH;

	length = security_getprocattr(task,
				      (char*)file->f_path.dentry->d_name.name,
				      &p);
	put_task_struct(task);
	if (length > 0)
		length = simple_read_from_buffer(buf, count, ppos, p, length);
	kfree(p);
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 83 69.75% 1 16.67%
al viro al viro 22 18.49% 2 33.33%
pre-git pre-git 7 5.88% 1 16.67%
albert cahalan albert cahalan 4 3.36% 1 16.67%
josef 'jeff' sipek josef 'jeff' sipek 3 2.52% 1 16.67%
Total 119 100.00% 6 100.00%



static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
				   size_t count, loff_t *ppos)
{
	struct inode * inode = file_inode(file);
	void *page;
	ssize_t length;
	struct task_struct *task = get_proc_task(inode);

	length = -ESRCH;
	if (!task)
		goto out_no_task;
	if (count > PAGE_SIZE)
		count = PAGE_SIZE;

	/* No partial writes. */
	length = -EINVAL;
	if (*ppos != 0)
		goto out;

	page = memdup_user(buf, count);
	if (IS_ERR(page)) {
		length = PTR_ERR(page);
		goto out;
	}

	/* Guard against adverse ptrace interaction */
	length = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
	if (length < 0)
		goto out_free;

	length = security_setprocattr(task,
				      (char*)file->f_path.dentry->d_name.name,
				      page, count);
	mutex_unlock(&task->signal->cred_guard_mutex);
out_free:
	kfree(page);
out:
	put_task_struct(task);
out_no_task:
	return length;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 126 64.95% 1 7.69%
david howells david howells 28 14.43% 1 7.69%
al viro al viro 17 8.76% 2 15.38%
pre-git pre-git 5 2.58% 1 7.69%
albert cahalan albert cahalan 4 2.06% 1 7.69%
kosaki motohiro kosaki motohiro 4 2.06% 1 7.69%
josef 'jeff' sipek josef 'jeff' sipek 3 1.55% 1 7.69%
christoph lameter christoph lameter 2 1.03% 1 7.69%
andrea arcangeli andrea arcangeli 2 1.03% 1 7.69%
chuck lever chuck lever 1 0.52% 1 7.69%
linus torvalds linus torvalds 1 0.52% 1 7.69%
andrew morton andrew morton 1 0.52% 1 7.69%
Total 194 100.00% 13 100.00%


static const struct file_operations proc_pid_attr_operations = {
	.read		= proc_pid_attr_read,
	.write		= proc_pid_attr_write,
	.llseek		= generic_file_llseek,
};


static const struct pid_entry attr_dir_stuff[] = {
	REG("current",    S_IRUGO|S_IWUGO, proc_pid_attr_operations),
	REG("prev",       S_IRUGO,	   proc_pid_attr_operations),
	REG("exec",       S_IRUGO|S_IWUGO, proc_pid_attr_operations),
	REG("fscreate",   S_IRUGO|S_IWUGO, proc_pid_attr_operations),
	REG("keycreate",  S_IRUGO|S_IWUGO, proc_pid_attr_operations),
	REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
};



static int proc_attr_dir_readdir(struct file *file, struct dir_context *ctx)
{
	return proc_pident_readdir(file, ctx, 
				   attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 25 80.65% 2 66.67%
al viro al viro 6 19.35% 1 33.33%
Total 31 100.00% 3 100.00%


static const struct file_operations proc_attr_dir_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= proc_attr_dir_readdir,
	.llseek		= generic_file_llseek,
};



static struct dentry *proc_attr_dir_lookup(struct inode *dir,
				struct dentry *dentry, unsigned int flags)
{
	return proc_pident_lookup(dir, dentry,
				  attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 34 91.89% 3 75.00%
al viro al viro 3 8.11% 1 25.00%
Total 37 100.00% 4 100.00%


static const struct inode_operations proc_attr_dir_inode_operations = {
	.lookup		= proc_attr_dir_lookup,
	.getattr	= pid_getattr,
	.setattr	= proc_setattr,
};

#endif

#ifdef CONFIG_ELF_CORE


static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
					 size_t count, loff_t *ppos)
{
	struct task_struct *task = get_proc_task(file_inode(file));
	struct mm_struct *mm;
	char buffer[PROC_NUMBUF];
	size_t len;
	int ret;

	if (!task)
		return -ESRCH;

	ret = 0;
	mm = get_task_mm(task);
	if (mm) {
		len = snprintf(buffer, sizeof(buffer), "%08lx\n",
			       ((mm->flags & MMF_DUMP_FILTER_MASK) >>
				MMF_DUMP_FILTER_SHIFT));
		mmput(mm);
		ret = simple_read_from_buffer(buf, count, ppos, buffer, len);
	}

	put_task_struct(task);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
hidehiro kawai hidehiro kawai 130 97.74% 1 50.00%
al viro al viro 3 2.26% 1 50.00%
Total 133 100.00% 2 100.00%



static ssize_t proc_coredump_filter_write(struct file *file,
					  const char __user *buf,
					  size_t count,
					  loff_t *ppos)
{
	struct task_struct *task;
	struct mm_struct *mm;
	unsigned int val;
	int ret;
	int i;
	unsigned long mask;

	ret = kstrtouint_from_user(buf, count, 0, &val);
	if (ret < 0)
		return ret;

	ret = -ESRCH;
	task = get_proc_task(file_inode(file));
	if (!task)
		goto out_no_task;

	mm = get_task_mm(task);
	if (!mm)
		goto out_no_mm;
	ret = 0;

	for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {
		if (val & mask)
			set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
		else
			clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
	}

	mmput(mm);
 out_no_mm:
	put_task_struct(task);
 out_no_task:
	if (ret < 0)
		return ret;
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
hidehiro kawai hidehiro kawai 168 87.05% 1 25.00%
alexey dobriyan alexey dobriyan 18 9.33% 1 25.00%
colin king colin king 4 2.07% 1 25.00%
al viro al viro 3 1.55% 1 25.00%
Total 193 100.00% 4 100.00%


static const struct file_operations proc_coredump_filter_operations = {
	.read		= proc_coredump_filter_read,
	.write		= proc_coredump_filter_write,
	.llseek		= generic_file_llseek,
};
#endif

#ifdef CONFIG_TASK_IO_ACCOUNTING


static int do_io_accounting(struct task_struct *task, struct seq_file *m, int whole)
{
	struct task_io_accounting acct = task->ioac;
	unsigned long flags;
	int result;

	result = mutex_lock_killable(&task->signal->cred_guard_mutex);
	if (result)
		return result;

	if (!ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS)) {
		result = -EACCES;
		goto out_unlock;
	}

	if (whole && lock_task_sighand(task, &flags)) {
		struct task_struct *t = task;

		task_io_accounting_add(&acct, &task->signal->ioac);
		while_each_thread(task, t)
			task_io_accounting_add(&acct, &t->ioac);

		unlock_task_sighand(task, &flags);
	}
	seq_printf(m,
		   "rchar: %llu\n"
		   "wchar: %llu\n"
		   "syscr: %llu\n"
		   "syscw: %llu\n"
		   "read_bytes: %llu\n"
		   "write_bytes: %llu\n"
		   "cancelled_write_bytes: %llu\n",
		   (unsigned long long)acct.rchar,
		   (unsigned long long)acct.wchar,
		   (unsigned long long)acct.syscr,
		   (unsigned long long)acct.syscw,
		   (unsigned long long)acct.read_bytes,
		   (unsigned long long)acct.write_bytes,
		   (unsigned long long)acct.cancelled_write_bytes);
	result = 0;

out_unlock:
	mutex_unlock(&task->signal->cred_guard_mutex);
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
andrea righi andrea righi 89 39.21% 4 36.36%
vasiliy kulikov vasiliy kulikov 56 24.67% 2 18.18%
andrew morton andrew morton 37 16.30% 1 9.09%
alexander beregalov alexander beregalov 35 15.42% 1 9.09%
alexey dobriyan alexey dobriyan 5 2.20% 1 9.09%
joe perches joe perches 4 1.76% 1 9.09%
jann horn jann horn 1 0.44% 1 9.09%
Total 227 100.00% 11 100.00%



static int proc_tid_io_accounting(struct seq_file *m, struct pid_namespace *ns,
				  struct pid *pid, struct task_struct *task)
{
	return do_io_accounting(task, m, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
andrea righi andrea righi 20 55.56% 1 50.00%
alexey dobriyan alexey dobriyan 16 44.44% 1 50.00%
Total 36 100.00% 2 100.00%



static int proc_tgid_io_accounting(struct seq_file *m, struct pid_namespace *ns,
				   struct pid *pid, struct task_struct *task)
{
	return do_io_accounting(task, m, 1);
}
Contributors
Person Tokens Prop Commits CommitProp
andrea righi andrea righi 20 55.56% 1 50.00%
alexey dobriyan alexey dobriyan 16 44.44% 1 50.00%
Total 36 100.00% 2 100.00%

#endif /* CONFIG_TASK_IO_ACCOUNTING */

#ifdef CONFIG_USER_NS


static int proc_id_map_open(struct inode *inode, struct file *file,
	const struct seq_operations *seq_ops)
{
	struct user_namespace *ns = NULL;
	struct task_struct *task;
	struct seq_file *seq;
	int ret = -EINVAL;

	task = get_proc_task(inode);
	if (task) {
		rcu_read_lock();
		ns = get_user_ns(task_cred_xxx(task, user_ns));
		rcu_read_unlock();
		put_task_struct(task);
	}
	if (!ns)
		goto err;

	ret = seq_open(file, seq_ops);
	if (ret)
		goto err_put_ns;

	seq = file->private_data;
	seq->private = ns;

	return 0;
err_put_ns:
	put_user_ns(ns);
err:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 131 99.24% 1 50.00%
fabian frederick fabian frederick 1 0.76% 1 50.00%
Total 132 100.00% 2 100.00%



static int proc_id_map_release(struct inode *inode, struct file *file)
{
	struct seq_file *seq = file->private_data;
	struct user_namespace *ns = seq->private;
	put_user_ns(ns);
	return seq_release(inode, file);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 47 100.00% 1 100.00%
Total 47 100.00% 1 100.00%



static int proc_uid_map_open(struct inode *inode, struct file *file)
{
	return proc_id_map_open(inode, file, &proc_uid_seq_operations);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static int proc_gid_map_open(struct inode *inode, struct file *file)
{
	return proc_id_map_open(inode, file, &proc_gid_seq_operations);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%



static int proc_projid_map_open(struct inode *inode, struct file *file)
{
	return proc_id_map_open(inode, file, &proc_projid_seq_operations);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 27 100.00% 1 100.00%
Total 27 100.00% 1 100.00%


static const struct file_operations proc_uid_map_operations = {
	.open		= proc_uid_map_open,
	.write		= proc_uid_map_write,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= proc_id_map_release,
};


static const struct file_operations proc_gid_map_operations = {
	.open		= proc_gid_map_open,
	.write		= proc_gid_map_write,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= proc_id_map_release,
};


static const struct file_operations proc_projid_map_operations = {
	.open		= proc_projid_map_open,
	.write		= proc_projid_map_write,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= proc_id_map_release,
};



static int proc_setgroups_open(struct inode *inode, struct file *file)
{
	struct user_namespace *ns = NULL;
	struct task_struct *task;
	int ret;

	ret = -ESRCH;
	task = get_proc_task(inode);
	if (task) {
		rcu_read_lock();
		ns = get_user_ns(task_cred_xxx(task, user_ns));
		rcu_read_unlock();
		put_task_struct(task);
	}
	if (!ns)
		goto err;

	if (file->f_mode & FMODE_WRITE) {
		ret = -EACCES;
		if (!ns_capable(ns, CAP_SYS_ADMIN))
			goto err_put_ns;
	}

	ret = single_open(file, &proc_setgroups_show, ns);
	if (ret)
		goto err_put_ns;

	return 0;
err_put_ns:
	put_user_ns(ns);
err:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 142 100.00% 1 100.00%
Total 142 100.00% 1 100.00%



static int proc_setgroups_release(struct inode *inode, struct file *file)
{
	struct seq_file *seq = file->private_data;
	struct user_namespace *ns = seq->private;
	int ret = single_release(inode, file);
	put_user_ns(ns);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 52 100.00% 1 100.00%
Total 52 100.00% 1 100.00%


static const struct file_operations proc_setgroups_operations = {
	.open		= proc_setgroups_open,
	.write		= proc_setgroups_write,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= proc_setgroups_release,
};
#endif /* CONFIG_USER_NS */



static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
				struct pid *pid, struct task_struct *task)
{
	int err = lock_trace(task);
	if (!err) {
		seq_printf(m, "%08x\n", task->personality);
		unlock_trace(task);
	}
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
kees cook kees cook 39 65.00% 1 50.00%
al viro al viro 21 35.00% 1 50.00%
Total 60 100.00% 2 100.00%

/*
 * Thread groups
 */

static const struct file_operations proc_task_operations;

static const struct inode_operations proc_task_inode_operations;


static const struct pid_entry tgid_base_stuff[] = {
	DIR("task",       S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations),
	DIR("fd",         S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
	DIR("map_files",  S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),
	DIR("fdinfo",     S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
	DIR("ns",	  S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
#ifdef CONFIG_NET
	DIR("net",        S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
#endif
	REG("environ",    S_IRUSR, proc_environ_operations),
	REG("auxv",       S_IRUSR, proc_auxv_operations),
	ONE("status",     S_IRUGO, proc_pid_status),
	ONE("personality", S_IRUSR, proc_pid_personality),
	ONE("limits",	  S_IRUGO, proc_pid_limits),
#ifdef CONFIG_SCHED_DEBUG
	REG("sched",      S_IRUGO|S_IWUSR, proc_pid_sched_operations),
#endif
#ifdef CONFIG_SCHED_AUTOGROUP
	REG("autogroup",  S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations),
#endif
	REG("comm",      S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
	ONE("syscall",    S_IRUSR, proc_pid_syscall),
#endif
	REG("cmdline",    S_IRUGO, proc_pid_cmdline_ops),
	ONE("stat",       S_IRUGO, proc_tgid_stat),
	ONE("statm",      S_IRUGO, proc_pid_statm),
	REG("maps",       S_IRUGO, proc_pid_maps_operations),
#ifdef CONFIG_NUMA
	REG("numa_maps",  S_IRUGO, proc_pid_numa_maps_operations),
#endif
	REG("mem",        S_IRUSR|S_IWUSR, proc_mem_operations),
	LNK("cwd",        proc_cwd_link),
	LNK("root",       proc_root_link),
	LNK("exe",        proc_exe_link),
	REG("mounts",     S_IRUGO, proc_mounts_operations),
	REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),
	REG("mountstats", S_IRUSR, proc_mountstats_operations),
#ifdef CONFIG_PROC_PAGE_MONITOR
	REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
	REG("smaps",      S_IRUGO, proc_pid_smaps_operations),
	REG("pagemap",    S_IRUSR, proc_pagemap_operations),
#endif
#ifdef CONFIG_SECURITY
	DIR("attr",       S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
#endif
#ifdef CONFIG_KALLSYMS
	ONE("wchan",      S_IRUGO, proc_pid_wchan),
#endif
#ifdef CONFIG_STACKTRACE
	ONE("stack",      S_IRUSR, proc_pid_stack),
#endif
#ifdef CONFIG_SCHED_INFO
	ONE("schedstat",  S_IRUGO, proc_pid_schedstat),
#endif
#ifdef CONFIG_LATENCYTOP
	REG("latency",  S_IRUGO, proc_lstats_operations),
#endif
#ifdef CONFIG_PROC_PID_CPUSET
	ONE("cpuset",     S_IRUGO, proc_cpuset_show),
#endif
#ifdef CONFIG_CGROUPS
	ONE("cgroup",  S_IRUGO, proc_cgroup_show),
#endif
	ONE("oom_score",  S_IRUGO, proc_oom_score),
	REG("oom_adj",    S_IRUGO|S_IWUSR, proc_oom_adj_operations),
	REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
#ifdef CONFIG_AUDITSYSCALL
	REG("loginuid",   S_IWUSR|S_IRUGO, proc_loginuid_operations),
	REG("sessionid",  S_IRUGO, proc_sessionid_operations),
#endif
#ifdef CONFIG_FAULT_INJECTION
	REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
#endif
#ifdef CONFIG_ELF_CORE
	REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations),
#endif
#ifdef CONFIG_TASK_IO_ACCOUNTING
	ONE("io",	S_IRUSR, proc_tgid_io_accounting),
#endif
#ifdef CONFIG_HARDWALL
	ONE("hardwall",   S_IRUGO, proc_pid_hardwall),
#endif
#ifdef CONFIG_USER_NS
	REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
	REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
	REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
	REG("setgroups",  S_IRUGO|S_IWUSR, proc_setgroups_operations),
#endif
#ifdef CONFIG_CHECKPOINT_RESTORE
	REG("timers",	  S_IRUGO, proc_timers_operations),
#endif
	REG("timerslack_ns", S_IRUGO|S_IWUGO, proc_pid_set_timerslack_ns_operations),
};



static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx)
{
	return proc_pident_readdir(file, ctx,
				   tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 22 70.97% 1 33.33%
al viro al viro 6 19.35% 1 33.33%
eric w. biederman eric w. biederman 3 9.68% 1 33.33%
Total 31 100.00% 3 100.00%


static const struct file_operations proc_tgid_base_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= proc_tgid_base_readdir,
	.llseek		= generic_file_llseek,
};



static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
{
	return proc_pident_lookup(dir, dentry,
				  tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 27 72.97% 2 40.00%
eric w. biederman eric w. biederman 7 18.92% 2 40.00%
al viro al viro 3 8.11% 1 20.00%
Total 37 100.00% 5 100.00%


static const struct inode_operations proc_tgid_base_inode_operations = {
	.lookup		= proc_tgid_base_lookup,
	.getattr	= pid_getattr,
	.setattr	= proc_setattr,
	.permission	= proc_pid_permission,
};



static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
{
	struct dentry *dentry, *leader, *dir;
	char buf[PROC_NUMBUF];
	struct qstr name;

	name.name = buf;
	name.len = snprintf(buf, sizeof(buf), "%d", pid);
	/* no ->d_hash() rejects on procfs */
	dentry = d_hash_and_lookup(mnt->mnt_root, &name);
	if (dentry) {
		d_invalidate(dentry);
		dput(dentry);
	}

	if (pid == tgid)
		return;

	name.name = buf;
	name.len = snprintf(buf, sizeof(buf), "%d", tgid);
	leader = d_hash_and_lookup(mnt->mnt_root, &name);
	if (!leader)
		goto out;

	name.name = "task";
	name.len = strlen(name.name);
	dir = d_hash_and_lookup(leader, &name);
	if (!dir)
		goto out_put_leader;

	name.name = buf;
	name.len = snprintf(buf, sizeof(buf), "%d", pid);
	dentry = d_hash_and_lookup(dir, &name);
	if (dentry) {
		d_invalidate(dentry);
		dput(dentry);
	}

	dput(dir);
out_put_leader:
	dput(leader);
out:
	return;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 207 85.54% 3 42.86%
pre-git pre-git 15 6.20% 1 14.29%
pavel emelianov pavel emelianov 12 4.96% 1 14.29%
oleg nesterov oleg nesterov 7 2.89% 1 14.29%
al viro al viro 1 0.41% 1 14.29%
Total 242 100.00% 7 100.00%

/**
 * proc_flush_task -  Remove dcache entries for @task from the /proc dcache.
 * @task: task that should be flushed.
 *
 * When flushing dentries from proc, one needs to flush them from global
 * proc (proc_mnt) and from all the namespaces' procs this task was seen
 * in. This call is supposed to do all of this job.
 *
 * Looks in the dcache for
 * /proc/@pid
 * /proc/@tgid/task/@pid
 * if either directory is present flushes it and all of it'ts children
 * from the dcache.
 *
 * It is safe and reasonable to cache /proc entries for a task until
 * that task exits.  After that they just clog up the dcache with
 * useless entries, possibly causing useful dcache entries to be
 * flushed instead.  This routine is proved to flush those useless
 * dcache entries at process exit time.
 *
 * NOTE: This routine is just an optimization so it does not guarantee
 *       that no dcache entries will exist at process exit time it
 *       just makes it very unlikely that any will persist.
 */



void proc_flush_task(struct task_struct *task)
{
	int i;
	struct pid *pid, *tgid;
	struct upid *upid;

	pid = task_pid(task);
	tgid = task_tgid(task);

	for (i = 0; i <= pid->level; i++) {
		upid = &pid->numbers[i];
		proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
					tgid->numbers[i].nr);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
pavel emelianov pavel emelianov 87 97.75% 2 66.67%
eric w. biederman eric w. biederman 2 2.25% 1 33.33%
Total 89 100.00% 3 100.00%



static int proc_pid_instantiate(struct inode *dir,
				   struct dentry * dentry,
				   struct task_struct *task, const void *ptr)
{
	struct inode *inode;

	inode = proc_pid_make_inode(dir->i_sb, task, S_IFDIR | S_IRUGO | S_IXUGO);
	if (!inode)
		goto out;

	inode->i_op = &proc_tgid_base_inode_operations;
	inode->i_fop = &proc_tgid_base_operations;
	inode->i_flags|=S_IMMUTABLE;

	set_nlink(inode, nlink_tgid);

	d_set_d_op(dentry, &pid_dentry_operations);

	d_add(dentry, inode);
	/* Close the race of the process dying before we return the dentry */
	if (pid_revalidate(dentry, 0))
		return 0;
out:
	return -ENOENT;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 93 79.49% 1 11.11%
al viro al viro 7 5.98% 2 22.22%
andreas gruenbacher andreas gruenbacher 6 5.13% 1 11.11%
miklos szeredi miklos szeredi 4 3.42% 1 11.11%
nick piggin nick piggin 4 3.42% 1 11.11%
eric dumazet eric dumazet 1 0.85% 1 11.11%
alexey dobriyan alexey dobriyan 1 0.85% 1 11.11%
adrian bunk adrian bunk 1 0.85% 1 11.11%
Total 117 100.00% 9 100.00%



struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
{
	int result = -ENOENT;
	struct task_struct *task;
	unsigned tgid;
	struct pid_namespace *ns;

	tgid = name_to_int(&dentry->d_name);
	if (tgid == ~0U)
		goto out;

	ns = dentry->d_sb->s_fs_info;
	rcu_read_lock();
	task = find_task_by_pid_ns(tgid, ns);
	if (task)
		get_task_struct(task);
	rcu_read_unlock();
	if (!task)
		goto out;

	result = proc_pid_instantiate(dir, dentry, task, NULL);
	put_task_struct(task);
out:
	return ERR_PTR(result);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 76 60.32% 4 33.33%
pavel emelianov pavel emelianov 16 12.70% 1 8.33%
andrew morton andrew morton 12 9.52% 1 8.33%
pre-git pre-git 9 7.14% 1 8.33%
al viro al viro 8 6.35% 3 25.00%
alexey dobriyan alexey dobriyan 5 3.97% 2 16.67%
Total 126 100.00% 12 100.00%

/*
 * Find the first task with tgid >= tgid
 *
 */

struct tgid_iter {
	
unsigned int tgid;
	
struct task_struct *task;
};


static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter)
{
	struct pid *pid;

	if (iter.task)
		put_task_struct(iter.task);
	rcu_read_lock();
retry:
	iter.task = NULL;
	pid = find_ge_pid(iter.tgid, ns);
	if (pid) {
		iter.tgid = pid_nr_ns(pid, ns);
		iter.task = pid_task(pid, PIDTYPE_PID);
		/* What we to know is if the pid we have find is the
                 * pid of a thread_group_leader.  Testing for task
                 * being a thread_group_leader is the obvious thing
                 * todo but there is a window when it fails, due to
                 * the pid transfer logic in de_thread.
                 *
                 * So we perform the straight forward test of seeing
                 * if the pid we have found is the pid of a thread
                 * group leader, and don't worry if the task we have
                 * found doesn't happen to be a thread group leader.
                 * As we don't care in the case of readdir.
                 */
		if (!iter.task || !has_group_leader_pid(iter.task)) {
			iter.tgid += 1;
			goto retry;
		}
		get_task_struct(iter.task);
	}
	rcu_read_unlock();
	return iter;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 102 82.26% 3 42.86%
pavel emelianov pavel emelianov 11 8.87% 2 28.57%
andrew morton andrew morton 10 8.06% 1 14.29%
ingo molnar ingo molnar 1 0.81% 1 14.29%
Total 124 100.00% 7 100.00%


#define TGID_OFFSET (FIRST_PROCESS_ENTRY + 2)

/* for the /proc/ directory itself, after non-process stuff has been done */


int proc_pid_readdir(struct file *file, struct dir_context *ctx)
{
	struct tgid_iter iter;
	struct pid_namespace *ns = file_inode(file)->i_sb->s_fs_info;
	loff_t pos = ctx->pos;

	if (pos >= PID_MAX_LIMIT + TGID_OFFSET)
		return 0;

	if (pos == TGID_OFFSET - 2) {
		struct inode *inode = d_inode(ns->proc_self);
		if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK))
			return 0;
		ctx->pos = pos = pos + 1;
	}
	if (pos == TGID_OFFSET - 1) {
		struct inode *inode = d_inode(ns->proc_thread_self);
		if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK))
			return 0;
		ctx->pos = pos = pos + 1;
	}
	iter.tgid = pos - TGID_OFFSET;
	iter.task = NULL;
	for (iter = next_tgid(ns, iter);
	     iter.task;
	     iter.tgid += 1, iter = next_tgid(ns, iter)) {
		char name[PROC_NUMBUF];
		int len;

		cond_resched();
		if (!has_pid_permissions(ns, iter.task, 2))
			continue;

		len = snprintf(name, sizeof(name), "%d", iter.tgid);
		ctx->pos = iter.tgid + TGID_OFFSET;
		if (!proc_fill_cache(file, ctx, name, len,
				     proc_pid_instantiate, iter.task, NULL)) {
			put_task_struct(iter.task);
			return 0;
		}
	}
	ctx->pos = PID_MAX_LIMIT + TGID_OFFSET;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 127 41.91% 4 25.00%
al viro al viro 126 41.58% 4 25.00%
pre-git pre-git 17 5.61% 3 18.75%
vasiliy kulikov vasiliy kulikov 16 5.28% 1 6.25%
linus torvalds linus torvalds 6 1.98% 1 6.25%
david howells david howells 6 1.98% 1 6.25%
eric dumazet eric dumazet 3 0.99% 1 6.25%
pavel emelianov pavel emelianov 2 0.66% 1 6.25%
Total 303 100.00% 16 100.00%

/*
 * proc_tid_comm_permission is a special permission function exclusively
 * used for the node /proc/<pid>/task/<tid>/comm.
 * It bypasses generic permission checks in the case where a task of the same
 * task group attempts to access the node.
 * The rationale behind this is that glibc and bionic access this node for
 * cross thread naming (pthread_set/getname_np(!self)). However, if
 * PR_SET_DUMPABLE gets set to 0 this node among others becomes uid=0 gid=0,
 * which locks out the cross thread naming implementation.
 * This function makes sure that the node is always accessible for members of
 * same thread group.
 */


static int proc_tid_comm_permission(struct inode *inode, int mask)
{
	bool is_same_tgroup;
	struct task_struct *task;

	task = get_proc_task(inode);
	if (!task)
		return -ESRCH;
	is_same_tgroup = same_thread_group(current, task);
	put_task_struct(task);

	if (likely(is_same_tgroup && !(mask & MAY_EXEC))) {
		/* This file (/proc/<pid>/task/<tid>/comm) can always be
                 * read or written by the members of the corresponding
                 * thread group.
                 */
		return 0;
	}

	return generic_permission(inode, mask);
}

Contributors
Person Tokens Prop Commits CommitProp
janis danisevskis janis danisevskis 80 100.00% 1 100.00%
Total 80 100.00% 1 100.00%


static const struct inode_operations proc_tid_comm_inode_operations = {
		.permission = proc_tid_comm_permission,
};

/*
 * Tasks
 */

static const struct pid_entry tid_base_stuff[] = {
	DIR("fd",        S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
	DIR("fdinfo",    S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
	DIR("ns",	 S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
#ifdef CONFIG_NET
	DIR("net",        S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
#endif
	REG("environ",   S_IRUSR, proc_environ_operations),
	REG("auxv",      S_IRUSR, proc_auxv_operations),
	ONE("status",    S_IRUGO, proc_pid_status),
	ONE("personality", S_IRUSR, proc_pid_personality),
	ONE("limits",	 S_IRUGO, proc_pid_limits),
#ifdef CONFIG_SCHED_DEBUG
	REG("sched",     S_IRUGO|S_IWUSR, proc_pid_sched_operations),
#endif
	NOD("comm",      S_IFREG|S_IRUGO|S_IWUSR,
			 &proc_tid_comm_inode_operations,
			 &proc_pid_set_comm_operations, {}),
#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
	ONE("syscall",   S_IRUSR, proc_pid_syscall),
#endif
	REG("cmdline",   S_IRUGO, proc_pid_cmdline_ops),
	ONE("stat",      S_IRUGO, proc_tid_stat),
	ONE("statm",     S_IRUGO, proc_pid_statm),
	REG("maps",      S_IRUGO, proc_tid_maps_operations),
#ifdef CONFIG_PROC_CHILDREN
	REG("children",  S_IRUGO, proc_tid_children_operations),
#endif
#ifdef CONFIG_NUMA
	REG("numa_maps", S_IRUGO, proc_tid_numa_maps_operations),
#endif
	REG("mem",       S_IRUSR|S_IWUSR, proc_mem_operations),
	LNK("cwd",       proc_cwd_link),
	LNK("root",      proc_root_link),
	LNK("exe",       proc_exe_link),
	REG("mounts",    S_IRUGO, proc_mounts_operations),
	REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),
#ifdef CONFIG_PROC_PAGE_MONITOR
	REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
	REG("smaps",     S_IRUGO, proc_tid_smaps_operations),
	REG("pagemap",    S_IRUSR, proc_pagemap_operations),
#endif
#ifdef CONFIG_SECURITY
	DIR("attr",      S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
#endif
#ifdef CONFIG_KALLSYMS
	ONE("wchan",     S_IRUGO, proc_pid_wchan),
#endif
#ifdef CONFIG_STACKTRACE
	ONE("stack",      S_IRUSR, proc_pid_stack),
#endif
#ifdef CONFIG_SCHED_INFO
	ONE("schedstat", S_IRUGO, proc_pid_schedstat),
#endif
#ifdef CONFIG_LATENCYTOP
	REG("latency",  S_IRUGO, proc_lstats_operations),
#endif
#ifdef CONFIG_PROC_PID_CPUSET
	ONE("cpuset",    S_IRUGO, proc_cpuset_show),
#endif
#ifdef CONFIG_CGROUPS
	ONE("cgroup",  S_IRUGO, proc_cgroup_show),
#endif
	ONE("oom_score", S_IRUGO, proc_oom_score),
	REG("oom_adj",   S_IRUGO|S_IWUSR, proc_oom_adj_operations),
	REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
#ifdef CONFIG_AUDITSYSCALL
	REG("loginuid",  S_IWUSR|S_IRUGO, proc_loginuid_operations),
	REG("sessionid",  S_IRUGO, proc_sessionid_operations),
#endif
#ifdef CONFIG_FAULT_INJECTION
	REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
#endif
#ifdef CONFIG_TASK_IO_ACCOUNTING
	ONE("io",	S_IRUSR, proc_tid_io_accounting),
#endif
#ifdef CONFIG_HARDWALL
	ONE("hardwall",   S_IRUGO, proc_pid_hardwall),
#endif
#ifdef CONFIG_USER_NS
	REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
	REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
	REG("projid_map", S_IRUGO|S_IWUSR, proc_projid_map_operations),
	REG("setgroups",  S_IRUGO|S_IWUSR, proc_setgroups_operations),
#endif
};



static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx)
{
	return proc_pident_readdir(file, ctx,
				   tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 22 70.97% 1 33.33%
al viro al viro 6 19.35% 1 33.33%
albert cahalan albert cahalan 3 9.68% 1 33.33%
Total 31 100.00% 3 100.00%



static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
{
	return proc_pident_lookup(dir, dentry,
				  tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 29 78.38% 5 71.43%
albert cahalan albert cahalan 5 13.51% 1 14.29%
al viro al viro 3 8.11% 1 14.29%
Total 37 100.00% 7 100.00%


static const struct file_operations proc_tid_base_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= proc_tid_base_readdir,
	.llseek		= generic_file_llseek,
};


static const struct inode_operations proc_tid_base_inode_operations = {
	.lookup		= proc_tid_base_lookup,
	.getattr	= pid_getattr,
	.setattr	= proc_setattr,
};



static int proc_task_instantiate(struct inode *dir,
	struct dentry *dentry, struct task_struct *task, const void *ptr)
{
	struct inode *inode;
	inode = proc_pid_make_inode(dir->i_sb, task, S_IFDIR | S_IRUGO | S_IXUGO);

	if (!inode)
		goto out;
	inode->i_op = &proc_tid_base_inode_operations;
	inode->i_fop = &proc_tid_base_operations;
	inode->i_flags|=S_IMMUTABLE;

	set_nlink(inode, nlink_tid);

	d_set_d_op(dentry, &pid_dentry_operations);

	d_add(dentry, inode);
	/* Close the race of the process dying before we return the dentry */
	if (pid_revalidate(dentry, 0))
		return 0;
out:
	return -ENOENT;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 94 80.34% 1 12.50%
al viro al viro 7 5.98% 2 25.00%
andreas gruenbacher andreas gruenbacher 6 5.13% 1 12.50%
nick piggin nick piggin 4 3.42% 1 12.50%
miklos szeredi miklos szeredi 4 3.42% 1 12.50%
alexey dobriyan alexey dobriyan 1 0.85% 1 12.50%
eric dumazet eric dumazet 1 0.85% 1 12.50%
Total 117 100.00% 8 100.00%



static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
{
	int result = -ENOENT;
	struct task_struct *task;
	struct task_struct *leader = get_proc_task(dir);
	unsigned tid;
	struct pid_namespace *ns;

	if (!leader)
		goto out_no_task;

	tid = name_to_int(&dentry->d_name);
	if (tid == ~0U)
		goto out;

	ns = dentry->d_sb->s_fs_info;
	rcu_read_lock();
	task = find_task_by_pid_ns(tid, ns);
	if (task)
		get_task_struct(task);
	rcu_read_unlock();
	if (!task)
		goto out;
	if (!same_thread_group(leader, task))
		goto out_drop_task;

	result = proc_task_instantiate(dir, dentry, task, NULL);
out_drop_task:
	put_task_struct(task);
out:
	put_task_struct(leader);
out_no_task:
	return ERR_PTR(result);
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 113 67.66% 4 33.33%
pavel emelianov pavel emelianov 21 12.57% 2 16.67%
albert cahalan albert cahalan 21 12.57% 1 8.33%
al viro al viro 7 4.19% 2 16.67%
alexey dobriyan alexey dobriyan 3 1.80% 1 8.33%
andrew morton andrew morton 1 0.60% 1 8.33%
manfred spraul manfred spraul 1 0.60% 1 8.33%
Total 167 100.00% 12 100.00%

/*
 * Find the first tid of a thread group to return to user space.
 *
 * Usually this is just the thread group leader, but if the users
 * buffer was too small or there was a seek into the middle of the
 * directory we have more work todo.
 *
 * In the case of a short read we start with find_task_by_pid.
 *
 * In the case of a seek we start with the leader and walk nr
 * threads past it.
 */


static struct task_struct *first_tid(struct pid *pid, int tid, loff_t f_pos,
					struct pid_namespace *ns)
{
	struct task_struct *pos, *task;
	unsigned long nr = f_pos;

	if (nr != f_pos)	/* 32bit overflow? */
		return NULL;

	rcu_read_lock();
	task = pid_task(pid, PIDTYPE_PID);
	if (!task)
		goto fail;

	/* Attempt to start with the tid of a thread */
	if (tid && nr) {
		pos = find_task_by_pid_ns(tid, ns);
		if (pos && same_thread_group(pos, task))
			goto found;
	}

	/* If nr exceeds the number of threads there is nothing todo */
	if (nr >= get_nr_threads(task))
		goto fail;

	/* If we haven't found our starting place yet start
         * with the leader and walk nr threads forward.
         */
	pos = task = task->group_leader;
	do {
		if (!nr--)
			goto found;
	} while_each_thread(task, pos);
Contributors
Person Tokens Prop Commits CommitProp
oleg nesterov oleg nesterov 78 56.52% 5 55.56%
eric w. biederman eric w. biederman 52 37.68% 3 33.33%
pavel emelianov pavel emelianov 8 5.80% 1 11.11%
Total 138 100.00% 9 100.00%

fail:
	pos = NULL;
	goto out;
found:
	get_task_struct(pos);
out:
	rcu_read_unlock();
	return pos;
}

/*
 * Find the next thread in the thread list.
 * Return NULL if there is an error or no next thread.
 *
 * The reference to the input task_struct is released.
 */

static 
struct task_struct *next_tid(struct task_struct *start)
{
	struct task_struct *pos = NULL;
	rcu_read_lock();
	if (pid_alive(start)) {
		pos = next_thread(start);
		if (thread_group_leader(pos))
			pos = NULL;
		else
			get_task_struct(pos);
	}
	rcu_read_unlock();
	put_task_struct(start);
	return pos;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 43 64.18% 2 25.00%
oleg nesterov oleg nesterov 11 16.42% 2 25.00%
pre-git pre-git 8 11.94% 1 12.50%
albert cahalan albert cahalan 3 4.48% 1 12.50%
andrew morton andrew morton 1 1.49% 1 12.50%
manfred spraul manfred spraul 1 1.49% 1 12.50%
Total 67 100.00% 8 100.00%

/* for the /proc/TGID/task/ directories */


static int proc_task_readdir(struct file *file, struct dir_context *ctx)
{
	struct inode *inode = file_inode(file);
	struct task_struct *task;
	struct pid_namespace *ns;
	int tid;

	if (proc_inode_is_dead(inode))
		return -ENOENT;

	if (!dir_emit_dots(file, ctx))
		return 0;

	/* f_version caches the tgid value that the last readdir call couldn't
         * return. lseek aka telldir automagically resets f_version to 0.
         */
	ns = inode->i_sb->s_fs_info;
	tid = (int)file->f_version;
	file->f_version = 0;
	for (task = first_tid(proc_pid(inode), tid, ctx->pos - 2, ns);
	     task;
	     task = next_tid(task), ctx->pos++) {
		char name[PROC_NUMBUF];
		int len;
		tid = task_pid_nr_ns(task, ns);
		len = snprintf(name, sizeof(name), "%d", tid);
		if (!proc_fill_cache(file, ctx, name, len,
				proc_task_instantiate, task, NULL)) {
			/* returning this tgid failed, save it as the first
                         * pid for the next readir call */
			file->f_version = (u64)tid;
			put_task_struct(task);
			break;
		}
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 64 32.00% 2 15.38%
al viro al viro 60 30.00% 2 15.38%
pre-git pre-git 27 13.50% 3 23.08%
pavel emelianov pavel emelianov 18 9.00% 1 7.69%
oleg nesterov oleg nesterov 15 7.50% 1 7.69%
mathieu desnoyers mathieu desnoyers 6 3.00% 1 7.69%
guillaume chazarain guillaume chazarain 4 2.00% 1 7.69%
albert cahalan albert cahalan 4 2.00% 1 7.69%
zhang le zhang le 2 1.00% 1 7.69%
Total 200 100.00% 13 100.00%



static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = d_inode(dentry);
	struct task_struct *p = get_proc_task(inode);
	generic_fillattr(inode, stat);

	if (p) {
		stat->nlink += get_nr_threads(p);
		put_task_struct(p);
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 68 95.77% 2 66.67%
david howells david howells 3 4.23% 1 33.33%
Total 71 100.00% 3 100.00%


static const struct inode_operations proc_task_inode_operations = {
	.lookup		= proc_task_lookup,
	.getattr	= proc_task_getattr,
	.setattr	= proc_setattr,
	.permission	= proc_pid_permission,
};


static const struct file_operations proc_task_operations = {
	.read		= generic_read_dir,
	.iterate_shared	= proc_task_readdir,
	.llseek		= generic_file_llseek,
};



void __init set_proc_pid_nlink(void)
{
	nlink_tid = pid_entry_nlink(tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
	nlink_tgid = pid_entry_nlink(tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
}
Contributors
Person Tokens Prop Commits CommitProp
alexey dobriyan alexey dobriyan 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
eric w. biederman eric w. biederman 4584 28.54% 37 10.72%
alexey dobriyan alexey dobriyan 1218 7.58% 28 8.12%
al viro al viro 1029 6.41% 33 9.57%
pavel emelianov pavel emelianov 783 4.88% 9 2.61%
cyrill gorcunov cyrill gorcunov 762 4.75% 3 0.87%
david rientjes david rientjes 675 4.20% 9 2.61%
john stultz john stultz 627 3.90% 5 1.45%
michal hocko michal hocko 416 2.59% 3 0.87%
neil horman neil horman 389 2.42% 1 0.29%
pre-git pre-git 372 2.32% 18 5.22%
oleg nesterov oleg nesterov 367 2.29% 13 3.77%
hidehiro kawai hidehiro kawai 335 2.09% 1 0.29%
mike galbraith mike galbraith 325 2.02% 1 0.29%
akinobu mita akinobu mita 281 1.75% 2 0.58%
arjan van de ven arjan van de ven 261 1.63% 3 0.87%
vasiliy kulikov vasiliy kulikov 257 1.60% 3 0.87%
ingo molnar ingo molnar 240 1.49% 5 1.45%
andrew morton andrew morton 239 1.49% 14 4.06%
james pearson james pearson 203 1.26% 1 0.29%
linus torvalds linus torvalds 195 1.21% 14 4.06%
ken chen ken chen 170 1.06% 2 0.58%
david howells david howells 152 0.95% 6 1.74%
andrea righi andrea righi 144 0.90% 4 1.16%
eric paris eric paris 140 0.87% 3 0.87%
roland mcgrath roland mcgrath 137 0.85% 2 0.58%
miklos szeredi miklos szeredi 130 0.81% 3 0.87%
janis danisevskis janis danisevskis 106 0.66% 1 0.29%
albert cahalan albert cahalan 98 0.61% 3 0.87%
serge hallyn serge hallyn 87 0.54% 2 0.58%
americo wang americo wang 87 0.54% 1 0.29%
matt helsley matt helsley 83 0.52% 1 0.29%
andrea arcangeli andrea arcangeli 65 0.40% 2 0.58%
vegard nossum vegard nossum 61 0.38% 1 0.29%
calvin owens calvin owens 59 0.37% 1 0.29%
kees cook kees cook 57 0.35% 3 0.87%
christoph hellwig christoph hellwig 56 0.35% 7 2.03%
arnd bergmann arnd bergmann 55 0.34% 2 0.58%
hiroshi shimamoto hiroshi shimamoto 52 0.32% 4 1.16%
andreas gruenbacher andreas gruenbacher 51 0.32% 1 0.29%
joe perches joe perches 50 0.31% 2 0.58%
nick piggin nick piggin 47 0.29% 2 0.58%
djalal harouni djalal harouni 46 0.29% 4 1.16%
mateusz guzik mateusz guzik 36 0.22% 2 0.58%
alexander beregalov alexander beregalov 35 0.22% 1 0.29%
chris metcalf chris metcalf 34 0.21% 1 0.29%
paul menage paul menage 29 0.18% 2 0.58%
hugh dickins hugh dickins 29 0.18% 1 0.29%
jan blunck jan blunck 24 0.15% 2 0.58%
naveen n. rao naveen n. rao 20 0.12% 1 0.29%
eric dumazet eric dumazet 19 0.12% 2 0.58%
robert love robert love 17 0.11% 1 0.29%
matt mackall matt mackall 16 0.10% 2 0.58%
ram pai ram pai 16 0.10% 1 0.29%
dave jones dave jones 15 0.09% 2 0.58%
rick lindsley rick lindsley 13 0.08% 1 0.29%
lorenzo stoakes lorenzo stoakes 13 0.08% 1 0.29%
paul e. mckenney paul e. mckenney 11 0.07% 1 0.29%
pavel tikhomirov pavel tikhomirov 11 0.07% 1 0.29%
eugene teo eugene teo 10 0.06% 1 0.29%
jann horn jann horn 10 0.06% 1 0.29%
xiaotian feng xiaotian feng 9 0.06% 1 0.29%
josef 'jeff' sipek josef 'jeff' sipek 9 0.06% 1 0.29%
dipankar sarma dipankar sarma 9 0.06% 3 0.87%
chris wright chris wright 9 0.06% 2 0.58%
kosaki motohiro kosaki motohiro 8 0.05% 2 0.58%
paul jackson paul jackson 8 0.05% 1 0.29%
leon yu leon yu 8 0.05% 1 0.29%
li zefan li zefan 8 0.05% 2 0.58%
stanislav kinsbursky stanislav kinsbursky 6 0.04% 1 0.29%
daniel drake daniel drake 6 0.04% 1 0.29%
vincent li vincent li 6 0.04% 1 0.29%
mathieu desnoyers mathieu desnoyers 6 0.04% 1 0.29%
siddhesh poyarekar siddhesh poyarekar 6 0.04% 1 0.29%
jake edge jake edge 6 0.04% 1 0.29%
mathias krause mathias krause 6 0.04% 1 0.29%
jovi zhang jovi zhang 6 0.04% 1 0.29%
artem fetishev artem fetishev 5 0.03% 1 0.29%
dave hansen dave hansen 5 0.03% 1 0.29%
eric engestrom eric engestrom 5 0.03% 1 0.29%
randy dunlap randy dunlap 4 0.02% 2 0.58%
guillaume chazarain guillaume chazarain 4 0.02% 1 0.29%
mel gorman mel gorman 4 0.02% 1 0.29%
christoph lameter christoph lameter 4 0.02% 1 0.29%
colin king colin king 4 0.02% 1 0.29%
deepa dinamani deepa dinamani 4 0.02% 1 0.29%
trond myklebust trond myklebust 3 0.02% 1 0.29%
tejun heo tejun heo 3 0.02% 1 0.29%
mandeep singh baines mandeep singh baines 3 0.02% 1 0.29%
andries brouwer andries brouwer 3 0.02% 1 0.29%
greg kroah-hartman greg kroah-hartman 3 0.02% 2 0.58%
chuck lever chuck lever 3 0.02% 1 0.29%
kamezawa hiroyuki kamezawa hiroyuki 3 0.02% 1 0.29%
michael lemay michael lemay 3 0.02% 1 0.29%
daniel jacobowitz daniel jacobowitz 3 0.02% 1 0.29%
art haas art haas 2 0.01% 1 0.29%
zhang le zhang le 2 0.01% 1 0.29%
manfred spraul manfred spraul 2 0.01% 1 0.29%
stephen d. smalley stephen d. smalley 2 0.01% 1 0.29%
jan kara jan kara 2 0.01% 1 0.29%
robin humble robin humble 2 0.01% 1 0.29%
stephen wilson stephen wilson 2 0.01% 1 0.29%
jiri olsa jiri olsa 2 0.01% 1 0.29%
rusty russell rusty russell 1 0.01% 1 0.29%
glauber de oliveira costa glauber de oliveira costa 1 0.01% 1 0.29%
mauricio lin mauricio lin 1 0.01% 1 0.29%
josh poimboeuf josh poimboeuf 1 0.01% 1 0.29%
andre noll andre noll 1 0.01% 1 0.29%
iago lopez galeiras iago lopez galeiras 1 0.01% 1 0.29%
jerome marchand jerome marchand 1 0.01% 1 0.29%
balbir singh balbir singh 1 0.01% 1 0.29%
kirill korotaev kirill korotaev 1 0.01% 1 0.29%
fabian frederick fabian frederick 1 0.01% 1 0.29%
adrian bunk adrian bunk 1 0.01% 1 0.29%
steve grubb steve grubb 1 0.01% 1 0.29%
Total 16059 100.00% 345 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
vegard nossum	vegard nossum	60	95.24%	1	50.00%
alexey dobriyan	alexey dobriyan	3	4.76%	1	50.00%
	Total	63	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/proc/base.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

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

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

Contributors

Contributors

Contributors
