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
52
53
54
55#include <linux/types.h>
56#include <linux/errno.h>
57#include <linux/time.h>
58#include <linux/kernel.h>
59#include <linux/kernel_stat.h>
60#include <linux/tty.h>
61#include <linux/string.h>
62#include <linux/mman.h>
63#include <linux/sched/mm.h>
64#include <linux/sched/numa_balancing.h>
65#include <linux/sched/task.h>
66#include <linux/sched/cputime.h>
67#include <linux/proc_fs.h>
68#include <linux/ioport.h>
69#include <linux/uaccess.h>
70#include <linux/io.h>
71#include <linux/mm.h>
72#include <linux/hugetlb.h>
73#include <linux/pagemap.h>
74#include <linux/swap.h>
75#include <linux/smp.h>
76#include <linux/signal.h>
77#include <linux/highmem.h>
78#include <linux/file.h>
79#include <linux/fdtable.h>
80#include <linux/times.h>
81#include <linux/cpuset.h>
82#include <linux/rcupdate.h>
83#include <linux/delayacct.h>
84#include <linux/seq_file.h>
85#include <linux/pid_namespace.h>
86#include <linux/ptrace.h>
87#include <linux/tracehook.h>
88#include <linux/string_helpers.h>
89#include <linux/user_namespace.h>
90#include <linux/fs_struct.h>
91
92#include <asm/pgtable.h>
93#include <asm/processor.h>
94#include "internal.h"
95
96static inline void task_name(struct seq_file *m, struct task_struct *p)
97{
98 char *buf;
99 size_t size;
100 char tcomm[sizeof(p->comm)];
101 int ret;
102
103 get_task_comm(tcomm, p);
104
105 seq_puts(m, "Name:\t");
106
107 size = seq_get_buf(m, &buf);
108 ret = string_escape_str(tcomm, buf, size, ESCAPE_SPACE | ESCAPE_SPECIAL, "\n\\");
109 seq_commit(m, ret < size ? ret : -1);
110
111 seq_putc(m, '\n');
112}
113
114
115
116
117
118
119
120static const char * const task_state_array[] = {
121 "R (running)",
122 "S (sleeping)",
123 "D (disk sleep)",
124 "T (stopped)",
125 "t (tracing stop)",
126 "X (dead)",
127 "Z (zombie)",
128};
129
130static inline const char *get_task_state(struct task_struct *tsk)
131{
132 unsigned int state = (tsk->state | tsk->exit_state) & TASK_REPORT;
133
134
135
136
137
138
139 if (tsk->state == TASK_PARKED)
140 state = TASK_INTERRUPTIBLE;
141
142 BUILD_BUG_ON(1 + ilog2(TASK_REPORT) != ARRAY_SIZE(task_state_array)-1);
143
144 return task_state_array[fls(state)];
145}
146
147static inline int get_task_umask(struct task_struct *tsk)
148{
149 struct fs_struct *fs;
150 int umask = -ENOENT;
151
152 task_lock(tsk);
153 fs = tsk->fs;
154 if (fs)
155 umask = fs->umask;
156 task_unlock(tsk);
157 return umask;
158}
159
160static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
161 struct pid *pid, struct task_struct *p)
162{
163 struct user_namespace *user_ns = seq_user_ns(m);
164 struct group_info *group_info;
165 int g, umask;
166 struct task_struct *tracer;
167 const struct cred *cred;
168 pid_t ppid, tpid = 0, tgid, ngid;
169 unsigned int max_fds = 0;
170
171 rcu_read_lock();
172 ppid = pid_alive(p) ?
173 task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
174
175 tracer = ptrace_parent(p);
176 if (tracer)
177 tpid = task_pid_nr_ns(tracer, ns);
178
179 tgid = task_tgid_nr_ns(p, ns);
180 ngid = task_numa_group_id(p);
181 cred = get_task_cred(p);
182
183 umask = get_task_umask(p);
184 if (umask >= 0)
185 seq_printf(m, "Umask:\t%#04o\n", umask);
186
187 task_lock(p);
188 if (p->files)
189 max_fds = files_fdtable(p->files)->max_fds;
190 task_unlock(p);
191 rcu_read_unlock();
192
193 seq_printf(m, "State:\t%s", get_task_state(p));
194
195 seq_put_decimal_ull(m, "\nTgid:\t", tgid);
196 seq_put_decimal_ull(m, "\nNgid:\t", ngid);
197 seq_put_decimal_ull(m, "\nPid:\t", pid_nr_ns(pid, ns));
198 seq_put_decimal_ull(m, "\nPPid:\t", ppid);
199 seq_put_decimal_ull(m, "\nTracerPid:\t", tpid);
200 seq_put_decimal_ull(m, "\nUid:\t", from_kuid_munged(user_ns, cred->uid));
201 seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->euid));
202 seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->suid));
203 seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->fsuid));
204 seq_put_decimal_ull(m, "\nGid:\t", from_kgid_munged(user_ns, cred->gid));
205 seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->egid));
206 seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->sgid));
207 seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->fsgid));
208 seq_put_decimal_ull(m, "\nFDSize:\t", max_fds);
209
210 seq_puts(m, "\nGroups:\t");
211 group_info = cred->group_info;
212 for (g = 0; g < group_info->ngroups; g++)
213 seq_put_decimal_ull(m, g ? " " : "",
214 from_kgid_munged(user_ns, group_info->gid[g]));
215 put_cred(cred);
216
217 seq_putc(m, ' ');
218
219#ifdef CONFIG_PID_NS
220 seq_puts(m, "\nNStgid:");
221 for (g = ns->level; g <= pid->level; g++)
222 seq_put_decimal_ull(m, "\t", task_tgid_nr_ns(p, pid->numbers[g].ns));
223 seq_puts(m, "\nNSpid:");
224 for (g = ns->level; g <= pid->level; g++)
225 seq_put_decimal_ull(m, "\t", task_pid_nr_ns(p, pid->numbers[g].ns));
226 seq_puts(m, "\nNSpgid:");
227 for (g = ns->level; g <= pid->level; g++)
228 seq_put_decimal_ull(m, "\t", task_pgrp_nr_ns(p, pid->numbers[g].ns));
229 seq_puts(m, "\nNSsid:");
230 for (g = ns->level; g <= pid->level; g++)
231 seq_put_decimal_ull(m, "\t", task_session_nr_ns(p, pid->numbers[g].ns));
232#endif
233 seq_putc(m, '\n');
234}
235
236void render_sigset_t(struct seq_file *m, const char *header,
237 sigset_t *set)
238{
239 int i;
240
241 seq_puts(m, header);
242
243 i = _NSIG;
244 do {
245 int x = 0;
246
247 i -= 4;
248 if (sigismember(set, i+1)) x |= 1;
249 if (sigismember(set, i+2)) x |= 2;
250 if (sigismember(set, i+3)) x |= 4;
251 if (sigismember(set, i+4)) x |= 8;
252 seq_putc(m, hex_asc[x]);
253 } while (i >= 4);
254
255 seq_putc(m, '\n');
256}
257
258static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
259 sigset_t *catch)
260{
261 struct k_sigaction *k;
262 int i;
263
264 k = p->sighand->action;
265 for (i = 1; i <= _NSIG; ++i, ++k) {
266 if (k->sa.sa_handler == SIG_IGN)
267 sigaddset(ign, i);
268 else if (k->sa.sa_handler != SIG_DFL)
269 sigaddset(catch, i);
270 }
271}
272
273static inline void task_sig(struct seq_file *m, struct task_struct *p)
274{
275 unsigned long flags;
276 sigset_t pending, shpending, blocked, ignored, caught;
277 int num_threads = 0;
278 unsigned long qsize = 0;
279 unsigned long qlim = 0;
280
281 sigemptyset(&pending);
282 sigemptyset(&shpending);
283 sigemptyset(&blocked);
284 sigemptyset(&ignored);
285 sigemptyset(&caught);
286
287 if (lock_task_sighand(p, &flags)) {
288 pending = p->pending.signal;
289 shpending = p->signal->shared_pending.signal;
290 blocked = p->blocked;
291 collect_sigign_sigcatch(p, &ignored, &caught);
292 num_threads = get_nr_threads(p);
293 rcu_read_lock();
294 qsize = atomic_read(&__task_cred(p)->user->sigpending);
295 rcu_read_unlock();
296 qlim = task_rlimit(p, RLIMIT_SIGPENDING);
297 unlock_task_sighand(p, &flags);
298 }
299
300 seq_put_decimal_ull(m, "Threads:\t", num_threads);
301 seq_put_decimal_ull(m, "\nSigQ:\t", qsize);
302 seq_put_decimal_ull(m, "/", qlim);
303
304
305 render_sigset_t(m, "\nSigPnd:\t", &pending);
306 render_sigset_t(m, "ShdPnd:\t", &shpending);
307 render_sigset_t(m, "SigBlk:\t", &blocked);
308 render_sigset_t(m, "SigIgn:\t", &ignored);
309 render_sigset_t(m, "SigCgt:\t", &caught);
310}
311
312static void render_cap_t(struct seq_file *m, const char *header,
313 kernel_cap_t *a)
314{
315 unsigned __capi;
316
317 seq_puts(m, header);
318 CAP_FOR_EACH_U32(__capi) {
319 seq_printf(m, "%08x",
320 a->cap[CAP_LAST_U32 - __capi]);
321 }
322 seq_putc(m, '\n');
323}
324
325static inline void task_cap(struct seq_file *m, struct task_struct *p)
326{
327 const struct cred *cred;
328 kernel_cap_t cap_inheritable, cap_permitted, cap_effective,
329 cap_bset, cap_ambient;
330
331 rcu_read_lock();
332 cred = __task_cred(p);
333 cap_inheritable = cred->cap_inheritable;
334 cap_permitted = cred->cap_permitted;
335 cap_effective = cred->cap_effective;
336 cap_bset = cred->cap_bset;
337 cap_ambient = cred->cap_ambient;
338 rcu_read_unlock();
339
340 render_cap_t(m, "CapInh:\t", &cap_inheritable);
341 render_cap_t(m, "CapPrm:\t", &cap_permitted);
342 render_cap_t(m, "CapEff:\t", &cap_effective);
343 render_cap_t(m, "CapBnd:\t", &cap_bset);
344 render_cap_t(m, "CapAmb:\t", &cap_ambient);
345}
346
347static inline void task_seccomp(struct seq_file *m, struct task_struct *p)
348{
349 seq_put_decimal_ull(m, "NoNewPrivs:\t", task_no_new_privs(p));
350#ifdef CONFIG_SECCOMP
351 seq_put_decimal_ull(m, "\nSeccomp:\t", p->seccomp.mode);
352#endif
353 seq_putc(m, '\n');
354}
355
356static inline void task_context_switch_counts(struct seq_file *m,
357 struct task_struct *p)
358{
359 seq_put_decimal_ull(m, "voluntary_ctxt_switches:\t", p->nvcsw);
360 seq_put_decimal_ull(m, "\nnonvoluntary_ctxt_switches:\t", p->nivcsw);
361 seq_putc(m, '\n');
362}
363
364static void task_cpus_allowed(struct seq_file *m, struct task_struct *task)
365{
366 seq_printf(m, "Cpus_allowed:\t%*pb\n",
367 cpumask_pr_args(&task->cpus_allowed));
368 seq_printf(m, "Cpus_allowed_list:\t%*pbl\n",
369 cpumask_pr_args(&task->cpus_allowed));
370}
371
372int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
373 struct pid *pid, struct task_struct *task)
374{
375 struct mm_struct *mm = get_task_mm(task);
376
377 task_name(m, task);
378 task_state(m, ns, pid, task);
379
380 if (mm) {
381 task_mem(m, mm);
382 mmput(mm);
383 }
384 task_sig(m, task);
385 task_cap(m, task);
386 task_seccomp(m, task);
387 task_cpus_allowed(m, task);
388 cpuset_task_status_allowed(m, task);
389 task_context_switch_counts(m, task);
390 return 0;
391}
392
393static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
394 struct pid *pid, struct task_struct *task, int whole)
395{
396 unsigned long vsize, eip, esp, wchan = 0;
397 int priority, nice;
398 int tty_pgrp = -1, tty_nr = 0;
399 sigset_t sigign, sigcatch;
400 char state;
401 pid_t ppid = 0, pgid = -1, sid = -1;
402 int num_threads = 0;
403 int permitted;
404 struct mm_struct *mm;
405 unsigned long long start_time;
406 unsigned long cmin_flt = 0, cmaj_flt = 0;
407 unsigned long min_flt = 0, maj_flt = 0;
408 u64 cutime, cstime, utime, stime;
409 u64 cgtime, gtime;
410 unsigned long rsslim = 0;
411 char tcomm[sizeof(task->comm)];
412 unsigned long flags;
413
414 state = *get_task_state(task);
415 vsize = eip = esp = 0;
416 permitted = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS | PTRACE_MODE_NOAUDIT);
417 mm = get_task_mm(task);
418 if (mm) {
419 vsize = task_vsize(mm);
420
421
422
423
424
425 }
426
427 get_task_comm(tcomm, task);
428
429 sigemptyset(&sigign);
430 sigemptyset(&sigcatch);
431 cutime = cstime = utime = stime = 0;
432 cgtime = gtime = 0;
433
434 if (lock_task_sighand(task, &flags)) {
435 struct signal_struct *sig = task->signal;
436
437 if (sig->tty) {
438 struct pid *pgrp = tty_get_pgrp(sig->tty);
439 tty_pgrp = pid_nr_ns(pgrp, ns);
440 put_pid(pgrp);
441 tty_nr = new_encode_dev(tty_devnum(sig->tty));
442 }
443
444 num_threads = get_nr_threads(task);
445 collect_sigign_sigcatch(task, &sigign, &sigcatch);
446
447 cmin_flt = sig->cmin_flt;
448 cmaj_flt = sig->cmaj_flt;
449 cutime = sig->cutime;
450 cstime = sig->cstime;
451 cgtime = sig->cgtime;
452 rsslim = ACCESS_ONCE(sig->rlim[RLIMIT_RSS].rlim_cur);
453
454
455 if (whole) {
456 struct task_struct *t = task;
457 do {
458 min_flt += t->min_flt;
459 maj_flt += t->maj_flt;
460 gtime += task_gtime(t);
461 } while_each_thread(task, t);
462
463 min_flt += sig->min_flt;
464 maj_flt += sig->maj_flt;
465 thread_group_cputime_adjusted(task, &utime, &stime);
466 gtime += sig->gtime;
467 }
468
469 sid = task_session_nr_ns(task, ns);
470 ppid = task_tgid_nr_ns(task->real_parent, ns);
471 pgid = task_pgrp_nr_ns(task, ns);
472
473 unlock_task_sighand(task, &flags);
474 }
475
476 if (permitted && (!whole || num_threads < 2))
477 wchan = get_wchan(task);
478 if (!whole) {
479 min_flt = task->min_flt;
480 maj_flt = task->maj_flt;
481 task_cputime_adjusted(task, &utime, &stime);
482 gtime = task_gtime(task);
483 }
484
485
486
487 priority = task_prio(task);
488 nice = task_nice(task);
489
490
491 start_time = nsec_to_clock_t(task->real_start_time);
492
493 seq_printf(m, "%d (%s) %c", pid_nr_ns(pid, ns), tcomm, state);
494 seq_put_decimal_ll(m, " ", ppid);
495 seq_put_decimal_ll(m, " ", pgid);
496 seq_put_decimal_ll(m, " ", sid);
497 seq_put_decimal_ll(m, " ", tty_nr);
498 seq_put_decimal_ll(m, " ", tty_pgrp);
499 seq_put_decimal_ull(m, " ", task->flags);
500 seq_put_decimal_ull(m, " ", min_flt);
501 seq_put_decimal_ull(m, " ", cmin_flt);
502 seq_put_decimal_ull(m, " ", maj_flt);
503 seq_put_decimal_ull(m, " ", cmaj_flt);
504 seq_put_decimal_ull(m, " ", nsec_to_clock_t(utime));
505 seq_put_decimal_ull(m, " ", nsec_to_clock_t(stime));
506 seq_put_decimal_ll(m, " ", nsec_to_clock_t(cutime));
507 seq_put_decimal_ll(m, " ", nsec_to_clock_t(cstime));
508 seq_put_decimal_ll(m, " ", priority);
509 seq_put_decimal_ll(m, " ", nice);
510 seq_put_decimal_ll(m, " ", num_threads);
511 seq_put_decimal_ull(m, " ", 0);
512 seq_put_decimal_ull(m, " ", start_time);
513 seq_put_decimal_ull(m, " ", vsize);
514 seq_put_decimal_ull(m, " ", mm ? get_mm_rss(mm) : 0);
515 seq_put_decimal_ull(m, " ", rsslim);
516 seq_put_decimal_ull(m, " ", mm ? (permitted ? mm->start_code : 1) : 0);
517 seq_put_decimal_ull(m, " ", mm ? (permitted ? mm->end_code : 1) : 0);
518 seq_put_decimal_ull(m, " ", (permitted && mm) ? mm->start_stack : 0);
519 seq_put_decimal_ull(m, " ", esp);
520 seq_put_decimal_ull(m, " ", eip);
521
522
523
524
525 seq_put_decimal_ull(m, " ", task->pending.signal.sig[0] & 0x7fffffffUL);
526 seq_put_decimal_ull(m, " ", task->blocked.sig[0] & 0x7fffffffUL);
527 seq_put_decimal_ull(m, " ", sigign.sig[0] & 0x7fffffffUL);
528 seq_put_decimal_ull(m, " ", sigcatch.sig[0] & 0x7fffffffUL);
529
530
531
532
533
534
535
536
537 if (wchan)
538 seq_puts(m, " 1");
539 else
540 seq_puts(m, " 0");
541
542 seq_put_decimal_ull(m, " ", 0);
543 seq_put_decimal_ull(m, " ", 0);
544 seq_put_decimal_ll(m, " ", task->exit_signal);
545 seq_put_decimal_ll(m, " ", task_cpu(task));
546 seq_put_decimal_ull(m, " ", task->rt_priority);
547 seq_put_decimal_ull(m, " ", task->policy);
548 seq_put_decimal_ull(m, " ", delayacct_blkio_ticks(task));
549 seq_put_decimal_ull(m, " ", nsec_to_clock_t(gtime));
550 seq_put_decimal_ll(m, " ", nsec_to_clock_t(cgtime));
551
552 if (mm && permitted) {
553 seq_put_decimal_ull(m, " ", mm->start_data);
554 seq_put_decimal_ull(m, " ", mm->end_data);
555 seq_put_decimal_ull(m, " ", mm->start_brk);
556 seq_put_decimal_ull(m, " ", mm->arg_start);
557 seq_put_decimal_ull(m, " ", mm->arg_end);
558 seq_put_decimal_ull(m, " ", mm->env_start);
559 seq_put_decimal_ull(m, " ", mm->env_end);
560 } else
561 seq_puts(m, " 0 0 0 0 0 0 0");
562
563 if (permitted)
564 seq_put_decimal_ll(m, " ", task->exit_code);
565 else
566 seq_puts(m, " 0");
567
568 seq_putc(m, '\n');
569 if (mm)
570 mmput(mm);
571 return 0;
572}
573
574int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
575 struct pid *pid, struct task_struct *task)
576{
577 return do_task_stat(m, ns, pid, task, 0);
578}
579
580int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
581 struct pid *pid, struct task_struct *task)
582{
583 return do_task_stat(m, ns, pid, task, 1);
584}
585
586int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
587 struct pid *pid, struct task_struct *task)
588{
589 unsigned long size = 0, resident = 0, shared = 0, text = 0, data = 0;
590 struct mm_struct *mm = get_task_mm(task);
591
592 if (mm) {
593 size = task_statm(mm, &shared, &text, &data, &resident);
594 mmput(mm);
595 }
596
597
598
599
600
601
602 seq_put_decimal_ull(m, "", size);
603 seq_put_decimal_ull(m, " ", resident);
604 seq_put_decimal_ull(m, " ", shared);
605 seq_put_decimal_ull(m, " ", text);
606 seq_put_decimal_ull(m, " ", 0);
607 seq_put_decimal_ull(m, " ", data);
608 seq_put_decimal_ull(m, " ", 0);
609 seq_putc(m, '\n');
610
611 return 0;
612}
613
614#ifdef CONFIG_PROC_CHILDREN
615static struct pid *
616get_children_pid(struct inode *inode, struct pid *pid_prev, loff_t pos)
617{
618 struct task_struct *start, *task;
619 struct pid *pid = NULL;
620
621 read_lock(&tasklist_lock);
622
623 start = pid_task(proc_pid(inode), PIDTYPE_PID);
624 if (!start)
625 goto out;
626
627
628
629
630
631 if (pid_prev) {
632 task = pid_task(pid_prev, PIDTYPE_PID);
633 if (task && task->real_parent == start &&
634 !(list_empty(&task->sibling))) {
635 if (list_is_last(&task->sibling, &start->children))
636 goto out;
637 task = list_first_entry(&task->sibling,
638 struct task_struct, sibling);
639 pid = get_pid(task_pid(task));
640 goto out;
641 }
642 }
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659 list_for_each_entry(task, &start->children, sibling) {
660 if (pos-- == 0) {
661 pid = get_pid(task_pid(task));
662 break;
663 }
664 }
665
666out:
667 read_unlock(&tasklist_lock);
668 return pid;
669}
670
671static int children_seq_show(struct seq_file *seq, void *v)
672{
673 struct inode *inode = seq->private;
674 pid_t pid;
675
676 pid = pid_nr_ns(v, inode->i_sb->s_fs_info);
677 seq_printf(seq, "%d ", pid);
678
679 return 0;
680}
681
682static void *children_seq_start(struct seq_file *seq, loff_t *pos)
683{
684 return get_children_pid(seq->private, NULL, *pos);
685}
686
687static void *children_seq_next(struct seq_file *seq, void *v, loff_t *pos)
688{
689 struct pid *pid;
690
691 pid = get_children_pid(seq->private, v, *pos + 1);
692 put_pid(v);
693
694 ++*pos;
695 return pid;
696}
697
698static void children_seq_stop(struct seq_file *seq, void *v)
699{
700 put_pid(v);
701}
702
703static const struct seq_operations children_seq_ops = {
704 .start = children_seq_start,
705 .next = children_seq_next,
706 .stop = children_seq_stop,
707 .show = children_seq_show,
708};
709
710static int children_seq_open(struct inode *inode, struct file *file)
711{
712 struct seq_file *m;
713 int ret;
714
715 ret = seq_open(file, &children_seq_ops);
716 if (ret)
717 return ret;
718
719 m = file->private_data;
720 m->private = inode;
721
722 return ret;
723}
724
725int children_seq_release(struct inode *inode, struct file *file)
726{
727 seq_release(inode, file);
728 return 0;
729}
730
731const struct file_operations proc_tid_children_operations = {
732 .open = children_seq_open,
733 .read = seq_read,
734 .llseek = seq_lseek,
735 .release = children_seq_release,
736};
737#endif
738