xref: /linux/fs/proc/base.c (revision 4413e16d9d21673bb5048a2e542f1aaa00015c2e)
1 /*
2  *  linux/fs/proc/base.c
3  *
4  *  Copyright (C) 1991, 1992 Linus Torvalds
5  *
6  *  proc base directory handling functions
7  *
8  *  1999, Al Viro. Rewritten. Now it covers the whole per-process part.
9  *  Instead of using magical inumbers to determine the kind of object
10  *  we allocate and fill in-core inodes upon lookup. They don't even
11  *  go into icache. We cache the reference to task_struct upon lookup too.
12  *  Eventually it should become a filesystem in its own. We don't use the
13  *  rest of procfs anymore.
14  *
15  *
16  *  Changelog:
17  *  17-Jan-2005
18  *  Allan Bezerra
19  *  Bruna Moreira <bruna.moreira@indt.org.br>
20  *  Edjard Mota <edjard.mota@indt.org.br>
21  *  Ilias Biris <ilias.biris@indt.org.br>
22  *  Mauricio Lin <mauricio.lin@indt.org.br>
23  *
24  *  Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
25  *
26  *  A new process specific entry (smaps) included in /proc. It shows the
27  *  size of rss for each memory area. The maps entry lacks information
28  *  about physical memory size (rss) for each mapped file, i.e.,
29  *  rss information for executables and library files.
30  *  This additional information is useful for any tools that need to know
31  *  about physical memory consumption for a process specific library.
32  *
33  *  Changelog:
34  *  21-Feb-2005
35  *  Embedded Linux Lab - 10LE Instituto Nokia de Tecnologia - INdT
36  *  Pud inclusion in the page table walking.
37  *
38  *  ChangeLog:
39  *  10-Mar-2005
40  *  10LE Instituto Nokia de Tecnologia - INdT:
41  *  A better way to walks through the page table as suggested by Hugh Dickins.
42  *
43  *  Simo Piiroinen <simo.piiroinen@nokia.com>:
44  *  Smaps information related to shared, private, clean and dirty pages.
45  *
46  *  Paul Mundt <paul.mundt@nokia.com>:
47  *  Overall revision about smaps.
48  */
49 
50 #include <asm/uaccess.h>
51 
52 #include <linux/errno.h>
53 #include <linux/time.h>
54 #include <linux/proc_fs.h>
55 #include <linux/stat.h>
56 #include <linux/task_io_accounting_ops.h>
57 #include <linux/init.h>
58 #include <linux/capability.h>
59 #include <linux/file.h>
60 #include <linux/fdtable.h>
61 #include <linux/string.h>
62 #include <linux/seq_file.h>
63 #include <linux/namei.h>
64 #include <linux/mnt_namespace.h>
65 #include <linux/mm.h>
66 #include <linux/swap.h>
67 #include <linux/rcupdate.h>
68 #include <linux/kallsyms.h>
69 #include <linux/stacktrace.h>
70 #include <linux/resource.h>
71 #include <linux/module.h>
72 #include <linux/mount.h>
73 #include <linux/security.h>
74 #include <linux/ptrace.h>
75 #include <linux/tracehook.h>
76 #include <linux/cgroup.h>
77 #include <linux/cpuset.h>
78 #include <linux/audit.h>
79 #include <linux/poll.h>
80 #include <linux/nsproxy.h>
81 #include <linux/oom.h>
82 #include <linux/elf.h>
83 #include <linux/pid_namespace.h>
84 #include <linux/user_namespace.h>
85 #include <linux/fs_struct.h>
86 #include <linux/slab.h>
87 #include <linux/flex_array.h>
88 #ifdef CONFIG_HARDWALL
89 #include <asm/hardwall.h>
90 #endif
91 #include <trace/events/oom.h>
92 #include "internal.h"
93 
94 /* NOTE:
95  *	Implementing inode permission operations in /proc is almost
96  *	certainly an error.  Permission checks need to happen during
97  *	each system call not at open time.  The reason is that most of
98  *	what we wish to check for permissions in /proc varies at runtime.
99  *
100  *	The classic example of a problem is opening file descriptors
101  *	in /proc for a task before it execs a suid executable.
102  */
103 
104 struct pid_entry {
105 	char *name;
106 	int len;
107 	umode_t mode;
108 	const struct inode_operations *iop;
109 	const struct file_operations *fop;
110 	union proc_op op;
111 };
112 
113 #define NOD(NAME, MODE, IOP, FOP, OP) {			\
114 	.name = (NAME),					\
115 	.len  = sizeof(NAME) - 1,			\
116 	.mode = MODE,					\
117 	.iop  = IOP,					\
118 	.fop  = FOP,					\
119 	.op   = OP,					\
120 }
121 
122 #define DIR(NAME, MODE, iops, fops)	\
123 	NOD(NAME, (S_IFDIR|(MODE)), &iops, &fops, {} )
124 #define LNK(NAME, get_link)					\
125 	NOD(NAME, (S_IFLNK|S_IRWXUGO),				\
126 		&proc_pid_link_inode_operations, NULL,		\
127 		{ .proc_get_link = get_link } )
128 #define REG(NAME, MODE, fops)				\
129 	NOD(NAME, (S_IFREG|(MODE)), NULL, &fops, {})
130 #define INF(NAME, MODE, read)				\
131 	NOD(NAME, (S_IFREG|(MODE)), 			\
132 		NULL, &proc_info_file_operations,	\
133 		{ .proc_read = read } )
134 #define ONE(NAME, MODE, show)				\
135 	NOD(NAME, (S_IFREG|(MODE)), 			\
136 		NULL, &proc_single_file_operations,	\
137 		{ .proc_show = show } )
138 
139 static int proc_fd_permission(struct inode *inode, int mask);
140 
141 /*
142  * Count the number of hardlinks for the pid_entry table, excluding the .
143  * and .. links.
144  */
145 static unsigned int pid_entry_count_dirs(const struct pid_entry *entries,
146 	unsigned int n)
147 {
148 	unsigned int i;
149 	unsigned int count;
150 
151 	count = 0;
152 	for (i = 0; i < n; ++i) {
153 		if (S_ISDIR(entries[i].mode))
154 			++count;
155 	}
156 
157 	return count;
158 }
159 
160 static int get_task_root(struct task_struct *task, struct path *root)
161 {
162 	int result = -ENOENT;
163 
164 	task_lock(task);
165 	if (task->fs) {
166 		get_fs_root(task->fs, root);
167 		result = 0;
168 	}
169 	task_unlock(task);
170 	return result;
171 }
172 
173 static int proc_cwd_link(struct dentry *dentry, struct path *path)
174 {
175 	struct task_struct *task = get_proc_task(dentry->d_inode);
176 	int result = -ENOENT;
177 
178 	if (task) {
179 		task_lock(task);
180 		if (task->fs) {
181 			get_fs_pwd(task->fs, path);
182 			result = 0;
183 		}
184 		task_unlock(task);
185 		put_task_struct(task);
186 	}
187 	return result;
188 }
189 
190 static int proc_root_link(struct dentry *dentry, struct path *path)
191 {
192 	struct task_struct *task = get_proc_task(dentry->d_inode);
193 	int result = -ENOENT;
194 
195 	if (task) {
196 		result = get_task_root(task, path);
197 		put_task_struct(task);
198 	}
199 	return result;
200 }
201 
202 static int proc_pid_cmdline(struct task_struct *task, char * buffer)
203 {
204 	int res = 0;
205 	unsigned int len;
206 	struct mm_struct *mm = get_task_mm(task);
207 	if (!mm)
208 		goto out;
209 	if (!mm->arg_end)
210 		goto out_mm;	/* Shh! No looking before we're done */
211 
212  	len = mm->arg_end - mm->arg_start;
213 
214 	if (len > PAGE_SIZE)
215 		len = PAGE_SIZE;
216 
217 	res = access_process_vm(task, mm->arg_start, buffer, len, 0);
218 
219 	// If the nul at the end of args has been overwritten, then
220 	// assume application is using setproctitle(3).
221 	if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) {
222 		len = strnlen(buffer, res);
223 		if (len < res) {
224 		    res = len;
225 		} else {
226 			len = mm->env_end - mm->env_start;
227 			if (len > PAGE_SIZE - res)
228 				len = PAGE_SIZE - res;
229 			res += access_process_vm(task, mm->env_start, buffer+res, len, 0);
230 			res = strnlen(buffer, res);
231 		}
232 	}
233 out_mm:
234 	mmput(mm);
235 out:
236 	return res;
237 }
238 
239 static int proc_pid_auxv(struct task_struct *task, char *buffer)
240 {
241 	struct mm_struct *mm = mm_access(task, PTRACE_MODE_READ);
242 	int res = PTR_ERR(mm);
243 	if (mm && !IS_ERR(mm)) {
244 		unsigned int nwords = 0;
245 		do {
246 			nwords += 2;
247 		} while (mm->saved_auxv[nwords - 2] != 0); /* AT_NULL */
248 		res = nwords * sizeof(mm->saved_auxv[0]);
249 		if (res > PAGE_SIZE)
250 			res = PAGE_SIZE;
251 		memcpy(buffer, mm->saved_auxv, res);
252 		mmput(mm);
253 	}
254 	return res;
255 }
256 
257 
258 #ifdef CONFIG_KALLSYMS
259 /*
260  * Provides a wchan file via kallsyms in a proper one-value-per-file format.
261  * Returns the resolved symbol.  If that fails, simply return the address.
262  */
263 static int proc_pid_wchan(struct task_struct *task, char *buffer)
264 {
265 	unsigned long wchan;
266 	char symname[KSYM_NAME_LEN];
267 
268 	wchan = get_wchan(task);
269 
270 	if (lookup_symbol_name(wchan, symname) < 0)
271 		if (!ptrace_may_access(task, PTRACE_MODE_READ))
272 			return 0;
273 		else
274 			return sprintf(buffer, "%lu", wchan);
275 	else
276 		return sprintf(buffer, "%s", symname);
277 }
278 #endif /* CONFIG_KALLSYMS */
279 
280 static int lock_trace(struct task_struct *task)
281 {
282 	int err = mutex_lock_killable(&task->signal->cred_guard_mutex);
283 	if (err)
284 		return err;
285 	if (!ptrace_may_access(task, PTRACE_MODE_ATTACH)) {
286 		mutex_unlock(&task->signal->cred_guard_mutex);
287 		return -EPERM;
288 	}
289 	return 0;
290 }
291 
292 static void unlock_trace(struct task_struct *task)
293 {
294 	mutex_unlock(&task->signal->cred_guard_mutex);
295 }
296 
297 #ifdef CONFIG_STACKTRACE
298 
299 #define MAX_STACK_TRACE_DEPTH	64
300 
301 static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,
302 			  struct pid *pid, struct task_struct *task)
303 {
304 	struct stack_trace trace;
305 	unsigned long *entries;
306 	int err;
307 	int i;
308 
309 	entries = kmalloc(MAX_STACK_TRACE_DEPTH * sizeof(*entries), GFP_KERNEL);
310 	if (!entries)
311 		return -ENOMEM;
312 
313 	trace.nr_entries	= 0;
314 	trace.max_entries	= MAX_STACK_TRACE_DEPTH;
315 	trace.entries		= entries;
316 	trace.skip		= 0;
317 
318 	err = lock_trace(task);
319 	if (!err) {
320 		save_stack_trace_tsk(task, &trace);
321 
322 		for (i = 0; i < trace.nr_entries; i++) {
323 			seq_printf(m, "[<%pK>] %pS\n",
324 				   (void *)entries[i], (void *)entries[i]);
325 		}
326 		unlock_trace(task);
327 	}
328 	kfree(entries);
329 
330 	return err;
331 }
332 #endif
333 
334 #ifdef CONFIG_SCHEDSTATS
335 /*
336  * Provides /proc/PID/schedstat
337  */
338 static int proc_pid_schedstat(struct task_struct *task, char *buffer)
339 {
340 	return sprintf(buffer, "%llu %llu %lu\n",
341 			(unsigned long long)task->se.sum_exec_runtime,
342 			(unsigned long long)task->sched_info.run_delay,
343 			task->sched_info.pcount);
344 }
345 #endif
346 
347 #ifdef CONFIG_LATENCYTOP
348 static int lstats_show_proc(struct seq_file *m, void *v)
349 {
350 	int i;
351 	struct inode *inode = m->private;
352 	struct task_struct *task = get_proc_task(inode);
353 
354 	if (!task)
355 		return -ESRCH;
356 	seq_puts(m, "Latency Top version : v0.1\n");
357 	for (i = 0; i < 32; i++) {
358 		struct latency_record *lr = &task->latency_record[i];
359 		if (lr->backtrace[0]) {
360 			int q;
361 			seq_printf(m, "%i %li %li",
362 				   lr->count, lr->time, lr->max);
363 			for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
364 				unsigned long bt = lr->backtrace[q];
365 				if (!bt)
366 					break;
367 				if (bt == ULONG_MAX)
368 					break;
369 				seq_printf(m, " %ps", (void *)bt);
370 			}
371 			seq_putc(m, '\n');
372 		}
373 
374 	}
375 	put_task_struct(task);
376 	return 0;
377 }
378 
379 static int lstats_open(struct inode *inode, struct file *file)
380 {
381 	return single_open(file, lstats_show_proc, inode);
382 }
383 
384 static ssize_t lstats_write(struct file *file, const char __user *buf,
385 			    size_t count, loff_t *offs)
386 {
387 	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
388 
389 	if (!task)
390 		return -ESRCH;
391 	clear_all_latency_tracing(task);
392 	put_task_struct(task);
393 
394 	return count;
395 }
396 
397 static const struct file_operations proc_lstats_operations = {
398 	.open		= lstats_open,
399 	.read		= seq_read,
400 	.write		= lstats_write,
401 	.llseek		= seq_lseek,
402 	.release	= single_release,
403 };
404 
405 #endif
406 
407 static int proc_oom_score(struct task_struct *task, char *buffer)
408 {
409 	unsigned long totalpages = totalram_pages + total_swap_pages;
410 	unsigned long points = 0;
411 
412 	read_lock(&tasklist_lock);
413 	if (pid_alive(task))
414 		points = oom_badness(task, NULL, NULL, totalpages) *
415 						1000 / totalpages;
416 	read_unlock(&tasklist_lock);
417 	return sprintf(buffer, "%lu\n", points);
418 }
419 
420 struct limit_names {
421 	char *name;
422 	char *unit;
423 };
424 
425 static const struct limit_names lnames[RLIM_NLIMITS] = {
426 	[RLIMIT_CPU] = {"Max cpu time", "seconds"},
427 	[RLIMIT_FSIZE] = {"Max file size", "bytes"},
428 	[RLIMIT_DATA] = {"Max data size", "bytes"},
429 	[RLIMIT_STACK] = {"Max stack size", "bytes"},
430 	[RLIMIT_CORE] = {"Max core file size", "bytes"},
431 	[RLIMIT_RSS] = {"Max resident set", "bytes"},
432 	[RLIMIT_NPROC] = {"Max processes", "processes"},
433 	[RLIMIT_NOFILE] = {"Max open files", "files"},
434 	[RLIMIT_MEMLOCK] = {"Max locked memory", "bytes"},
435 	[RLIMIT_AS] = {"Max address space", "bytes"},
436 	[RLIMIT_LOCKS] = {"Max file locks", "locks"},
437 	[RLIMIT_SIGPENDING] = {"Max pending signals", "signals"},
438 	[RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
439 	[RLIMIT_NICE] = {"Max nice priority", NULL},
440 	[RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
441 	[RLIMIT_RTTIME] = {"Max realtime timeout", "us"},
442 };
443 
444 /* Display limits for a process */
445 static int proc_pid_limits(struct task_struct *task, char *buffer)
446 {
447 	unsigned int i;
448 	int count = 0;
449 	unsigned long flags;
450 	char *bufptr = buffer;
451 
452 	struct rlimit rlim[RLIM_NLIMITS];
453 
454 	if (!lock_task_sighand(task, &flags))
455 		return 0;
456 	memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);
457 	unlock_task_sighand(task, &flags);
458 
459 	/*
460 	 * print the file header
461 	 */
462 	count += sprintf(&bufptr[count], "%-25s %-20s %-20s %-10s\n",
463 			"Limit", "Soft Limit", "Hard Limit", "Units");
464 
465 	for (i = 0; i < RLIM_NLIMITS; i++) {
466 		if (rlim[i].rlim_cur == RLIM_INFINITY)
467 			count += sprintf(&bufptr[count], "%-25s %-20s ",
468 					 lnames[i].name, "unlimited");
469 		else
470 			count += sprintf(&bufptr[count], "%-25s %-20lu ",
471 					 lnames[i].name, rlim[i].rlim_cur);
472 
473 		if (rlim[i].rlim_max == RLIM_INFINITY)
474 			count += sprintf(&bufptr[count], "%-20s ", "unlimited");
475 		else
476 			count += sprintf(&bufptr[count], "%-20lu ",
477 					 rlim[i].rlim_max);
478 
479 		if (lnames[i].unit)
480 			count += sprintf(&bufptr[count], "%-10s\n",
481 					 lnames[i].unit);
482 		else
483 			count += sprintf(&bufptr[count], "\n");
484 	}
485 
486 	return count;
487 }
488 
489 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
490 static int proc_pid_syscall(struct task_struct *task, char *buffer)
491 {
492 	long nr;
493 	unsigned long args[6], sp, pc;
494 	int res = lock_trace(task);
495 	if (res)
496 		return res;
497 
498 	if (task_current_syscall(task, &nr, args, 6, &sp, &pc))
499 		res = sprintf(buffer, "running\n");
500 	else if (nr < 0)
501 		res = sprintf(buffer, "%ld 0x%lx 0x%lx\n", nr, sp, pc);
502 	else
503 		res = sprintf(buffer,
504 		       "%ld 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
505 		       nr,
506 		       args[0], args[1], args[2], args[3], args[4], args[5],
507 		       sp, pc);
508 	unlock_trace(task);
509 	return res;
510 }
511 #endif /* CONFIG_HAVE_ARCH_TRACEHOOK */
512 
513 /************************************************************************/
514 /*                       Here the fs part begins                        */
515 /************************************************************************/
516 
517 /* permission checks */
518 static int proc_fd_access_allowed(struct inode *inode)
519 {
520 	struct task_struct *task;
521 	int allowed = 0;
522 	/* Allow access to a task's file descriptors if it is us or we
523 	 * may use ptrace attach to the process and find out that
524 	 * information.
525 	 */
526 	task = get_proc_task(inode);
527 	if (task) {
528 		allowed = ptrace_may_access(task, PTRACE_MODE_READ);
529 		put_task_struct(task);
530 	}
531 	return allowed;
532 }
533 
534 int proc_setattr(struct dentry *dentry, struct iattr *attr)
535 {
536 	int error;
537 	struct inode *inode = dentry->d_inode;
538 
539 	if (attr->ia_valid & ATTR_MODE)
540 		return -EPERM;
541 
542 	error = inode_change_ok(inode, attr);
543 	if (error)
544 		return error;
545 
546 	if ((attr->ia_valid & ATTR_SIZE) &&
547 	    attr->ia_size != i_size_read(inode)) {
548 		error = vmtruncate(inode, attr->ia_size);
549 		if (error)
550 			return error;
551 	}
552 
553 	setattr_copy(inode, attr);
554 	mark_inode_dirty(inode);
555 	return 0;
556 }
557 
558 /*
559  * May current process learn task's sched/cmdline info (for hide_pid_min=1)
560  * or euid/egid (for hide_pid_min=2)?
561  */
562 static bool has_pid_permissions(struct pid_namespace *pid,
563 				 struct task_struct *task,
564 				 int hide_pid_min)
565 {
566 	if (pid->hide_pid < hide_pid_min)
567 		return true;
568 	if (in_group_p(pid->pid_gid))
569 		return true;
570 	return ptrace_may_access(task, PTRACE_MODE_READ);
571 }
572 
573 
574 static int proc_pid_permission(struct inode *inode, int mask)
575 {
576 	struct pid_namespace *pid = inode->i_sb->s_fs_info;
577 	struct task_struct *task;
578 	bool has_perms;
579 
580 	task = get_proc_task(inode);
581 	if (!task)
582 		return -ESRCH;
583 	has_perms = has_pid_permissions(pid, task, 1);
584 	put_task_struct(task);
585 
586 	if (!has_perms) {
587 		if (pid->hide_pid == 2) {
588 			/*
589 			 * Let's make getdents(), stat(), and open()
590 			 * consistent with each other.  If a process
591 			 * may not stat() a file, it shouldn't be seen
592 			 * in procfs at all.
593 			 */
594 			return -ENOENT;
595 		}
596 
597 		return -EPERM;
598 	}
599 	return generic_permission(inode, mask);
600 }
601 
602 
603 
604 static const struct inode_operations proc_def_inode_operations = {
605 	.setattr	= proc_setattr,
606 };
607 
608 #define PROC_BLOCK_SIZE	(3*1024)		/* 4K page size but our output routines use some slack for overruns */
609 
610 static ssize_t proc_info_read(struct file * file, char __user * buf,
611 			  size_t count, loff_t *ppos)
612 {
613 	struct inode * inode = file->f_path.dentry->d_inode;
614 	unsigned long page;
615 	ssize_t length;
616 	struct task_struct *task = get_proc_task(inode);
617 
618 	length = -ESRCH;
619 	if (!task)
620 		goto out_no_task;
621 
622 	if (count > PROC_BLOCK_SIZE)
623 		count = PROC_BLOCK_SIZE;
624 
625 	length = -ENOMEM;
626 	if (!(page = __get_free_page(GFP_TEMPORARY)))
627 		goto out;
628 
629 	length = PROC_I(inode)->op.proc_read(task, (char*)page);
630 
631 	if (length >= 0)
632 		length = simple_read_from_buffer(buf, count, ppos, (char *)page, length);
633 	free_page(page);
634 out:
635 	put_task_struct(task);
636 out_no_task:
637 	return length;
638 }
639 
640 static const struct file_operations proc_info_file_operations = {
641 	.read		= proc_info_read,
642 	.llseek		= generic_file_llseek,
643 };
644 
645 static int proc_single_show(struct seq_file *m, void *v)
646 {
647 	struct inode *inode = m->private;
648 	struct pid_namespace *ns;
649 	struct pid *pid;
650 	struct task_struct *task;
651 	int ret;
652 
653 	ns = inode->i_sb->s_fs_info;
654 	pid = proc_pid(inode);
655 	task = get_pid_task(pid, PIDTYPE_PID);
656 	if (!task)
657 		return -ESRCH;
658 
659 	ret = PROC_I(inode)->op.proc_show(m, ns, pid, task);
660 
661 	put_task_struct(task);
662 	return ret;
663 }
664 
665 static int proc_single_open(struct inode *inode, struct file *filp)
666 {
667 	return single_open(filp, proc_single_show, inode);
668 }
669 
670 static const struct file_operations proc_single_file_operations = {
671 	.open		= proc_single_open,
672 	.read		= seq_read,
673 	.llseek		= seq_lseek,
674 	.release	= single_release,
675 };
676 
677 static int __mem_open(struct inode *inode, struct file *file, unsigned int mode)
678 {
679 	struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
680 	struct mm_struct *mm;
681 
682 	if (!task)
683 		return -ESRCH;
684 
685 	mm = mm_access(task, mode);
686 	put_task_struct(task);
687 
688 	if (IS_ERR(mm))
689 		return PTR_ERR(mm);
690 
691 	if (mm) {
692 		/* ensure this mm_struct can't be freed */
693 		atomic_inc(&mm->mm_count);
694 		/* but do not pin its memory */
695 		mmput(mm);
696 	}
697 
698 	file->private_data = mm;
699 
700 	return 0;
701 }
702 
703 static int mem_open(struct inode *inode, struct file *file)
704 {
705 	int ret = __mem_open(inode, file, PTRACE_MODE_ATTACH);
706 
707 	/* OK to pass negative loff_t, we can catch out-of-range */
708 	file->f_mode |= FMODE_UNSIGNED_OFFSET;
709 
710 	return ret;
711 }
712 
713 static ssize_t mem_rw(struct file *file, char __user *buf,
714 			size_t count, loff_t *ppos, int write)
715 {
716 	struct mm_struct *mm = file->private_data;
717 	unsigned long addr = *ppos;
718 	ssize_t copied;
719 	char *page;
720 
721 	if (!mm)
722 		return 0;
723 
724 	page = (char *)__get_free_page(GFP_TEMPORARY);
725 	if (!page)
726 		return -ENOMEM;
727 
728 	copied = 0;
729 	if (!atomic_inc_not_zero(&mm->mm_users))
730 		goto free;
731 
732 	while (count > 0) {
733 		int this_len = min_t(int, count, PAGE_SIZE);
734 
735 		if (write && copy_from_user(page, buf, this_len)) {
736 			copied = -EFAULT;
737 			break;
738 		}
739 
740 		this_len = access_remote_vm(mm, addr, page, this_len, write);
741 		if (!this_len) {
742 			if (!copied)
743 				copied = -EIO;
744 			break;
745 		}
746 
747 		if (!write && copy_to_user(buf, page, this_len)) {
748 			copied = -EFAULT;
749 			break;
750 		}
751 
752 		buf += this_len;
753 		addr += this_len;
754 		copied += this_len;
755 		count -= this_len;
756 	}
757 	*ppos = addr;
758 
759 	mmput(mm);
760 free:
761 	free_page((unsigned long) page);
762 	return copied;
763 }
764 
765 static ssize_t mem_read(struct file *file, char __user *buf,
766 			size_t count, loff_t *ppos)
767 {
768 	return mem_rw(file, buf, count, ppos, 0);
769 }
770 
771 static ssize_t mem_write(struct file *file, const char __user *buf,
772 			 size_t count, loff_t *ppos)
773 {
774 	return mem_rw(file, (char __user*)buf, count, ppos, 1);
775 }
776 
777 loff_t mem_lseek(struct file *file, loff_t offset, int orig)
778 {
779 	switch (orig) {
780 	case 0:
781 		file->f_pos = offset;
782 		break;
783 	case 1:
784 		file->f_pos += offset;
785 		break;
786 	default:
787 		return -EINVAL;
788 	}
789 	force_successful_syscall_return();
790 	return file->f_pos;
791 }
792 
793 static int mem_release(struct inode *inode, struct file *file)
794 {
795 	struct mm_struct *mm = file->private_data;
796 	if (mm)
797 		mmdrop(mm);
798 	return 0;
799 }
800 
801 static const struct file_operations proc_mem_operations = {
802 	.llseek		= mem_lseek,
803 	.read		= mem_read,
804 	.write		= mem_write,
805 	.open		= mem_open,
806 	.release	= mem_release,
807 };
808 
809 static int environ_open(struct inode *inode, struct file *file)
810 {
811 	return __mem_open(inode, file, PTRACE_MODE_READ);
812 }
813 
814 static ssize_t environ_read(struct file *file, char __user *buf,
815 			size_t count, loff_t *ppos)
816 {
817 	char *page;
818 	unsigned long src = *ppos;
819 	int ret = 0;
820 	struct mm_struct *mm = file->private_data;
821 
822 	if (!mm)
823 		return 0;
824 
825 	page = (char *)__get_free_page(GFP_TEMPORARY);
826 	if (!page)
827 		return -ENOMEM;
828 
829 	ret = 0;
830 	if (!atomic_inc_not_zero(&mm->mm_users))
831 		goto free;
832 	while (count > 0) {
833 		size_t this_len, max_len;
834 		int retval;
835 
836 		if (src >= (mm->env_end - mm->env_start))
837 			break;
838 
839 		this_len = mm->env_end - (mm->env_start + src);
840 
841 		max_len = min_t(size_t, PAGE_SIZE, count);
842 		this_len = min(max_len, this_len);
843 
844 		retval = access_remote_vm(mm, (mm->env_start + src),
845 			page, this_len, 0);
846 
847 		if (retval <= 0) {
848 			ret = retval;
849 			break;
850 		}
851 
852 		if (copy_to_user(buf, page, retval)) {
853 			ret = -EFAULT;
854 			break;
855 		}
856 
857 		ret += retval;
858 		src += retval;
859 		buf += retval;
860 		count -= retval;
861 	}
862 	*ppos = src;
863 	mmput(mm);
864 
865 free:
866 	free_page((unsigned long) page);
867 	return ret;
868 }
869 
870 static const struct file_operations proc_environ_operations = {
871 	.open		= environ_open,
872 	.read		= environ_read,
873 	.llseek		= generic_file_llseek,
874 	.release	= mem_release,
875 };
876 
877 static ssize_t oom_adjust_read(struct file *file, char __user *buf,
878 				size_t count, loff_t *ppos)
879 {
880 	struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
881 	char buffer[PROC_NUMBUF];
882 	size_t len;
883 	int oom_adjust = OOM_DISABLE;
884 	unsigned long flags;
885 
886 	if (!task)
887 		return -ESRCH;
888 
889 	if (lock_task_sighand(task, &flags)) {
890 		oom_adjust = task->signal->oom_adj;
891 		unlock_task_sighand(task, &flags);
892 	}
893 
894 	put_task_struct(task);
895 
896 	len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust);
897 
898 	return simple_read_from_buffer(buf, count, ppos, buffer, len);
899 }
900 
901 static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
902 				size_t count, loff_t *ppos)
903 {
904 	struct task_struct *task;
905 	char buffer[PROC_NUMBUF];
906 	int oom_adjust;
907 	unsigned long flags;
908 	int err;
909 
910 	memset(buffer, 0, sizeof(buffer));
911 	if (count > sizeof(buffer) - 1)
912 		count = sizeof(buffer) - 1;
913 	if (copy_from_user(buffer, buf, count)) {
914 		err = -EFAULT;
915 		goto out;
916 	}
917 
918 	err = kstrtoint(strstrip(buffer), 0, &oom_adjust);
919 	if (err)
920 		goto out;
921 	if ((oom_adjust < OOM_ADJUST_MIN || oom_adjust > OOM_ADJUST_MAX) &&
922 	     oom_adjust != OOM_DISABLE) {
923 		err = -EINVAL;
924 		goto out;
925 	}
926 
927 	task = get_proc_task(file->f_path.dentry->d_inode);
928 	if (!task) {
929 		err = -ESRCH;
930 		goto out;
931 	}
932 
933 	task_lock(task);
934 	if (!task->mm) {
935 		err = -EINVAL;
936 		goto err_task_lock;
937 	}
938 
939 	if (!lock_task_sighand(task, &flags)) {
940 		err = -ESRCH;
941 		goto err_task_lock;
942 	}
943 
944 	if (oom_adjust < task->signal->oom_adj && !capable(CAP_SYS_RESOURCE)) {
945 		err = -EACCES;
946 		goto err_sighand;
947 	}
948 
949 	/*
950 	 * Warn that /proc/pid/oom_adj is deprecated, see
951 	 * Documentation/feature-removal-schedule.txt.
952 	 */
953 	printk_once(KERN_WARNING "%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
954 		  current->comm, task_pid_nr(current), task_pid_nr(task),
955 		  task_pid_nr(task));
956 	task->signal->oom_adj = oom_adjust;
957 	/*
958 	 * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
959 	 * value is always attainable.
960 	 */
961 	if (task->signal->oom_adj == OOM_ADJUST_MAX)
962 		task->signal->oom_score_adj = OOM_SCORE_ADJ_MAX;
963 	else
964 		task->signal->oom_score_adj = (oom_adjust * OOM_SCORE_ADJ_MAX) /
965 								-OOM_DISABLE;
966 	trace_oom_score_adj_update(task);
967 err_sighand:
968 	unlock_task_sighand(task, &flags);
969 err_task_lock:
970 	task_unlock(task);
971 	put_task_struct(task);
972 out:
973 	return err < 0 ? err : count;
974 }
975 
976 static const struct file_operations proc_oom_adjust_operations = {
977 	.read		= oom_adjust_read,
978 	.write		= oom_adjust_write,
979 	.llseek		= generic_file_llseek,
980 };
981 
982 static ssize_t oom_score_adj_read(struct file *file, char __user *buf,
983 					size_t count, loff_t *ppos)
984 {
985 	struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
986 	char buffer[PROC_NUMBUF];
987 	int oom_score_adj = OOM_SCORE_ADJ_MIN;
988 	unsigned long flags;
989 	size_t len;
990 
991 	if (!task)
992 		return -ESRCH;
993 	if (lock_task_sighand(task, &flags)) {
994 		oom_score_adj = task->signal->oom_score_adj;
995 		unlock_task_sighand(task, &flags);
996 	}
997 	put_task_struct(task);
998 	len = snprintf(buffer, sizeof(buffer), "%d\n", oom_score_adj);
999 	return simple_read_from_buffer(buf, count, ppos, buffer, len);
1000 }
1001 
1002 static ssize_t oom_score_adj_write(struct file *file, const char __user *buf,
1003 					size_t count, loff_t *ppos)
1004 {
1005 	struct task_struct *task;
1006 	char buffer[PROC_NUMBUF];
1007 	unsigned long flags;
1008 	int oom_score_adj;
1009 	int err;
1010 
1011 	memset(buffer, 0, sizeof(buffer));
1012 	if (count > sizeof(buffer) - 1)
1013 		count = sizeof(buffer) - 1;
1014 	if (copy_from_user(buffer, buf, count)) {
1015 		err = -EFAULT;
1016 		goto out;
1017 	}
1018 
1019 	err = kstrtoint(strstrip(buffer), 0, &oom_score_adj);
1020 	if (err)
1021 		goto out;
1022 	if (oom_score_adj < OOM_SCORE_ADJ_MIN ||
1023 			oom_score_adj > OOM_SCORE_ADJ_MAX) {
1024 		err = -EINVAL;
1025 		goto out;
1026 	}
1027 
1028 	task = get_proc_task(file->f_path.dentry->d_inode);
1029 	if (!task) {
1030 		err = -ESRCH;
1031 		goto out;
1032 	}
1033 
1034 	task_lock(task);
1035 	if (!task->mm) {
1036 		err = -EINVAL;
1037 		goto err_task_lock;
1038 	}
1039 
1040 	if (!lock_task_sighand(task, &flags)) {
1041 		err = -ESRCH;
1042 		goto err_task_lock;
1043 	}
1044 
1045 	if (oom_score_adj < task->signal->oom_score_adj_min &&
1046 			!capable(CAP_SYS_RESOURCE)) {
1047 		err = -EACCES;
1048 		goto err_sighand;
1049 	}
1050 
1051 	task->signal->oom_score_adj = oom_score_adj;
1052 	if (has_capability_noaudit(current, CAP_SYS_RESOURCE))
1053 		task->signal->oom_score_adj_min = oom_score_adj;
1054 	trace_oom_score_adj_update(task);
1055 	/*
1056 	 * Scale /proc/pid/oom_adj appropriately ensuring that OOM_DISABLE is
1057 	 * always attainable.
1058 	 */
1059 	if (task->signal->oom_score_adj == OOM_SCORE_ADJ_MIN)
1060 		task->signal->oom_adj = OOM_DISABLE;
1061 	else
1062 		task->signal->oom_adj = (oom_score_adj * OOM_ADJUST_MAX) /
1063 							OOM_SCORE_ADJ_MAX;
1064 err_sighand:
1065 	unlock_task_sighand(task, &flags);
1066 err_task_lock:
1067 	task_unlock(task);
1068 	put_task_struct(task);
1069 out:
1070 	return err < 0 ? err : count;
1071 }
1072 
1073 static const struct file_operations proc_oom_score_adj_operations = {
1074 	.read		= oom_score_adj_read,
1075 	.write		= oom_score_adj_write,
1076 	.llseek		= default_llseek,
1077 };
1078 
1079 #ifdef CONFIG_AUDITSYSCALL
1080 #define TMPBUFLEN 21
1081 static ssize_t proc_loginuid_read(struct file * file, char __user * buf,
1082 				  size_t count, loff_t *ppos)
1083 {
1084 	struct inode * inode = file->f_path.dentry->d_inode;
1085 	struct task_struct *task = get_proc_task(inode);
1086 	ssize_t length;
1087 	char tmpbuf[TMPBUFLEN];
1088 
1089 	if (!task)
1090 		return -ESRCH;
1091 	length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
1092 				audit_get_loginuid(task));
1093 	put_task_struct(task);
1094 	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1095 }
1096 
1097 static ssize_t proc_loginuid_write(struct file * file, const char __user * buf,
1098 				   size_t count, loff_t *ppos)
1099 {
1100 	struct inode * inode = file->f_path.dentry->d_inode;
1101 	char *page, *tmp;
1102 	ssize_t length;
1103 	uid_t loginuid;
1104 
1105 	rcu_read_lock();
1106 	if (current != pid_task(proc_pid(inode), PIDTYPE_PID)) {
1107 		rcu_read_unlock();
1108 		return -EPERM;
1109 	}
1110 	rcu_read_unlock();
1111 
1112 	if (count >= PAGE_SIZE)
1113 		count = PAGE_SIZE - 1;
1114 
1115 	if (*ppos != 0) {
1116 		/* No partial writes. */
1117 		return -EINVAL;
1118 	}
1119 	page = (char*)__get_free_page(GFP_TEMPORARY);
1120 	if (!page)
1121 		return -ENOMEM;
1122 	length = -EFAULT;
1123 	if (copy_from_user(page, buf, count))
1124 		goto out_free_page;
1125 
1126 	page[count] = '\0';
1127 	loginuid = simple_strtoul(page, &tmp, 10);
1128 	if (tmp == page) {
1129 		length = -EINVAL;
1130 		goto out_free_page;
1131 
1132 	}
1133 	length = audit_set_loginuid(loginuid);
1134 	if (likely(length == 0))
1135 		length = count;
1136 
1137 out_free_page:
1138 	free_page((unsigned long) page);
1139 	return length;
1140 }
1141 
1142 static const struct file_operations proc_loginuid_operations = {
1143 	.read		= proc_loginuid_read,
1144 	.write		= proc_loginuid_write,
1145 	.llseek		= generic_file_llseek,
1146 };
1147 
1148 static ssize_t proc_sessionid_read(struct file * file, char __user * buf,
1149 				  size_t count, loff_t *ppos)
1150 {
1151 	struct inode * inode = file->f_path.dentry->d_inode;
1152 	struct task_struct *task = get_proc_task(inode);
1153 	ssize_t length;
1154 	char tmpbuf[TMPBUFLEN];
1155 
1156 	if (!task)
1157 		return -ESRCH;
1158 	length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
1159 				audit_get_sessionid(task));
1160 	put_task_struct(task);
1161 	return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
1162 }
1163 
1164 static const struct file_operations proc_sessionid_operations = {
1165 	.read		= proc_sessionid_read,
1166 	.llseek		= generic_file_llseek,
1167 };
1168 #endif
1169 
1170 #ifdef CONFIG_FAULT_INJECTION
1171 static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
1172 				      size_t count, loff_t *ppos)
1173 {
1174 	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
1175 	char buffer[PROC_NUMBUF];
1176 	size_t len;
1177 	int make_it_fail;
1178 
1179 	if (!task)
1180 		return -ESRCH;
1181 	make_it_fail = task->make_it_fail;
1182 	put_task_struct(task);
1183 
1184 	len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);
1185 
1186 	return simple_read_from_buffer(buf, count, ppos, buffer, len);
1187 }
1188 
1189 static ssize_t proc_fault_inject_write(struct file * file,
1190 			const char __user * buf, size_t count, loff_t *ppos)
1191 {
1192 	struct task_struct *task;
1193 	char buffer[PROC_NUMBUF], *end;
1194 	int make_it_fail;
1195 
1196 	if (!capable(CAP_SYS_RESOURCE))
1197 		return -EPERM;
1198 	memset(buffer, 0, sizeof(buffer));
1199 	if (count > sizeof(buffer) - 1)
1200 		count = sizeof(buffer) - 1;
1201 	if (copy_from_user(buffer, buf, count))
1202 		return -EFAULT;
1203 	make_it_fail = simple_strtol(strstrip(buffer), &end, 0);
1204 	if (*end)
1205 		return -EINVAL;
1206 	task = get_proc_task(file->f_dentry->d_inode);
1207 	if (!task)
1208 		return -ESRCH;
1209 	task->make_it_fail = make_it_fail;
1210 	put_task_struct(task);
1211 
1212 	return count;
1213 }
1214 
1215 static const struct file_operations proc_fault_inject_operations = {
1216 	.read		= proc_fault_inject_read,
1217 	.write		= proc_fault_inject_write,
1218 	.llseek		= generic_file_llseek,
1219 };
1220 #endif
1221 
1222 
1223 #ifdef CONFIG_SCHED_DEBUG
1224 /*
1225  * Print out various scheduling related per-task fields:
1226  */
1227 static int sched_show(struct seq_file *m, void *v)
1228 {
1229 	struct inode *inode = m->private;
1230 	struct task_struct *p;
1231 
1232 	p = get_proc_task(inode);
1233 	if (!p)
1234 		return -ESRCH;
1235 	proc_sched_show_task(p, m);
1236 
1237 	put_task_struct(p);
1238 
1239 	return 0;
1240 }
1241 
1242 static ssize_t
1243 sched_write(struct file *file, const char __user *buf,
1244 	    size_t count, loff_t *offset)
1245 {
1246 	struct inode *inode = file->f_path.dentry->d_inode;
1247 	struct task_struct *p;
1248 
1249 	p = get_proc_task(inode);
1250 	if (!p)
1251 		return -ESRCH;
1252 	proc_sched_set_task(p);
1253 
1254 	put_task_struct(p);
1255 
1256 	return count;
1257 }
1258 
1259 static int sched_open(struct inode *inode, struct file *filp)
1260 {
1261 	return single_open(filp, sched_show, inode);
1262 }
1263 
1264 static const struct file_operations proc_pid_sched_operations = {
1265 	.open		= sched_open,
1266 	.read		= seq_read,
1267 	.write		= sched_write,
1268 	.llseek		= seq_lseek,
1269 	.release	= single_release,
1270 };
1271 
1272 #endif
1273 
1274 #ifdef CONFIG_SCHED_AUTOGROUP
1275 /*
1276  * Print out autogroup related information:
1277  */
1278 static int sched_autogroup_show(struct seq_file *m, void *v)
1279 {
1280 	struct inode *inode = m->private;
1281 	struct task_struct *p;
1282 
1283 	p = get_proc_task(inode);
1284 	if (!p)
1285 		return -ESRCH;
1286 	proc_sched_autogroup_show_task(p, m);
1287 
1288 	put_task_struct(p);
1289 
1290 	return 0;
1291 }
1292 
1293 static ssize_t
1294 sched_autogroup_write(struct file *file, const char __user *buf,
1295 	    size_t count, loff_t *offset)
1296 {
1297 	struct inode *inode = file->f_path.dentry->d_inode;
1298 	struct task_struct *p;
1299 	char buffer[PROC_NUMBUF];
1300 	int nice;
1301 	int err;
1302 
1303 	memset(buffer, 0, sizeof(buffer));
1304 	if (count > sizeof(buffer) - 1)
1305 		count = sizeof(buffer) - 1;
1306 	if (copy_from_user(buffer, buf, count))
1307 		return -EFAULT;
1308 
1309 	err = kstrtoint(strstrip(buffer), 0, &nice);
1310 	if (err < 0)
1311 		return err;
1312 
1313 	p = get_proc_task(inode);
1314 	if (!p)
1315 		return -ESRCH;
1316 
1317 	err = proc_sched_autogroup_set_nice(p, nice);
1318 	if (err)
1319 		count = err;
1320 
1321 	put_task_struct(p);
1322 
1323 	return count;
1324 }
1325 
1326 static int sched_autogroup_open(struct inode *inode, struct file *filp)
1327 {
1328 	int ret;
1329 
1330 	ret = single_open(filp, sched_autogroup_show, NULL);
1331 	if (!ret) {
1332 		struct seq_file *m = filp->private_data;
1333 
1334 		m->private = inode;
1335 	}
1336 	return ret;
1337 }
1338 
1339 static const struct file_operations proc_pid_sched_autogroup_operations = {
1340 	.open		= sched_autogroup_open,
1341 	.read		= seq_read,
1342 	.write		= sched_autogroup_write,
1343 	.llseek		= seq_lseek,
1344 	.release	= single_release,
1345 };
1346 
1347 #endif /* CONFIG_SCHED_AUTOGROUP */
1348 
1349 static ssize_t comm_write(struct file *file, const char __user *buf,
1350 				size_t count, loff_t *offset)
1351 {
1352 	struct inode *inode = file->f_path.dentry->d_inode;
1353 	struct task_struct *p;
1354 	char buffer[TASK_COMM_LEN];
1355 
1356 	memset(buffer, 0, sizeof(buffer));
1357 	if (count > sizeof(buffer) - 1)
1358 		count = sizeof(buffer) - 1;
1359 	if (copy_from_user(buffer, buf, count))
1360 		return -EFAULT;
1361 
1362 	p = get_proc_task(inode);
1363 	if (!p)
1364 		return -ESRCH;
1365 
1366 	if (same_thread_group(current, p))
1367 		set_task_comm(p, buffer);
1368 	else
1369 		count = -EINVAL;
1370 
1371 	put_task_struct(p);
1372 
1373 	return count;
1374 }
1375 
1376 static int comm_show(struct seq_file *m, void *v)
1377 {
1378 	struct inode *inode = m->private;
1379 	struct task_struct *p;
1380 
1381 	p = get_proc_task(inode);
1382 	if (!p)
1383 		return -ESRCH;
1384 
1385 	task_lock(p);
1386 	seq_printf(m, "%s\n", p->comm);
1387 	task_unlock(p);
1388 
1389 	put_task_struct(p);
1390 
1391 	return 0;
1392 }
1393 
1394 static int comm_open(struct inode *inode, struct file *filp)
1395 {
1396 	return single_open(filp, comm_show, inode);
1397 }
1398 
1399 static const struct file_operations proc_pid_set_comm_operations = {
1400 	.open		= comm_open,
1401 	.read		= seq_read,
1402 	.write		= comm_write,
1403 	.llseek		= seq_lseek,
1404 	.release	= single_release,
1405 };
1406 
1407 static int proc_exe_link(struct dentry *dentry, struct path *exe_path)
1408 {
1409 	struct task_struct *task;
1410 	struct mm_struct *mm;
1411 	struct file *exe_file;
1412 
1413 	task = get_proc_task(dentry->d_inode);
1414 	if (!task)
1415 		return -ENOENT;
1416 	mm = get_task_mm(task);
1417 	put_task_struct(task);
1418 	if (!mm)
1419 		return -ENOENT;
1420 	exe_file = get_mm_exe_file(mm);
1421 	mmput(mm);
1422 	if (exe_file) {
1423 		*exe_path = exe_file->f_path;
1424 		path_get(&exe_file->f_path);
1425 		fput(exe_file);
1426 		return 0;
1427 	} else
1428 		return -ENOENT;
1429 }
1430 
1431 static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd)
1432 {
1433 	struct inode *inode = dentry->d_inode;
1434 	struct path path;
1435 	int error = -EACCES;
1436 
1437 	/* Are we allowed to snoop on the tasks file descriptors? */
1438 	if (!proc_fd_access_allowed(inode))
1439 		goto out;
1440 
1441 	error = PROC_I(inode)->op.proc_get_link(dentry, &path);
1442 	if (error)
1443 		goto out;
1444 
1445 	nd_jump_link(nd, &path);
1446 	return NULL;
1447 out:
1448 	return ERR_PTR(error);
1449 }
1450 
1451 static int do_proc_readlink(struct path *path, char __user *buffer, int buflen)
1452 {
1453 	char *tmp = (char*)__get_free_page(GFP_TEMPORARY);
1454 	char *pathname;
1455 	int len;
1456 
1457 	if (!tmp)
1458 		return -ENOMEM;
1459 
1460 	pathname = d_path(path, tmp, PAGE_SIZE);
1461 	len = PTR_ERR(pathname);
1462 	if (IS_ERR(pathname))
1463 		goto out;
1464 	len = tmp + PAGE_SIZE - 1 - pathname;
1465 
1466 	if (len > buflen)
1467 		len = buflen;
1468 	if (copy_to_user(buffer, pathname, len))
1469 		len = -EFAULT;
1470  out:
1471 	free_page((unsigned long)tmp);
1472 	return len;
1473 }
1474 
1475 static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen)
1476 {
1477 	int error = -EACCES;
1478 	struct inode *inode = dentry->d_inode;
1479 	struct path path;
1480 
1481 	/* Are we allowed to snoop on the tasks file descriptors? */
1482 	if (!proc_fd_access_allowed(inode))
1483 		goto out;
1484 
1485 	error = PROC_I(inode)->op.proc_get_link(dentry, &path);
1486 	if (error)
1487 		goto out;
1488 
1489 	error = do_proc_readlink(&path, buffer, buflen);
1490 	path_put(&path);
1491 out:
1492 	return error;
1493 }
1494 
1495 static const struct inode_operations proc_pid_link_inode_operations = {
1496 	.readlink	= proc_pid_readlink,
1497 	.follow_link	= proc_pid_follow_link,
1498 	.setattr	= proc_setattr,
1499 };
1500 
1501 
1502 /* building an inode */
1503 
1504 static int task_dumpable(struct task_struct *task)
1505 {
1506 	int dumpable = 0;
1507 	struct mm_struct *mm;
1508 
1509 	task_lock(task);
1510 	mm = task->mm;
1511 	if (mm)
1512 		dumpable = get_dumpable(mm);
1513 	task_unlock(task);
1514 	if(dumpable == 1)
1515 		return 1;
1516 	return 0;
1517 }
1518 
1519 struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *task)
1520 {
1521 	struct inode * inode;
1522 	struct proc_inode *ei;
1523 	const struct cred *cred;
1524 
1525 	/* We need a new inode */
1526 
1527 	inode = new_inode(sb);
1528 	if (!inode)
1529 		goto out;
1530 
1531 	/* Common stuff */
1532 	ei = PROC_I(inode);
1533 	inode->i_ino = get_next_ino();
1534 	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
1535 	inode->i_op = &proc_def_inode_operations;
1536 
1537 	/*
1538 	 * grab the reference to task.
1539 	 */
1540 	ei->pid = get_task_pid(task, PIDTYPE_PID);
1541 	if (!ei->pid)
1542 		goto out_unlock;
1543 
1544 	if (task_dumpable(task)) {
1545 		rcu_read_lock();
1546 		cred = __task_cred(task);
1547 		inode->i_uid = cred->euid;
1548 		inode->i_gid = cred->egid;
1549 		rcu_read_unlock();
1550 	}
1551 	security_task_to_inode(task, inode);
1552 
1553 out:
1554 	return inode;
1555 
1556 out_unlock:
1557 	iput(inode);
1558 	return NULL;
1559 }
1560 
1561 int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
1562 {
1563 	struct inode *inode = dentry->d_inode;
1564 	struct task_struct *task;
1565 	const struct cred *cred;
1566 	struct pid_namespace *pid = dentry->d_sb->s_fs_info;
1567 
1568 	generic_fillattr(inode, stat);
1569 
1570 	rcu_read_lock();
1571 	stat->uid = GLOBAL_ROOT_UID;
1572 	stat->gid = GLOBAL_ROOT_GID;
1573 	task = pid_task(proc_pid(inode), PIDTYPE_PID);
1574 	if (task) {
1575 		if (!has_pid_permissions(pid, task, 2)) {
1576 			rcu_read_unlock();
1577 			/*
1578 			 * This doesn't prevent learning whether PID exists,
1579 			 * it only makes getattr() consistent with readdir().
1580 			 */
1581 			return -ENOENT;
1582 		}
1583 		if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
1584 		    task_dumpable(task)) {
1585 			cred = __task_cred(task);
1586 			stat->uid = cred->euid;
1587 			stat->gid = cred->egid;
1588 		}
1589 	}
1590 	rcu_read_unlock();
1591 	return 0;
1592 }
1593 
1594 /* dentry stuff */
1595 
1596 /*
1597  *	Exceptional case: normally we are not allowed to unhash a busy
1598  * directory. In this case, however, we can do it - no aliasing problems
1599  * due to the way we treat inodes.
1600  *
1601  * Rewrite the inode's ownerships here because the owning task may have
1602  * performed a setuid(), etc.
1603  *
1604  * Before the /proc/pid/status file was created the only way to read
1605  * the effective uid of a /process was to stat /proc/pid.  Reading
1606  * /proc/pid/status is slow enough that procps and other packages
1607  * kept stating /proc/pid.  To keep the rules in /proc simple I have
1608  * made this apply to all per process world readable and executable
1609  * directories.
1610  */
1611 int pid_revalidate(struct dentry *dentry, unsigned int flags)
1612 {
1613 	struct inode *inode;
1614 	struct task_struct *task;
1615 	const struct cred *cred;
1616 
1617 	if (flags & LOOKUP_RCU)
1618 		return -ECHILD;
1619 
1620 	inode = dentry->d_inode;
1621 	task = get_proc_task(inode);
1622 
1623 	if (task) {
1624 		if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
1625 		    task_dumpable(task)) {
1626 			rcu_read_lock();
1627 			cred = __task_cred(task);
1628 			inode->i_uid = cred->euid;
1629 			inode->i_gid = cred->egid;
1630 			rcu_read_unlock();
1631 		} else {
1632 			inode->i_uid = GLOBAL_ROOT_UID;
1633 			inode->i_gid = GLOBAL_ROOT_GID;
1634 		}
1635 		inode->i_mode &= ~(S_ISUID | S_ISGID);
1636 		security_task_to_inode(task, inode);
1637 		put_task_struct(task);
1638 		return 1;
1639 	}
1640 	d_drop(dentry);
1641 	return 0;
1642 }
1643 
1644 static int pid_delete_dentry(const struct dentry * dentry)
1645 {
1646 	/* Is the task we represent dead?
1647 	 * If so, then don't put the dentry on the lru list,
1648 	 * kill it immediately.
1649 	 */
1650 	return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first;
1651 }
1652 
1653 const struct dentry_operations pid_dentry_operations =
1654 {
1655 	.d_revalidate	= pid_revalidate,
1656 	.d_delete	= pid_delete_dentry,
1657 };
1658 
1659 /* Lookups */
1660 
1661 /*
1662  * Fill a directory entry.
1663  *
1664  * If possible create the dcache entry and derive our inode number and
1665  * file type from dcache entry.
1666  *
1667  * Since all of the proc inode numbers are dynamically generated, the inode
1668  * numbers do not exist until the inode is cache.  This means creating the
1669  * the dcache entry in readdir is necessary to keep the inode numbers
1670  * reported by readdir in sync with the inode numbers reported
1671  * by stat.
1672  */
1673 int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
1674 	const char *name, int len,
1675 	instantiate_t instantiate, struct task_struct *task, const void *ptr)
1676 {
1677 	struct dentry *child, *dir = filp->f_path.dentry;
1678 	struct inode *inode;
1679 	struct qstr qname;
1680 	ino_t ino = 0;
1681 	unsigned type = DT_UNKNOWN;
1682 
1683 	qname.name = name;
1684 	qname.len  = len;
1685 	qname.hash = full_name_hash(name, len);
1686 
1687 	child = d_lookup(dir, &qname);
1688 	if (!child) {
1689 		struct dentry *new;
1690 		new = d_alloc(dir, &qname);
1691 		if (new) {
1692 			child = instantiate(dir->d_inode, new, task, ptr);
1693 			if (child)
1694 				dput(new);
1695 			else
1696 				child = new;
1697 		}
1698 	}
1699 	if (!child || IS_ERR(child) || !child->d_inode)
1700 		goto end_instantiate;
1701 	inode = child->d_inode;
1702 	if (inode) {
1703 		ino = inode->i_ino;
1704 		type = inode->i_mode >> 12;
1705 	}
1706 	dput(child);
1707 end_instantiate:
1708 	if (!ino)
1709 		ino = find_inode_number(dir, &qname);
1710 	if (!ino)
1711 		ino = 1;
1712 	return filldir(dirent, name, len, filp->f_pos, ino, type);
1713 }
1714 
1715 static unsigned name_to_int(struct dentry *dentry)
1716 {
1717 	const char *name = dentry->d_name.name;
1718 	int len = dentry->d_name.len;
1719 	unsigned n = 0;
1720 
1721 	if (len > 1 && *name == '0')
1722 		goto out;
1723 	while (len-- > 0) {
1724 		unsigned c = *name++ - '0';
1725 		if (c > 9)
1726 			goto out;
1727 		if (n >= (~0U-9)/10)
1728 			goto out;
1729 		n *= 10;
1730 		n += c;
1731 	}
1732 	return n;
1733 out:
1734 	return ~0U;
1735 }
1736 
1737 #define PROC_FDINFO_MAX 64
1738 
1739 static int proc_fd_info(struct inode *inode, struct path *path, char *info)
1740 {
1741 	struct task_struct *task = get_proc_task(inode);
1742 	struct files_struct *files = NULL;
1743 	struct file *file;
1744 	int fd = proc_fd(inode);
1745 
1746 	if (task) {
1747 		files = get_files_struct(task);
1748 		put_task_struct(task);
1749 	}
1750 	if (files) {
1751 		/*
1752 		 * We are not taking a ref to the file structure, so we must
1753 		 * hold ->file_lock.
1754 		 */
1755 		spin_lock(&files->file_lock);
1756 		file = fcheck_files(files, fd);
1757 		if (file) {
1758 			unsigned int f_flags;
1759 			struct fdtable *fdt;
1760 
1761 			fdt = files_fdtable(files);
1762 			f_flags = file->f_flags & ~O_CLOEXEC;
1763 			if (close_on_exec(fd, fdt))
1764 				f_flags |= O_CLOEXEC;
1765 
1766 			if (path) {
1767 				*path = file->f_path;
1768 				path_get(&file->f_path);
1769 			}
1770 			if (info)
1771 				snprintf(info, PROC_FDINFO_MAX,
1772 					 "pos:\t%lli\n"
1773 					 "flags:\t0%o\n",
1774 					 (long long) file->f_pos,
1775 					 f_flags);
1776 			spin_unlock(&files->file_lock);
1777 			put_files_struct(files);
1778 			return 0;
1779 		}
1780 		spin_unlock(&files->file_lock);
1781 		put_files_struct(files);
1782 	}
1783 	return -ENOENT;
1784 }
1785 
1786 static int proc_fd_link(struct dentry *dentry, struct path *path)
1787 {
1788 	return proc_fd_info(dentry->d_inode, path, NULL);
1789 }
1790 
1791 static int tid_fd_revalidate(struct dentry *dentry, unsigned int flags)
1792 {
1793 	struct inode *inode;
1794 	struct task_struct *task;
1795 	int fd;
1796 	struct files_struct *files;
1797 	const struct cred *cred;
1798 
1799 	if (flags & LOOKUP_RCU)
1800 		return -ECHILD;
1801 
1802 	inode = dentry->d_inode;
1803 	task = get_proc_task(inode);
1804 	fd = proc_fd(inode);
1805 
1806 	if (task) {
1807 		files = get_files_struct(task);
1808 		if (files) {
1809 			struct file *file;
1810 			rcu_read_lock();
1811 			file = fcheck_files(files, fd);
1812 			if (file) {
1813 				unsigned f_mode = file->f_mode;
1814 
1815 				rcu_read_unlock();
1816 				put_files_struct(files);
1817 
1818 				if (task_dumpable(task)) {
1819 					rcu_read_lock();
1820 					cred = __task_cred(task);
1821 					inode->i_uid = cred->euid;
1822 					inode->i_gid = cred->egid;
1823 					rcu_read_unlock();
1824 				} else {
1825 					inode->i_uid = GLOBAL_ROOT_UID;
1826 					inode->i_gid = GLOBAL_ROOT_GID;
1827 				}
1828 
1829 				if (S_ISLNK(inode->i_mode)) {
1830 					unsigned i_mode = S_IFLNK;
1831 					if (f_mode & FMODE_READ)
1832 						i_mode |= S_IRUSR | S_IXUSR;
1833 					if (f_mode & FMODE_WRITE)
1834 						i_mode |= S_IWUSR | S_IXUSR;
1835 					inode->i_mode = i_mode;
1836 				}
1837 
1838 				security_task_to_inode(task, inode);
1839 				put_task_struct(task);
1840 				return 1;
1841 			}
1842 			rcu_read_unlock();
1843 			put_files_struct(files);
1844 		}
1845 		put_task_struct(task);
1846 	}
1847 	d_drop(dentry);
1848 	return 0;
1849 }
1850 
1851 static const struct dentry_operations tid_fd_dentry_operations =
1852 {
1853 	.d_revalidate	= tid_fd_revalidate,
1854 	.d_delete	= pid_delete_dentry,
1855 };
1856 
1857 static struct dentry *proc_fd_instantiate(struct inode *dir,
1858 	struct dentry *dentry, struct task_struct *task, const void *ptr)
1859 {
1860 	unsigned fd = (unsigned long)ptr;
1861  	struct inode *inode;
1862  	struct proc_inode *ei;
1863 	struct dentry *error = ERR_PTR(-ENOENT);
1864 
1865 	inode = proc_pid_make_inode(dir->i_sb, task);
1866 	if (!inode)
1867 		goto out;
1868 	ei = PROC_I(inode);
1869 	ei->fd = fd;
1870 
1871 	inode->i_mode = S_IFLNK;
1872 	inode->i_op = &proc_pid_link_inode_operations;
1873 	inode->i_size = 64;
1874 	ei->op.proc_get_link = proc_fd_link;
1875 	d_set_d_op(dentry, &tid_fd_dentry_operations);
1876 	d_add(dentry, inode);
1877 	/* Close the race of the process dying before we return the dentry */
1878 	if (tid_fd_revalidate(dentry, 0))
1879 		error = NULL;
1880 
1881  out:
1882 	return error;
1883 }
1884 
1885 static struct dentry *proc_lookupfd_common(struct inode *dir,
1886 					   struct dentry *dentry,
1887 					   instantiate_t instantiate)
1888 {
1889 	struct task_struct *task = get_proc_task(dir);
1890 	unsigned fd = name_to_int(dentry);
1891 	struct dentry *result = ERR_PTR(-ENOENT);
1892 
1893 	if (!task)
1894 		goto out_no_task;
1895 	if (fd == ~0U)
1896 		goto out;
1897 
1898 	result = instantiate(dir, dentry, task, (void *)(unsigned long)fd);
1899 out:
1900 	put_task_struct(task);
1901 out_no_task:
1902 	return result;
1903 }
1904 
1905 static int proc_readfd_common(struct file * filp, void * dirent,
1906 			      filldir_t filldir, instantiate_t instantiate)
1907 {
1908 	struct dentry *dentry = filp->f_path.dentry;
1909 	struct inode *inode = dentry->d_inode;
1910 	struct task_struct *p = get_proc_task(inode);
1911 	unsigned int fd, ino;
1912 	int retval;
1913 	struct files_struct * files;
1914 
1915 	retval = -ENOENT;
1916 	if (!p)
1917 		goto out_no_task;
1918 	retval = 0;
1919 
1920 	fd = filp->f_pos;
1921 	switch (fd) {
1922 		case 0:
1923 			if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
1924 				goto out;
1925 			filp->f_pos++;
1926 		case 1:
1927 			ino = parent_ino(dentry);
1928 			if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
1929 				goto out;
1930 			filp->f_pos++;
1931 		default:
1932 			files = get_files_struct(p);
1933 			if (!files)
1934 				goto out;
1935 			rcu_read_lock();
1936 			for (fd = filp->f_pos-2;
1937 			     fd < files_fdtable(files)->max_fds;
1938 			     fd++, filp->f_pos++) {
1939 				char name[PROC_NUMBUF];
1940 				int len;
1941 				int rv;
1942 
1943 				if (!fcheck_files(files, fd))
1944 					continue;
1945 				rcu_read_unlock();
1946 
1947 				len = snprintf(name, sizeof(name), "%d", fd);
1948 				rv = proc_fill_cache(filp, dirent, filldir,
1949 						     name, len, instantiate, p,
1950 						     (void *)(unsigned long)fd);
1951 				if (rv < 0)
1952 					goto out_fd_loop;
1953 				rcu_read_lock();
1954 			}
1955 			rcu_read_unlock();
1956 out_fd_loop:
1957 			put_files_struct(files);
1958 	}
1959 out:
1960 	put_task_struct(p);
1961 out_no_task:
1962 	return retval;
1963 }
1964 
1965 static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
1966 				    unsigned int flags)
1967 {
1968 	return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
1969 }
1970 
1971 static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir)
1972 {
1973 	return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate);
1974 }
1975 
1976 static ssize_t proc_fdinfo_read(struct file *file, char __user *buf,
1977 				      size_t len, loff_t *ppos)
1978 {
1979 	char tmp[PROC_FDINFO_MAX];
1980 	int err = proc_fd_info(file->f_path.dentry->d_inode, NULL, tmp);
1981 	if (!err)
1982 		err = simple_read_from_buffer(buf, len, ppos, tmp, strlen(tmp));
1983 	return err;
1984 }
1985 
1986 static const struct file_operations proc_fdinfo_file_operations = {
1987 	.open           = nonseekable_open,
1988 	.read		= proc_fdinfo_read,
1989 	.llseek		= no_llseek,
1990 };
1991 
1992 static const struct file_operations proc_fd_operations = {
1993 	.read		= generic_read_dir,
1994 	.readdir	= proc_readfd,
1995 	.llseek		= default_llseek,
1996 };
1997 
1998 #ifdef CONFIG_CHECKPOINT_RESTORE
1999 
2000 /*
2001  * dname_to_vma_addr - maps a dentry name into two unsigned longs
2002  * which represent vma start and end addresses.
2003  */
2004 static int dname_to_vma_addr(struct dentry *dentry,
2005 			     unsigned long *start, unsigned long *end)
2006 {
2007 	if (sscanf(dentry->d_name.name, "%lx-%lx", start, end) != 2)
2008 		return -EINVAL;
2009 
2010 	return 0;
2011 }
2012 
2013 static int map_files_d_revalidate(struct dentry *dentry, unsigned int flags)
2014 {
2015 	unsigned long vm_start, vm_end;
2016 	bool exact_vma_exists = false;
2017 	struct mm_struct *mm = NULL;
2018 	struct task_struct *task;
2019 	const struct cred *cred;
2020 	struct inode *inode;
2021 	int status = 0;
2022 
2023 	if (flags & LOOKUP_RCU)
2024 		return -ECHILD;
2025 
2026 	if (!capable(CAP_SYS_ADMIN)) {
2027 		status = -EACCES;
2028 		goto out_notask;
2029 	}
2030 
2031 	inode = dentry->d_inode;
2032 	task = get_proc_task(inode);
2033 	if (!task)
2034 		goto out_notask;
2035 
2036 	mm = mm_access(task, PTRACE_MODE_READ);
2037 	if (IS_ERR_OR_NULL(mm))
2038 		goto out;
2039 
2040 	if (!dname_to_vma_addr(dentry, &vm_start, &vm_end)) {
2041 		down_read(&mm->mmap_sem);
2042 		exact_vma_exists = !!find_exact_vma(mm, vm_start, vm_end);
2043 		up_read(&mm->mmap_sem);
2044 	}
2045 
2046 	mmput(mm);
2047 
2048 	if (exact_vma_exists) {
2049 		if (task_dumpable(task)) {
2050 			rcu_read_lock();
2051 			cred = __task_cred(task);
2052 			inode->i_uid = cred->euid;
2053 			inode->i_gid = cred->egid;
2054 			rcu_read_unlock();
2055 		} else {
2056 			inode->i_uid = GLOBAL_ROOT_UID;
2057 			inode->i_gid = GLOBAL_ROOT_GID;
2058 		}
2059 		security_task_to_inode(task, inode);
2060 		status = 1;
2061 	}
2062 
2063 out:
2064 	put_task_struct(task);
2065 
2066 out_notask:
2067 	if (status <= 0)
2068 		d_drop(dentry);
2069 
2070 	return status;
2071 }
2072 
2073 static const struct dentry_operations tid_map_files_dentry_operations = {
2074 	.d_revalidate	= map_files_d_revalidate,
2075 	.d_delete	= pid_delete_dentry,
2076 };
2077 
2078 static int proc_map_files_get_link(struct dentry *dentry, struct path *path)
2079 {
2080 	unsigned long vm_start, vm_end;
2081 	struct vm_area_struct *vma;
2082 	struct task_struct *task;
2083 	struct mm_struct *mm;
2084 	int rc;
2085 
2086 	rc = -ENOENT;
2087 	task = get_proc_task(dentry->d_inode);
2088 	if (!task)
2089 		goto out;
2090 
2091 	mm = get_task_mm(task);
2092 	put_task_struct(task);
2093 	if (!mm)
2094 		goto out;
2095 
2096 	rc = dname_to_vma_addr(dentry, &vm_start, &vm_end);
2097 	if (rc)
2098 		goto out_mmput;
2099 
2100 	down_read(&mm->mmap_sem);
2101 	vma = find_exact_vma(mm, vm_start, vm_end);
2102 	if (vma && vma->vm_file) {
2103 		*path = vma->vm_file->f_path;
2104 		path_get(path);
2105 		rc = 0;
2106 	}
2107 	up_read(&mm->mmap_sem);
2108 
2109 out_mmput:
2110 	mmput(mm);
2111 out:
2112 	return rc;
2113 }
2114 
2115 struct map_files_info {
2116 	struct file	*file;
2117 	unsigned long	len;
2118 	unsigned char	name[4*sizeof(long)+2]; /* max: %lx-%lx\0 */
2119 };
2120 
2121 static struct dentry *
2122 proc_map_files_instantiate(struct inode *dir, struct dentry *dentry,
2123 			   struct task_struct *task, const void *ptr)
2124 {
2125 	const struct file *file = ptr;
2126 	struct proc_inode *ei;
2127 	struct inode *inode;
2128 
2129 	if (!file)
2130 		return ERR_PTR(-ENOENT);
2131 
2132 	inode = proc_pid_make_inode(dir->i_sb, task);
2133 	if (!inode)
2134 		return ERR_PTR(-ENOENT);
2135 
2136 	ei = PROC_I(inode);
2137 	ei->op.proc_get_link = proc_map_files_get_link;
2138 
2139 	inode->i_op = &proc_pid_link_inode_operations;
2140 	inode->i_size = 64;
2141 	inode->i_mode = S_IFLNK;
2142 
2143 	if (file->f_mode & FMODE_READ)
2144 		inode->i_mode |= S_IRUSR;
2145 	if (file->f_mode & FMODE_WRITE)
2146 		inode->i_mode |= S_IWUSR;
2147 
2148 	d_set_d_op(dentry, &tid_map_files_dentry_operations);
2149 	d_add(dentry, inode);
2150 
2151 	return NULL;
2152 }
2153 
2154 static struct dentry *proc_map_files_lookup(struct inode *dir,
2155 		struct dentry *dentry, unsigned int flags)
2156 {
2157 	unsigned long vm_start, vm_end;
2158 	struct vm_area_struct *vma;
2159 	struct task_struct *task;
2160 	struct dentry *result;
2161 	struct mm_struct *mm;
2162 
2163 	result = ERR_PTR(-EACCES);
2164 	if (!capable(CAP_SYS_ADMIN))
2165 		goto out;
2166 
2167 	result = ERR_PTR(-ENOENT);
2168 	task = get_proc_task(dir);
2169 	if (!task)
2170 		goto out;
2171 
2172 	result = ERR_PTR(-EACCES);
2173 	if (!ptrace_may_access(task, PTRACE_MODE_READ))
2174 		goto out_put_task;
2175 
2176 	result = ERR_PTR(-ENOENT);
2177 	if (dname_to_vma_addr(dentry, &vm_start, &vm_end))
2178 		goto out_put_task;
2179 
2180 	mm = get_task_mm(task);
2181 	if (!mm)
2182 		goto out_put_task;
2183 
2184 	down_read(&mm->mmap_sem);
2185 	vma = find_exact_vma(mm, vm_start, vm_end);
2186 	if (!vma)
2187 		goto out_no_vma;
2188 
2189 	result = proc_map_files_instantiate(dir, dentry, task, vma->vm_file);
2190 
2191 out_no_vma:
2192 	up_read(&mm->mmap_sem);
2193 	mmput(mm);
2194 out_put_task:
2195 	put_task_struct(task);
2196 out:
2197 	return result;
2198 }
2199 
2200 static const struct inode_operations proc_map_files_inode_operations = {
2201 	.lookup		= proc_map_files_lookup,
2202 	.permission	= proc_fd_permission,
2203 	.setattr	= proc_setattr,
2204 };
2205 
2206 static int
2207 proc_map_files_readdir(struct file *filp, void *dirent, filldir_t filldir)
2208 {
2209 	struct dentry *dentry = filp->f_path.dentry;
2210 	struct inode *inode = dentry->d_inode;
2211 	struct vm_area_struct *vma;
2212 	struct task_struct *task;
2213 	struct mm_struct *mm;
2214 	ino_t ino;
2215 	int ret;
2216 
2217 	ret = -EACCES;
2218 	if (!capable(CAP_SYS_ADMIN))
2219 		goto out;
2220 
2221 	ret = -ENOENT;
2222 	task = get_proc_task(inode);
2223 	if (!task)
2224 		goto out;
2225 
2226 	ret = -EACCES;
2227 	if (!ptrace_may_access(task, PTRACE_MODE_READ))
2228 		goto out_put_task;
2229 
2230 	ret = 0;
2231 	switch (filp->f_pos) {
2232 	case 0:
2233 		ino = inode->i_ino;
2234 		if (filldir(dirent, ".", 1, 0, ino, DT_DIR) < 0)
2235 			goto out_put_task;
2236 		filp->f_pos++;
2237 	case 1:
2238 		ino = parent_ino(dentry);
2239 		if (filldir(dirent, "..", 2, 1, ino, DT_DIR) < 0)
2240 			goto out_put_task;
2241 		filp->f_pos++;
2242 	default:
2243 	{
2244 		unsigned long nr_files, pos, i;
2245 		struct flex_array *fa = NULL;
2246 		struct map_files_info info;
2247 		struct map_files_info *p;
2248 
2249 		mm = get_task_mm(task);
2250 		if (!mm)
2251 			goto out_put_task;
2252 		down_read(&mm->mmap_sem);
2253 
2254 		nr_files = 0;
2255 
2256 		/*
2257 		 * We need two passes here:
2258 		 *
2259 		 *  1) Collect vmas of mapped files with mmap_sem taken
2260 		 *  2) Release mmap_sem and instantiate entries
2261 		 *
2262 		 * otherwise we get lockdep complained, since filldir()
2263 		 * routine might require mmap_sem taken in might_fault().
2264 		 */
2265 
2266 		for (vma = mm->mmap, pos = 2; vma; vma = vma->vm_next) {
2267 			if (vma->vm_file && ++pos > filp->f_pos)
2268 				nr_files++;
2269 		}
2270 
2271 		if (nr_files) {
2272 			fa = flex_array_alloc(sizeof(info), nr_files,
2273 						GFP_KERNEL);
2274 			if (!fa || flex_array_prealloc(fa, 0, nr_files,
2275 							GFP_KERNEL)) {
2276 				ret = -ENOMEM;
2277 				if (fa)
2278 					flex_array_free(fa);
2279 				up_read(&mm->mmap_sem);
2280 				mmput(mm);
2281 				goto out_put_task;
2282 			}
2283 			for (i = 0, vma = mm->mmap, pos = 2; vma;
2284 					vma = vma->vm_next) {
2285 				if (!vma->vm_file)
2286 					continue;
2287 				if (++pos <= filp->f_pos)
2288 					continue;
2289 
2290 				get_file(vma->vm_file);
2291 				info.file = vma->vm_file;
2292 				info.len = snprintf(info.name,
2293 						sizeof(info.name), "%lx-%lx",
2294 						vma->vm_start, vma->vm_end);
2295 				if (flex_array_put(fa, i++, &info, GFP_KERNEL))
2296 					BUG();
2297 			}
2298 		}
2299 		up_read(&mm->mmap_sem);
2300 
2301 		for (i = 0; i < nr_files; i++) {
2302 			p = flex_array_get(fa, i);
2303 			ret = proc_fill_cache(filp, dirent, filldir,
2304 					      p->name, p->len,
2305 					      proc_map_files_instantiate,
2306 					      task, p->file);
2307 			if (ret)
2308 				break;
2309 			filp->f_pos++;
2310 			fput(p->file);
2311 		}
2312 		for (; i < nr_files; i++) {
2313 			/*
2314 			 * In case of error don't forget
2315 			 * to put rest of file refs.
2316 			 */
2317 			p = flex_array_get(fa, i);
2318 			fput(p->file);
2319 		}
2320 		if (fa)
2321 			flex_array_free(fa);
2322 		mmput(mm);
2323 	}
2324 	}
2325 
2326 out_put_task:
2327 	put_task_struct(task);
2328 out:
2329 	return ret;
2330 }
2331 
2332 static const struct file_operations proc_map_files_operations = {
2333 	.read		= generic_read_dir,
2334 	.readdir	= proc_map_files_readdir,
2335 	.llseek		= default_llseek,
2336 };
2337 
2338 #endif /* CONFIG_CHECKPOINT_RESTORE */
2339 
2340 /*
2341  * /proc/pid/fd needs a special permission handler so that a process can still
2342  * access /proc/self/fd after it has executed a setuid().
2343  */
2344 static int proc_fd_permission(struct inode *inode, int mask)
2345 {
2346 	int rv = generic_permission(inode, mask);
2347 	if (rv == 0)
2348 		return 0;
2349 	if (task_pid(current) == proc_pid(inode))
2350 		rv = 0;
2351 	return rv;
2352 }
2353 
2354 /*
2355  * proc directories can do almost nothing..
2356  */
2357 static const struct inode_operations proc_fd_inode_operations = {
2358 	.lookup		= proc_lookupfd,
2359 	.permission	= proc_fd_permission,
2360 	.setattr	= proc_setattr,
2361 };
2362 
2363 static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
2364 	struct dentry *dentry, struct task_struct *task, const void *ptr)
2365 {
2366 	unsigned fd = (unsigned long)ptr;
2367  	struct inode *inode;
2368  	struct proc_inode *ei;
2369 	struct dentry *error = ERR_PTR(-ENOENT);
2370 
2371 	inode = proc_pid_make_inode(dir->i_sb, task);
2372 	if (!inode)
2373 		goto out;
2374 	ei = PROC_I(inode);
2375 	ei->fd = fd;
2376 	inode->i_mode = S_IFREG | S_IRUSR;
2377 	inode->i_fop = &proc_fdinfo_file_operations;
2378 	d_set_d_op(dentry, &tid_fd_dentry_operations);
2379 	d_add(dentry, inode);
2380 	/* Close the race of the process dying before we return the dentry */
2381 	if (tid_fd_revalidate(dentry, 0))
2382 		error = NULL;
2383 
2384  out:
2385 	return error;
2386 }
2387 
2388 static struct dentry *proc_lookupfdinfo(struct inode *dir,
2389 					struct dentry *dentry,
2390 					unsigned int flags)
2391 {
2392 	return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
2393 }
2394 
2395 static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir)
2396 {
2397 	return proc_readfd_common(filp, dirent, filldir,
2398 				  proc_fdinfo_instantiate);
2399 }
2400 
2401 static const struct file_operations proc_fdinfo_operations = {
2402 	.read		= generic_read_dir,
2403 	.readdir	= proc_readfdinfo,
2404 	.llseek		= default_llseek,
2405 };
2406 
2407 /*
2408  * proc directories can do almost nothing..
2409  */
2410 static const struct inode_operations proc_fdinfo_inode_operations = {
2411 	.lookup		= proc_lookupfdinfo,
2412 	.setattr	= proc_setattr,
2413 };
2414 
2415 
2416 static struct dentry *proc_pident_instantiate(struct inode *dir,
2417 	struct dentry *dentry, struct task_struct *task, const void *ptr)
2418 {
2419 	const struct pid_entry *p = ptr;
2420 	struct inode *inode;
2421 	struct proc_inode *ei;
2422 	struct dentry *error = ERR_PTR(-ENOENT);
2423 
2424 	inode = proc_pid_make_inode(dir->i_sb, task);
2425 	if (!inode)
2426 		goto out;
2427 
2428 	ei = PROC_I(inode);
2429 	inode->i_mode = p->mode;
2430 	if (S_ISDIR(inode->i_mode))
2431 		set_nlink(inode, 2);	/* Use getattr to fix if necessary */
2432 	if (p->iop)
2433 		inode->i_op = p->iop;
2434 	if (p->fop)
2435 		inode->i_fop = p->fop;
2436 	ei->op = p->op;
2437 	d_set_d_op(dentry, &pid_dentry_operations);
2438 	d_add(dentry, inode);
2439 	/* Close the race of the process dying before we return the dentry */
2440 	if (pid_revalidate(dentry, 0))
2441 		error = NULL;
2442 out:
2443 	return error;
2444 }
2445 
2446 static struct dentry *proc_pident_lookup(struct inode *dir,
2447 					 struct dentry *dentry,
2448 					 const struct pid_entry *ents,
2449 					 unsigned int nents)
2450 {
2451 	struct dentry *error;
2452 	struct task_struct *task = get_proc_task(dir);
2453 	const struct pid_entry *p, *last;
2454 
2455 	error = ERR_PTR(-ENOENT);
2456 
2457 	if (!task)
2458 		goto out_no_task;
2459 
2460 	/*
2461 	 * Yes, it does not scale. And it should not. Don't add
2462 	 * new entries into /proc/<tgid>/ without very good reasons.
2463 	 */
2464 	last = &ents[nents - 1];
2465 	for (p = ents; p <= last; p++) {
2466 		if (p->len != dentry->d_name.len)
2467 			continue;
2468 		if (!memcmp(dentry->d_name.name, p->name, p->len))
2469 			break;
2470 	}
2471 	if (p > last)
2472 		goto out;
2473 
2474 	error = proc_pident_instantiate(dir, dentry, task, p);
2475 out:
2476 	put_task_struct(task);
2477 out_no_task:
2478 	return error;
2479 }
2480 
2481 static int proc_pident_fill_cache(struct file *filp, void *dirent,
2482 	filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
2483 {
2484 	return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
2485 				proc_pident_instantiate, task, p);
2486 }
2487 
2488 static int proc_pident_readdir(struct file *filp,
2489 		void *dirent, filldir_t filldir,
2490 		const struct pid_entry *ents, unsigned int nents)
2491 {
2492 	int i;
2493 	struct dentry *dentry = filp->f_path.dentry;
2494 	struct inode *inode = dentry->d_inode;
2495 	struct task_struct *task = get_proc_task(inode);
2496 	const struct pid_entry *p, *last;
2497 	ino_t ino;
2498 	int ret;
2499 
2500 	ret = -ENOENT;
2501 	if (!task)
2502 		goto out_no_task;
2503 
2504 	ret = 0;
2505 	i = filp->f_pos;
2506 	switch (i) {
2507 	case 0:
2508 		ino = inode->i_ino;
2509 		if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
2510 			goto out;
2511 		i++;
2512 		filp->f_pos++;
2513 		/* fall through */
2514 	case 1:
2515 		ino = parent_ino(dentry);
2516 		if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
2517 			goto out;
2518 		i++;
2519 		filp->f_pos++;
2520 		/* fall through */
2521 	default:
2522 		i -= 2;
2523 		if (i >= nents) {
2524 			ret = 1;
2525 			goto out;
2526 		}
2527 		p = ents + i;
2528 		last = &ents[nents - 1];
2529 		while (p <= last) {
2530 			if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0)
2531 				goto out;
2532 			filp->f_pos++;
2533 			p++;
2534 		}
2535 	}
2536 
2537 	ret = 1;
2538 out:
2539 	put_task_struct(task);
2540 out_no_task:
2541 	return ret;
2542 }
2543 
2544 #ifdef CONFIG_SECURITY
2545 static ssize_t proc_pid_attr_read(struct file * file, char __user * buf,
2546 				  size_t count, loff_t *ppos)
2547 {
2548 	struct inode * inode = file->f_path.dentry->d_inode;
2549 	char *p = NULL;
2550 	ssize_t length;
2551 	struct task_struct *task = get_proc_task(inode);
2552 
2553 	if (!task)
2554 		return -ESRCH;
2555 
2556 	length = security_getprocattr(task,
2557 				      (char*)file->f_path.dentry->d_name.name,
2558 				      &p);
2559 	put_task_struct(task);
2560 	if (length > 0)
2561 		length = simple_read_from_buffer(buf, count, ppos, p, length);
2562 	kfree(p);
2563 	return length;
2564 }
2565 
2566 static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
2567 				   size_t count, loff_t *ppos)
2568 {
2569 	struct inode * inode = file->f_path.dentry->d_inode;
2570 	char *page;
2571 	ssize_t length;
2572 	struct task_struct *task = get_proc_task(inode);
2573 
2574 	length = -ESRCH;
2575 	if (!task)
2576 		goto out_no_task;
2577 	if (count > PAGE_SIZE)
2578 		count = PAGE_SIZE;
2579 
2580 	/* No partial writes. */
2581 	length = -EINVAL;
2582 	if (*ppos != 0)
2583 		goto out;
2584 
2585 	length = -ENOMEM;
2586 	page = (char*)__get_free_page(GFP_TEMPORARY);
2587 	if (!page)
2588 		goto out;
2589 
2590 	length = -EFAULT;
2591 	if (copy_from_user(page, buf, count))
2592 		goto out_free;
2593 
2594 	/* Guard against adverse ptrace interaction */
2595 	length = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
2596 	if (length < 0)
2597 		goto out_free;
2598 
2599 	length = security_setprocattr(task,
2600 				      (char*)file->f_path.dentry->d_name.name,
2601 				      (void*)page, count);
2602 	mutex_unlock(&task->signal->cred_guard_mutex);
2603 out_free:
2604 	free_page((unsigned long) page);
2605 out:
2606 	put_task_struct(task);
2607 out_no_task:
2608 	return length;
2609 }
2610 
2611 static const struct file_operations proc_pid_attr_operations = {
2612 	.read		= proc_pid_attr_read,
2613 	.write		= proc_pid_attr_write,
2614 	.llseek		= generic_file_llseek,
2615 };
2616 
2617 static const struct pid_entry attr_dir_stuff[] = {
2618 	REG("current",    S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2619 	REG("prev",       S_IRUGO,	   proc_pid_attr_operations),
2620 	REG("exec",       S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2621 	REG("fscreate",   S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2622 	REG("keycreate",  S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2623 	REG("sockcreate", S_IRUGO|S_IWUGO, proc_pid_attr_operations),
2624 };
2625 
2626 static int proc_attr_dir_readdir(struct file * filp,
2627 			     void * dirent, filldir_t filldir)
2628 {
2629 	return proc_pident_readdir(filp,dirent,filldir,
2630 				   attr_dir_stuff,ARRAY_SIZE(attr_dir_stuff));
2631 }
2632 
2633 static const struct file_operations proc_attr_dir_operations = {
2634 	.read		= generic_read_dir,
2635 	.readdir	= proc_attr_dir_readdir,
2636 	.llseek		= default_llseek,
2637 };
2638 
2639 static struct dentry *proc_attr_dir_lookup(struct inode *dir,
2640 				struct dentry *dentry, unsigned int flags)
2641 {
2642 	return proc_pident_lookup(dir, dentry,
2643 				  attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
2644 }
2645 
2646 static const struct inode_operations proc_attr_dir_inode_operations = {
2647 	.lookup		= proc_attr_dir_lookup,
2648 	.getattr	= pid_getattr,
2649 	.setattr	= proc_setattr,
2650 };
2651 
2652 #endif
2653 
2654 #ifdef CONFIG_ELF_CORE
2655 static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf,
2656 					 size_t count, loff_t *ppos)
2657 {
2658 	struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
2659 	struct mm_struct *mm;
2660 	char buffer[PROC_NUMBUF];
2661 	size_t len;
2662 	int ret;
2663 
2664 	if (!task)
2665 		return -ESRCH;
2666 
2667 	ret = 0;
2668 	mm = get_task_mm(task);
2669 	if (mm) {
2670 		len = snprintf(buffer, sizeof(buffer), "%08lx\n",
2671 			       ((mm->flags & MMF_DUMP_FILTER_MASK) >>
2672 				MMF_DUMP_FILTER_SHIFT));
2673 		mmput(mm);
2674 		ret = simple_read_from_buffer(buf, count, ppos, buffer, len);
2675 	}
2676 
2677 	put_task_struct(task);
2678 
2679 	return ret;
2680 }
2681 
2682 static ssize_t proc_coredump_filter_write(struct file *file,
2683 					  const char __user *buf,
2684 					  size_t count,
2685 					  loff_t *ppos)
2686 {
2687 	struct task_struct *task;
2688 	struct mm_struct *mm;
2689 	char buffer[PROC_NUMBUF], *end;
2690 	unsigned int val;
2691 	int ret;
2692 	int i;
2693 	unsigned long mask;
2694 
2695 	ret = -EFAULT;
2696 	memset(buffer, 0, sizeof(buffer));
2697 	if (count > sizeof(buffer) - 1)
2698 		count = sizeof(buffer) - 1;
2699 	if (copy_from_user(buffer, buf, count))
2700 		goto out_no_task;
2701 
2702 	ret = -EINVAL;
2703 	val = (unsigned int)simple_strtoul(buffer, &end, 0);
2704 	if (*end == '\n')
2705 		end++;
2706 	if (end - buffer == 0)
2707 		goto out_no_task;
2708 
2709 	ret = -ESRCH;
2710 	task = get_proc_task(file->f_dentry->d_inode);
2711 	if (!task)
2712 		goto out_no_task;
2713 
2714 	ret = end - buffer;
2715 	mm = get_task_mm(task);
2716 	if (!mm)
2717 		goto out_no_mm;
2718 
2719 	for (i = 0, mask = 1; i < MMF_DUMP_FILTER_BITS; i++, mask <<= 1) {
2720 		if (val & mask)
2721 			set_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
2722 		else
2723 			clear_bit(i + MMF_DUMP_FILTER_SHIFT, &mm->flags);
2724 	}
2725 
2726 	mmput(mm);
2727  out_no_mm:
2728 	put_task_struct(task);
2729  out_no_task:
2730 	return ret;
2731 }
2732 
2733 static const struct file_operations proc_coredump_filter_operations = {
2734 	.read		= proc_coredump_filter_read,
2735 	.write		= proc_coredump_filter_write,
2736 	.llseek		= generic_file_llseek,
2737 };
2738 #endif
2739 
2740 /*
2741  * /proc/self:
2742  */
2743 static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
2744 			      int buflen)
2745 {
2746 	struct pid_namespace *ns = dentry->d_sb->s_fs_info;
2747 	pid_t tgid = task_tgid_nr_ns(current, ns);
2748 	char tmp[PROC_NUMBUF];
2749 	if (!tgid)
2750 		return -ENOENT;
2751 	sprintf(tmp, "%d", tgid);
2752 	return vfs_readlink(dentry,buffer,buflen,tmp);
2753 }
2754 
2755 static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
2756 {
2757 	struct pid_namespace *ns = dentry->d_sb->s_fs_info;
2758 	pid_t tgid = task_tgid_nr_ns(current, ns);
2759 	char *name = ERR_PTR(-ENOENT);
2760 	if (tgid) {
2761 		name = __getname();
2762 		if (!name)
2763 			name = ERR_PTR(-ENOMEM);
2764 		else
2765 			sprintf(name, "%d", tgid);
2766 	}
2767 	nd_set_link(nd, name);
2768 	return NULL;
2769 }
2770 
2771 static void proc_self_put_link(struct dentry *dentry, struct nameidata *nd,
2772 				void *cookie)
2773 {
2774 	char *s = nd_get_link(nd);
2775 	if (!IS_ERR(s))
2776 		__putname(s);
2777 }
2778 
2779 static const struct inode_operations proc_self_inode_operations = {
2780 	.readlink	= proc_self_readlink,
2781 	.follow_link	= proc_self_follow_link,
2782 	.put_link	= proc_self_put_link,
2783 };
2784 
2785 /*
2786  * proc base
2787  *
2788  * These are the directory entries in the root directory of /proc
2789  * that properly belong to the /proc filesystem, as they describe
2790  * describe something that is process related.
2791  */
2792 static const struct pid_entry proc_base_stuff[] = {
2793 	NOD("self", S_IFLNK|S_IRWXUGO,
2794 		&proc_self_inode_operations, NULL, {}),
2795 };
2796 
2797 static struct dentry *proc_base_instantiate(struct inode *dir,
2798 	struct dentry *dentry, struct task_struct *task, const void *ptr)
2799 {
2800 	const struct pid_entry *p = ptr;
2801 	struct inode *inode;
2802 	struct proc_inode *ei;
2803 	struct dentry *error;
2804 
2805 	/* Allocate the inode */
2806 	error = ERR_PTR(-ENOMEM);
2807 	inode = new_inode(dir->i_sb);
2808 	if (!inode)
2809 		goto out;
2810 
2811 	/* Initialize the inode */
2812 	ei = PROC_I(inode);
2813 	inode->i_ino = get_next_ino();
2814 	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
2815 
2816 	/*
2817 	 * grab the reference to the task.
2818 	 */
2819 	ei->pid = get_task_pid(task, PIDTYPE_PID);
2820 	if (!ei->pid)
2821 		goto out_iput;
2822 
2823 	inode->i_mode = p->mode;
2824 	if (S_ISDIR(inode->i_mode))
2825 		set_nlink(inode, 2);
2826 	if (S_ISLNK(inode->i_mode))
2827 		inode->i_size = 64;
2828 	if (p->iop)
2829 		inode->i_op = p->iop;
2830 	if (p->fop)
2831 		inode->i_fop = p->fop;
2832 	ei->op = p->op;
2833 	d_add(dentry, inode);
2834 	error = NULL;
2835 out:
2836 	return error;
2837 out_iput:
2838 	iput(inode);
2839 	goto out;
2840 }
2841 
2842 static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry)
2843 {
2844 	struct dentry *error;
2845 	struct task_struct *task = get_proc_task(dir);
2846 	const struct pid_entry *p, *last;
2847 
2848 	error = ERR_PTR(-ENOENT);
2849 
2850 	if (!task)
2851 		goto out_no_task;
2852 
2853 	/* Lookup the directory entry */
2854 	last = &proc_base_stuff[ARRAY_SIZE(proc_base_stuff) - 1];
2855 	for (p = proc_base_stuff; p <= last; p++) {
2856 		if (p->len != dentry->d_name.len)
2857 			continue;
2858 		if (!memcmp(dentry->d_name.name, p->name, p->len))
2859 			break;
2860 	}
2861 	if (p > last)
2862 		goto out;
2863 
2864 	error = proc_base_instantiate(dir, dentry, task, p);
2865 
2866 out:
2867 	put_task_struct(task);
2868 out_no_task:
2869 	return error;
2870 }
2871 
2872 static int proc_base_fill_cache(struct file *filp, void *dirent,
2873 	filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
2874 {
2875 	return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
2876 				proc_base_instantiate, task, p);
2877 }
2878 
2879 #ifdef CONFIG_TASK_IO_ACCOUNTING
2880 static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
2881 {
2882 	struct task_io_accounting acct = task->ioac;
2883 	unsigned long flags;
2884 	int result;
2885 
2886 	result = mutex_lock_killable(&task->signal->cred_guard_mutex);
2887 	if (result)
2888 		return result;
2889 
2890 	if (!ptrace_may_access(task, PTRACE_MODE_READ)) {
2891 		result = -EACCES;
2892 		goto out_unlock;
2893 	}
2894 
2895 	if (whole && lock_task_sighand(task, &flags)) {
2896 		struct task_struct *t = task;
2897 
2898 		task_io_accounting_add(&acct, &task->signal->ioac);
2899 		while_each_thread(task, t)
2900 			task_io_accounting_add(&acct, &t->ioac);
2901 
2902 		unlock_task_sighand(task, &flags);
2903 	}
2904 	result = sprintf(buffer,
2905 			"rchar: %llu\n"
2906 			"wchar: %llu\n"
2907 			"syscr: %llu\n"
2908 			"syscw: %llu\n"
2909 			"read_bytes: %llu\n"
2910 			"write_bytes: %llu\n"
2911 			"cancelled_write_bytes: %llu\n",
2912 			(unsigned long long)acct.rchar,
2913 			(unsigned long long)acct.wchar,
2914 			(unsigned long long)acct.syscr,
2915 			(unsigned long long)acct.syscw,
2916 			(unsigned long long)acct.read_bytes,
2917 			(unsigned long long)acct.write_bytes,
2918 			(unsigned long long)acct.cancelled_write_bytes);
2919 out_unlock:
2920 	mutex_unlock(&task->signal->cred_guard_mutex);
2921 	return result;
2922 }
2923 
2924 static int proc_tid_io_accounting(struct task_struct *task, char *buffer)
2925 {
2926 	return do_io_accounting(task, buffer, 0);
2927 }
2928 
2929 static int proc_tgid_io_accounting(struct task_struct *task, char *buffer)
2930 {
2931 	return do_io_accounting(task, buffer, 1);
2932 }
2933 #endif /* CONFIG_TASK_IO_ACCOUNTING */
2934 
2935 #ifdef CONFIG_USER_NS
2936 static int proc_id_map_open(struct inode *inode, struct file *file,
2937 	struct seq_operations *seq_ops)
2938 {
2939 	struct user_namespace *ns = NULL;
2940 	struct task_struct *task;
2941 	struct seq_file *seq;
2942 	int ret = -EINVAL;
2943 
2944 	task = get_proc_task(inode);
2945 	if (task) {
2946 		rcu_read_lock();
2947 		ns = get_user_ns(task_cred_xxx(task, user_ns));
2948 		rcu_read_unlock();
2949 		put_task_struct(task);
2950 	}
2951 	if (!ns)
2952 		goto err;
2953 
2954 	ret = seq_open(file, seq_ops);
2955 	if (ret)
2956 		goto err_put_ns;
2957 
2958 	seq = file->private_data;
2959 	seq->private = ns;
2960 
2961 	return 0;
2962 err_put_ns:
2963 	put_user_ns(ns);
2964 err:
2965 	return ret;
2966 }
2967 
2968 static int proc_id_map_release(struct inode *inode, struct file *file)
2969 {
2970 	struct seq_file *seq = file->private_data;
2971 	struct user_namespace *ns = seq->private;
2972 	put_user_ns(ns);
2973 	return seq_release(inode, file);
2974 }
2975 
2976 static int proc_uid_map_open(struct inode *inode, struct file *file)
2977 {
2978 	return proc_id_map_open(inode, file, &proc_uid_seq_operations);
2979 }
2980 
2981 static int proc_gid_map_open(struct inode *inode, struct file *file)
2982 {
2983 	return proc_id_map_open(inode, file, &proc_gid_seq_operations);
2984 }
2985 
2986 static const struct file_operations proc_uid_map_operations = {
2987 	.open		= proc_uid_map_open,
2988 	.write		= proc_uid_map_write,
2989 	.read		= seq_read,
2990 	.llseek		= seq_lseek,
2991 	.release	= proc_id_map_release,
2992 };
2993 
2994 static const struct file_operations proc_gid_map_operations = {
2995 	.open		= proc_gid_map_open,
2996 	.write		= proc_gid_map_write,
2997 	.read		= seq_read,
2998 	.llseek		= seq_lseek,
2999 	.release	= proc_id_map_release,
3000 };
3001 #endif /* CONFIG_USER_NS */
3002 
3003 static int proc_pid_personality(struct seq_file *m, struct pid_namespace *ns,
3004 				struct pid *pid, struct task_struct *task)
3005 {
3006 	int err = lock_trace(task);
3007 	if (!err) {
3008 		seq_printf(m, "%08x\n", task->personality);
3009 		unlock_trace(task);
3010 	}
3011 	return err;
3012 }
3013 
3014 /*
3015  * Thread groups
3016  */
3017 static const struct file_operations proc_task_operations;
3018 static const struct inode_operations proc_task_inode_operations;
3019 
3020 static const struct pid_entry tgid_base_stuff[] = {
3021 	DIR("task",       S_IRUGO|S_IXUGO, proc_task_inode_operations, proc_task_operations),
3022 	DIR("fd",         S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
3023 #ifdef CONFIG_CHECKPOINT_RESTORE
3024 	DIR("map_files",  S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),
3025 #endif
3026 	DIR("fdinfo",     S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
3027 	DIR("ns",	  S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
3028 #ifdef CONFIG_NET
3029 	DIR("net",        S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
3030 #endif
3031 	REG("environ",    S_IRUSR, proc_environ_operations),
3032 	INF("auxv",       S_IRUSR, proc_pid_auxv),
3033 	ONE("status",     S_IRUGO, proc_pid_status),
3034 	ONE("personality", S_IRUGO, proc_pid_personality),
3035 	INF("limits",	  S_IRUGO, proc_pid_limits),
3036 #ifdef CONFIG_SCHED_DEBUG
3037 	REG("sched",      S_IRUGO|S_IWUSR, proc_pid_sched_operations),
3038 #endif
3039 #ifdef CONFIG_SCHED_AUTOGROUP
3040 	REG("autogroup",  S_IRUGO|S_IWUSR, proc_pid_sched_autogroup_operations),
3041 #endif
3042 	REG("comm",      S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
3043 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
3044 	INF("syscall",    S_IRUGO, proc_pid_syscall),
3045 #endif
3046 	INF("cmdline",    S_IRUGO, proc_pid_cmdline),
3047 	ONE("stat",       S_IRUGO, proc_tgid_stat),
3048 	ONE("statm",      S_IRUGO, proc_pid_statm),
3049 	REG("maps",       S_IRUGO, proc_pid_maps_operations),
3050 #ifdef CONFIG_NUMA
3051 	REG("numa_maps",  S_IRUGO, proc_pid_numa_maps_operations),
3052 #endif
3053 	REG("mem",        S_IRUSR|S_IWUSR, proc_mem_operations),
3054 	LNK("cwd",        proc_cwd_link),
3055 	LNK("root",       proc_root_link),
3056 	LNK("exe",        proc_exe_link),
3057 	REG("mounts",     S_IRUGO, proc_mounts_operations),
3058 	REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),
3059 	REG("mountstats", S_IRUSR, proc_mountstats_operations),
3060 #ifdef CONFIG_PROC_PAGE_MONITOR
3061 	REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
3062 	REG("smaps",      S_IRUGO, proc_pid_smaps_operations),
3063 	REG("pagemap",    S_IRUGO, proc_pagemap_operations),
3064 #endif
3065 #ifdef CONFIG_SECURITY
3066 	DIR("attr",       S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
3067 #endif
3068 #ifdef CONFIG_KALLSYMS
3069 	INF("wchan",      S_IRUGO, proc_pid_wchan),
3070 #endif
3071 #ifdef CONFIG_STACKTRACE
3072 	ONE("stack",      S_IRUGO, proc_pid_stack),
3073 #endif
3074 #ifdef CONFIG_SCHEDSTATS
3075 	INF("schedstat",  S_IRUGO, proc_pid_schedstat),
3076 #endif
3077 #ifdef CONFIG_LATENCYTOP
3078 	REG("latency",  S_IRUGO, proc_lstats_operations),
3079 #endif
3080 #ifdef CONFIG_PROC_PID_CPUSET
3081 	REG("cpuset",     S_IRUGO, proc_cpuset_operations),
3082 #endif
3083 #ifdef CONFIG_CGROUPS
3084 	REG("cgroup",  S_IRUGO, proc_cgroup_operations),
3085 #endif
3086 	INF("oom_score",  S_IRUGO, proc_oom_score),
3087 	REG("oom_adj",    S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
3088 	REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
3089 #ifdef CONFIG_AUDITSYSCALL
3090 	REG("loginuid",   S_IWUSR|S_IRUGO, proc_loginuid_operations),
3091 	REG("sessionid",  S_IRUGO, proc_sessionid_operations),
3092 #endif
3093 #ifdef CONFIG_FAULT_INJECTION
3094 	REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
3095 #endif
3096 #ifdef CONFIG_ELF_CORE
3097 	REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations),
3098 #endif
3099 #ifdef CONFIG_TASK_IO_ACCOUNTING
3100 	INF("io",	S_IRUSR, proc_tgid_io_accounting),
3101 #endif
3102 #ifdef CONFIG_HARDWALL
3103 	INF("hardwall",   S_IRUGO, proc_pid_hardwall),
3104 #endif
3105 #ifdef CONFIG_USER_NS
3106 	REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
3107 	REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
3108 #endif
3109 };
3110 
3111 static int proc_tgid_base_readdir(struct file * filp,
3112 			     void * dirent, filldir_t filldir)
3113 {
3114 	return proc_pident_readdir(filp,dirent,filldir,
3115 				   tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff));
3116 }
3117 
3118 static const struct file_operations proc_tgid_base_operations = {
3119 	.read		= generic_read_dir,
3120 	.readdir	= proc_tgid_base_readdir,
3121 	.llseek		= default_llseek,
3122 };
3123 
3124 static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
3125 {
3126 	return proc_pident_lookup(dir, dentry,
3127 				  tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
3128 }
3129 
3130 static const struct inode_operations proc_tgid_base_inode_operations = {
3131 	.lookup		= proc_tgid_base_lookup,
3132 	.getattr	= pid_getattr,
3133 	.setattr	= proc_setattr,
3134 	.permission	= proc_pid_permission,
3135 };
3136 
3137 static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
3138 {
3139 	struct dentry *dentry, *leader, *dir;
3140 	char buf[PROC_NUMBUF];
3141 	struct qstr name;
3142 
3143 	name.name = buf;
3144 	name.len = snprintf(buf, sizeof(buf), "%d", pid);
3145 	dentry = d_hash_and_lookup(mnt->mnt_root, &name);
3146 	if (dentry) {
3147 		shrink_dcache_parent(dentry);
3148 		d_drop(dentry);
3149 		dput(dentry);
3150 	}
3151 
3152 	name.name = buf;
3153 	name.len = snprintf(buf, sizeof(buf), "%d", tgid);
3154 	leader = d_hash_and_lookup(mnt->mnt_root, &name);
3155 	if (!leader)
3156 		goto out;
3157 
3158 	name.name = "task";
3159 	name.len = strlen(name.name);
3160 	dir = d_hash_and_lookup(leader, &name);
3161 	if (!dir)
3162 		goto out_put_leader;
3163 
3164 	name.name = buf;
3165 	name.len = snprintf(buf, sizeof(buf), "%d", pid);
3166 	dentry = d_hash_and_lookup(dir, &name);
3167 	if (dentry) {
3168 		shrink_dcache_parent(dentry);
3169 		d_drop(dentry);
3170 		dput(dentry);
3171 	}
3172 
3173 	dput(dir);
3174 out_put_leader:
3175 	dput(leader);
3176 out:
3177 	return;
3178 }
3179 
3180 /**
3181  * proc_flush_task -  Remove dcache entries for @task from the /proc dcache.
3182  * @task: task that should be flushed.
3183  *
3184  * When flushing dentries from proc, one needs to flush them from global
3185  * proc (proc_mnt) and from all the namespaces' procs this task was seen
3186  * in. This call is supposed to do all of this job.
3187  *
3188  * Looks in the dcache for
3189  * /proc/@pid
3190  * /proc/@tgid/task/@pid
3191  * if either directory is present flushes it and all of it'ts children
3192  * from the dcache.
3193  *
3194  * It is safe and reasonable to cache /proc entries for a task until
3195  * that task exits.  After that they just clog up the dcache with
3196  * useless entries, possibly causing useful dcache entries to be
3197  * flushed instead.  This routine is proved to flush those useless
3198  * dcache entries at process exit time.
3199  *
3200  * NOTE: This routine is just an optimization so it does not guarantee
3201  *       that no dcache entries will exist at process exit time it
3202  *       just makes it very unlikely that any will persist.
3203  */
3204 
3205 void proc_flush_task(struct task_struct *task)
3206 {
3207 	int i;
3208 	struct pid *pid, *tgid;
3209 	struct upid *upid;
3210 
3211 	pid = task_pid(task);
3212 	tgid = task_tgid(task);
3213 
3214 	for (i = 0; i <= pid->level; i++) {
3215 		upid = &pid->numbers[i];
3216 		proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
3217 					tgid->numbers[i].nr);
3218 	}
3219 
3220 	upid = &pid->numbers[pid->level];
3221 	if (upid->nr == 1)
3222 		pid_ns_release_proc(upid->ns);
3223 }
3224 
3225 static struct dentry *proc_pid_instantiate(struct inode *dir,
3226 					   struct dentry * dentry,
3227 					   struct task_struct *task, const void *ptr)
3228 {
3229 	struct dentry *error = ERR_PTR(-ENOENT);
3230 	struct inode *inode;
3231 
3232 	inode = proc_pid_make_inode(dir->i_sb, task);
3233 	if (!inode)
3234 		goto out;
3235 
3236 	inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
3237 	inode->i_op = &proc_tgid_base_inode_operations;
3238 	inode->i_fop = &proc_tgid_base_operations;
3239 	inode->i_flags|=S_IMMUTABLE;
3240 
3241 	set_nlink(inode, 2 + pid_entry_count_dirs(tgid_base_stuff,
3242 						  ARRAY_SIZE(tgid_base_stuff)));
3243 
3244 	d_set_d_op(dentry, &pid_dentry_operations);
3245 
3246 	d_add(dentry, inode);
3247 	/* Close the race of the process dying before we return the dentry */
3248 	if (pid_revalidate(dentry, 0))
3249 		error = NULL;
3250 out:
3251 	return error;
3252 }
3253 
3254 struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
3255 {
3256 	struct dentry *result;
3257 	struct task_struct *task;
3258 	unsigned tgid;
3259 	struct pid_namespace *ns;
3260 
3261 	result = proc_base_lookup(dir, dentry);
3262 	if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT)
3263 		goto out;
3264 
3265 	tgid = name_to_int(dentry);
3266 	if (tgid == ~0U)
3267 		goto out;
3268 
3269 	ns = dentry->d_sb->s_fs_info;
3270 	rcu_read_lock();
3271 	task = find_task_by_pid_ns(tgid, ns);
3272 	if (task)
3273 		get_task_struct(task);
3274 	rcu_read_unlock();
3275 	if (!task)
3276 		goto out;
3277 
3278 	result = proc_pid_instantiate(dir, dentry, task, NULL);
3279 	put_task_struct(task);
3280 out:
3281 	return result;
3282 }
3283 
3284 /*
3285  * Find the first task with tgid >= tgid
3286  *
3287  */
3288 struct tgid_iter {
3289 	unsigned int tgid;
3290 	struct task_struct *task;
3291 };
3292 static struct tgid_iter next_tgid(struct pid_namespace *ns, struct tgid_iter iter)
3293 {
3294 	struct pid *pid;
3295 
3296 	if (iter.task)
3297 		put_task_struct(iter.task);
3298 	rcu_read_lock();
3299 retry:
3300 	iter.task = NULL;
3301 	pid = find_ge_pid(iter.tgid, ns);
3302 	if (pid) {
3303 		iter.tgid = pid_nr_ns(pid, ns);
3304 		iter.task = pid_task(pid, PIDTYPE_PID);
3305 		/* What we to know is if the pid we have find is the
3306 		 * pid of a thread_group_leader.  Testing for task
3307 		 * being a thread_group_leader is the obvious thing
3308 		 * todo but there is a window when it fails, due to
3309 		 * the pid transfer logic in de_thread.
3310 		 *
3311 		 * So we perform the straight forward test of seeing
3312 		 * if the pid we have found is the pid of a thread
3313 		 * group leader, and don't worry if the task we have
3314 		 * found doesn't happen to be a thread group leader.
3315 		 * As we don't care in the case of readdir.
3316 		 */
3317 		if (!iter.task || !has_group_leader_pid(iter.task)) {
3318 			iter.tgid += 1;
3319 			goto retry;
3320 		}
3321 		get_task_struct(iter.task);
3322 	}
3323 	rcu_read_unlock();
3324 	return iter;
3325 }
3326 
3327 #define TGID_OFFSET (FIRST_PROCESS_ENTRY + ARRAY_SIZE(proc_base_stuff))
3328 
3329 static int proc_pid_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
3330 	struct tgid_iter iter)
3331 {
3332 	char name[PROC_NUMBUF];
3333 	int len = snprintf(name, sizeof(name), "%d", iter.tgid);
3334 	return proc_fill_cache(filp, dirent, filldir, name, len,
3335 				proc_pid_instantiate, iter.task, NULL);
3336 }
3337 
3338 static int fake_filldir(void *buf, const char *name, int namelen,
3339 			loff_t offset, u64 ino, unsigned d_type)
3340 {
3341 	return 0;
3342 }
3343 
3344 /* for the /proc/ directory itself, after non-process stuff has been done */
3345 int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
3346 {
3347 	unsigned int nr;
3348 	struct task_struct *reaper;
3349 	struct tgid_iter iter;
3350 	struct pid_namespace *ns;
3351 	filldir_t __filldir;
3352 
3353 	if (filp->f_pos >= PID_MAX_LIMIT + TGID_OFFSET)
3354 		goto out_no_task;
3355 	nr = filp->f_pos - FIRST_PROCESS_ENTRY;
3356 
3357 	reaper = get_proc_task(filp->f_path.dentry->d_inode);
3358 	if (!reaper)
3359 		goto out_no_task;
3360 
3361 	for (; nr < ARRAY_SIZE(proc_base_stuff); filp->f_pos++, nr++) {
3362 		const struct pid_entry *p = &proc_base_stuff[nr];
3363 		if (proc_base_fill_cache(filp, dirent, filldir, reaper, p) < 0)
3364 			goto out;
3365 	}
3366 
3367 	ns = filp->f_dentry->d_sb->s_fs_info;
3368 	iter.task = NULL;
3369 	iter.tgid = filp->f_pos - TGID_OFFSET;
3370 	for (iter = next_tgid(ns, iter);
3371 	     iter.task;
3372 	     iter.tgid += 1, iter = next_tgid(ns, iter)) {
3373 		if (has_pid_permissions(ns, iter.task, 2))
3374 			__filldir = filldir;
3375 		else
3376 			__filldir = fake_filldir;
3377 
3378 		filp->f_pos = iter.tgid + TGID_OFFSET;
3379 		if (proc_pid_fill_cache(filp, dirent, __filldir, iter) < 0) {
3380 			put_task_struct(iter.task);
3381 			goto out;
3382 		}
3383 	}
3384 	filp->f_pos = PID_MAX_LIMIT + TGID_OFFSET;
3385 out:
3386 	put_task_struct(reaper);
3387 out_no_task:
3388 	return 0;
3389 }
3390 
3391 /*
3392  * Tasks
3393  */
3394 static const struct pid_entry tid_base_stuff[] = {
3395 	DIR("fd",        S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
3396 	DIR("fdinfo",    S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
3397 	DIR("ns",	 S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
3398 	REG("environ",   S_IRUSR, proc_environ_operations),
3399 	INF("auxv",      S_IRUSR, proc_pid_auxv),
3400 	ONE("status",    S_IRUGO, proc_pid_status),
3401 	ONE("personality", S_IRUGO, proc_pid_personality),
3402 	INF("limits",	 S_IRUGO, proc_pid_limits),
3403 #ifdef CONFIG_SCHED_DEBUG
3404 	REG("sched",     S_IRUGO|S_IWUSR, proc_pid_sched_operations),
3405 #endif
3406 	REG("comm",      S_IRUGO|S_IWUSR, proc_pid_set_comm_operations),
3407 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
3408 	INF("syscall",   S_IRUGO, proc_pid_syscall),
3409 #endif
3410 	INF("cmdline",   S_IRUGO, proc_pid_cmdline),
3411 	ONE("stat",      S_IRUGO, proc_tid_stat),
3412 	ONE("statm",     S_IRUGO, proc_pid_statm),
3413 	REG("maps",      S_IRUGO, proc_tid_maps_operations),
3414 #ifdef CONFIG_CHECKPOINT_RESTORE
3415 	REG("children",  S_IRUGO, proc_tid_children_operations),
3416 #endif
3417 #ifdef CONFIG_NUMA
3418 	REG("numa_maps", S_IRUGO, proc_tid_numa_maps_operations),
3419 #endif
3420 	REG("mem",       S_IRUSR|S_IWUSR, proc_mem_operations),
3421 	LNK("cwd",       proc_cwd_link),
3422 	LNK("root",      proc_root_link),
3423 	LNK("exe",       proc_exe_link),
3424 	REG("mounts",    S_IRUGO, proc_mounts_operations),
3425 	REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),
3426 #ifdef CONFIG_PROC_PAGE_MONITOR
3427 	REG("clear_refs", S_IWUSR, proc_clear_refs_operations),
3428 	REG("smaps",     S_IRUGO, proc_tid_smaps_operations),
3429 	REG("pagemap",    S_IRUGO, proc_pagemap_operations),
3430 #endif
3431 #ifdef CONFIG_SECURITY
3432 	DIR("attr",      S_IRUGO|S_IXUGO, proc_attr_dir_inode_operations, proc_attr_dir_operations),
3433 #endif
3434 #ifdef CONFIG_KALLSYMS
3435 	INF("wchan",     S_IRUGO, proc_pid_wchan),
3436 #endif
3437 #ifdef CONFIG_STACKTRACE
3438 	ONE("stack",      S_IRUGO, proc_pid_stack),
3439 #endif
3440 #ifdef CONFIG_SCHEDSTATS
3441 	INF("schedstat", S_IRUGO, proc_pid_schedstat),
3442 #endif
3443 #ifdef CONFIG_LATENCYTOP
3444 	REG("latency",  S_IRUGO, proc_lstats_operations),
3445 #endif
3446 #ifdef CONFIG_PROC_PID_CPUSET
3447 	REG("cpuset",    S_IRUGO, proc_cpuset_operations),
3448 #endif
3449 #ifdef CONFIG_CGROUPS
3450 	REG("cgroup",  S_IRUGO, proc_cgroup_operations),
3451 #endif
3452 	INF("oom_score", S_IRUGO, proc_oom_score),
3453 	REG("oom_adj",   S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
3454 	REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
3455 #ifdef CONFIG_AUDITSYSCALL
3456 	REG("loginuid",  S_IWUSR|S_IRUGO, proc_loginuid_operations),
3457 	REG("sessionid",  S_IRUGO, proc_sessionid_operations),
3458 #endif
3459 #ifdef CONFIG_FAULT_INJECTION
3460 	REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
3461 #endif
3462 #ifdef CONFIG_TASK_IO_ACCOUNTING
3463 	INF("io",	S_IRUSR, proc_tid_io_accounting),
3464 #endif
3465 #ifdef CONFIG_HARDWALL
3466 	INF("hardwall",   S_IRUGO, proc_pid_hardwall),
3467 #endif
3468 #ifdef CONFIG_USER_NS
3469 	REG("uid_map",    S_IRUGO|S_IWUSR, proc_uid_map_operations),
3470 	REG("gid_map",    S_IRUGO|S_IWUSR, proc_gid_map_operations),
3471 #endif
3472 };
3473 
3474 static int proc_tid_base_readdir(struct file * filp,
3475 			     void * dirent, filldir_t filldir)
3476 {
3477 	return proc_pident_readdir(filp,dirent,filldir,
3478 				   tid_base_stuff,ARRAY_SIZE(tid_base_stuff));
3479 }
3480 
3481 static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
3482 {
3483 	return proc_pident_lookup(dir, dentry,
3484 				  tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
3485 }
3486 
3487 static const struct file_operations proc_tid_base_operations = {
3488 	.read		= generic_read_dir,
3489 	.readdir	= proc_tid_base_readdir,
3490 	.llseek		= default_llseek,
3491 };
3492 
3493 static const struct inode_operations proc_tid_base_inode_operations = {
3494 	.lookup		= proc_tid_base_lookup,
3495 	.getattr	= pid_getattr,
3496 	.setattr	= proc_setattr,
3497 };
3498 
3499 static struct dentry *proc_task_instantiate(struct inode *dir,
3500 	struct dentry *dentry, struct task_struct *task, const void *ptr)
3501 {
3502 	struct dentry *error = ERR_PTR(-ENOENT);
3503 	struct inode *inode;
3504 	inode = proc_pid_make_inode(dir->i_sb, task);
3505 
3506 	if (!inode)
3507 		goto out;
3508 	inode->i_mode = S_IFDIR|S_IRUGO|S_IXUGO;
3509 	inode->i_op = &proc_tid_base_inode_operations;
3510 	inode->i_fop = &proc_tid_base_operations;
3511 	inode->i_flags|=S_IMMUTABLE;
3512 
3513 	set_nlink(inode, 2 + pid_entry_count_dirs(tid_base_stuff,
3514 						  ARRAY_SIZE(tid_base_stuff)));
3515 
3516 	d_set_d_op(dentry, &pid_dentry_operations);
3517 
3518 	d_add(dentry, inode);
3519 	/* Close the race of the process dying before we return the dentry */
3520 	if (pid_revalidate(dentry, 0))
3521 		error = NULL;
3522 out:
3523 	return error;
3524 }
3525 
3526 static struct dentry *proc_task_lookup(struct inode *dir, struct dentry * dentry, unsigned int flags)
3527 {
3528 	struct dentry *result = ERR_PTR(-ENOENT);
3529 	struct task_struct *task;
3530 	struct task_struct *leader = get_proc_task(dir);
3531 	unsigned tid;
3532 	struct pid_namespace *ns;
3533 
3534 	if (!leader)
3535 		goto out_no_task;
3536 
3537 	tid = name_to_int(dentry);
3538 	if (tid == ~0U)
3539 		goto out;
3540 
3541 	ns = dentry->d_sb->s_fs_info;
3542 	rcu_read_lock();
3543 	task = find_task_by_pid_ns(tid, ns);
3544 	if (task)
3545 		get_task_struct(task);
3546 	rcu_read_unlock();
3547 	if (!task)
3548 		goto out;
3549 	if (!same_thread_group(leader, task))
3550 		goto out_drop_task;
3551 
3552 	result = proc_task_instantiate(dir, dentry, task, NULL);
3553 out_drop_task:
3554 	put_task_struct(task);
3555 out:
3556 	put_task_struct(leader);
3557 out_no_task:
3558 	return result;
3559 }
3560 
3561 /*
3562  * Find the first tid of a thread group to return to user space.
3563  *
3564  * Usually this is just the thread group leader, but if the users
3565  * buffer was too small or there was a seek into the middle of the
3566  * directory we have more work todo.
3567  *
3568  * In the case of a short read we start with find_task_by_pid.
3569  *
3570  * In the case of a seek we start with the leader and walk nr
3571  * threads past it.
3572  */
3573 static struct task_struct *first_tid(struct task_struct *leader,
3574 		int tid, int nr, struct pid_namespace *ns)
3575 {
3576 	struct task_struct *pos;
3577 
3578 	rcu_read_lock();
3579 	/* Attempt to start with the pid of a thread */
3580 	if (tid && (nr > 0)) {
3581 		pos = find_task_by_pid_ns(tid, ns);
3582 		if (pos && (pos->group_leader == leader))
3583 			goto found;
3584 	}
3585 
3586 	/* If nr exceeds the number of threads there is nothing todo */
3587 	pos = NULL;
3588 	if (nr && nr >= get_nr_threads(leader))
3589 		goto out;
3590 
3591 	/* If we haven't found our starting place yet start
3592 	 * with the leader and walk nr threads forward.
3593 	 */
3594 	for (pos = leader; nr > 0; --nr) {
3595 		pos = next_thread(pos);
3596 		if (pos == leader) {
3597 			pos = NULL;
3598 			goto out;
3599 		}
3600 	}
3601 found:
3602 	get_task_struct(pos);
3603 out:
3604 	rcu_read_unlock();
3605 	return pos;
3606 }
3607 
3608 /*
3609  * Find the next thread in the thread list.
3610  * Return NULL if there is an error or no next thread.
3611  *
3612  * The reference to the input task_struct is released.
3613  */
3614 static struct task_struct *next_tid(struct task_struct *start)
3615 {
3616 	struct task_struct *pos = NULL;
3617 	rcu_read_lock();
3618 	if (pid_alive(start)) {
3619 		pos = next_thread(start);
3620 		if (thread_group_leader(pos))
3621 			pos = NULL;
3622 		else
3623 			get_task_struct(pos);
3624 	}
3625 	rcu_read_unlock();
3626 	put_task_struct(start);
3627 	return pos;
3628 }
3629 
3630 static int proc_task_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
3631 	struct task_struct *task, int tid)
3632 {
3633 	char name[PROC_NUMBUF];
3634 	int len = snprintf(name, sizeof(name), "%d", tid);
3635 	return proc_fill_cache(filp, dirent, filldir, name, len,
3636 				proc_task_instantiate, task, NULL);
3637 }
3638 
3639 /* for the /proc/TGID/task/ directories */
3640 static int proc_task_readdir(struct file * filp, void * dirent, filldir_t filldir)
3641 {
3642 	struct dentry *dentry = filp->f_path.dentry;
3643 	struct inode *inode = dentry->d_inode;
3644 	struct task_struct *leader = NULL;
3645 	struct task_struct *task;
3646 	int retval = -ENOENT;
3647 	ino_t ino;
3648 	int tid;
3649 	struct pid_namespace *ns;
3650 
3651 	task = get_proc_task(inode);
3652 	if (!task)
3653 		goto out_no_task;
3654 	rcu_read_lock();
3655 	if (pid_alive(task)) {
3656 		leader = task->group_leader;
3657 		get_task_struct(leader);
3658 	}
3659 	rcu_read_unlock();
3660 	put_task_struct(task);
3661 	if (!leader)
3662 		goto out_no_task;
3663 	retval = 0;
3664 
3665 	switch ((unsigned long)filp->f_pos) {
3666 	case 0:
3667 		ino = inode->i_ino;
3668 		if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) < 0)
3669 			goto out;
3670 		filp->f_pos++;
3671 		/* fall through */
3672 	case 1:
3673 		ino = parent_ino(dentry);
3674 		if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) < 0)
3675 			goto out;
3676 		filp->f_pos++;
3677 		/* fall through */
3678 	}
3679 
3680 	/* f_version caches the tgid value that the last readdir call couldn't
3681 	 * return. lseek aka telldir automagically resets f_version to 0.
3682 	 */
3683 	ns = filp->f_dentry->d_sb->s_fs_info;
3684 	tid = (int)filp->f_version;
3685 	filp->f_version = 0;
3686 	for (task = first_tid(leader, tid, filp->f_pos - 2, ns);
3687 	     task;
3688 	     task = next_tid(task), filp->f_pos++) {
3689 		tid = task_pid_nr_ns(task, ns);
3690 		if (proc_task_fill_cache(filp, dirent, filldir, task, tid) < 0) {
3691 			/* returning this tgid failed, save it as the first
3692 			 * pid for the next readir call */
3693 			filp->f_version = (u64)tid;
3694 			put_task_struct(task);
3695 			break;
3696 		}
3697 	}
3698 out:
3699 	put_task_struct(leader);
3700 out_no_task:
3701 	return retval;
3702 }
3703 
3704 static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
3705 {
3706 	struct inode *inode = dentry->d_inode;
3707 	struct task_struct *p = get_proc_task(inode);
3708 	generic_fillattr(inode, stat);
3709 
3710 	if (p) {
3711 		stat->nlink += get_nr_threads(p);
3712 		put_task_struct(p);
3713 	}
3714 
3715 	return 0;
3716 }
3717 
3718 static const struct inode_operations proc_task_inode_operations = {
3719 	.lookup		= proc_task_lookup,
3720 	.getattr	= proc_task_getattr,
3721 	.setattr	= proc_setattr,
3722 	.permission	= proc_pid_permission,
3723 };
3724 
3725 static const struct file_operations proc_task_operations = {
3726 	.read		= generic_read_dir,
3727 	.readdir	= proc_task_readdir,
3728 	.llseek		= default_llseek,
3729 };
3730