xref: /openbmc/linux/fs/proc/array.c (revision f15cbe6f1a4b4d9df59142fc8e4abb973302cf44) 
1 /*
2  *  linux/fs/proc/array.c
3  *
4  *  Copyright (C) 1992  by Linus Torvalds
5  *  based on ideas by Darren Senn
6  *
7  * Fixes:
8  * Michael. K. Johnson: stat,statm extensions.
9  *                      <johnsonm@stolaf.edu>
10  *
11  * Pauline Middelink :  Made cmdline,envline only break at '\0's, to
12  *                      make sure SET_PROCTITLE works. Also removed
13  *                      bad '!' which forced address recalculation for
14  *                      EVERY character on the current page.
15  *                      <middelin@polyware.iaf.nl>
16  *
17  * Danny ter Haar    :	added cpuinfo
18  *			<dth@cistron.nl>
19  *
20  * Alessandro Rubini :  profile extension.
21  *                      <rubini@ipvvis.unipv.it>
22  *
23  * Jeff Tranter      :  added BogoMips field to cpuinfo
24  *                      <Jeff_Tranter@Mitel.COM>
25  *
26  * Bruno Haible      :  remove 4K limit for the maps file
27  *			<haible@ma2s2.mathematik.uni-karlsruhe.de>
28  *
29  * Yves Arrouye      :  remove removal of trailing spaces in get_array.
30  *			<Yves.Arrouye@marin.fdn.fr>
31  *
32  * Jerome Forissier  :  added per-CPU time information to /proc/stat
33  *                      and /proc/<pid>/cpu extension
34  *                      <forissier@isia.cma.fr>
35  *			- Incorporation and non-SMP safe operation
36  *			of forissier patch in 2.1.78 by
37  *			Hans Marcus <crowbar@concepts.nl>
38  *
39  * aeb@cwi.nl        :  /proc/partitions
40  *
41  *
42  * Alan Cox	     :  security fixes.
43  *			<Alan.Cox@linux.org>
44  *
45  * Al Viro           :  safe handling of mm_struct
46  *
47  * Gerhard Wichert   :  added BIGMEM support
48  * Siemens AG           <Gerhard.Wichert@pdb.siemens.de>
49  *
50  * Al Viro & Jeff Garzik :  moved most of the thing into base.c and
51  *			 :  proc_misc.c. The rest may eventually go into
52  *			 :  base.c too.
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/slab.h>
72 #include <linux/smp.h>
73 #include <linux/signal.h>
74 #include <linux/highmem.h>
75 #include <linux/file.h>
76 #include <linux/fdtable.h>
77 #include <linux/times.h>
78 #include <linux/cpuset.h>
79 #include <linux/rcupdate.h>
80 #include <linux/delayacct.h>
81 #include <linux/seq_file.h>
82 #include <linux/pid_namespace.h>
83 #include <linux/tracehook.h>
84 
85 #include <asm/pgtable.h>
86 #include <asm/processor.h>
87 #include "internal.h"
88 
89 /* Gcc optimizes away "strlen(x)" for constant x */
90 #define ADDBUF(buffer, string) \
91 do { memcpy(buffer, string, strlen(string)); \
92      buffer += strlen(string); } while (0)
93 
94 static inline void task_name(struct seq_file *m, struct task_struct *p)
95 {
96 	int i;
97 	char *buf, *end;
98 	char *name;
99 	char tcomm[sizeof(p->comm)];
100 
101 	get_task_comm(tcomm, p);
102 
103 	seq_printf(m, "Name:\t");
104 	end = m->buf + m->size;
105 	buf = m->buf + m->count;
106 	name = tcomm;
107 	i = sizeof(tcomm);
108 	while (i && (buf < end)) {
109 		unsigned char c = *name;
110 		name++;
111 		i--;
112 		*buf = c;
113 		if (!c)
114 			break;
115 		if (c == '\\') {
116 			buf++;
117 			if (buf < end)
118 				*buf++ = c;
119 			continue;
120 		}
121 		if (c == '\n') {
122 			*buf++ = '\\';
123 			if (buf < end)
124 				*buf++ = 'n';
125 			continue;
126 		}
127 		buf++;
128 	}
129 	m->count = buf - m->buf;
130 	seq_printf(m, "\n");
131 }
132 
133 /*
134  * The task state array is a strange "bitmap" of
135  * reasons to sleep. Thus "running" is zero, and
136  * you can test for combinations of others with
137  * simple bit tests.
138  */
139 static const char *task_state_array[] = {
140 	"R (running)",		/*  0 */
141 	"S (sleeping)",		/*  1 */
142 	"D (disk sleep)",	/*  2 */
143 	"T (stopped)",		/*  4 */
144 	"T (tracing stop)",	/*  8 */
145 	"Z (zombie)",		/* 16 */
146 	"X (dead)"		/* 32 */
147 };
148 
149 static 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 **p = &task_state_array[0];
153 
154 	while (state) {
155 		p++;
156 		state >>= 1;
157 	}
158 	return *p;
159 }
160 
161 static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
162 				struct pid *pid, struct task_struct *p)
163 {
164 	struct group_info *group_info;
165 	int g;
166 	struct fdtable *fdt = NULL;
167 	pid_t ppid, tpid;
168 
169 	rcu_read_lock();
170 	ppid = pid_alive(p) ?
171 		task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
172 	tpid = 0;
173 	if (pid_alive(p)) {
174 		struct task_struct *tracer = tracehook_tracer_task(p);
175 		if (tracer)
176 			tpid = task_pid_nr_ns(tracer, ns);
177 	}
178 	seq_printf(m,
179 		"State:\t%s\n"
180 		"Tgid:\t%d\n"
181 		"Pid:\t%d\n"
182 		"PPid:\t%d\n"
183 		"TracerPid:\t%d\n"
184 		"Uid:\t%d\t%d\t%d\t%d\n"
185 		"Gid:\t%d\t%d\t%d\t%d\n",
186 		get_task_state(p),
187 		task_tgid_nr_ns(p, ns),
188 		pid_nr_ns(pid, ns),
189 		ppid, tpid,
190 		p->uid, p->euid, p->suid, p->fsuid,
191 		p->gid, p->egid, p->sgid, p->fsgid);
192 
193 	task_lock(p);
194 	if (p->files)
195 		fdt = files_fdtable(p->files);
196 	seq_printf(m,
197 		"FDSize:\t%d\n"
198 		"Groups:\t",
199 		fdt ? fdt->max_fds : 0);
200 	rcu_read_unlock();
201 
202 	group_info = p->group_info;
203 	get_group_info(group_info);
204 	task_unlock(p);
205 
206 	for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)
207 		seq_printf(m, "%d ", GROUP_AT(group_info, g));
208 	put_group_info(group_info);
209 
210 	seq_printf(m, "\n");
211 }
212 
213 static void render_sigset_t(struct seq_file *m, const char *header,
214 				sigset_t *set)
215 {
216 	int i;
217 
218 	seq_printf(m, "%s", header);
219 
220 	i = _NSIG;
221 	do {
222 		int x = 0;
223 
224 		i -= 4;
225 		if (sigismember(set, i+1)) x |= 1;
226 		if (sigismember(set, i+2)) x |= 2;
227 		if (sigismember(set, i+3)) x |= 4;
228 		if (sigismember(set, i+4)) x |= 8;
229 		seq_printf(m, "%x", x);
230 	} while (i >= 4);
231 
232 	seq_printf(m, "\n");
233 }
234 
235 static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
236 				    sigset_t *catch)
237 {
238 	struct k_sigaction *k;
239 	int i;
240 
241 	k = p->sighand->action;
242 	for (i = 1; i <= _NSIG; ++i, ++k) {
243 		if (k->sa.sa_handler == SIG_IGN)
244 			sigaddset(ign, i);
245 		else if (k->sa.sa_handler != SIG_DFL)
246 			sigaddset(catch, i);
247 	}
248 }
249 
250 static inline void task_sig(struct seq_file *m, struct task_struct *p)
251 {
252 	unsigned long flags;
253 	sigset_t pending, shpending, blocked, ignored, caught;
254 	int num_threads = 0;
255 	unsigned long qsize = 0;
256 	unsigned long qlim = 0;
257 
258 	sigemptyset(&pending);
259 	sigemptyset(&shpending);
260 	sigemptyset(&blocked);
261 	sigemptyset(&ignored);
262 	sigemptyset(&caught);
263 
264 	rcu_read_lock();
265 	if (lock_task_sighand(p, &flags)) {
266 		pending = p->pending.signal;
267 		shpending = p->signal->shared_pending.signal;
268 		blocked = p->blocked;
269 		collect_sigign_sigcatch(p, &ignored, &caught);
270 		num_threads = atomic_read(&p->signal->count);
271 		qsize = atomic_read(&p->user->sigpending);
272 		qlim = p->signal->rlim[RLIMIT_SIGPENDING].rlim_cur;
273 		unlock_task_sighand(p, &flags);
274 	}
275 	rcu_read_unlock();
276 
277 	seq_printf(m, "Threads:\t%d\n", num_threads);
278 	seq_printf(m, "SigQ:\t%lu/%lu\n", qsize, qlim);
279 
280 	/* render them all */
281 	render_sigset_t(m, "SigPnd:\t", &pending);
282 	render_sigset_t(m, "ShdPnd:\t", &shpending);
283 	render_sigset_t(m, "SigBlk:\t", &blocked);
284 	render_sigset_t(m, "SigIgn:\t", &ignored);
285 	render_sigset_t(m, "SigCgt:\t", &caught);
286 }
287 
288 static void render_cap_t(struct seq_file *m, const char *header,
289 			kernel_cap_t *a)
290 {
291 	unsigned __capi;
292 
293 	seq_printf(m, "%s", header);
294 	CAP_FOR_EACH_U32(__capi) {
295 		seq_printf(m, "%08x",
296 			   a->cap[(_KERNEL_CAPABILITY_U32S-1) - __capi]);
297 	}
298 	seq_printf(m, "\n");
299 }
300 
301 static inline void task_cap(struct seq_file *m, struct task_struct *p)
302 {
303 	render_cap_t(m, "CapInh:\t", &p->cap_inheritable);
304 	render_cap_t(m, "CapPrm:\t", &p->cap_permitted);
305 	render_cap_t(m, "CapEff:\t", &p->cap_effective);
306 	render_cap_t(m, "CapBnd:\t", &p->cap_bset);
307 }
308 
309 static inline void task_context_switch_counts(struct seq_file *m,
310 						struct task_struct *p)
311 {
312 	seq_printf(m,	"voluntary_ctxt_switches:\t%lu\n"
313 			"nonvoluntary_ctxt_switches:\t%lu\n",
314 			p->nvcsw,
315 			p->nivcsw);
316 }
317 
318 int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
319 			struct pid *pid, struct task_struct *task)
320 {
321 	struct mm_struct *mm = get_task_mm(task);
322 
323 	task_name(m, task);
324 	task_state(m, ns, pid, task);
325 
326 	if (mm) {
327 		task_mem(m, mm);
328 		mmput(mm);
329 	}
330 	task_sig(m, task);
331 	task_cap(m, task);
332 	cpuset_task_status_allowed(m, task);
333 #if defined(CONFIG_S390)
334 	task_show_regs(m, task);
335 #endif
336 	task_context_switch_counts(m, task);
337 	return 0;
338 }
339 
340 /*
341  * Use precise platform statistics if available:
342  */
343 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
344 static cputime_t task_utime(struct task_struct *p)
345 {
346 	return p->utime;
347 }
348 
349 static cputime_t task_stime(struct task_struct *p)
350 {
351 	return p->stime;
352 }
353 #else
354 static cputime_t task_utime(struct task_struct *p)
355 {
356 	clock_t utime = cputime_to_clock_t(p->utime),
357 		total = utime + cputime_to_clock_t(p->stime);
358 	u64 temp;
359 
360 	/*
361 	 * Use CFS's precise accounting:
362 	 */
363 	temp = (u64)nsec_to_clock_t(p->se.sum_exec_runtime);
364 
365 	if (total) {
366 		temp *= utime;
367 		do_div(temp, total);
368 	}
369 	utime = (clock_t)temp;
370 
371 	p->prev_utime = max(p->prev_utime, clock_t_to_cputime(utime));
372 	return p->prev_utime;
373 }
374 
375 static cputime_t task_stime(struct task_struct *p)
376 {
377 	clock_t stime;
378 
379 	/*
380 	 * Use CFS's precise accounting. (we subtract utime from
381 	 * the total, to make sure the total observed by userspace
382 	 * grows monotonically - apps rely on that):
383 	 */
384 	stime = nsec_to_clock_t(p->se.sum_exec_runtime) -
385 			cputime_to_clock_t(task_utime(p));
386 
387 	if (stime >= 0)
388 		p->prev_stime = max(p->prev_stime, clock_t_to_cputime(stime));
389 
390 	return p->prev_stime;
391 }
392 #endif
393 
394 static cputime_t task_gtime(struct task_struct *p)
395 {
396 	return p->gtime;
397 }
398 
399 static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
400 			struct pid *pid, struct task_struct *task, int whole)
401 {
402 	unsigned long vsize, eip, esp, wchan = ~0UL;
403 	long priority, nice;
404 	int tty_pgrp = -1, tty_nr = 0;
405 	sigset_t sigign, sigcatch;
406 	char state;
407 	pid_t ppid = 0, pgid = -1, sid = -1;
408 	int num_threads = 0;
409 	struct mm_struct *mm;
410 	unsigned long long start_time;
411 	unsigned long cmin_flt = 0, cmaj_flt = 0;
412 	unsigned long  min_flt = 0,  maj_flt = 0;
413 	cputime_t cutime, cstime, utime, stime;
414 	cputime_t cgtime, gtime;
415 	unsigned long rsslim = 0;
416 	char tcomm[sizeof(task->comm)];
417 	unsigned long flags;
418 
419 	state = *get_task_state(task);
420 	vsize = eip = esp = 0;
421 	mm = get_task_mm(task);
422 	if (mm) {
423 		vsize = task_vsize(mm);
424 		eip = KSTK_EIP(task);
425 		esp = KSTK_ESP(task);
426 	}
427 
428 	get_task_comm(tcomm, task);
429 
430 	sigemptyset(&sigign);
431 	sigemptyset(&sigcatch);
432 	cutime = cstime = utime = stime = cputime_zero;
433 	cgtime = gtime = cputime_zero;
434 
435 	if (lock_task_sighand(task, &flags)) {
436 		struct signal_struct *sig = task->signal;
437 
438 		if (sig->tty) {
439 			struct pid *pgrp = tty_get_pgrp(sig->tty);
440 			tty_pgrp = pid_nr_ns(pgrp, ns);
441 			put_pid(pgrp);
442 			tty_nr = new_encode_dev(tty_devnum(sig->tty));
443 		}
444 
445 		num_threads = atomic_read(&sig->count);
446 		collect_sigign_sigcatch(task, &sigign, &sigcatch);
447 
448 		cmin_flt = sig->cmin_flt;
449 		cmaj_flt = sig->cmaj_flt;
450 		cutime = sig->cutime;
451 		cstime = sig->cstime;
452 		cgtime = sig->cgtime;
453 		rsslim = sig->rlim[RLIMIT_RSS].rlim_cur;
454 
455 		/* add up live thread stats at the group level */
456 		if (whole) {
457 			struct task_struct *t = task;
458 			do {
459 				min_flt += t->min_flt;
460 				maj_flt += t->maj_flt;
461 				utime = cputime_add(utime, task_utime(t));
462 				stime = cputime_add(stime, task_stime(t));
463 				gtime = cputime_add(gtime, task_gtime(t));
464 				t = next_thread(t);
465 			} while (t != task);
466 
467 			min_flt += sig->min_flt;
468 			maj_flt += sig->maj_flt;
469 			utime = cputime_add(utime, sig->utime);
470 			stime = cputime_add(stime, sig->stime);
471 			gtime = cputime_add(gtime, sig->gtime);
472 		}
473 
474 		sid = task_session_nr_ns(task, ns);
475 		ppid = task_tgid_nr_ns(task->real_parent, ns);
476 		pgid = task_pgrp_nr_ns(task, ns);
477 
478 		unlock_task_sighand(task, &flags);
479 	}
480 
481 	if (!whole || num_threads < 2)
482 		wchan = get_wchan(task);
483 	if (!whole) {
484 		min_flt = task->min_flt;
485 		maj_flt = task->maj_flt;
486 		utime = task_utime(task);
487 		stime = task_stime(task);
488 		gtime = task_gtime(task);
489 	}
490 
491 	/* scale priority and nice values from timeslices to -20..20 */
492 	/* to make it look like a "normal" Unix priority/nice value  */
493 	priority = task_prio(task);
494 	nice = task_nice(task);
495 
496 	/* Temporary variable needed for gcc-2.96 */
497 	/* convert timespec -> nsec*/
498 	start_time =
499 		(unsigned long long)task->real_start_time.tv_sec * NSEC_PER_SEC
500 				+ task->real_start_time.tv_nsec;
501 	/* convert nsec -> ticks */
502 	start_time = nsec_to_clock_t(start_time);
503 
504 	seq_printf(m, "%d (%s) %c %d %d %d %d %d %u %lu \
505 %lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
506 %lu %lu %lu %lu %lu %lu %lu %lu %d %d %u %u %llu %lu %ld\n",
507 		pid_nr_ns(pid, ns),
508 		tcomm,
509 		state,
510 		ppid,
511 		pgid,
512 		sid,
513 		tty_nr,
514 		tty_pgrp,
515 		task->flags,
516 		min_flt,
517 		cmin_flt,
518 		maj_flt,
519 		cmaj_flt,
520 		cputime_to_clock_t(utime),
521 		cputime_to_clock_t(stime),
522 		cputime_to_clock_t(cutime),
523 		cputime_to_clock_t(cstime),
524 		priority,
525 		nice,
526 		num_threads,
527 		start_time,
528 		vsize,
529 		mm ? get_mm_rss(mm) : 0,
530 		rsslim,
531 		mm ? mm->start_code : 0,
532 		mm ? mm->end_code : 0,
533 		mm ? mm->start_stack : 0,
534 		esp,
535 		eip,
536 		/* The signal information here is obsolete.
537 		 * It must be decimal for Linux 2.0 compatibility.
538 		 * Use /proc/#/status for real-time signals.
539 		 */
540 		task->pending.signal.sig[0] & 0x7fffffffUL,
541 		task->blocked.sig[0] & 0x7fffffffUL,
542 		sigign      .sig[0] & 0x7fffffffUL,
543 		sigcatch    .sig[0] & 0x7fffffffUL,
544 		wchan,
545 		0UL,
546 		0UL,
547 		task->exit_signal,
548 		task_cpu(task),
549 		task->rt_priority,
550 		task->policy,
551 		(unsigned long long)delayacct_blkio_ticks(task),
552 		cputime_to_clock_t(gtime),
553 		cputime_to_clock_t(cgtime));
554 	if (mm)
555 		mmput(mm);
556 	return 0;
557 }
558 
559 int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
560 			struct pid *pid, struct task_struct *task)
561 {
562 	return do_task_stat(m, ns, pid, task, 0);
563 }
564 
565 int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
566 			struct pid *pid, struct task_struct *task)
567 {
568 	return do_task_stat(m, ns, pid, task, 1);
569 }
570 
571 int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
572 			struct pid *pid, struct task_struct *task)
573 {
574 	int size = 0, resident = 0, shared = 0, text = 0, lib = 0, data = 0;
575 	struct mm_struct *mm = get_task_mm(task);
576 
577 	if (mm) {
578 		size = task_statm(mm, &shared, &text, &data, &resident);
579 		mmput(mm);
580 	}
581 	seq_printf(m, "%d %d %d %d %d %d %d\n",
582 			size, resident, shared, text, lib, data, 0);
583 
584 	return 0;
585 }
586