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