/*
   *  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 <asm/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.
   */

  struct pid_entry {

  	const char *name;

  	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 pid_entry_count_dirs(const struct pid_entry *entries,
  	unsigned int n)
  {
  	unsigned int i;
  	unsigned int count;
  
  	count = 0;
  	for (i = 0; i < n; ++i) {
  		if (S_ISDIR(entries[i].mode))
  			++count;
  	}
  
  	return count;
  }

  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;

  }

  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;
  }

  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;
  }

  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;

  }

  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;

  }
  #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;
  }
  
  static void unlock_trace(struct task_struct *task)
  {
  	mutex_unlock(&task->signal->cred_guard_mutex);
  }

  #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
  ",

  				   (void *)entries[i], (void *)entries[i]);
  		}
  		unlock_trace(task);

  	}
  	kfree(entries);

  	return err;

  }
  #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
  ");
  	else
  		seq_printf(m, "%llu %llu %lu
  ",

  		   (unsigned long long)task->se.sum_exec_runtime,
  		   (unsigned long long)task->sched_info.run_delay,
  		   task->sched_info.pcount);
  
  	return 0;

  }
  #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
  ");

  	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, '
  ');

  		}
  
  	}

  	put_task_struct(task);

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

  	return single_open(file, lstats_show_proc, inode);

  }

  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;
  }
  
  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
  ", points);
  
  	return 0;

  }

  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
  ",

  		  "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
  ", lnames[i].unit);

  		else

  			seq_putc(m, '
  ');

  	}

  	return 0;

  }

  #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
  ");

  	else if (nr < 0)

  		seq_printf(m, "%ld 0x%lx 0x%lx
  ", nr, sp, pc);

  	else

  		seq_printf(m,

  		       "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx
  ",
  		       nr,
  		       args[0], args[1], args[2], args[3], args[4], args[5],
  		       sp, pc);

  	unlock_trace(task);

  
  	return 0;

  }
  #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;

  }

  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;

  }

  /*
   * 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);

  }
  
  
  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);
  }

  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;
  }
  
  static int proc_single_open(struct inode *inode, struct file *filp)
  {

  	return single_open(filp, proc_single_show, inode);

  }
  
  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;
  }
  
  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;
  }

  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;

  }

  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;
  }

  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);
  }
  
  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);
  }

  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;
  }

  static int mem_release(struct inode *inode, struct file *file)
  {
  	struct mm_struct *mm = file->private_data;

  	if (mm)

  		mmdrop(mm);

  	return 0;
  }

  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);
  }

  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;
  }
  
  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);
  }
  
  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]));
  }
  
  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
  ", oom_adj);
  	return simple_read_from_buffer(buf, count, ppos, buffer, len);
  }

  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.
  ",
  			  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.
  ",
  						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;
  }

  /*
   * /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;
  }
  
  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
  ", oom_score_adj);

  	return simple_read_from_buffer(buf, count, ppos, buffer, len);
  }
  
  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;

  }
  
  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 21
  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);
  }
  
  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;

  }

  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);
  }
  
  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
  ", make_it_fail);

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

  }
  
  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;

  }

  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;
  }
  
  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;
  }
  
  static int sched_open(struct inode *inode, struct file *filp)
  {

  	return single_open(filp, sched_show, inode);

  }
  
  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;
  }
  
  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;
  }
  
  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;
  }
  
  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;
  }
  
  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
  ", p->comm);
  	task_unlock(p);
  
  	put_task_struct(p);
  
  	return 0;
  }
  
  static int comm_open(struct inode *inode, struct file *filp)
  {

  	return single_open(filp, comm_show, inode);

  }
  
  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;
  }

  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);

  }

  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;
  }
  
  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;
  }

  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)

  {
  	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_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;

  }

  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;

  }

  /* 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;
  }

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

  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));

  }

  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);

  }

  /*
   * 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;
  }

  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;
  }
  
  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;
  }
  
  struct map_files_info {

  	fmode_t		mode;

  	unsigned long	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);

  }
  
  /*

   * 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);
  	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;
  	inode->i_mode = S_IFLNK;

  	if (mode & FMODE_READ)

  		inode->i_mode |= S_IRUSR;

  	if (mode & FMODE_WRITE)

  		inode->i_mode |= S_IWUSR;
  
  	d_set_d_op(dentry, &tid_map_files_dentry_operations);
  	d_add(dentry, inode);