2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* linux/fs/proc/array.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992 by Linus Torvalds
|
|
|
|
* based on ideas by Darren Senn
|
|
|
|
*
|
|
|
|
* Fixes:
|
|
|
|
* Michael. K. Johnson: stat,statm extensions.
|
|
|
|
* <johnsonm@stolaf.edu>
|
|
|
|
*
|
|
|
|
* Pauline Middelink : Made cmdline,envline only break at '\0's, to
|
|
|
|
* make sure SET_PROCTITLE works. Also removed
|
|
|
|
* bad '!' which forced address recalculation for
|
|
|
|
* EVERY character on the current page.
|
|
|
|
* <middelin@polyware.iaf.nl>
|
|
|
|
*
|
|
|
|
* Danny ter Haar : added cpuinfo
|
|
|
|
* <dth@cistron.nl>
|
|
|
|
*
|
|
|
|
* Alessandro Rubini : profile extension.
|
|
|
|
* <rubini@ipvvis.unipv.it>
|
|
|
|
*
|
|
|
|
* Jeff Tranter : added BogoMips field to cpuinfo
|
|
|
|
* <Jeff_Tranter@Mitel.COM>
|
|
|
|
*
|
|
|
|
* Bruno Haible : remove 4K limit for the maps file
|
|
|
|
* <haible@ma2s2.mathematik.uni-karlsruhe.de>
|
|
|
|
*
|
|
|
|
* Yves Arrouye : remove removal of trailing spaces in get_array.
|
|
|
|
* <Yves.Arrouye@marin.fdn.fr>
|
|
|
|
*
|
|
|
|
* Jerome Forissier : added per-CPU time information to /proc/stat
|
|
|
|
* and /proc/<pid>/cpu extension
|
|
|
|
* <forissier@isia.cma.fr>
|
|
|
|
* - Incorporation and non-SMP safe operation
|
|
|
|
* of forissier patch in 2.1.78 by
|
|
|
|
* Hans Marcus <crowbar@concepts.nl>
|
|
|
|
*
|
|
|
|
* aeb@cwi.nl : /proc/partitions
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Alan Cox : security fixes.
|
2008-10-27 16:19:48 +01:00
|
|
|
* <alan@lxorguk.ukuu.org.uk>
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Al Viro : safe handling of mm_struct
|
|
|
|
*
|
|
|
|
* Gerhard Wichert : added BIGMEM support
|
|
|
|
* Siemens AG <Gerhard.Wichert@pdb.siemens.de>
|
|
|
|
*
|
|
|
|
* Al Viro & Jeff Garzik : moved most of the thing into base.c and
|
|
|
|
* : proc_misc.c. The rest may eventually go into
|
|
|
|
* : base.c too.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/mman.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/ioport.h>
|
2007-07-16 09:46:31 +02:00
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/io.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/hugetlb.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/file.h>
|
2008-04-24 13:44:08 +02:00
|
|
|
#include <linux/fdtable.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/times.h>
|
|
|
|
#include <linux/cpuset.h>
|
2005-09-17 04:28:13 +02:00
|
|
|
#include <linux/rcupdate.h>
|
2006-07-14 09:24:43 +02:00
|
|
|
#include <linux/delayacct.h>
|
2008-02-08 13:18:31 +01:00
|
|
|
#include <linux/seq_file.h>
|
2007-10-19 08:40:14 +02:00
|
|
|
#include <linux/pid_namespace.h>
|
2009-05-04 20:51:14 +02:00
|
|
|
#include <linux/ptrace.h>
|
2008-07-26 04:45:49 +02:00
|
|
|
#include <linux/tracehook.h>
|
2011-11-15 00:56:38 +01:00
|
|
|
#include <linux/user_namespace.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include "internal.h"
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
static inline void task_name(struct seq_file *m, struct task_struct *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int i;
|
2008-02-08 13:18:33 +01:00
|
|
|
char *buf, *end;
|
2007-07-16 09:46:31 +02:00
|
|
|
char *name;
|
2005-04-17 00:20:36 +02:00
|
|
|
char tcomm[sizeof(p->comm)];
|
|
|
|
|
|
|
|
get_task_comm(tcomm, p);
|
|
|
|
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_puts(m, "Name:\t");
|
2008-02-08 13:18:33 +01:00
|
|
|
end = m->buf + m->size;
|
|
|
|
buf = m->buf + m->count;
|
2005-04-17 00:20:36 +02:00
|
|
|
name = tcomm;
|
|
|
|
i = sizeof(tcomm);
|
2008-02-08 13:18:33 +01:00
|
|
|
while (i && (buf < end)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned char c = *name;
|
|
|
|
name++;
|
|
|
|
i--;
|
|
|
|
*buf = c;
|
|
|
|
if (!c)
|
|
|
|
break;
|
|
|
|
if (c == '\\') {
|
2008-02-08 13:18:33 +01:00
|
|
|
buf++;
|
|
|
|
if (buf < end)
|
|
|
|
*buf++ = c;
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (c == '\n') {
|
2008-02-08 13:18:33 +01:00
|
|
|
*buf++ = '\\';
|
|
|
|
if (buf < end)
|
|
|
|
*buf++ = 'n';
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
buf++;
|
2008-02-08 13:18:33 +01:00
|
|
|
}
|
|
|
|
m->count = buf - m->buf;
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_putc(m, '\n');
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The task state array is a strange "bitmap" of
|
|
|
|
* reasons to sleep. Thus "running" is zero, and
|
|
|
|
* you can test for combinations of others with
|
|
|
|
* simple bit tests.
|
|
|
|
*/
|
2011-05-27 01:25:51 +02:00
|
|
|
static const char * const task_state_array[] = {
|
2009-12-17 13:16:30 +01:00
|
|
|
"R (running)", /* 0 */
|
|
|
|
"S (sleeping)", /* 1 */
|
|
|
|
"D (disk sleep)", /* 2 */
|
|
|
|
"T (stopped)", /* 4 */
|
|
|
|
"t (tracing stop)", /* 8 */
|
|
|
|
"Z (zombie)", /* 16 */
|
|
|
|
"X (dead)", /* 32 */
|
|
|
|
"x (dead)", /* 64 */
|
2009-12-17 13:16:29 +01:00
|
|
|
"K (wakekill)", /* 128 */
|
|
|
|
"W (waking)", /* 256 */
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2007-07-16 09:46:31 +02:00
|
|
|
static inline const char *get_task_state(struct task_struct *tsk)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-12-06 17:03:36 +01:00
|
|
|
unsigned int state = (tsk->state & TASK_REPORT) | tsk->exit_state;
|
2011-05-27 01:25:51 +02:00
|
|
|
const char * const *p = &task_state_array[0];
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-12-17 13:16:30 +01:00
|
|
|
BUILD_BUG_ON(1 + ilog2(TASK_STATE_MAX) != ARRAY_SIZE(task_state_array));
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
while (state) {
|
|
|
|
p++;
|
|
|
|
state >>= 1;
|
|
|
|
}
|
|
|
|
return *p;
|
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
|
|
|
|
struct pid *pid, struct task_struct *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2011-11-15 00:56:38 +01:00
|
|
|
struct user_namespace *user_ns = current_user_ns();
|
2005-04-17 00:20:36 +02:00
|
|
|
struct group_info *group_info;
|
|
|
|
int g;
|
2005-09-09 22:04:10 +02:00
|
|
|
struct fdtable *fdt = NULL;
|
2008-11-14 00:39:19 +01:00
|
|
|
const struct cred *cred;
|
2007-10-19 08:40:14 +02:00
|
|
|
pid_t ppid, tpid;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-10-02 11:18:54 +02:00
|
|
|
rcu_read_lock();
|
2007-10-19 08:40:14 +02:00
|
|
|
ppid = pid_alive(p) ?
|
|
|
|
task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
|
2008-07-26 04:45:49 +02:00
|
|
|
tpid = 0;
|
|
|
|
if (pid_alive(p)) {
|
2011-06-17 16:50:40 +02:00
|
|
|
struct task_struct *tracer = ptrace_parent(p);
|
2008-07-26 04:45:49 +02:00
|
|
|
if (tracer)
|
|
|
|
tpid = task_pid_nr_ns(tracer, ns);
|
|
|
|
}
|
CRED: Fix get_task_cred() and task_state() to not resurrect dead credentials
It's possible for get_task_cred() as it currently stands to 'corrupt' a set of
credentials by incrementing their usage count after their replacement by the
task being accessed.
What happens is that get_task_cred() can race with commit_creds():
TASK_1 TASK_2 RCU_CLEANER
-->get_task_cred(TASK_2)
rcu_read_lock()
__cred = __task_cred(TASK_2)
-->commit_creds()
old_cred = TASK_2->real_cred
TASK_2->real_cred = ...
put_cred(old_cred)
call_rcu(old_cred)
[__cred->usage == 0]
get_cred(__cred)
[__cred->usage == 1]
rcu_read_unlock()
-->put_cred_rcu()
[__cred->usage == 1]
panic()
However, since a tasks credentials are generally not changed very often, we can
reasonably make use of a loop involving reading the creds pointer and using
atomic_inc_not_zero() to attempt to increment it if it hasn't already hit zero.
If successful, we can safely return the credentials in the knowledge that, even
if the task we're accessing has released them, they haven't gone to the RCU
cleanup code.
We then change task_state() in procfs to use get_task_cred() rather than
calling get_cred() on the result of __task_cred(), as that suffers from the
same problem.
Without this change, a BUG_ON in __put_cred() or in put_cred_rcu() can be
tripped when it is noticed that the usage count is not zero as it ought to be,
for example:
kernel BUG at kernel/cred.c:168!
invalid opcode: 0000 [#1] SMP
last sysfs file: /sys/kernel/mm/ksm/run
CPU 0
Pid: 2436, comm: master Not tainted 2.6.33.3-85.fc13.x86_64 #1 0HR330/OptiPlex
745
RIP: 0010:[<ffffffff81069881>] [<ffffffff81069881>] __put_cred+0xc/0x45
RSP: 0018:ffff88019e7e9eb8 EFLAGS: 00010202
RAX: 0000000000000001 RBX: ffff880161514480 RCX: 00000000ffffffff
RDX: 00000000ffffffff RSI: ffff880140c690c0 RDI: ffff880140c690c0
RBP: ffff88019e7e9eb8 R08: 00000000000000d0 R09: 0000000000000000
R10: 0000000000000001 R11: 0000000000000040 R12: ffff880140c690c0
R13: ffff88019e77aea0 R14: 00007fff336b0a5c R15: 0000000000000001
FS: 00007f12f50d97c0(0000) GS:ffff880007400000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f8f461bc000 CR3: 00000001b26ce000 CR4: 00000000000006f0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
Process master (pid: 2436, threadinfo ffff88019e7e8000, task ffff88019e77aea0)
Stack:
ffff88019e7e9ec8 ffffffff810698cd ffff88019e7e9ef8 ffffffff81069b45
<0> ffff880161514180 ffff880161514480 ffff880161514180 0000000000000000
<0> ffff88019e7e9f28 ffffffff8106aace 0000000000000001 0000000000000246
Call Trace:
[<ffffffff810698cd>] put_cred+0x13/0x15
[<ffffffff81069b45>] commit_creds+0x16b/0x175
[<ffffffff8106aace>] set_current_groups+0x47/0x4e
[<ffffffff8106ac89>] sys_setgroups+0xf6/0x105
[<ffffffff81009b02>] system_call_fastpath+0x16/0x1b
Code: 48 8d 71 ff e8 7e 4e 15 00 85 c0 78 0b 8b 75 ec 48 89 df e8 ef 4a 15 00
48 83 c4 18 5b c9 c3 55 8b 07 8b 07 48 89 e5 85 c0 74 04 <0f> 0b eb fe 65 48 8b
04 25 00 cc 00 00 48 3b b8 58 04 00 00 75
RIP [<ffffffff81069881>] __put_cred+0xc/0x45
RSP <ffff88019e7e9eb8>
---[ end trace df391256a100ebdd ]---
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Jiri Olsa <jolsa@redhat.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-07-29 13:45:49 +02:00
|
|
|
cred = get_task_cred(p);
|
2008-02-08 13:18:33 +01:00
|
|
|
seq_printf(m,
|
2005-04-17 00:20:36 +02:00
|
|
|
"State:\t%s\n"
|
|
|
|
"Tgid:\t%d\n"
|
|
|
|
"Pid:\t%d\n"
|
|
|
|
"PPid:\t%d\n"
|
|
|
|
"TracerPid:\t%d\n"
|
|
|
|
"Uid:\t%d\t%d\t%d\t%d\n"
|
|
|
|
"Gid:\t%d\t%d\t%d\t%d\n",
|
|
|
|
get_task_state(p),
|
2007-10-19 08:40:14 +02:00
|
|
|
task_tgid_nr_ns(p, ns),
|
2008-02-08 13:18:33 +01:00
|
|
|
pid_nr_ns(pid, ns),
|
2007-10-19 08:40:14 +02:00
|
|
|
ppid, tpid,
|
2012-02-09 17:48:21 +01:00
|
|
|
from_kuid_munged(user_ns, cred->uid),
|
|
|
|
from_kuid_munged(user_ns, cred->euid),
|
|
|
|
from_kuid_munged(user_ns, cred->suid),
|
|
|
|
from_kuid_munged(user_ns, cred->fsuid),
|
|
|
|
from_kgid_munged(user_ns, cred->gid),
|
|
|
|
from_kgid_munged(user_ns, cred->egid),
|
|
|
|
from_kgid_munged(user_ns, cred->sgid),
|
|
|
|
from_kgid_munged(user_ns, cred->fsgid));
|
2006-10-02 11:18:54 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
task_lock(p);
|
2005-09-09 22:04:10 +02:00
|
|
|
if (p->files)
|
|
|
|
fdt = files_fdtable(p->files);
|
2008-02-08 13:18:33 +01:00
|
|
|
seq_printf(m,
|
2005-04-17 00:20:36 +02:00
|
|
|
"FDSize:\t%d\n"
|
|
|
|
"Groups:\t",
|
2005-09-09 22:04:10 +02:00
|
|
|
fdt ? fdt->max_fds : 0);
|
2005-09-17 04:28:13 +02:00
|
|
|
rcu_read_unlock();
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-11-14 00:39:19 +01:00
|
|
|
group_info = cred->group_info;
|
2005-04-17 00:20:36 +02:00
|
|
|
task_unlock(p);
|
|
|
|
|
2007-07-16 09:46:31 +02:00
|
|
|
for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)
|
2011-11-15 00:56:38 +01:00
|
|
|
seq_printf(m, "%d ",
|
|
|
|
from_kgid_munged(user_ns, GROUP_AT(group_info, g)));
|
2008-11-14 00:39:19 +01:00
|
|
|
put_cred(cred);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_putc(m, '\n');
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
static void render_sigset_t(struct seq_file *m, const char *header,
|
|
|
|
sigset_t *set)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-02-08 13:18:33 +01:00
|
|
|
int i;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_puts(m, header);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
i = _NSIG;
|
|
|
|
do {
|
|
|
|
int x = 0;
|
|
|
|
|
|
|
|
i -= 4;
|
|
|
|
if (sigismember(set, i+1)) x |= 1;
|
|
|
|
if (sigismember(set, i+2)) x |= 2;
|
|
|
|
if (sigismember(set, i+3)) x |= 4;
|
|
|
|
if (sigismember(set, i+4)) x |= 8;
|
2008-02-08 13:18:33 +01:00
|
|
|
seq_printf(m, "%x", x);
|
2005-04-17 00:20:36 +02:00
|
|
|
} while (i >= 4);
|
|
|
|
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_putc(m, '\n');
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
|
|
|
|
sigset_t *catch)
|
|
|
|
{
|
|
|
|
struct k_sigaction *k;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
k = p->sighand->action;
|
|
|
|
for (i = 1; i <= _NSIG; ++i, ++k) {
|
|
|
|
if (k->sa.sa_handler == SIG_IGN)
|
|
|
|
sigaddset(ign, i);
|
|
|
|
else if (k->sa.sa_handler != SIG_DFL)
|
|
|
|
sigaddset(catch, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
static inline void task_sig(struct seq_file *m, struct task_struct *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-02 11:18:52 +02:00
|
|
|
unsigned long flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
sigset_t pending, shpending, blocked, ignored, caught;
|
|
|
|
int num_threads = 0;
|
|
|
|
unsigned long qsize = 0;
|
|
|
|
unsigned long qlim = 0;
|
|
|
|
|
|
|
|
sigemptyset(&pending);
|
|
|
|
sigemptyset(&shpending);
|
|
|
|
sigemptyset(&blocked);
|
|
|
|
sigemptyset(&ignored);
|
|
|
|
sigemptyset(&caught);
|
|
|
|
|
2006-10-02 11:18:52 +02:00
|
|
|
if (lock_task_sighand(p, &flags)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
pending = p->pending.signal;
|
|
|
|
shpending = p->signal->shared_pending.signal;
|
|
|
|
blocked = p->blocked;
|
|
|
|
collect_sigign_sigcatch(p, &ignored, &caught);
|
2010-05-26 23:43:22 +02:00
|
|
|
num_threads = get_nr_threads(p);
|
2010-02-23 02:04:52 +01:00
|
|
|
rcu_read_lock(); /* FIXME: is this correct? */
|
2008-11-14 00:39:19 +01:00
|
|
|
qsize = atomic_read(&__task_cred(p)->user->sigpending);
|
2010-02-23 02:04:52 +01:00
|
|
|
rcu_read_unlock();
|
2010-03-05 22:42:42 +01:00
|
|
|
qlim = task_rlimit(p, RLIMIT_SIGPENDING);
|
2006-10-02 11:18:52 +02:00
|
|
|
unlock_task_sighand(p, &flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
seq_printf(m, "Threads:\t%d\n", num_threads);
|
|
|
|
seq_printf(m, "SigQ:\t%lu/%lu\n", qsize, qlim);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* render them all */
|
2008-02-08 13:18:33 +01:00
|
|
|
render_sigset_t(m, "SigPnd:\t", &pending);
|
|
|
|
render_sigset_t(m, "ShdPnd:\t", &shpending);
|
|
|
|
render_sigset_t(m, "SigBlk:\t", &blocked);
|
|
|
|
render_sigset_t(m, "SigIgn:\t", &ignored);
|
|
|
|
render_sigset_t(m, "SigCgt:\t", &caught);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
static void render_cap_t(struct seq_file *m, const char *header,
|
|
|
|
kernel_cap_t *a)
|
2008-02-05 07:29:42 +01:00
|
|
|
{
|
|
|
|
unsigned __capi;
|
|
|
|
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_puts(m, header);
|
2008-02-05 07:29:42 +01:00
|
|
|
CAP_FOR_EACH_U32(__capi) {
|
2008-02-08 13:18:33 +01:00
|
|
|
seq_printf(m, "%08x",
|
2008-05-28 07:05:17 +02:00
|
|
|
a->cap[(_KERNEL_CAPABILITY_U32S-1) - __capi]);
|
2008-02-05 07:29:42 +01:00
|
|
|
}
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_putc(m, '\n');
|
2008-02-05 07:29:42 +01:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
static inline void task_cap(struct seq_file *m, struct task_struct *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-11-14 00:39:19 +01:00
|
|
|
const struct cred *cred;
|
|
|
|
kernel_cap_t cap_inheritable, cap_permitted, cap_effective, cap_bset;
|
2008-11-14 00:39:16 +01:00
|
|
|
|
2008-11-14 00:39:19 +01:00
|
|
|
rcu_read_lock();
|
|
|
|
cred = __task_cred(p);
|
|
|
|
cap_inheritable = cred->cap_inheritable;
|
|
|
|
cap_permitted = cred->cap_permitted;
|
|
|
|
cap_effective = cred->cap_effective;
|
|
|
|
cap_bset = cred->cap_bset;
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
render_cap_t(m, "CapInh:\t", &cap_inheritable);
|
|
|
|
render_cap_t(m, "CapPrm:\t", &cap_permitted);
|
|
|
|
render_cap_t(m, "CapEff:\t", &cap_effective);
|
|
|
|
render_cap_t(m, "CapBnd:\t", &cap_bset);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
static inline void task_context_switch_counts(struct seq_file *m,
|
|
|
|
struct task_struct *p)
|
2007-07-16 08:40:48 +02:00
|
|
|
{
|
2008-02-08 13:18:33 +01:00
|
|
|
seq_printf(m, "voluntary_ctxt_switches:\t%lu\n"
|
|
|
|
"nonvoluntary_ctxt_switches:\t%lu\n",
|
|
|
|
p->nvcsw,
|
|
|
|
p->nivcsw);
|
2007-07-16 08:40:48 +02:00
|
|
|
}
|
|
|
|
|
2009-09-21 11:06:27 +02:00
|
|
|
static void task_cpus_allowed(struct seq_file *m, struct task_struct *task)
|
|
|
|
{
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_puts(m, "Cpus_allowed:\t");
|
2009-09-21 11:06:27 +02:00
|
|
|
seq_cpumask(m, &task->cpus_allowed);
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_putc(m, '\n');
|
|
|
|
seq_puts(m, "Cpus_allowed_list:\t");
|
2009-09-21 11:06:27 +02:00
|
|
|
seq_cpumask_list(m, &task->cpus_allowed);
|
2011-01-13 02:00:32 +01:00
|
|
|
seq_putc(m, '\n');
|
2009-09-21 11:06:27 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
|
|
|
|
struct pid *pid, struct task_struct *task)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct mm_struct *mm = get_task_mm(task);
|
|
|
|
|
2008-02-08 13:18:33 +01:00
|
|
|
task_name(m, task);
|
|
|
|
task_state(m, ns, pid, task);
|
2007-07-16 09:46:31 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (mm) {
|
2008-02-08 13:18:33 +01:00
|
|
|
task_mem(m, mm);
|
2005-04-17 00:20:36 +02:00
|
|
|
mmput(mm);
|
|
|
|
}
|
2008-02-08 13:18:33 +01:00
|
|
|
task_sig(m, task);
|
|
|
|
task_cap(m, task);
|
2009-09-21 11:06:27 +02:00
|
|
|
task_cpus_allowed(m, task);
|
2008-02-08 13:18:33 +01:00
|
|
|
cpuset_task_status_allowed(m, task);
|
|
|
|
task_context_switch_counts(m, task);
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:31 +01:00
|
|
|
static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
|
|
|
|
struct pid *pid, struct task_struct *task, int whole)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned long vsize, eip, esp, wchan = ~0UL;
|
2012-06-01 01:26:19 +02:00
|
|
|
int priority, nice;
|
2005-04-17 00:20:36 +02:00
|
|
|
int tty_pgrp = -1, tty_nr = 0;
|
|
|
|
sigset_t sigign, sigcatch;
|
|
|
|
char state;
|
2007-07-16 09:46:31 +02:00
|
|
|
pid_t ppid = 0, pgid = -1, sid = -1;
|
2005-04-17 00:20:36 +02:00
|
|
|
int num_threads = 0;
|
2009-05-04 20:51:14 +02:00
|
|
|
int permitted;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct mm_struct *mm;
|
|
|
|
unsigned long long start_time;
|
|
|
|
unsigned long cmin_flt = 0, cmaj_flt = 0;
|
|
|
|
unsigned long min_flt = 0, maj_flt = 0;
|
2007-08-23 15:18:02 +02:00
|
|
|
cputime_t cutime, cstime, utime, stime;
|
2007-10-15 17:00:19 +02:00
|
|
|
cputime_t cgtime, gtime;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long rsslim = 0;
|
|
|
|
char tcomm[sizeof(task->comm)];
|
2006-10-02 11:18:53 +02:00
|
|
|
unsigned long flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
state = *get_task_state(task);
|
|
|
|
vsize = eip = esp = 0;
|
2012-01-03 18:25:15 +01:00
|
|
|
permitted = ptrace_may_access(task, PTRACE_MODE_READ | PTRACE_MODE_NOAUDIT);
|
2005-04-17 00:20:36 +02:00
|
|
|
mm = get_task_mm(task);
|
|
|
|
if (mm) {
|
|
|
|
vsize = task_vsize(mm);
|
2009-05-04 20:51:14 +02:00
|
|
|
if (permitted) {
|
|
|
|
eip = KSTK_EIP(task);
|
|
|
|
esp = KSTK_ESP(task);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
get_task_comm(tcomm, task);
|
|
|
|
|
|
|
|
sigemptyset(&sigign);
|
|
|
|
sigemptyset(&sigcatch);
|
2011-12-15 14:56:09 +01:00
|
|
|
cutime = cstime = utime = stime = 0;
|
|
|
|
cgtime = gtime = 0;
|
2006-09-29 11:00:41 +02:00
|
|
|
|
2006-10-02 11:18:53 +02:00
|
|
|
if (lock_task_sighand(task, &flags)) {
|
|
|
|
struct signal_struct *sig = task->signal;
|
2006-12-08 11:36:07 +01:00
|
|
|
|
|
|
|
if (sig->tty) {
|
2008-04-30 09:53:31 +02:00
|
|
|
struct pid *pgrp = tty_get_pgrp(sig->tty);
|
|
|
|
tty_pgrp = pid_nr_ns(pgrp, ns);
|
|
|
|
put_pid(pgrp);
|
2006-12-08 11:36:07 +01:00
|
|
|
tty_nr = new_encode_dev(tty_devnum(sig->tty));
|
2006-10-02 11:18:53 +02:00
|
|
|
}
|
|
|
|
|
2010-05-26 23:43:22 +02:00
|
|
|
num_threads = get_nr_threads(task);
|
2005-04-17 00:20:36 +02:00
|
|
|
collect_sigign_sigcatch(task, &sigign, &sigcatch);
|
|
|
|
|
2006-10-02 11:18:53 +02:00
|
|
|
cmin_flt = sig->cmin_flt;
|
|
|
|
cmaj_flt = sig->cmaj_flt;
|
|
|
|
cutime = sig->cutime;
|
|
|
|
cstime = sig->cstime;
|
2007-10-15 17:00:19 +02:00
|
|
|
cgtime = sig->cgtime;
|
2010-03-05 22:42:42 +01:00
|
|
|
rsslim = ACCESS_ONCE(sig->rlim[RLIMIT_RSS].rlim_cur);
|
2006-10-02 11:18:53 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* add up live thread stats at the group level */
|
|
|
|
if (whole) {
|
2006-10-02 11:18:53 +02:00
|
|
|
struct task_struct *t = task;
|
2005-04-17 00:20:36 +02:00
|
|
|
do {
|
|
|
|
min_flt += t->min_flt;
|
|
|
|
maj_flt += t->maj_flt;
|
2011-12-15 14:56:09 +01:00
|
|
|
gtime += t->gtime;
|
2005-04-17 00:20:36 +02:00
|
|
|
t = next_thread(t);
|
|
|
|
} while (t != task);
|
|
|
|
|
2006-10-02 11:18:53 +02:00
|
|
|
min_flt += sig->min_flt;
|
|
|
|
maj_flt += sig->maj_flt;
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 09:28:07 +01:00
|
|
|
thread_group_times(task, &utime, &stime);
|
2011-12-15 14:56:09 +01:00
|
|
|
gtime += sig->gtime;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-10-02 11:18:53 +02:00
|
|
|
|
2007-10-19 08:40:14 +02:00
|
|
|
sid = task_session_nr_ns(task, ns);
|
2008-01-14 22:02:37 +01:00
|
|
|
ppid = task_tgid_nr_ns(task->real_parent, ns);
|
2007-10-19 08:40:14 +02:00
|
|
|
pgid = task_pgrp_nr_ns(task, ns);
|
2006-10-02 11:18:53 +02:00
|
|
|
|
|
|
|
unlock_task_sighand(task, &flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-05-04 20:51:14 +02:00
|
|
|
if (permitted && (!whole || num_threads < 2))
|
2005-04-17 00:20:36 +02:00
|
|
|
wchan = get_wchan(task);
|
|
|
|
if (!whole) {
|
|
|
|
min_flt = task->min_flt;
|
|
|
|
maj_flt = task->maj_flt;
|
2009-11-26 06:48:30 +01:00
|
|
|
task_times(task, &utime, &stime);
|
2009-11-26 06:49:05 +01:00
|
|
|
gtime = task->gtime;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* scale priority and nice values from timeslices to -20..20 */
|
|
|
|
/* to make it look like a "normal" Unix priority/nice value */
|
|
|
|
priority = task_prio(task);
|
|
|
|
nice = task_nice(task);
|
|
|
|
|
|
|
|
/* Temporary variable needed for gcc-2.96 */
|
|
|
|
/* convert timespec -> nsec*/
|
2007-07-16 08:39:42 +02:00
|
|
|
start_time =
|
|
|
|
(unsigned long long)task->real_start_time.tv_sec * NSEC_PER_SEC
|
|
|
|
+ task->real_start_time.tv_nsec;
|
2005-04-17 00:20:36 +02:00
|
|
|
/* convert nsec -> ticks */
|
|
|
|
start_time = nsec_to_clock_t(start_time);
|
|
|
|
|
2012-03-23 23:02:54 +01:00
|
|
|
seq_printf(m, "%d (%s) %c", pid_nr_ns(pid, ns), tcomm, state);
|
|
|
|
seq_put_decimal_ll(m, ' ', ppid);
|
|
|
|
seq_put_decimal_ll(m, ' ', pgid);
|
|
|
|
seq_put_decimal_ll(m, ' ', sid);
|
|
|
|
seq_put_decimal_ll(m, ' ', tty_nr);
|
|
|
|
seq_put_decimal_ll(m, ' ', tty_pgrp);
|
|
|
|
seq_put_decimal_ull(m, ' ', task->flags);
|
|
|
|
seq_put_decimal_ull(m, ' ', min_flt);
|
|
|
|
seq_put_decimal_ull(m, ' ', cmin_flt);
|
|
|
|
seq_put_decimal_ull(m, ' ', maj_flt);
|
|
|
|
seq_put_decimal_ull(m, ' ', cmaj_flt);
|
|
|
|
seq_put_decimal_ull(m, ' ', cputime_to_clock_t(utime));
|
|
|
|
seq_put_decimal_ull(m, ' ', cputime_to_clock_t(stime));
|
|
|
|
seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cutime));
|
|
|
|
seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cstime));
|
|
|
|
seq_put_decimal_ll(m, ' ', priority);
|
|
|
|
seq_put_decimal_ll(m, ' ', nice);
|
|
|
|
seq_put_decimal_ll(m, ' ', num_threads);
|
|
|
|
seq_put_decimal_ull(m, ' ', 0);
|
|
|
|
seq_put_decimal_ull(m, ' ', start_time);
|
|
|
|
seq_put_decimal_ull(m, ' ', vsize);
|
2012-06-01 01:26:19 +02:00
|
|
|
seq_put_decimal_ull(m, ' ', mm ? get_mm_rss(mm) : 0);
|
2012-03-23 23:02:54 +01:00
|
|
|
seq_put_decimal_ull(m, ' ', rsslim);
|
|
|
|
seq_put_decimal_ull(m, ' ', mm ? (permitted ? mm->start_code : 1) : 0);
|
|
|
|
seq_put_decimal_ull(m, ' ', mm ? (permitted ? mm->end_code : 1) : 0);
|
|
|
|
seq_put_decimal_ull(m, ' ', (permitted && mm) ? mm->start_stack : 0);
|
|
|
|
seq_put_decimal_ull(m, ' ', esp);
|
|
|
|
seq_put_decimal_ull(m, ' ', eip);
|
|
|
|
/* The signal information here is obsolete.
|
|
|
|
* It must be decimal for Linux 2.0 compatibility.
|
|
|
|
* Use /proc/#/status for real-time signals.
|
|
|
|
*/
|
|
|
|
seq_put_decimal_ull(m, ' ', task->pending.signal.sig[0] & 0x7fffffffUL);
|
|
|
|
seq_put_decimal_ull(m, ' ', task->blocked.sig[0] & 0x7fffffffUL);
|
|
|
|
seq_put_decimal_ull(m, ' ', sigign.sig[0] & 0x7fffffffUL);
|
|
|
|
seq_put_decimal_ull(m, ' ', sigcatch.sig[0] & 0x7fffffffUL);
|
|
|
|
seq_put_decimal_ull(m, ' ', wchan);
|
|
|
|
seq_put_decimal_ull(m, ' ', 0);
|
|
|
|
seq_put_decimal_ull(m, ' ', 0);
|
|
|
|
seq_put_decimal_ll(m, ' ', task->exit_signal);
|
|
|
|
seq_put_decimal_ll(m, ' ', task_cpu(task));
|
|
|
|
seq_put_decimal_ull(m, ' ', task->rt_priority);
|
|
|
|
seq_put_decimal_ull(m, ' ', task->policy);
|
|
|
|
seq_put_decimal_ull(m, ' ', delayacct_blkio_ticks(task));
|
|
|
|
seq_put_decimal_ull(m, ' ', cputime_to_clock_t(gtime));
|
|
|
|
seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cgtime));
|
|
|
|
seq_put_decimal_ull(m, ' ', (mm && permitted) ? mm->start_data : 0);
|
|
|
|
seq_put_decimal_ull(m, ' ', (mm && permitted) ? mm->end_data : 0);
|
|
|
|
seq_put_decimal_ull(m, ' ', (mm && permitted) ? mm->start_brk : 0);
|
|
|
|
seq_putc(m, '\n');
|
2007-07-16 09:46:31 +02:00
|
|
|
if (mm)
|
2005-04-17 00:20:36 +02:00
|
|
|
mmput(mm);
|
2008-02-08 13:18:31 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:31 +01:00
|
|
|
int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
|
|
|
|
struct pid *pid, struct task_struct *task)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-02-08 13:18:31 +01:00
|
|
|
return do_task_stat(m, ns, pid, task, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:31 +01:00
|
|
|
int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
|
|
|
|
struct pid *pid, struct task_struct *task)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-02-08 13:18:31 +01:00
|
|
|
return do_task_stat(m, ns, pid, task, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:32 +01:00
|
|
|
int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
|
|
|
|
struct pid *pid, struct task_struct *task)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2011-01-13 02:00:32 +01:00
|
|
|
unsigned long size = 0, resident = 0, shared = 0, text = 0, data = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct mm_struct *mm = get_task_mm(task);
|
2007-07-16 09:46:31 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (mm) {
|
|
|
|
size = task_statm(mm, &shared, &text, &data, &resident);
|
|
|
|
mmput(mm);
|
|
|
|
}
|
2012-03-23 23:02:54 +01:00
|
|
|
/*
|
|
|
|
* For quick read, open code by putting numbers directly
|
|
|
|
* expected format is
|
|
|
|
* seq_printf(m, "%lu %lu %lu %lu 0 %lu 0\n",
|
|
|
|
* size, resident, shared, text, data);
|
|
|
|
*/
|
|
|
|
seq_put_decimal_ull(m, 0, size);
|
|
|
|
seq_put_decimal_ull(m, ' ', resident);
|
|
|
|
seq_put_decimal_ull(m, ' ', shared);
|
|
|
|
seq_put_decimal_ull(m, ' ', text);
|
|
|
|
seq_put_decimal_ull(m, ' ', 0);
|
2012-03-28 23:42:39 +02:00
|
|
|
seq_put_decimal_ull(m, ' ', data);
|
2012-03-23 23:02:54 +01:00
|
|
|
seq_put_decimal_ull(m, ' ', 0);
|
|
|
|
seq_putc(m, '\n');
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-02-08 13:18:32 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2012-06-01 01:26:43 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_CHECKPOINT_RESTORE
|
|
|
|
static struct pid *
|
|
|
|
get_children_pid(struct inode *inode, struct pid *pid_prev, loff_t pos)
|
|
|
|
{
|
|
|
|
struct task_struct *start, *task;
|
|
|
|
struct pid *pid = NULL;
|
|
|
|
|
|
|
|
read_lock(&tasklist_lock);
|
|
|
|
|
|
|
|
start = pid_task(proc_pid(inode), PIDTYPE_PID);
|
|
|
|
if (!start)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lets try to continue searching first, this gives
|
|
|
|
* us significant speedup on children-rich processes.
|
|
|
|
*/
|
|
|
|
if (pid_prev) {
|
|
|
|
task = pid_task(pid_prev, PIDTYPE_PID);
|
|
|
|
if (task && task->real_parent == start &&
|
|
|
|
!(list_empty(&task->sibling))) {
|
|
|
|
if (list_is_last(&task->sibling, &start->children))
|
|
|
|
goto out;
|
|
|
|
task = list_first_entry(&task->sibling,
|
|
|
|
struct task_struct, sibling);
|
|
|
|
pid = get_pid(task_pid(task));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Slow search case.
|
|
|
|
*
|
|
|
|
* We might miss some children here if children
|
|
|
|
* are exited while we were not holding the lock,
|
|
|
|
* but it was never promised to be accurate that
|
|
|
|
* much.
|
|
|
|
*
|
|
|
|
* "Just suppose that the parent sleeps, but N children
|
|
|
|
* exit after we printed their tids. Now the slow paths
|
|
|
|
* skips N extra children, we miss N tasks." (c)
|
|
|
|
*
|
|
|
|
* So one need to stop or freeze the leader and all
|
|
|
|
* its children to get a precise result.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(task, &start->children, sibling) {
|
|
|
|
if (pos-- == 0) {
|
|
|
|
pid = get_pid(task_pid(task));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
read_unlock(&tasklist_lock);
|
|
|
|
return pid;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int children_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct inode *inode = seq->private;
|
|
|
|
pid_t pid;
|
|
|
|
|
|
|
|
pid = pid_nr_ns(v, inode->i_sb->s_fs_info);
|
|
|
|
return seq_printf(seq, "%d ", pid);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *children_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
{
|
|
|
|
return get_children_pid(seq->private, NULL, *pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *children_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct pid *pid;
|
|
|
|
|
|
|
|
pid = get_children_pid(seq->private, v, *pos + 1);
|
|
|
|
put_pid(v);
|
|
|
|
|
|
|
|
++*pos;
|
|
|
|
return pid;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void children_seq_stop(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
put_pid(v);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations children_seq_ops = {
|
|
|
|
.start = children_seq_start,
|
|
|
|
.next = children_seq_next,
|
|
|
|
.stop = children_seq_stop,
|
|
|
|
.show = children_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int children_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct seq_file *m;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = seq_open(file, &children_seq_ops);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
m = file->private_data;
|
|
|
|
m->private = inode;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int children_seq_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
seq_release(inode, file);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct file_operations proc_tid_children_operations = {
|
|
|
|
.open = children_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = children_seq_release,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_CHECKPOINT_RESTORE */
|