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