blob: 9682bbf325d6bd2b569f165c6304426e3cc375d1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
Alan Cox526719b2008-10-27 15:19:48 +000043 * <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#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>
John Ogness9ad15a22017-09-14 11:42:17 +020063#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <linux/proc_fs.h>
65#include <linux/ioport.h>
Ingo Molnar8ea02602007-07-16 09:46:31 +020066#include <linux/uaccess.h>
67#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/mm.h>
69#include <linux/hugetlb.h>
70#include <linux/pagemap.h>
71#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <linux/smp.h>
73#include <linux/signal.h>
74#include <linux/highmem.h>
75#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040076#include <linux/fdtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070077#include <linux/times.h>
78#include <linux/cpuset.h>
Dipankar Sarma4fb3a532005-09-16 19:28:13 -070079#include <linux/rcupdate.h>
Shailabh Nagar25890452006-07-14 00:24:43 -070080#include <linux/delayacct.h>
Eric W. Biedermanee992742008-02-08 04:18:31 -080081#include <linux/seq_file.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -070082#include <linux/pid_namespace.h>
Kees Cook51ef9af2018-05-01 15:31:45 -070083#include <linux/prctl.h>
Jake Edgef83ce3e2009-05-04 12:51:14 -060084#include <linux/ptrace.h>
Roland McGrath0d094ef2008-07-25 19:45:49 -070085#include <linux/tracehook.h>
Andy Shevchenkoedc924e2015-02-12 15:01:11 -080086#include <linux/string_helpers.h>
Eric W. Biedermanae2975b2011-11-14 15:56:38 -080087#include <linux/user_namespace.h>
Richard W.M. Jones3e429792016-05-20 17:00:05 -070088#include <linux/fs_struct.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Linus Torvalds1da177e2005-04-16 15:20:36 -070090#include <asm/pgtable.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070091#include <asm/processor.h>
92#include "internal.h"
93
Eric W. Biedermandf5f8312008-02-08 04:18:33 -080094static inline void task_name(struct seq_file *m, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
Andy Shevchenkoedc924e2015-02-12 15:01:11 -080096 char *buf;
Andy Shevchenko3a49f3d2015-11-06 16:30:03 -080097 size_t size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 char tcomm[sizeof(p->comm)];
Andy Shevchenko3a49f3d2015-11-06 16:30:03 -080099 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
101 get_task_comm(tcomm, p);
102
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800103 seq_puts(m, "Name:\t");
Andy Shevchenkoedc924e2015-02-12 15:01:11 -0800104
Andy Shevchenko3a49f3d2015-11-06 16:30:03 -0800105 size = seq_get_buf(m, &buf);
106 ret = string_escape_str(tcomm, buf, size, ESCAPE_SPACE | ESCAPE_SPECIAL, "\n\\");
107 seq_commit(m, ret < size ? ret : -1);
Andy Shevchenkoedc924e2015-02-12 15:01:11 -0800108
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800109 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
112/*
113 * The task state array is a strange "bitmap" of
114 * reasons to sleep. Thus "running" is zero, and
115 * you can test for combinations of others with
116 * simple bit tests.
117 */
Mike Frysingere130aa72011-05-26 16:25:51 -0700118static const char * const task_state_array[] = {
Peter Zijlstrae1781532009-12-17 13:16:30 +0100119 "R (running)", /* 0 */
120 "S (sleeping)", /* 1 */
121 "D (disk sleep)", /* 2 */
122 "T (stopped)", /* 4 */
123 "t (tracing stop)", /* 8 */
Oleg Nesterovad866222014-04-07 15:38:46 -0700124 "X (dead)", /* 16 */
125 "Z (zombie)", /* 32 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126};
127
Ingo Molnar8ea02602007-07-16 09:46:31 +0200128static inline const char *get_task_state(struct task_struct *tsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
Oleg Nesterov74e37202014-01-23 15:55:35 -0800130 unsigned int state = (tsk->state | tsk->exit_state) & TASK_REPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Chris Metcalff51c0ea2015-06-24 16:55:48 -0700132 /*
133 * Parked tasks do not run; they sit in __kthread_parkme().
134 * Without this check, we would report them as running, which is
135 * clearly wrong, so we report them as sleeping instead.
136 */
137 if (tsk->state == TASK_PARKED)
138 state = TASK_INTERRUPTIBLE;
139
Oleg Nesterov74e37202014-01-23 15:55:35 -0800140 BUILD_BUG_ON(1 + ilog2(TASK_REPORT) != ARRAY_SIZE(task_state_array)-1);
Peter Zijlstrae1781532009-12-17 13:16:30 +0100141
Oleg Nesterov74e37202014-01-23 15:55:35 -0800142 return task_state_array[fls(state)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143}
144
Richard W.M. Jones3e429792016-05-20 17:00:05 -0700145static 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
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800158static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
159 struct pid *pid, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
Eric W. Biedermane9f238c2012-08-11 12:38:26 -0700161 struct user_namespace *user_ns = seq_user_ns(m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 struct group_info *group_info;
Richard W.M. Jones3e429792016-05-20 17:00:05 -0700163 int g, umask;
Oleg Nesterovabdba6e2014-12-10 15:45:18 -0800164 struct task_struct *tracer;
David Howellsc69e8d92008-11-14 10:39:19 +1100165 const struct cred *cred;
Oleg Nesterovabdba6e2014-12-10 15:45:18 -0800166 pid_t ppid, tpid = 0, tgid, ngid;
Oleg Nesterov0f4a0d52014-12-10 15:45:12 -0800167 unsigned int max_fds = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Oleg Nesterovb0fa9db2006-10-02 02:18:54 -0700169 rcu_read_lock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700170 ppid = pid_alive(p) ?
171 task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
Oleg Nesterovabdba6e2014-12-10 15:45:18 -0800172
173 tracer = ptrace_parent(p);
174 if (tracer)
175 tpid = task_pid_nr_ns(tracer, ns);
Oleg Nesterovb0fafc12014-12-10 15:45:15 -0800176
177 tgid = task_tgid_nr_ns(p, ns);
178 ngid = task_numa_group_id(p);
David Howellsde09a972010-07-29 12:45:49 +0100179 cred = get_task_cred(p);
Oleg Nesterov0f4a0d52014-12-10 15:45:12 -0800180
Richard W.M. Jones3e429792016-05-20 17:00:05 -0700181 umask = get_task_umask(p);
182 if (umask >= 0)
183 seq_printf(m, "Umask:\t%#04o\n", umask);
184
Oleg Nesterov0f4a0d52014-12-10 15:45:12 -0800185 task_lock(p);
186 if (p->files)
187 max_fds = files_fdtable(p->files)->max_fds;
188 task_unlock(p);
Oleg Nesterovb0fafc12014-12-10 15:45:15 -0800189 rcu_read_unlock();
Oleg Nesterov0f4a0d52014-12-10 15:45:12 -0800190
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700191 seq_printf(m, "State:\t%s", get_task_state(p));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Joe Perches75ba1d02016-10-07 17:02:20 -0700193 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);
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700207
208 seq_puts(m, "\nGroups:\t");
David Howellsc69e8d92008-11-14 10:39:19 +1100209 group_info = cred->group_info;
Artem Bityutskiy8d238022012-12-17 16:03:17 -0800210 for (g = 0; g < group_info->ngroups; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700211 seq_put_decimal_ull(m, g ? " " : "",
Alexey Dobriyan81243ea2016-10-07 17:03:12 -0700212 from_kgid_munged(user_ns, group_info->gid[g]));
David Howellsc69e8d92008-11-14 10:39:19 +1100213 put_cred(cred);
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700214 /* Trailing space shouldn't have been added in the first place. */
215 seq_putc(m, ' ');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700217#ifdef CONFIG_PID_NS
218 seq_puts(m, "\nNStgid:");
219 for (g = ns->level; g <= pid->level; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700220 seq_put_decimal_ull(m, "\t", task_tgid_nr_ns(p, pid->numbers[g].ns));
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700221 seq_puts(m, "\nNSpid:");
222 for (g = ns->level; g <= pid->level; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700223 seq_put_decimal_ull(m, "\t", task_pid_nr_ns(p, pid->numbers[g].ns));
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700224 seq_puts(m, "\nNSpgid:");
225 for (g = ns->level; g <= pid->level; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700226 seq_put_decimal_ull(m, "\t", task_pgrp_nr_ns(p, pid->numbers[g].ns));
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700227 seq_puts(m, "\nNSsid:");
228 for (g = ns->level; g <= pid->level; g++)
Joe Perches75ba1d02016-10-07 17:02:20 -0700229 seq_put_decimal_ull(m, "\t", task_session_nr_ns(p, pid->numbers[g].ns));
Chen Hanxiaoe4bc3322015-04-15 16:16:30 -0700230#endif
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800231 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232}
233
Cyrill Gorcunov138d22b2012-12-17 16:05:02 -0800234void render_sigset_t(struct seq_file *m, const char *header,
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800235 sigset_t *set)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800237 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800239 seq_puts(m, header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
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;
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800250 seq_printf(m, "%x", x);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 } while (i >= 4);
252
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800253 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254}
255
256static 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
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800271static inline void task_sig(struct seq_file *m, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
Oleg Nesterov5e6b3f42006-10-02 02:18:52 -0700273 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 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
Oleg Nesterov5e6b3f42006-10-02 02:18:52 -0700285 if (lock_task_sighand(p, &flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 pending = p->pending.signal;
287 shpending = p->signal->shared_pending.signal;
288 blocked = p->blocked;
289 collect_sigign_sigcatch(p, &ignored, &caught);
Oleg Nesterov7e498272010-05-26 14:43:22 -0700290 num_threads = get_nr_threads(p);
Paul E. McKenney7dc52152010-02-22 17:04:52 -0800291 rcu_read_lock(); /* FIXME: is this correct? */
David Howellsc69e8d92008-11-14 10:39:19 +1100292 qsize = atomic_read(&__task_cred(p)->user->sigpending);
Paul E. McKenney7dc52152010-02-22 17:04:52 -0800293 rcu_read_unlock();
Jiri Slabyd554ed892010-03-05 13:42:42 -0800294 qlim = task_rlimit(p, RLIMIT_SIGPENDING);
Oleg Nesterov5e6b3f42006-10-02 02:18:52 -0700295 unlock_task_sighand(p, &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Joe Perches75ba1d02016-10-07 17:02:20 -0700298 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 /* render them all */
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700303 render_sigset_t(m, "\nSigPnd:\t", &pending);
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800304 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308}
309
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800310static void render_cap_t(struct seq_file *m, const char *header,
311 kernel_cap_t *a)
Andrew Morgane338d262008-02-04 22:29:42 -0800312{
313 unsigned __capi;
314
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800315 seq_puts(m, header);
Andrew Morgane338d262008-02-04 22:29:42 -0800316 CAP_FOR_EACH_U32(__capi) {
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800317 seq_printf(m, "%08x",
Eric Paris7d8b6c62014-07-23 15:36:26 -0400318 a->cap[CAP_LAST_U32 - __capi]);
Andrew Morgane338d262008-02-04 22:29:42 -0800319 }
Alexey Dobriyan9d6de122011-01-12 17:00:32 -0800320 seq_putc(m, '\n');
Andrew Morgane338d262008-02-04 22:29:42 -0800321}
322
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800323static inline void task_cap(struct seq_file *m, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
David Howellsc69e8d92008-11-14 10:39:19 +1100325 const struct cred *cred;
Andy Lutomirski58319052015-09-04 15:42:45 -0700326 kernel_cap_t cap_inheritable, cap_permitted, cap_effective,
327 cap_bset, cap_ambient;
David Howellsb6dff3e2008-11-14 10:39:16 +1100328
David Howellsc69e8d92008-11-14 10:39:19 +1100329 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;
Andy Lutomirski58319052015-09-04 15:42:45 -0700335 cap_ambient = cred->cap_ambient;
David Howellsc69e8d92008-11-14 10:39:19 +1100336 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);
Andy Lutomirski58319052015-09-04 15:42:45 -0700342 render_cap_t(m, "CapAmb:\t", &cap_ambient);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343}
344
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800345static inline void task_seccomp(struct seq_file *m, struct task_struct *p)
346{
347#ifdef CONFIG_SECCOMP
Joe Perches75ba1d02016-10-07 17:02:20 -0700348 seq_put_decimal_ull(m, "Seccomp:\t", p->seccomp.mode);
Guenter Roeckf311b6c2019-01-16 10:58:31 -0800349 seq_putc(m, '\n');
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800350#endif
Guenter Roeckf311b6c2019-01-16 10:58:31 -0800351 seq_printf(m, "Speculation_Store_Bypass:\t");
Kees Cook51ef9af2018-05-01 15:31:45 -0700352 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;
Thomas Gleixner036608d2018-05-03 22:09:15 +0200359 case PR_SPEC_PRCTL | PR_SPEC_FORCE_DISABLE:
360 seq_printf(m, "thread force mitigated");
361 break;
Kees Cook51ef9af2018-05-01 15:31:45 -0700362 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');
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800376}
377
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800378static inline void task_context_switch_counts(struct seq_file *m,
379 struct task_struct *p)
Maxim Uvarovb663a792007-07-15 23:40:48 -0700380{
Joe Perches75ba1d02016-10-07 17:02:20 -0700381 seq_put_decimal_ull(m, "voluntary_ctxt_switches:\t", p->nvcsw);
382 seq_put_decimal_ull(m, "\nnonvoluntary_ctxt_switches:\t", p->nivcsw);
Alexey Dobriyanf7a5f132016-10-07 17:02:17 -0700383 seq_putc(m, '\n');
Maxim Uvarovb663a792007-07-15 23:40:48 -0700384}
385
Heiko Carstensd01d4822009-09-21 11:06:27 +0200386static void task_cpus_allowed(struct seq_file *m, struct task_struct *task)
387{
Tejun Heoa0c2e072015-02-13 14:38:07 -0800388 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));
Heiko Carstensd01d4822009-09-21 11:06:27 +0200392}
393
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800394int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
395 struct pid *pid, struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 struct mm_struct *mm = get_task_mm(task);
398
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800399 task_name(m, task);
400 task_state(m, ns, pid, task);
Ingo Molnar8ea02602007-07-16 09:46:31 +0200401
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 if (mm) {
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800403 task_mem(m, mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 mmput(mm);
405 }
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800406 task_sig(m, task);
407 task_cap(m, task);
Kees Cook2f4b3bf2012-12-17 16:03:14 -0800408 task_seccomp(m, task);
Heiko Carstensd01d4822009-09-21 11:06:27 +0200409 task_cpus_allowed(m, task);
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800410 cpuset_task_status_allowed(m, task);
Eric W. Biedermandf5f8312008-02-08 04:18:33 -0800411 task_context_switch_counts(m, task);
412 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413}
414
Eric W. Biedermanee992742008-02-08 04:18:31 -0800415static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
416 struct pid *pid, struct task_struct *task, int whole)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417{
Ingo Molnarb2f73922015-09-30 15:59:17 +0200418 unsigned long vsize, eip, esp, wchan = 0;
Jan Engelhardt715be1f2012-05-31 16:26:19 -0700419 int priority, nice;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 int tty_pgrp = -1, tty_nr = 0;
421 sigset_t sigign, sigcatch;
422 char state;
Ingo Molnar8ea02602007-07-16 09:46:31 +0200423 pid_t ppid = 0, pgid = -1, sid = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 int num_threads = 0;
Jake Edgef83ce3e2009-05-04 12:51:14 -0600425 int permitted;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 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;
Christian Borntraegerefe567f2007-08-23 15:18:02 +0200430 cputime_t cutime, cstime, utime, stime;
Laurent Vivier9ac52312007-10-15 17:00:19 +0200431 cputime_t cgtime, gtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 unsigned long rsslim = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 char tcomm[sizeof(task->comm)];
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700434 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436 state = *get_task_state(task);
437 vsize = eip = esp = 0;
Jann Horncaaee622016-01-20 15:00:04 -0800438 permitted = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS | PTRACE_MODE_NOAUDIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 mm = get_task_mm(task);
440 if (mm) {
441 vsize = task_vsize(mm);
Andy Lutomirski0a1eb2d2016-09-30 10:58:56 -0700442 /*
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).
John Ogness9ad15a22017-09-14 11:42:17 +0200446 *
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.
Andy Lutomirski0a1eb2d2016-09-30 10:58:56 -0700450 */
John Ogness730855b2019-06-28 12:06:40 -0700451 if (permitted && (task->flags & (PF_EXITING|PF_DUMPCORE))) {
Alexey Dobriyan8a3f4ba2018-01-18 16:34:05 -0800452 if (try_get_task_stack(task)) {
453 eip = KSTK_EIP(task);
454 esp = KSTK_ESP(task);
455 put_task_stack(task);
456 }
John Ogness9ad15a22017-09-14 11:42:17 +0200457 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 }
459
460 get_task_comm(tcomm, task);
461
462 sigemptyset(&sigign);
463 sigemptyset(&sigcatch);
Martin Schwidefsky64861632011-12-15 14:56:09 +0100464 cutime = cstime = utime = stime = 0;
465 cgtime = gtime = 0;
Alan Cox3cfd0882006-09-29 02:00:41 -0700466
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700467 if (lock_task_sighand(task, &flags)) {
468 struct signal_struct *sig = task->signal;
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700469
Oleg Nesterov91593502006-12-08 02:36:07 -0800470 if (sig->tty) {
Alan Cox5d0fdf12008-04-30 00:53:31 -0700471 struct pid *pgrp = tty_get_pgrp(sig->tty);
472 tty_pgrp = pid_nr_ns(pgrp, ns);
473 put_pid(pgrp);
Oleg Nesterov91593502006-12-08 02:36:07 -0800474 tty_nr = new_encode_dev(tty_devnum(sig->tty));
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700475 }
476
Oleg Nesterov7e498272010-05-26 14:43:22 -0700477 num_threads = get_nr_threads(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 collect_sigign_sigcatch(task, &sigign, &sigcatch);
479
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700480 cmin_flt = sig->cmin_flt;
481 cmaj_flt = sig->cmaj_flt;
482 cutime = sig->cutime;
483 cstime = sig->cstime;
Laurent Vivier9ac52312007-10-15 17:00:19 +0200484 cgtime = sig->cgtime;
Jiri Slabyd554ed892010-03-05 13:42:42 -0800485 rsslim = ACCESS_ONCE(sig->rlim[RLIMIT_RSS].rlim_cur);
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 /* add up live thread stats at the group level */
488 if (whole) {
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700489 struct task_struct *t = task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 do {
491 min_flt += t->min_flt;
492 maj_flt += t->maj_flt;
Frederic Weisbecker6fac4822012-11-13 14:20:55 +0100493 gtime += task_gtime(t);
Oleg Nesterov185ee402014-01-23 15:55:53 -0800494 } while_each_thread(task, t);
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700495
496 min_flt += sig->min_flt;
497 maj_flt += sig->maj_flt;
Frederic Weisbeckere80d0a1a2012-11-21 16:26:44 +0100498 thread_group_cputime_adjusted(task, &utime, &stime);
Martin Schwidefsky64861632011-12-15 14:56:09 +0100499 gtime += sig->gtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 }
501
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700502 sid = task_session_nr_ns(task, ns);
Oleg Nesterova98fdce2008-01-15 00:02:37 +0300503 ppid = task_tgid_nr_ns(task->real_parent, ns);
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700504 pgid = task_pgrp_nr_ns(task, ns);
Oleg Nesterova593d6e2006-10-02 02:18:53 -0700505
506 unlock_task_sighand(task, &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Jake Edgef83ce3e2009-05-04 12:51:14 -0600509 if (permitted && (!whole || num_threads < 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 wchan = get_wchan(task);
511 if (!whole) {
512 min_flt = task->min_flt;
513 maj_flt = task->maj_flt;
Frederic Weisbeckere80d0a1a2012-11-21 16:26:44 +0100514 task_cputime_adjusted(task, &utime, &stime);
Frederic Weisbecker6fac4822012-11-13 14:20:55 +0100515 gtime = task_gtime(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 }
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 /* convert nsec -> ticks */
Thomas Gleixner57e0be02014-07-16 21:04:32 +0000524 start_time = nsec_to_clock_t(task->real_start_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700526 seq_printf(m, "%d (%s) %c", pid_nr_ns(pid, ns), tcomm, state);
Joe Perches75ba1d02016-10-07 17:02:20 -0700527 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, " ", cputime_to_clock_t(utime));
538 seq_put_decimal_ull(m, " ", cputime_to_clock_t(stime));
539 seq_put_decimal_ll(m, " ", cputime_to_clock_t(cutime));
540 seq_put_decimal_ll(m, " ", cputime_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);
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700554 /* 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 */
Joe Perches75ba1d02016-10-07 17:02:20 -0700558 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);
Ingo Molnarb2f73922015-09-30 15:59:17 +0200562
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
Joe Perches75ba1d02016-10-07 17:02:20 -0700575 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, " ", cputime_to_clock_t(gtime));
583 seq_put_decimal_ll(m, " ", cputime_to_clock_t(cgtime));
Cyrill Gorcunov5b1720872012-05-31 16:26:44 -0700584
585 if (mm && permitted) {
Joe Perches75ba1d02016-10-07 17:02:20 -0700586 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);
Cyrill Gorcunov5b1720872012-05-31 16:26:44 -0700593 } else
Joe Perches75ba1d02016-10-07 17:02:20 -0700594 seq_puts(m, " 0 0 0 0 0 0 0");
Cyrill Gorcunov5b1720872012-05-31 16:26:44 -0700595
596 if (permitted)
Joe Perches75ba1d02016-10-07 17:02:20 -0700597 seq_put_decimal_ll(m, " ", task->exit_code);
Cyrill Gorcunov5b1720872012-05-31 16:26:44 -0700598 else
Joe Perches75ba1d02016-10-07 17:02:20 -0700599 seq_puts(m, " 0");
Cyrill Gorcunov5b1720872012-05-31 16:26:44 -0700600
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700601 seq_putc(m, '\n');
Ingo Molnar8ea02602007-07-16 09:46:31 +0200602 if (mm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 mmput(mm);
Eric W. Biedermanee992742008-02-08 04:18:31 -0800604 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605}
606
Eric W. Biedermanee992742008-02-08 04:18:31 -0800607int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
608 struct pid *pid, struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609{
Eric W. Biedermanee992742008-02-08 04:18:31 -0800610 return do_task_stat(m, ns, pid, task, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611}
612
Eric W. Biedermanee992742008-02-08 04:18:31 -0800613int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
614 struct pid *pid, struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615{
Eric W. Biedermanee992742008-02-08 04:18:31 -0800616 return do_task_stat(m, ns, pid, task, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617}
618
Eric W. Biedermana56d3fc2008-02-08 04:18:32 -0800619int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
620 struct pid *pid, struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621{
Alexey Dobriyana2ade7b2011-01-12 17:00:32 -0800622 unsigned long size = 0, resident = 0, shared = 0, text = 0, data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 struct mm_struct *mm = get_task_mm(task);
Ingo Molnar8ea02602007-07-16 09:46:31 +0200624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 if (mm) {
626 size = task_statm(mm, &shared, &text, &data, &resident);
627 mmput(mm);
628 }
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700629 /*
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 */
Joe Perches75ba1d02016-10-07 17:02:20 -0700635 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);
KAMEZAWA Hiroyukibda7bad2012-03-23 15:02:54 -0700642 seq_putc(m, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Eric W. Biedermana56d3fc2008-02-08 04:18:32 -0800644 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645}
Cyrill Gorcunov818411612012-05-31 16:26:43 -0700646
Iago López Galeiras2e13ba52015-06-25 15:00:57 -0700647#ifdef CONFIG_PROC_CHILDREN
Cyrill Gorcunov818411612012-05-31 16:26:43 -0700648static struct pid *
649get_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
699out:
700 read_unlock(&tasklist_lock);
701 return pid;
702}
703
704static 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);
Joe Perches25ce3192015-04-15 16:18:17 -0700710 seq_printf(seq, "%d ", pid);
711
712 return 0;
Cyrill Gorcunov818411612012-05-31 16:26:43 -0700713}
714
715static void *children_seq_start(struct seq_file *seq, loff_t *pos)
716{
717 return get_children_pid(seq->private, NULL, *pos);
718}
719
720static 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
731static void children_seq_stop(struct seq_file *seq, void *v)
732{
733 put_pid(v);
734}
735
736static 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
743static 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
758int children_seq_release(struct inode *inode, struct file *file)
759{
760 seq_release(inode, file);
761 return 0;
762}
763
764const 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};
Iago López Galeiras2e13ba52015-06-25 15:00:57 -0700770#endif /* CONFIG_PROC_CHILDREN */