• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  linux/fs/proc/array.c
4  *
5  *  Copyright (C) 1992  by Linus Torvalds
6  *  based on ideas by Darren Senn
7  *
8  * Fixes:
9  * Michael. K. Johnson: stat,statm extensions.
10  *                      <johnsonm@stolaf.edu>
11  *
12  * Pauline Middelink :  Made cmdline,envline only break at '\0's, to
13  *                      make sure SET_PROCTITLE works. Also removed
14  *                      bad '!' which forced address recalculation for
15  *                      EVERY character on the current page.
16  *                      <middelin@polyware.iaf.nl>
17  *
18  * Danny ter Haar    :	added cpuinfo
19  *			<dth@cistron.nl>
20  *
21  * Alessandro Rubini :  profile extension.
22  *                      <rubini@ipvvis.unipv.it>
23  *
24  * Jeff Tranter      :  added BogoMips field to cpuinfo
25  *                      <Jeff_Tranter@Mitel.COM>
26  *
27  * Bruno Haible      :  remove 4K limit for the maps file
28  *			<haible@ma2s2.mathematik.uni-karlsruhe.de>
29  *
30  * Yves Arrouye      :  remove removal of trailing spaces in get_array.
31  *			<Yves.Arrouye@marin.fdn.fr>
32  *
33  * Jerome Forissier  :  added per-CPU time information to /proc/stat
34  *                      and /proc/<pid>/cpu extension
35  *                      <forissier@isia.cma.fr>
36  *			- Incorporation and non-SMP safe operation
37  *			of forissier patch in 2.1.78 by
38  *			Hans Marcus <crowbar@concepts.nl>
39  *
40  * aeb@cwi.nl        :  /proc/partitions
41  *
42  *
43  * Alan Cox	     :  security fixes.
44  *			<alan@lxorguk.ukuu.org.uk>
45  *
46  * Al Viro           :  safe handling of mm_struct
47  *
48  * Gerhard Wichert   :  added BIGMEM support
49  * Siemens AG           <Gerhard.Wichert@pdb.siemens.de>
50  *
51  * Al Viro & Jeff Garzik :  moved most of the thing into base.c and
52  *			 :  proc_misc.c. The rest may eventually go into
53  *			 :  base.c too.
54  */
55 
56 #include <linux/types.h>
57 #include <linux/errno.h>
58 #include <linux/time.h>
59 #include <linux/kernel.h>
60 #include <linux/kernel_stat.h>
61 #include <linux/tty.h>
62 #include <linux/string.h>
63 #include <linux/mman.h>
64 #include <linux/sched/mm.h>
65 #include <linux/sched/numa_balancing.h>
66 #include <linux/sched/task_stack.h>
67 #include <linux/sched/task.h>
68 #include <linux/sched/cputime.h>
69 #include <linux/proc_fs.h>
70 #include <linux/ioport.h>
71 #include <linux/uaccess.h>
72 #include <linux/io.h>
73 #include <linux/mm.h>
74 #include <linux/hugetlb.h>
75 #include <linux/pagemap.h>
76 #include <linux/swap.h>
77 #include <linux/smp.h>
78 #include <linux/signal.h>
79 #include <linux/highmem.h>
80 #include <linux/file.h>
81 #include <linux/fdtable.h>
82 #include <linux/times.h>
83 #include <linux/cpuset.h>
84 #include <linux/rcupdate.h>
85 #include <linux/delayacct.h>
86 #include <linux/seq_file.h>
87 #include <linux/pid_namespace.h>
88 #include <linux/prctl.h>
89 #include <linux/ptrace.h>
90 #include <linux/tracehook.h>
91 #include <linux/string_helpers.h>
92 #include <linux/user_namespace.h>
93 #include <linux/fs_struct.h>
94 
95 #include <asm/pgtable.h>
96 #include <asm/processor.h>
97 #include "internal.h"
98 
task_name(struct seq_file * m,struct task_struct * p)99 static inline void task_name(struct seq_file *m, struct task_struct *p)
100 {
101 	char *buf;
102 	size_t size;
103 	char tcomm[sizeof(p->comm)];
104 	int ret;
105 
106 	get_task_comm(tcomm, p);
107 
108 	seq_puts(m, "Name:\t");
109 
110 	size = seq_get_buf(m, &buf);
111 	ret = string_escape_str(tcomm, buf, size, ESCAPE_SPACE | ESCAPE_SPECIAL, "\n\\");
112 	seq_commit(m, ret < size ? ret : -1);
113 
114 	seq_putc(m, '\n');
115 }
116 
117 /*
118  * The task state array is a strange "bitmap" of
119  * reasons to sleep. Thus "running" is zero, and
120  * you can test for combinations of others with
121  * simple bit tests.
122  */
123 static const char * const task_state_array[] = {
124 
125 	/* states in TASK_REPORT: */
126 	"R (running)",		/* 0x00 */
127 	"S (sleeping)",		/* 0x01 */
128 	"D (disk sleep)",	/* 0x02 */
129 	"T (stopped)",		/* 0x04 */
130 	"t (tracing stop)",	/* 0x08 */
131 	"X (dead)",		/* 0x10 */
132 	"Z (zombie)",		/* 0x20 */
133 	"P (parked)",		/* 0x40 */
134 
135 	/* states beyond TASK_REPORT: */
136 	"I (idle)",		/* 0x80 */
137 };
138 
get_task_state(struct task_struct * tsk)139 static inline const char *get_task_state(struct task_struct *tsk)
140 {
141 	BUILD_BUG_ON(1 + ilog2(TASK_REPORT_MAX) != ARRAY_SIZE(task_state_array));
142 	return task_state_array[__get_task_state(tsk)];
143 }
144 
get_task_umask(struct task_struct * tsk)145 static inline int get_task_umask(struct task_struct *tsk)
146 {
147 	struct fs_struct *fs;
148 	int umask = -ENOENT;
149 
150 	task_lock(tsk);
151 	fs = tsk->fs;
152 	if (fs)
153 		umask = fs->umask;
154 	task_unlock(tsk);
155 	return umask;
156 }
157 
task_state(struct seq_file * m,struct pid_namespace * ns,struct pid * pid,struct task_struct * p)158 static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
159 				struct pid *pid, struct task_struct *p)
160 {
161 	struct user_namespace *user_ns = seq_user_ns(m);
162 	struct group_info *group_info;
163 	int g, umask;
164 	struct task_struct *tracer;
165 	const struct cred *cred;
166 	pid_t ppid, tpid = 0, tgid, ngid;
167 	unsigned int max_fds = 0;
168 
169 	rcu_read_lock();
170 	ppid = pid_alive(p) ?
171 		task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
172 
173 	tracer = ptrace_parent(p);
174 	if (tracer)
175 		tpid = task_pid_nr_ns(tracer, ns);
176 
177 	tgid = task_tgid_nr_ns(p, ns);
178 	ngid = task_numa_group_id(p);
179 	cred = get_task_cred(p);
180 
181 	umask = get_task_umask(p);
182 	if (umask >= 0)
183 		seq_printf(m, "Umask:\t%#04o\n", umask);
184 
185 	task_lock(p);
186 	if (p->files)
187 		max_fds = files_fdtable(p->files)->max_fds;
188 	task_unlock(p);
189 	rcu_read_unlock();
190 
191 	seq_printf(m, "State:\t%s", get_task_state(p));
192 
193 	seq_put_decimal_ull(m, "\nTgid:\t", tgid);
194 	seq_put_decimal_ull(m, "\nNgid:\t", ngid);
195 	seq_put_decimal_ull(m, "\nPid:\t", pid_nr_ns(pid, ns));
196 	seq_put_decimal_ull(m, "\nPPid:\t", ppid);
197 	seq_put_decimal_ull(m, "\nTracerPid:\t", tpid);
198 	seq_put_decimal_ull(m, "\nUid:\t", from_kuid_munged(user_ns, cred->uid));
199 	seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->euid));
200 	seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->suid));
201 	seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->fsuid));
202 	seq_put_decimal_ull(m, "\nGid:\t", from_kgid_munged(user_ns, cred->gid));
203 	seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->egid));
204 	seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->sgid));
205 	seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->fsgid));
206 	seq_put_decimal_ull(m, "\nFDSize:\t", max_fds);
207 
208 	seq_puts(m, "\nGroups:\t");
209 	group_info = cred->group_info;
210 	for (g = 0; g < group_info->ngroups; g++)
211 		seq_put_decimal_ull(m, g ? " " : "",
212 				from_kgid_munged(user_ns, group_info->gid[g]));
213 	put_cred(cred);
214 	/* Trailing space shouldn't have been added in the first place. */
215 	seq_putc(m, ' ');
216 
217 #ifdef CONFIG_PID_NS
218 	seq_puts(m, "\nNStgid:");
219 	for (g = ns->level; g <= pid->level; g++)
220 		seq_put_decimal_ull(m, "\t", task_tgid_nr_ns(p, pid->numbers[g].ns));
221 	seq_puts(m, "\nNSpid:");
222 	for (g = ns->level; g <= pid->level; g++)
223 		seq_put_decimal_ull(m, "\t", task_pid_nr_ns(p, pid->numbers[g].ns));
224 	seq_puts(m, "\nNSpgid:");
225 	for (g = ns->level; g <= pid->level; g++)
226 		seq_put_decimal_ull(m, "\t", task_pgrp_nr_ns(p, pid->numbers[g].ns));
227 	seq_puts(m, "\nNSsid:");
228 	for (g = ns->level; g <= pid->level; g++)
229 		seq_put_decimal_ull(m, "\t", task_session_nr_ns(p, pid->numbers[g].ns));
230 #endif
231 	seq_putc(m, '\n');
232 }
233 
render_sigset_t(struct seq_file * m,const char * header,sigset_t * set)234 void render_sigset_t(struct seq_file *m, const char *header,
235 				sigset_t *set)
236 {
237 	int i;
238 
239 	seq_puts(m, header);
240 
241 	i = _NSIG;
242 	do {
243 		int x = 0;
244 
245 		i -= 4;
246 		if (sigismember(set, i+1)) x |= 1;
247 		if (sigismember(set, i+2)) x |= 2;
248 		if (sigismember(set, i+3)) x |= 4;
249 		if (sigismember(set, i+4)) x |= 8;
250 		seq_putc(m, hex_asc[x]);
251 	} while (i >= 4);
252 
253 	seq_putc(m, '\n');
254 }
255 
collect_sigign_sigcatch(struct task_struct * p,sigset_t * ign,sigset_t * catch)256 static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
257 				    sigset_t *catch)
258 {
259 	struct k_sigaction *k;
260 	int i;
261 
262 	k = p->sighand->action;
263 	for (i = 1; i <= _NSIG; ++i, ++k) {
264 		if (k->sa.sa_handler == SIG_IGN)
265 			sigaddset(ign, i);
266 		else if (k->sa.sa_handler != SIG_DFL)
267 			sigaddset(catch, i);
268 	}
269 }
270 
task_sig(struct seq_file * m,struct task_struct * p)271 static inline void task_sig(struct seq_file *m, struct task_struct *p)
272 {
273 	unsigned long flags;
274 	sigset_t pending, shpending, blocked, ignored, caught;
275 	int num_threads = 0;
276 	unsigned long qsize = 0;
277 	unsigned long qlim = 0;
278 
279 	sigemptyset(&pending);
280 	sigemptyset(&shpending);
281 	sigemptyset(&blocked);
282 	sigemptyset(&ignored);
283 	sigemptyset(&caught);
284 
285 	if (lock_task_sighand(p, &flags)) {
286 		pending = p->pending.signal;
287 		shpending = p->signal->shared_pending.signal;
288 		blocked = p->blocked;
289 		collect_sigign_sigcatch(p, &ignored, &caught);
290 		num_threads = get_nr_threads(p);
291 		rcu_read_lock();  /* FIXME: is this correct? */
292 		qsize = atomic_read(&__task_cred(p)->user->sigpending);
293 		rcu_read_unlock();
294 		qlim = task_rlimit(p, RLIMIT_SIGPENDING);
295 		unlock_task_sighand(p, &flags);
296 	}
297 
298 	seq_put_decimal_ull(m, "Threads:\t", num_threads);
299 	seq_put_decimal_ull(m, "\nSigQ:\t", qsize);
300 	seq_put_decimal_ull(m, "/", qlim);
301 
302 	/* render them all */
303 	render_sigset_t(m, "\nSigPnd:\t", &pending);
304 	render_sigset_t(m, "ShdPnd:\t", &shpending);
305 	render_sigset_t(m, "SigBlk:\t", &blocked);
306 	render_sigset_t(m, "SigIgn:\t", &ignored);
307 	render_sigset_t(m, "SigCgt:\t", &caught);
308 }
309 
render_cap_t(struct seq_file * m,const char * header,kernel_cap_t * a)310 static void render_cap_t(struct seq_file *m, const char *header,
311 			kernel_cap_t *a)
312 {
313 	unsigned __capi;
314 
315 	seq_puts(m, header);
316 	CAP_FOR_EACH_U32(__capi) {
317 		seq_printf(m, "%08x",
318 			   a->cap[CAP_LAST_U32 - __capi]);
319 	}
320 	seq_putc(m, '\n');
321 }
322 
task_cap(struct seq_file * m,struct task_struct * p)323 static inline void task_cap(struct seq_file *m, struct task_struct *p)
324 {
325 	const struct cred *cred;
326 	kernel_cap_t cap_inheritable, cap_permitted, cap_effective,
327 			cap_bset, cap_ambient;
328 
329 	rcu_read_lock();
330 	cred = __task_cred(p);
331 	cap_inheritable	= cred->cap_inheritable;
332 	cap_permitted	= cred->cap_permitted;
333 	cap_effective	= cred->cap_effective;
334 	cap_bset	= cred->cap_bset;
335 	cap_ambient	= cred->cap_ambient;
336 	rcu_read_unlock();
337 
338 	render_cap_t(m, "CapInh:\t", &cap_inheritable);
339 	render_cap_t(m, "CapPrm:\t", &cap_permitted);
340 	render_cap_t(m, "CapEff:\t", &cap_effective);
341 	render_cap_t(m, "CapBnd:\t", &cap_bset);
342 	render_cap_t(m, "CapAmb:\t", &cap_ambient);
343 }
344 
task_seccomp(struct seq_file * m,struct task_struct * p)345 static inline void task_seccomp(struct seq_file *m, struct task_struct *p)
346 {
347 	seq_put_decimal_ull(m, "NoNewPrivs:\t", task_no_new_privs(p));
348 #ifdef CONFIG_SECCOMP
349 	seq_put_decimal_ull(m, "\nSeccomp:\t", p->seccomp.mode);
350 #endif
351 	seq_printf(m, "\nSpeculation_Store_Bypass:\t");
352 	switch (arch_prctl_spec_ctrl_get(p, PR_SPEC_STORE_BYPASS)) {
353 	case -EINVAL:
354 		seq_printf(m, "unknown");
355 		break;
356 	case PR_SPEC_NOT_AFFECTED:
357 		seq_printf(m, "not vulnerable");
358 		break;
359 	case PR_SPEC_PRCTL | PR_SPEC_FORCE_DISABLE:
360 		seq_printf(m, "thread force mitigated");
361 		break;
362 	case PR_SPEC_PRCTL | PR_SPEC_DISABLE:
363 		seq_printf(m, "thread mitigated");
364 		break;
365 	case PR_SPEC_PRCTL | PR_SPEC_ENABLE:
366 		seq_printf(m, "thread vulnerable");
367 		break;
368 	case PR_SPEC_DISABLE:
369 		seq_printf(m, "globally mitigated");
370 		break;
371 	default:
372 		seq_printf(m, "vulnerable");
373 		break;
374 	}
375 	seq_putc(m, '\n');
376 }
377 
task_context_switch_counts(struct seq_file * m,struct task_struct * p)378 static inline void task_context_switch_counts(struct seq_file *m,
379 						struct task_struct *p)
380 {
381 	seq_put_decimal_ull(m, "voluntary_ctxt_switches:\t", p->nvcsw);
382 	seq_put_decimal_ull(m, "\nnonvoluntary_ctxt_switches:\t", p->nivcsw);
383 	seq_putc(m, '\n');
384 }
385 
task_cpus_allowed(struct seq_file * m,struct task_struct * task)386 static void task_cpus_allowed(struct seq_file *m, struct task_struct *task)
387 {
388 	seq_printf(m, "Cpus_allowed:\t%*pb\n",
389 		   cpumask_pr_args(&task->cpus_allowed));
390 	seq_printf(m, "Cpus_allowed_list:\t%*pbl\n",
391 		   cpumask_pr_args(&task->cpus_allowed));
392 }
393 
proc_pid_status(struct seq_file * m,struct pid_namespace * ns,struct pid * pid,struct task_struct * task)394 int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
395 			struct pid *pid, struct task_struct *task)
396 {
397 	struct mm_struct *mm = get_task_mm(task);
398 
399 	task_name(m, task);
400 	task_state(m, ns, pid, task);
401 
402 	if (mm) {
403 		task_mem(m, mm);
404 		mmput(mm);
405 	}
406 	task_sig(m, task);
407 	task_cap(m, task);
408 	task_seccomp(m, task);
409 	task_cpus_allowed(m, task);
410 	cpuset_task_status_allowed(m, task);
411 	task_context_switch_counts(m, task);
412 	return 0;
413 }
414 
do_task_stat(struct seq_file * m,struct pid_namespace * ns,struct pid * pid,struct task_struct * task,int whole)415 static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
416 			struct pid *pid, struct task_struct *task, int whole)
417 {
418 	unsigned long vsize, eip, esp, wchan = 0;
419 	int priority, nice;
420 	int tty_pgrp = -1, tty_nr = 0;
421 	sigset_t sigign, sigcatch;
422 	char state;
423 	pid_t ppid = 0, pgid = -1, sid = -1;
424 	int num_threads = 0;
425 	int permitted;
426 	struct mm_struct *mm;
427 	unsigned long long start_time;
428 	unsigned long cmin_flt = 0, cmaj_flt = 0;
429 	unsigned long  min_flt = 0,  maj_flt = 0;
430 	u64 cutime, cstime, utime, stime;
431 	u64 cgtime, gtime;
432 	unsigned long rsslim = 0;
433 	char tcomm[sizeof(task->comm)];
434 	unsigned long flags;
435 
436 	state = *get_task_state(task);
437 	vsize = eip = esp = 0;
438 	permitted = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS | PTRACE_MODE_NOAUDIT);
439 	mm = get_task_mm(task);
440 	if (mm) {
441 		vsize = task_vsize(mm);
442 		/*
443 		 * esp and eip are intentionally zeroed out.  There is no
444 		 * non-racy way to read them without freezing the task.
445 		 * Programs that need reliable values can use ptrace(2).
446 		 *
447 		 * The only exception is if the task is core dumping because
448 		 * a program is not able to use ptrace(2) in that case. It is
449 		 * safe because the task has stopped executing permanently.
450 		 */
451 		if (permitted && (task->flags & (PF_EXITING|PF_DUMPCORE))) {
452 			if (try_get_task_stack(task)) {
453 				eip = KSTK_EIP(task);
454 				esp = KSTK_ESP(task);
455 				put_task_stack(task);
456 			}
457 		}
458 	}
459 
460 	get_task_comm(tcomm, task);
461 
462 	sigemptyset(&sigign);
463 	sigemptyset(&sigcatch);
464 	cutime = cstime = utime = stime = 0;
465 	cgtime = gtime = 0;
466 
467 	if (lock_task_sighand(task, &flags)) {
468 		struct signal_struct *sig = task->signal;
469 
470 		if (sig->tty) {
471 			struct pid *pgrp = tty_get_pgrp(sig->tty);
472 			tty_pgrp = pid_nr_ns(pgrp, ns);
473 			put_pid(pgrp);
474 			tty_nr = new_encode_dev(tty_devnum(sig->tty));
475 		}
476 
477 		num_threads = get_nr_threads(task);
478 		collect_sigign_sigcatch(task, &sigign, &sigcatch);
479 
480 		cmin_flt = sig->cmin_flt;
481 		cmaj_flt = sig->cmaj_flt;
482 		cutime = sig->cutime;
483 		cstime = sig->cstime;
484 		cgtime = sig->cgtime;
485 		rsslim = ACCESS_ONCE(sig->rlim[RLIMIT_RSS].rlim_cur);
486 
487 		/* add up live thread stats at the group level */
488 		if (whole) {
489 			struct task_struct *t = task;
490 			do {
491 				min_flt += t->min_flt;
492 				maj_flt += t->maj_flt;
493 				gtime += task_gtime(t);
494 			} while_each_thread(task, t);
495 
496 			min_flt += sig->min_flt;
497 			maj_flt += sig->maj_flt;
498 			thread_group_cputime_adjusted(task, &utime, &stime);
499 			gtime += sig->gtime;
500 		}
501 
502 		sid = task_session_nr_ns(task, ns);
503 		ppid = task_tgid_nr_ns(task->real_parent, ns);
504 		pgid = task_pgrp_nr_ns(task, ns);
505 
506 		unlock_task_sighand(task, &flags);
507 	}
508 
509 	if (permitted && (!whole || num_threads < 2))
510 		wchan = get_wchan(task);
511 	if (!whole) {
512 		min_flt = task->min_flt;
513 		maj_flt = task->maj_flt;
514 		task_cputime_adjusted(task, &utime, &stime);
515 		gtime = task_gtime(task);
516 	}
517 
518 	/* scale priority and nice values from timeslices to -20..20 */
519 	/* to make it look like a "normal" Unix priority/nice value  */
520 	priority = task_prio(task);
521 	nice = task_nice(task);
522 
523 	/* convert nsec -> ticks */
524 	start_time = nsec_to_clock_t(task->real_start_time);
525 
526 	seq_printf(m, "%d (%s) %c", pid_nr_ns(pid, ns), tcomm, state);
527 	seq_put_decimal_ll(m, " ", ppid);
528 	seq_put_decimal_ll(m, " ", pgid);
529 	seq_put_decimal_ll(m, " ", sid);
530 	seq_put_decimal_ll(m, " ", tty_nr);
531 	seq_put_decimal_ll(m, " ", tty_pgrp);
532 	seq_put_decimal_ull(m, " ", task->flags);
533 	seq_put_decimal_ull(m, " ", min_flt);
534 	seq_put_decimal_ull(m, " ", cmin_flt);
535 	seq_put_decimal_ull(m, " ", maj_flt);
536 	seq_put_decimal_ull(m, " ", cmaj_flt);
537 	seq_put_decimal_ull(m, " ", nsec_to_clock_t(utime));
538 	seq_put_decimal_ull(m, " ", nsec_to_clock_t(stime));
539 	seq_put_decimal_ll(m, " ", nsec_to_clock_t(cutime));
540 	seq_put_decimal_ll(m, " ", nsec_to_clock_t(cstime));
541 	seq_put_decimal_ll(m, " ", priority);
542 	seq_put_decimal_ll(m, " ", nice);
543 	seq_put_decimal_ll(m, " ", num_threads);
544 	seq_put_decimal_ull(m, " ", 0);
545 	seq_put_decimal_ull(m, " ", start_time);
546 	seq_put_decimal_ull(m, " ", vsize);
547 	seq_put_decimal_ull(m, " ", mm ? get_mm_rss(mm) : 0);
548 	seq_put_decimal_ull(m, " ", rsslim);
549 	seq_put_decimal_ull(m, " ", mm ? (permitted ? mm->start_code : 1) : 0);
550 	seq_put_decimal_ull(m, " ", mm ? (permitted ? mm->end_code : 1) : 0);
551 	seq_put_decimal_ull(m, " ", (permitted && mm) ? mm->start_stack : 0);
552 	seq_put_decimal_ull(m, " ", esp);
553 	seq_put_decimal_ull(m, " ", eip);
554 	/* The signal information here is obsolete.
555 	 * It must be decimal for Linux 2.0 compatibility.
556 	 * Use /proc/#/status for real-time signals.
557 	 */
558 	seq_put_decimal_ull(m, " ", task->pending.signal.sig[0] & 0x7fffffffUL);
559 	seq_put_decimal_ull(m, " ", task->blocked.sig[0] & 0x7fffffffUL);
560 	seq_put_decimal_ull(m, " ", sigign.sig[0] & 0x7fffffffUL);
561 	seq_put_decimal_ull(m, " ", sigcatch.sig[0] & 0x7fffffffUL);
562 
563 	/*
564 	 * We used to output the absolute kernel address, but that's an
565 	 * information leak - so instead we show a 0/1 flag here, to signal
566 	 * to user-space whether there's a wchan field in /proc/PID/wchan.
567 	 *
568 	 * This works with older implementations of procps as well.
569 	 */
570 	if (wchan)
571 		seq_puts(m, " 1");
572 	else
573 		seq_puts(m, " 0");
574 
575 	seq_put_decimal_ull(m, " ", 0);
576 	seq_put_decimal_ull(m, " ", 0);
577 	seq_put_decimal_ll(m, " ", task->exit_signal);
578 	seq_put_decimal_ll(m, " ", task_cpu(task));
579 	seq_put_decimal_ull(m, " ", task->rt_priority);
580 	seq_put_decimal_ull(m, " ", task->policy);
581 	seq_put_decimal_ull(m, " ", delayacct_blkio_ticks(task));
582 	seq_put_decimal_ull(m, " ", nsec_to_clock_t(gtime));
583 	seq_put_decimal_ll(m, " ", nsec_to_clock_t(cgtime));
584 
585 	if (mm && permitted) {
586 		seq_put_decimal_ull(m, " ", mm->start_data);
587 		seq_put_decimal_ull(m, " ", mm->end_data);
588 		seq_put_decimal_ull(m, " ", mm->start_brk);
589 		seq_put_decimal_ull(m, " ", mm->arg_start);
590 		seq_put_decimal_ull(m, " ", mm->arg_end);
591 		seq_put_decimal_ull(m, " ", mm->env_start);
592 		seq_put_decimal_ull(m, " ", mm->env_end);
593 	} else
594 		seq_puts(m, " 0 0 0 0 0 0 0");
595 
596 	if (permitted)
597 		seq_put_decimal_ll(m, " ", task->exit_code);
598 	else
599 		seq_puts(m, " 0");
600 
601 	seq_putc(m, '\n');
602 	if (mm)
603 		mmput(mm);
604 	return 0;
605 }
606 
proc_tid_stat(struct seq_file * m,struct pid_namespace * ns,struct pid * pid,struct task_struct * task)607 int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
608 			struct pid *pid, struct task_struct *task)
609 {
610 	return do_task_stat(m, ns, pid, task, 0);
611 }
612 
proc_tgid_stat(struct seq_file * m,struct pid_namespace * ns,struct pid * pid,struct task_struct * task)613 int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
614 			struct pid *pid, struct task_struct *task)
615 {
616 	return do_task_stat(m, ns, pid, task, 1);
617 }
618 
proc_pid_statm(struct seq_file * m,struct pid_namespace * ns,struct pid * pid,struct task_struct * task)619 int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
620 			struct pid *pid, struct task_struct *task)
621 {
622 	unsigned long size = 0, resident = 0, shared = 0, text = 0, data = 0;
623 	struct mm_struct *mm = get_task_mm(task);
624 
625 	if (mm) {
626 		size = task_statm(mm, &shared, &text, &data, &resident);
627 		mmput(mm);
628 	}
629 	/*
630 	 * For quick read, open code by putting numbers directly
631 	 * expected format is
632 	 * seq_printf(m, "%lu %lu %lu %lu 0 %lu 0\n",
633 	 *               size, resident, shared, text, data);
634 	 */
635 	seq_put_decimal_ull(m, "", size);
636 	seq_put_decimal_ull(m, " ", resident);
637 	seq_put_decimal_ull(m, " ", shared);
638 	seq_put_decimal_ull(m, " ", text);
639 	seq_put_decimal_ull(m, " ", 0);
640 	seq_put_decimal_ull(m, " ", data);
641 	seq_put_decimal_ull(m, " ", 0);
642 	seq_putc(m, '\n');
643 
644 	return 0;
645 }
646 
647 #ifdef CONFIG_PROC_CHILDREN
648 static struct pid *
get_children_pid(struct inode * inode,struct pid * pid_prev,loff_t pos)649 get_children_pid(struct inode *inode, struct pid *pid_prev, loff_t pos)
650 {
651 	struct task_struct *start, *task;
652 	struct pid *pid = NULL;
653 
654 	read_lock(&tasklist_lock);
655 
656 	start = pid_task(proc_pid(inode), PIDTYPE_PID);
657 	if (!start)
658 		goto out;
659 
660 	/*
661 	 * Lets try to continue searching first, this gives
662 	 * us significant speedup on children-rich processes.
663 	 */
664 	if (pid_prev) {
665 		task = pid_task(pid_prev, PIDTYPE_PID);
666 		if (task && task->real_parent == start &&
667 		    !(list_empty(&task->sibling))) {
668 			if (list_is_last(&task->sibling, &start->children))
669 				goto out;
670 			task = list_first_entry(&task->sibling,
671 						struct task_struct, sibling);
672 			pid = get_pid(task_pid(task));
673 			goto out;
674 		}
675 	}
676 
677 	/*
678 	 * Slow search case.
679 	 *
680 	 * We might miss some children here if children
681 	 * are exited while we were not holding the lock,
682 	 * but it was never promised to be accurate that
683 	 * much.
684 	 *
685 	 * "Just suppose that the parent sleeps, but N children
686 	 *  exit after we printed their tids. Now the slow paths
687 	 *  skips N extra children, we miss N tasks." (c)
688 	 *
689 	 * So one need to stop or freeze the leader and all
690 	 * its children to get a precise result.
691 	 */
692 	list_for_each_entry(task, &start->children, sibling) {
693 		if (pos-- == 0) {
694 			pid = get_pid(task_pid(task));
695 			break;
696 		}
697 	}
698 
699 out:
700 	read_unlock(&tasklist_lock);
701 	return pid;
702 }
703 
children_seq_show(struct seq_file * seq,void * v)704 static int children_seq_show(struct seq_file *seq, void *v)
705 {
706 	struct inode *inode = seq->private;
707 	pid_t pid;
708 
709 	pid = pid_nr_ns(v, inode->i_sb->s_fs_info);
710 	seq_printf(seq, "%d ", pid);
711 
712 	return 0;
713 }
714 
children_seq_start(struct seq_file * seq,loff_t * pos)715 static void *children_seq_start(struct seq_file *seq, loff_t *pos)
716 {
717 	return get_children_pid(seq->private, NULL, *pos);
718 }
719 
children_seq_next(struct seq_file * seq,void * v,loff_t * pos)720 static void *children_seq_next(struct seq_file *seq, void *v, loff_t *pos)
721 {
722 	struct pid *pid;
723 
724 	pid = get_children_pid(seq->private, v, *pos + 1);
725 	put_pid(v);
726 
727 	++*pos;
728 	return pid;
729 }
730 
children_seq_stop(struct seq_file * seq,void * v)731 static void children_seq_stop(struct seq_file *seq, void *v)
732 {
733 	put_pid(v);
734 }
735 
736 static const struct seq_operations children_seq_ops = {
737 	.start	= children_seq_start,
738 	.next	= children_seq_next,
739 	.stop	= children_seq_stop,
740 	.show	= children_seq_show,
741 };
742 
children_seq_open(struct inode * inode,struct file * file)743 static int children_seq_open(struct inode *inode, struct file *file)
744 {
745 	struct seq_file *m;
746 	int ret;
747 
748 	ret = seq_open(file, &children_seq_ops);
749 	if (ret)
750 		return ret;
751 
752 	m = file->private_data;
753 	m->private = inode;
754 
755 	return ret;
756 }
757 
children_seq_release(struct inode * inode,struct file * file)758 int children_seq_release(struct inode *inode, struct file *file)
759 {
760 	seq_release(inode, file);
761 	return 0;
762 }
763 
764 const struct file_operations proc_tid_children_operations = {
765 	.open    = children_seq_open,
766 	.read    = seq_read,
767 	.llseek  = seq_lseek,
768 	.release = children_seq_release,
769 };
770 #endif /* CONFIG_PROC_CHILDREN */
771