blob: ae2c807fd719540312d18a94c7676ceb51b10f12 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
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.
Alan Cox526719b2008-10-27 15:19:48 +000044 * <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#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>
Ingo Molnar6e84f312017-02-08 18:51:29 +010064#include <linux/sched/mm.h>
Ingo Molnar6a3827d2017-02-08 18:51:31 +010065#include <linux/sched/numa_balancing.h>
John Ognessfd7d5622017-09-14 11:42:17 +020066#include <linux/sched/task_stack.h>
Ingo Molnar29930022017-02-08 18:51:36 +010067#include <linux/sched/task.h>
Ingo Molnar32ef5512017-02-05 11:48:36 +010068#include <linux/sched/cputime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/proc_fs.h>
70#include <linux/ioport.h>
Ingo Molnar8ea02602007-07-16 09:46:31 +020071#include <linux/uaccess.h>
72#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#include <linux/mm.h>
74#include <linux/hugetlb.h>
75#include <linux/pagemap.h>
76#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070077#include <linux/smp.h>
78#include <linux/signal.h>
79#include <linux/highmem.h>
80#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040081#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#include <linux/times.h>
83#include <linux/cpuset.h>
Dipankar Sarma4fb3a532005-09-16 19:28:13 -070084#include <linux/rcupdate.h>
Shailabh Nagar25890452006-07-14 00:24:43 -070085#include <linux/delayacct.h>
Eric W. Biedermanee992742008-02-08 04:18:31 -080086#include <linux/seq_file.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -070087#include <linux/pid_namespace.h>
Jake Edgef83ce3e2009-05-04 12:51:14 -060088#include <linux/ptrace.h>
Roland McGrath0d094ef2008-07-25 19:45:49 -070089#include <linux/tracehook.h>
Andy Shevchenkoedc924e2015-02-12 15:01:11 -080090#include <linux/string_helpers.h>
Eric W. Biedermanae2975b2011-11-14 15:56:38 -080091#include <linux/user_namespace.h>
Richard W.M. Jones3e429792016-05-20 17:00:05 -070092#include <linux/fs_struct.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#include <asm/pgtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#include <asm/processor.h>
96#include "internal.h"
97
Eric W. Biedermandf5f8312008-02-08 04:18:33 -080098static inline void task_name(struct seq_file *m, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099{
Andy Shevchenkoedc924e2015-02-12 15:01:11 -0800100 char *buf;
Andy Shevchenko3a49f3d2015-11-06 16:30:03 -0800101 size_t size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 char tcomm[sizeof(p->comm)];
Andy Shevchenko3a49f3d2015-11-06 16:30:03 -0800103 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
105 get_task_comm(tcomm, p);
106
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800107 seq_puts(m, "Name:\t");
Andy Shevchenkoedc924e2015-02-12 15:01:11 -0800108
Andy Shevchenko3a49f3d2015-11-06 16:30:03 -0800109 size = seq_get_buf(m, &buf);
110 ret = string_escape_str(tcomm, buf, size, ESCAPE_SPACE | ESCAPE_SPECIAL, "\n\\");
111 seq_commit(m, ret < size ? ret : -1);
Andy Shevchenkoedc924e2015-02-12 15:01:11 -0800112
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800113 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
116/*
117 * The task state array is a strange "bitmap" of
118 * reasons to sleep. Thus "running" is zero, and
119 * you can test for combinations of others with
120 * simple bit tests.
121 */
Mike Frysingere130aa72011-05-26 16:25:51 -0700122static const char * const task_state_array[] = {
Peter Zijlstra06eb6182017-09-22 18:30:40 +0200123
124 /* states in TASK_REPORT: */
125 "R (running)", /* 0x00 */
126 "S (sleeping)", /* 0x01 */
127 "D (disk sleep)", /* 0x02 */
128 "T (stopped)", /* 0x04 */
129 "t (tracing stop)", /* 0x08 */
130 "X (dead)", /* 0x10 */
131 "Z (zombie)", /* 0x20 */
Peter Zijlstra8ef99252017-09-22 18:37:28 +0200132 "P (parked)", /* 0x40 */
Peter Zijlstra06eb6182017-09-22 18:30:40 +0200133
134 /* states beyond TASK_REPORT: */
Peter Zijlstra8ef99252017-09-22 18:37:28 +0200135 "I (idle)", /* 0x80 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136};
137
Ingo Molnar8ea02602007-07-16 09:46:31 +0200138static inline const char *get_task_state(struct task_struct *tsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139{
Peter Zijlstra06eb6182017-09-22 18:30:40 +0200140 BUILD_BUG_ON(1 + ilog2(TASK_REPORT_MAX) != ARRAY_SIZE(task_state_array));
Peter Zijlstra1d48b082017-09-29 13:50:16 +0200141 return task_state_array[task_state_index(tsk)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142}
143
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800144static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
145 struct pid *pid, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
Eric W. Biedermane9f238c2012-08-11 12:38:26 -0700147 struct user_namespace *user_ns = seq_user_ns(m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 struct group_info *group_info;
Mateusz Guzik68c34112018-04-10 16:30:51 -0700149 int g, umask = -1;
Oleg Nesterovabdba6e2014-12-10 15:45:18 -0800150 struct task_struct *tracer;
David Howellsc69e8d92008-11-14 10:39:19 +1100151 const struct cred *cred;
Oleg Nesterovabdba6e2014-12-10 15:45:18 -0800152 pid_t ppid, tpid = 0, tgid, ngid;
Oleg Nesterov0f4a0d52014-12-10 15:45:12 -0800153 unsigned int max_fds = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Oleg Nesterovb0fa9db2006-10-02 02:18:54 -0700155 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700156 ppid = pid_alive(p) ?
157 task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
Oleg Nesterovabdba6e2014-12-10 15:45:18 -0800158
159 tracer = ptrace_parent(p);
160 if (tracer)
161 tpid = task_pid_nr_ns(tracer, ns);
Oleg Nesterovb0fafc12014-12-10 15:45:15 -0800162
163 tgid = task_tgid_nr_ns(p, ns);
164 ngid = task_numa_group_id(p);
David Howellsde09a972010-07-29 12:45:49 +0100165 cred = get_task_cred(p);
Oleg Nesterov0f4a0d52014-12-10 15:45:12 -0800166
167 task_lock(p);
Mateusz Guzik68c34112018-04-10 16:30:51 -0700168 if (p->fs)
169 umask = p->fs->umask;
Oleg Nesterov0f4a0d52014-12-10 15:45:12 -0800170 if (p->files)
171 max_fds = files_fdtable(p->files)->max_fds;
172 task_unlock(p);
Oleg Nesterovb0fafc12014-12-10 15:45:15 -0800173 rcu_read_unlock();
Oleg Nesterov0f4a0d52014-12-10 15:45:12 -0800174
Mateusz Guzik68c34112018-04-10 16:30:51 -0700175 if (umask >= 0)
176 seq_printf(m, "Umask:\t%#04o\n", umask);
Andrei Vagind0f02232018-04-10 16:31:26 -0700177 seq_puts(m, "State:\t");
178 seq_puts(m, get_task_state(p));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
Joe Perches75ba1d02016-10-07 17:02:20 -0700180 seq_put_decimal_ull(m, "\nTgid:\t", tgid);
181 seq_put_decimal_ull(m, "\nNgid:\t", ngid);
182 seq_put_decimal_ull(m, "\nPid:\t", pid_nr_ns(pid, ns));
183 seq_put_decimal_ull(m, "\nPPid:\t", ppid);
184 seq_put_decimal_ull(m, "\nTracerPid:\t", tpid);
185 seq_put_decimal_ull(m, "\nUid:\t", from_kuid_munged(user_ns, cred->uid));
186 seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->euid));
187 seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->suid));
188 seq_put_decimal_ull(m, "\t", from_kuid_munged(user_ns, cred->fsuid));
189 seq_put_decimal_ull(m, "\nGid:\t", from_kgid_munged(user_ns, cred->gid));
190 seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->egid));
191 seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->sgid));
192 seq_put_decimal_ull(m, "\t", from_kgid_munged(user_ns, cred->fsgid));
193 seq_put_decimal_ull(m, "\nFDSize:\t", max_fds);
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700194
195 seq_puts(m, "\nGroups:\t");
David Howellsc69e8d92008-11-14 10:39:19 +1100196 group_info = cred->group_info;
Artem Bityutskiy8d238022012-12-17 16:03:17 -0800197 for (g = 0; g < group_info->ngroups; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700198 seq_put_decimal_ull(m, g ? " " : "",
Alexey Dobriyan81243ea2016-10-07 17:03:12 -0700199 from_kgid_munged(user_ns, group_info->gid[g]));
David Howellsc69e8d92008-11-14 10:39:19 +1100200 put_cred(cred);
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700201 /* Trailing space shouldn't have been added in the first place. */
202 seq_putc(m, ' ');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700204#ifdef CONFIG_PID_NS
205 seq_puts(m, "\nNStgid:");
206 for (g = ns->level; g <= pid->level; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700207 seq_put_decimal_ull(m, "\t", task_tgid_nr_ns(p, pid->numbers[g].ns));
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700208 seq_puts(m, "\nNSpid:");
209 for (g = ns->level; g <= pid->level; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700210 seq_put_decimal_ull(m, "\t", task_pid_nr_ns(p, pid->numbers[g].ns));
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700211 seq_puts(m, "\nNSpgid:");
212 for (g = ns->level; g <= pid->level; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700213 seq_put_decimal_ull(m, "\t", task_pgrp_nr_ns(p, pid->numbers[g].ns));
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700214 seq_puts(m, "\nNSsid:");
215 for (g = ns->level; g <= pid->level; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700216 seq_put_decimal_ull(m, "\t", task_session_nr_ns(p, pid->numbers[g].ns));
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700217#endif
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800218 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219}
220
Cyrill Gorcunov138d22b2012-12-17 16:05:02 -0800221void render_sigset_t(struct seq_file *m, const char *header,
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800222 sigset_t *set)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223{
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800224 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800226 seq_puts(m, header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228 i = _NSIG;
229 do {
230 int x = 0;
231
232 i -= 4;
233 if (sigismember(set, i+1)) x |= 1;
234 if (sigismember(set, i+2)) x |= 2;
235 if (sigismember(set, i+3)) x |= 4;
236 if (sigismember(set, i+4)) x |= 8;
Rasmus Villemoes209b14d2016-12-12 16:45:25 -0800237 seq_putc(m, hex_asc[x]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 } while (i >= 4);
239
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800240 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241}
242
243static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
244 sigset_t *catch)
245{
246 struct k_sigaction *k;
247 int i;
248
249 k = p->sighand->action;
250 for (i = 1; i <= _NSIG; ++i, ++k) {
251 if (k->sa.sa_handler == SIG_IGN)
252 sigaddset(ign, i);
253 else if (k->sa.sa_handler != SIG_DFL)
254 sigaddset(catch, i);
255 }
256}
257
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800258static inline void task_sig(struct seq_file *m, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259{
Oleg Nesterov5e6b3f42006-10-02 02:18:52 -0700260 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 sigset_t pending, shpending, blocked, ignored, caught;
262 int num_threads = 0;
263 unsigned long qsize = 0;
264 unsigned long qlim = 0;
265
266 sigemptyset(&pending);
267 sigemptyset(&shpending);
268 sigemptyset(&blocked);
269 sigemptyset(&ignored);
270 sigemptyset(&caught);
271
Oleg Nesterov5e6b3f42006-10-02 02:18:52 -0700272 if (lock_task_sighand(p, &flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 pending = p->pending.signal;
274 shpending = p->signal->shared_pending.signal;
275 blocked = p->blocked;
276 collect_sigign_sigcatch(p, &ignored, &caught);
Oleg Nesterov7e498272010-05-26 14:43:22 -0700277 num_threads = get_nr_threads(p);
Paul E. McKenney7dc52152010-02-22 17:04:52 -0800278 rcu_read_lock(); /* FIXME: is this correct? */
David Howellsc69e8d92008-11-14 10:39:19 +1100279 qsize = atomic_read(&__task_cred(p)->user->sigpending);
Paul E. McKenney7dc52152010-02-22 17:04:52 -0800280 rcu_read_unlock();
Jiri Slabyd554ed892010-03-05 13:42:42 -0800281 qlim = task_rlimit(p, RLIMIT_SIGPENDING);
Oleg Nesterov5e6b3f42006-10-02 02:18:52 -0700282 unlock_task_sighand(p, &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Joe Perches75ba1d02016-10-07 17:02:20 -0700285 seq_put_decimal_ull(m, "Threads:\t", num_threads);
286 seq_put_decimal_ull(m, "\nSigQ:\t", qsize);
287 seq_put_decimal_ull(m, "/", qlim);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 /* render them all */
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700290 render_sigset_t(m, "\nSigPnd:\t", &pending);
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800291 render_sigset_t(m, "ShdPnd:\t", &shpending);
292 render_sigset_t(m, "SigBlk:\t", &blocked);
293 render_sigset_t(m, "SigIgn:\t", &ignored);
294 render_sigset_t(m, "SigCgt:\t", &caught);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800297static void render_cap_t(struct seq_file *m, const char *header,
298 kernel_cap_t *a)
Andrew Morgane338d262008-02-04 22:29:42 -0800299{
300 unsigned __capi;
301
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800302 seq_puts(m, header);
Andrew Morgane338d262008-02-04 22:29:42 -0800303 CAP_FOR_EACH_U32(__capi) {
Andrei Vagind0f02232018-04-10 16:31:26 -0700304 seq_put_hex_ll(m, NULL,
305 a->cap[CAP_LAST_U32 - __capi], 8);
Andrew Morgane338d262008-02-04 22:29:42 -0800306 }
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800307 seq_putc(m, '\n');
Andrew Morgane338d262008-02-04 22:29:42 -0800308}
309
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800310static inline void task_cap(struct seq_file *m, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
David Howellsc69e8d92008-11-14 10:39:19 +1100312 const struct cred *cred;
Andy Lutomirski58319052015-09-04 15:42:45 -0700313 kernel_cap_t cap_inheritable, cap_permitted, cap_effective,
314 cap_bset, cap_ambient;
David Howellsb6dff3e2008-11-14 10:39:16 +1100315
David Howellsc69e8d92008-11-14 10:39:19 +1100316 rcu_read_lock();
317 cred = __task_cred(p);
318 cap_inheritable = cred->cap_inheritable;
319 cap_permitted = cred->cap_permitted;
320 cap_effective = cred->cap_effective;
321 cap_bset = cred->cap_bset;
Andy Lutomirski58319052015-09-04 15:42:45 -0700322 cap_ambient = cred->cap_ambient;
David Howellsc69e8d92008-11-14 10:39:19 +1100323 rcu_read_unlock();
324
325 render_cap_t(m, "CapInh:\t", &cap_inheritable);
326 render_cap_t(m, "CapPrm:\t", &cap_permitted);
327 render_cap_t(m, "CapEff:\t", &cap_effective);
328 render_cap_t(m, "CapBnd:\t", &cap_bset);
Andy Lutomirski58319052015-09-04 15:42:45 -0700329 render_cap_t(m, "CapAmb:\t", &cap_ambient);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330}
331
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800332static inline void task_seccomp(struct seq_file *m, struct task_struct *p)
333{
Kees Cookaf884cd2016-12-12 16:45:05 -0800334 seq_put_decimal_ull(m, "NoNewPrivs:\t", task_no_new_privs(p));
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800335#ifdef CONFIG_SECCOMP
Kees Cookaf884cd2016-12-12 16:45:05 -0800336 seq_put_decimal_ull(m, "\nSeccomp:\t", p->seccomp.mode);
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800337#endif
Kees Cookaf884cd2016-12-12 16:45:05 -0800338 seq_putc(m, '\n');
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800339}
340
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800341static inline void task_context_switch_counts(struct seq_file *m,
342 struct task_struct *p)
Maxim Uvarovb663a792007-07-15 23:40:48 -0700343{
Joe Perches75ba1d02016-10-07 17:02:20 -0700344 seq_put_decimal_ull(m, "voluntary_ctxt_switches:\t", p->nvcsw);
345 seq_put_decimal_ull(m, "\nnonvoluntary_ctxt_switches:\t", p->nivcsw);
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700346 seq_putc(m, '\n');
Maxim Uvarovb663a792007-07-15 23:40:48 -0700347}
348
Heiko Carstensd01d4822009-09-21 11:06:27 +0200349static void task_cpus_allowed(struct seq_file *m, struct task_struct *task)
350{
Tejun Heoa0c2e072015-02-13 14:38:07 -0800351 seq_printf(m, "Cpus_allowed:\t%*pb\n",
352 cpumask_pr_args(&task->cpus_allowed));
353 seq_printf(m, "Cpus_allowed_list:\t%*pbl\n",
354 cpumask_pr_args(&task->cpus_allowed));
Heiko Carstensd01d4822009-09-21 11:06:27 +0200355}
356
Roman Gushchinc6434012017-11-17 15:26:45 -0800357static inline void task_core_dumping(struct seq_file *m, struct mm_struct *mm)
358{
Andrei Vagind0f02232018-04-10 16:31:26 -0700359 seq_put_decimal_ull(m, "CoreDumping:\t", !!mm->core_state);
360 seq_putc(m, '\n');
Roman Gushchinc6434012017-11-17 15:26:45 -0800361}
362
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800363int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
364 struct pid *pid, struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 struct mm_struct *mm = get_task_mm(task);
367
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800368 task_name(m, task);
369 task_state(m, ns, pid, task);
Ingo Molnar8ea02602007-07-16 09:46:31 +0200370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 if (mm) {
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800372 task_mem(m, mm);
Roman Gushchinc6434012017-11-17 15:26:45 -0800373 task_core_dumping(m, mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 mmput(mm);
375 }
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800376 task_sig(m, task);
377 task_cap(m, task);
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800378 task_seccomp(m, task);
Heiko Carstensd01d4822009-09-21 11:06:27 +0200379 task_cpus_allowed(m, task);
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800380 cpuset_task_status_allowed(m, task);
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800381 task_context_switch_counts(m, task);
382 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383}
384
Eric W. Biedermanee992742008-02-08 04:18:31 -0800385static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
386 struct pid *pid, struct task_struct *task, int whole)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
Ingo Molnarb2f73922015-09-30 15:59:17 +0200388 unsigned long vsize, eip, esp, wchan = 0;
Jan Engelhardt715be1f2012-05-31 16:26:19 -0700389 int priority, nice;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 int tty_pgrp = -1, tty_nr = 0;
391 sigset_t sigign, sigcatch;
392 char state;
Ingo Molnar8ea02602007-07-16 09:46:31 +0200393 pid_t ppid = 0, pgid = -1, sid = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 int num_threads = 0;
Jake Edgef83ce3e2009-05-04 12:51:14 -0600395 int permitted;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 struct mm_struct *mm;
397 unsigned long long start_time;
398 unsigned long cmin_flt = 0, cmaj_flt = 0;
399 unsigned long min_flt = 0, maj_flt = 0;
Frederic Weisbecker5613fda2017-01-31 04:09:23 +0100400 u64 cutime, cstime, utime, stime;
Frederic Weisbecker16a6d9b2017-01-31 04:09:21 +0100401 u64 cgtime, gtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 unsigned long rsslim = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 char tcomm[sizeof(task->comm)];
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700404 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406 state = *get_task_state(task);
407 vsize = eip = esp = 0;
Jann Horncaaee622016-01-20 15:00:04 -0800408 permitted = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS | PTRACE_MODE_NOAUDIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 mm = get_task_mm(task);
410 if (mm) {
411 vsize = task_vsize(mm);
Andy Lutomirski0a1eb2d2016-09-30 10:58:56 -0700412 /*
413 * esp and eip are intentionally zeroed out. There is no
414 * non-racy way to read them without freezing the task.
415 * Programs that need reliable values can use ptrace(2).
John Ognessfd7d5622017-09-14 11:42:17 +0200416 *
417 * The only exception is if the task is core dumping because
418 * a program is not able to use ptrace(2) in that case. It is
419 * safe because the task has stopped executing permanently.
Andy Lutomirski0a1eb2d2016-09-30 10:58:56 -0700420 */
John Ognessfd7d5622017-09-14 11:42:17 +0200421 if (permitted && (task->flags & PF_DUMPCORE)) {
Alexey Dobriyan8bb2ee12018-01-18 16:34:05 -0800422 if (try_get_task_stack(task)) {
423 eip = KSTK_EIP(task);
424 esp = KSTK_ESP(task);
425 put_task_stack(task);
426 }
John Ognessfd7d5622017-09-14 11:42:17 +0200427 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 }
429
430 get_task_comm(tcomm, task);
431
432 sigemptyset(&sigign);
433 sigemptyset(&sigcatch);
Martin Schwidefsky64861632011-12-15 14:56:09 +0100434 cutime = cstime = utime = stime = 0;
435 cgtime = gtime = 0;
Alan Cox3cfd0882006-09-29 02:00:41 -0700436
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700437 if (lock_task_sighand(task, &flags)) {
438 struct signal_struct *sig = task->signal;
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700439
Oleg Nesterov91593502006-12-08 02:36:07 -0800440 if (sig->tty) {
Alan Cox5d0fdf12008-04-30 00:53:31 -0700441 struct pid *pgrp = tty_get_pgrp(sig->tty);
442 tty_pgrp = pid_nr_ns(pgrp, ns);
443 put_pid(pgrp);
Oleg Nesterov91593502006-12-08 02:36:07 -0800444 tty_nr = new_encode_dev(tty_devnum(sig->tty));
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700445 }
446
Oleg Nesterov7e498272010-05-26 14:43:22 -0700447 num_threads = get_nr_threads(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 collect_sigign_sigcatch(task, &sigign, &sigcatch);
449
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700450 cmin_flt = sig->cmin_flt;
451 cmaj_flt = sig->cmaj_flt;
452 cutime = sig->cutime;
453 cstime = sig->cstime;
Laurent Vivier9ac52312007-10-15 17:00:19 +0200454 cgtime = sig->cgtime;
Mark Rutland6aa7de02017-10-23 14:07:29 -0700455 rsslim = READ_ONCE(sig->rlim[RLIMIT_RSS].rlim_cur);
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 /* add up live thread stats at the group level */
458 if (whole) {
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700459 struct task_struct *t = task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 do {
461 min_flt += t->min_flt;
462 maj_flt += t->maj_flt;
Frederic Weisbecker6fac4822012-11-13 14:20:55 +0100463 gtime += task_gtime(t);
Oleg Nesterov185ee402014-01-23 15:55:53 -0800464 } while_each_thread(task, t);
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700465
466 min_flt += sig->min_flt;
467 maj_flt += sig->maj_flt;
Frederic Weisbeckere80d0a1a2012-11-21 16:26:44 +0100468 thread_group_cputime_adjusted(task, &utime, &stime);
Martin Schwidefsky64861632011-12-15 14:56:09 +0100469 gtime += sig->gtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
471
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700472 sid = task_session_nr_ns(task, ns);
Oleg Nesterova98fdce2008-01-15 00:02:37 +0300473 ppid = task_tgid_nr_ns(task->real_parent, ns);
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700474 pgid = task_pgrp_nr_ns(task, ns);
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700475
476 unlock_task_sighand(task, &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Jake Edgef83ce3e2009-05-04 12:51:14 -0600479 if (permitted && (!whole || num_threads < 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 wchan = get_wchan(task);
481 if (!whole) {
482 min_flt = task->min_flt;
483 maj_flt = task->maj_flt;
Frederic Weisbeckere80d0a1a2012-11-21 16:26:44 +0100484 task_cputime_adjusted(task, &utime, &stime);
Frederic Weisbecker6fac4822012-11-13 14:20:55 +0100485 gtime = task_gtime(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 }
487
488 /* scale priority and nice values from timeslices to -20..20 */
489 /* to make it look like a "normal" Unix priority/nice value */
490 priority = task_prio(task);
491 nice = task_nice(task);
492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 /* convert nsec -> ticks */
Thomas Gleixner57e0be02014-07-16 21:04:32 +0000494 start_time = nsec_to_clock_t(task->real_start_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
Andrei Vagind0f02232018-04-10 16:31:26 -0700496 seq_put_decimal_ull(m, "", pid_nr_ns(pid, ns));
497 seq_puts(m, " (");
498 seq_puts(m, tcomm);
499 seq_puts(m, ") ");
500 seq_putc(m, state);
Joe Perches75ba1d02016-10-07 17:02:20 -0700501 seq_put_decimal_ll(m, " ", ppid);
502 seq_put_decimal_ll(m, " ", pgid);
503 seq_put_decimal_ll(m, " ", sid);
504 seq_put_decimal_ll(m, " ", tty_nr);
505 seq_put_decimal_ll(m, " ", tty_pgrp);
506 seq_put_decimal_ull(m, " ", task->flags);
507 seq_put_decimal_ull(m, " ", min_flt);
508 seq_put_decimal_ull(m, " ", cmin_flt);
509 seq_put_decimal_ull(m, " ", maj_flt);
510 seq_put_decimal_ull(m, " ", cmaj_flt);
Frederic Weisbecker5613fda2017-01-31 04:09:23 +0100511 seq_put_decimal_ull(m, " ", nsec_to_clock_t(utime));
512 seq_put_decimal_ull(m, " ", nsec_to_clock_t(stime));
513 seq_put_decimal_ll(m, " ", nsec_to_clock_t(cutime));
514 seq_put_decimal_ll(m, " ", nsec_to_clock_t(cstime));
Joe Perches75ba1d02016-10-07 17:02:20 -0700515 seq_put_decimal_ll(m, " ", priority);
516 seq_put_decimal_ll(m, " ", nice);
517 seq_put_decimal_ll(m, " ", num_threads);
518 seq_put_decimal_ull(m, " ", 0);
519 seq_put_decimal_ull(m, " ", start_time);
520 seq_put_decimal_ull(m, " ", vsize);
521 seq_put_decimal_ull(m, " ", mm ? get_mm_rss(mm) : 0);
522 seq_put_decimal_ull(m, " ", rsslim);
523 seq_put_decimal_ull(m, " ", mm ? (permitted ? mm->start_code : 1) : 0);
524 seq_put_decimal_ull(m, " ", mm ? (permitted ? mm->end_code : 1) : 0);
525 seq_put_decimal_ull(m, " ", (permitted && mm) ? mm->start_stack : 0);
526 seq_put_decimal_ull(m, " ", esp);
527 seq_put_decimal_ull(m, " ", eip);
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700528 /* The signal information here is obsolete.
529 * It must be decimal for Linux 2.0 compatibility.
530 * Use /proc/#/status for real-time signals.
531 */
Joe Perches75ba1d02016-10-07 17:02:20 -0700532 seq_put_decimal_ull(m, " ", task->pending.signal.sig[0] & 0x7fffffffUL);
533 seq_put_decimal_ull(m, " ", task->blocked.sig[0] & 0x7fffffffUL);
534 seq_put_decimal_ull(m, " ", sigign.sig[0] & 0x7fffffffUL);
535 seq_put_decimal_ull(m, " ", sigcatch.sig[0] & 0x7fffffffUL);
Ingo Molnarb2f73922015-09-30 15:59:17 +0200536
537 /*
538 * We used to output the absolute kernel address, but that's an
539 * information leak - so instead we show a 0/1 flag here, to signal
540 * to user-space whether there's a wchan field in /proc/PID/wchan.
541 *
542 * This works with older implementations of procps as well.
543 */
544 if (wchan)
545 seq_puts(m, " 1");
546 else
547 seq_puts(m, " 0");
548
Joe Perches75ba1d02016-10-07 17:02:20 -0700549 seq_put_decimal_ull(m, " ", 0);
550 seq_put_decimal_ull(m, " ", 0);
551 seq_put_decimal_ll(m, " ", task->exit_signal);
552 seq_put_decimal_ll(m, " ", task_cpu(task));
553 seq_put_decimal_ull(m, " ", task->rt_priority);
554 seq_put_decimal_ull(m, " ", task->policy);
555 seq_put_decimal_ull(m, " ", delayacct_blkio_ticks(task));
Frederic Weisbecker16a6d9b2017-01-31 04:09:21 +0100556 seq_put_decimal_ull(m, " ", nsec_to_clock_t(gtime));
557 seq_put_decimal_ll(m, " ", nsec_to_clock_t(cgtime));
Cyrill Gorcunov5b172082012-05-31 16:26:44 -0700558
559 if (mm && permitted) {
Joe Perches75ba1d02016-10-07 17:02:20 -0700560 seq_put_decimal_ull(m, " ", mm->start_data);
561 seq_put_decimal_ull(m, " ", mm->end_data);
562 seq_put_decimal_ull(m, " ", mm->start_brk);
563 seq_put_decimal_ull(m, " ", mm->arg_start);
564 seq_put_decimal_ull(m, " ", mm->arg_end);
565 seq_put_decimal_ull(m, " ", mm->env_start);
566 seq_put_decimal_ull(m, " ", mm->env_end);
Cyrill Gorcunov5b172082012-05-31 16:26:44 -0700567 } else
Joe Perches75ba1d02016-10-07 17:02:20 -0700568 seq_puts(m, " 0 0 0 0 0 0 0");
Cyrill Gorcunov5b172082012-05-31 16:26:44 -0700569
570 if (permitted)
Joe Perches75ba1d02016-10-07 17:02:20 -0700571 seq_put_decimal_ll(m, " ", task->exit_code);
Cyrill Gorcunov5b172082012-05-31 16:26:44 -0700572 else
Joe Perches75ba1d02016-10-07 17:02:20 -0700573 seq_puts(m, " 0");
Cyrill Gorcunov5b172082012-05-31 16:26:44 -0700574
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700575 seq_putc(m, '\n');
Ingo Molnar8ea02602007-07-16 09:46:31 +0200576 if (mm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 mmput(mm);
Eric W. Biedermanee992742008-02-08 04:18:31 -0800578 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
580
Eric W. Biedermanee992742008-02-08 04:18:31 -0800581int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
582 struct pid *pid, struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583{
Eric W. Biedermanee992742008-02-08 04:18:31 -0800584 return do_task_stat(m, ns, pid, task, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585}
586
Eric W. Biedermanee992742008-02-08 04:18:31 -0800587int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
588 struct pid *pid, struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589{
Eric W. Biedermanee992742008-02-08 04:18:31 -0800590 return do_task_stat(m, ns, pid, task, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591}
592
Eric W. Biedermana56d3fc2008-02-08 04:18:32 -0800593int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
594 struct pid *pid, struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
Alexey Dobriyana2ade7b2011-01-12 17:00:32 -0800596 unsigned long size = 0, resident = 0, shared = 0, text = 0, data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 struct mm_struct *mm = get_task_mm(task);
Ingo Molnar8ea02602007-07-16 09:46:31 +0200598
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 if (mm) {
600 size = task_statm(mm, &shared, &text, &data, &resident);
601 mmput(mm);
602 }
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700603 /*
604 * For quick read, open code by putting numbers directly
605 * expected format is
606 * seq_printf(m, "%lu %lu %lu %lu 0 %lu 0\n",
607 * size, resident, shared, text, data);
608 */
Joe Perches75ba1d02016-10-07 17:02:20 -0700609 seq_put_decimal_ull(m, "", size);
610 seq_put_decimal_ull(m, " ", resident);
611 seq_put_decimal_ull(m, " ", shared);
612 seq_put_decimal_ull(m, " ", text);
613 seq_put_decimal_ull(m, " ", 0);
614 seq_put_decimal_ull(m, " ", data);
615 seq_put_decimal_ull(m, " ", 0);
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700616 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Eric W. Biedermana56d3fc2008-02-08 04:18:32 -0800618 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619}
Cyrill Gorcunov818411612012-05-31 16:26:43 -0700620
Iago López Galeiras2e13ba52015-06-25 15:00:57 -0700621#ifdef CONFIG_PROC_CHILDREN
Cyrill Gorcunov818411612012-05-31 16:26:43 -0700622static struct pid *
623get_children_pid(struct inode *inode, struct pid *pid_prev, loff_t pos)
624{
625 struct task_struct *start, *task;
626 struct pid *pid = NULL;
627
628 read_lock(&tasklist_lock);
629
630 start = pid_task(proc_pid(inode), PIDTYPE_PID);
631 if (!start)
632 goto out;
633
634 /*
635 * Lets try to continue searching first, this gives
636 * us significant speedup on children-rich processes.
637 */
638 if (pid_prev) {
639 task = pid_task(pid_prev, PIDTYPE_PID);
640 if (task && task->real_parent == start &&
641 !(list_empty(&task->sibling))) {
642 if (list_is_last(&task->sibling, &start->children))
643 goto out;
644 task = list_first_entry(&task->sibling,
645 struct task_struct, sibling);
646 pid = get_pid(task_pid(task));
647 goto out;
648 }
649 }
650
651 /*
652 * Slow search case.
653 *
654 * We might miss some children here if children
655 * are exited while we were not holding the lock,
656 * but it was never promised to be accurate that
657 * much.
658 *
659 * "Just suppose that the parent sleeps, but N children
660 * exit after we printed their tids. Now the slow paths
661 * skips N extra children, we miss N tasks." (c)
662 *
663 * So one need to stop or freeze the leader and all
664 * its children to get a precise result.
665 */
666 list_for_each_entry(task, &start->children, sibling) {
667 if (pos-- == 0) {
668 pid = get_pid(task_pid(task));
669 break;
670 }
671 }
672
673out:
674 read_unlock(&tasklist_lock);
675 return pid;
676}
677
678static int children_seq_show(struct seq_file *seq, void *v)
679{
680 struct inode *inode = seq->private;
681 pid_t pid;
682
683 pid = pid_nr_ns(v, inode->i_sb->s_fs_info);
Joe Perches25ce3192015-04-15 16:18:17 -0700684 seq_printf(seq, "%d ", pid);
685
686 return 0;
Cyrill Gorcunov818411612012-05-31 16:26:43 -0700687}
688
689static void *children_seq_start(struct seq_file *seq, loff_t *pos)
690{
691 return get_children_pid(seq->private, NULL, *pos);
692}
693
694static void *children_seq_next(struct seq_file *seq, void *v, loff_t *pos)
695{
696 struct pid *pid;
697
698 pid = get_children_pid(seq->private, v, *pos + 1);
699 put_pid(v);
700
701 ++*pos;
702 return pid;
703}
704
705static void children_seq_stop(struct seq_file *seq, void *v)
706{
707 put_pid(v);
708}
709
710static const struct seq_operations children_seq_ops = {
711 .start = children_seq_start,
712 .next = children_seq_next,
713 .stop = children_seq_stop,
714 .show = children_seq_show,
715};
716
717static int children_seq_open(struct inode *inode, struct file *file)
718{
719 struct seq_file *m;
720 int ret;
721
722 ret = seq_open(file, &children_seq_ops);
723 if (ret)
724 return ret;
725
726 m = file->private_data;
727 m->private = inode;
728
729 return ret;
730}
731
Cyrill Gorcunov818411612012-05-31 16:26:43 -0700732const struct file_operations proc_tid_children_operations = {
733 .open = children_seq_open,
734 .read = seq_read,
735 .llseek = seq_lseek,
Alexey Dobriyan171ef912018-02-06 15:37:10 -0800736 .release = seq_release,
Cyrill Gorcunov818411612012-05-31 16:26:43 -0700737};
Iago López Galeiras2e13ba52015-06-25 15:00:57 -0700738#endif /* CONFIG_PROC_CHILDREN */