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