2 * taskstats.c - Export per-task statistics to userland
4 * Copyright (C) Shailabh Nagar, IBM Corp. 2006
5 * (C) Balbir Singh, IBM Corp. 2006
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
19 #include <linux/kernel.h>
20 #include <linux/taskstats_kern.h>
21 #include <linux/tsacct_kern.h>
22 #include <linux/delayacct.h>
23 #include <linux/cpumask.h>
24 #include <linux/percpu.h>
25 #include <linux/slab.h>
26 #include <linux/cgroupstats.h>
27 #include <linux/cgroup.h>
29 #include <linux/file.h>
30 #include <net/genetlink.h>
31 #include <asm/atomic.h>
34 * Maximum length of a cpumask that can be specified in
35 * the TASKSTATS_CMD_ATTR_REGISTER/DEREGISTER_CPUMASK attribute
37 #define TASKSTATS_CPUMASK_MAXLEN (100+6*NR_CPUS)
39 static DEFINE_PER_CPU(__u32
, taskstats_seqnum
);
40 static int family_registered
;
41 struct kmem_cache
*taskstats_cache
;
43 static struct genl_family family
= {
44 .id
= GENL_ID_GENERATE
,
45 .name
= TASKSTATS_GENL_NAME
,
46 .version
= TASKSTATS_GENL_VERSION
,
47 .maxattr
= TASKSTATS_CMD_ATTR_MAX
,
50 static const struct nla_policy taskstats_cmd_get_policy
[TASKSTATS_CMD_ATTR_MAX
+1] = {
51 [TASKSTATS_CMD_ATTR_PID
] = { .type
= NLA_U32
},
52 [TASKSTATS_CMD_ATTR_TGID
] = { .type
= NLA_U32
},
53 [TASKSTATS_CMD_ATTR_REGISTER_CPUMASK
] = { .type
= NLA_STRING
},
54 [TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK
] = { .type
= NLA_STRING
},};
56 static const struct nla_policy cgroupstats_cmd_get_policy
[CGROUPSTATS_CMD_ATTR_MAX
+1] = {
57 [CGROUPSTATS_CMD_ATTR_FD
] = { .type
= NLA_U32
},
61 struct list_head list
;
66 struct listener_list
{
67 struct rw_semaphore sem
;
68 struct list_head list
;
70 static DEFINE_PER_CPU(struct listener_list
, listener_array
);
78 static int prepare_reply(struct genl_info
*info
, u8 cmd
, struct sk_buff
**skbp
,
85 * If new attributes are added, please revisit this allocation
87 skb
= genlmsg_new(size
, GFP_KERNEL
);
92 int seq
= get_cpu_var(taskstats_seqnum
)++;
93 put_cpu_var(taskstats_seqnum
);
95 reply
= genlmsg_put(skb
, 0, seq
, &family
, 0, cmd
);
97 reply
= genlmsg_put_reply(skb
, info
, &family
, 0, cmd
);
108 * Send taskstats data in @skb to listener with nl_pid @pid
110 static int send_reply(struct sk_buff
*skb
, struct genl_info
*info
)
112 struct genlmsghdr
*genlhdr
= nlmsg_data(nlmsg_hdr(skb
));
113 void *reply
= genlmsg_data(genlhdr
);
116 rc
= genlmsg_end(skb
, reply
);
122 return genlmsg_reply(skb
, info
);
126 * Send taskstats data in @skb to listeners registered for @cpu's exit data
128 static void send_cpu_listeners(struct sk_buff
*skb
,
129 struct listener_list
*listeners
)
131 struct genlmsghdr
*genlhdr
= nlmsg_data(nlmsg_hdr(skb
));
132 struct listener
*s
, *tmp
;
133 struct sk_buff
*skb_next
, *skb_cur
= skb
;
134 void *reply
= genlmsg_data(genlhdr
);
135 int rc
, delcount
= 0;
137 rc
= genlmsg_end(skb
, reply
);
144 down_read(&listeners
->sem
);
145 list_for_each_entry(s
, &listeners
->list
, list
) {
147 if (!list_is_last(&s
->list
, &listeners
->list
)) {
148 skb_next
= skb_clone(skb_cur
, GFP_KERNEL
);
152 rc
= genlmsg_unicast(&init_net
, skb_cur
, s
->pid
);
153 if (rc
== -ECONNREFUSED
) {
159 up_read(&listeners
->sem
);
167 /* Delete invalidated entries */
168 down_write(&listeners
->sem
);
169 list_for_each_entry_safe(s
, tmp
, &listeners
->list
, list
) {
175 up_write(&listeners
->sem
);
178 static int fill_pid(pid_t pid
, struct task_struct
*tsk
,
179 struct taskstats
*stats
)
185 tsk
= find_task_by_vpid(pid
);
187 get_task_struct(tsk
);
192 get_task_struct(tsk
);
194 memset(stats
, 0, sizeof(*stats
));
196 * Each accounting subsystem adds calls to its functions to
197 * fill in relevant parts of struct taskstsats as follows
199 * per-task-foo(stats, tsk);
202 delayacct_add_tsk(stats
, tsk
);
204 /* fill in basic acct fields */
205 stats
->version
= TASKSTATS_VERSION
;
206 stats
->nvcsw
= tsk
->nvcsw
;
207 stats
->nivcsw
= tsk
->nivcsw
;
208 bacct_add_tsk(stats
, tsk
);
210 /* fill in extended acct fields */
211 xacct_add_tsk(stats
, tsk
);
213 /* Define err: label here if needed */
214 put_task_struct(tsk
);
219 static int fill_tgid(pid_t tgid
, struct task_struct
*first
,
220 struct taskstats
*stats
)
222 struct task_struct
*tsk
;
227 * Add additional stats from live tasks except zombie thread group
228 * leaders who are already counted with the dead tasks
232 first
= find_task_by_vpid(tgid
);
234 if (!first
|| !lock_task_sighand(first
, &flags
))
237 if (first
->signal
->stats
)
238 memcpy(stats
, first
->signal
->stats
, sizeof(*stats
));
240 memset(stats
, 0, sizeof(*stats
));
247 * Accounting subsystem can call its functions here to
248 * fill in relevant parts of struct taskstsats as follows
250 * per-task-foo(stats, tsk);
252 delayacct_add_tsk(stats
, tsk
);
254 stats
->nvcsw
+= tsk
->nvcsw
;
255 stats
->nivcsw
+= tsk
->nivcsw
;
256 } while_each_thread(first
, tsk
);
258 unlock_task_sighand(first
, &flags
);
263 stats
->version
= TASKSTATS_VERSION
;
265 * Accounting subsystems can also add calls here to modify
266 * fields of taskstats.
272 static void fill_tgid_exit(struct task_struct
*tsk
)
276 spin_lock_irqsave(&tsk
->sighand
->siglock
, flags
);
277 if (!tsk
->signal
->stats
)
281 * Each accounting subsystem calls its functions here to
282 * accumalate its per-task stats for tsk, into the per-tgid structure
284 * per-task-foo(tsk->signal->stats, tsk);
286 delayacct_add_tsk(tsk
->signal
->stats
, tsk
);
288 spin_unlock_irqrestore(&tsk
->sighand
->siglock
, flags
);
292 static int add_del_listener(pid_t pid
, const struct cpumask
*mask
, int isadd
)
294 struct listener_list
*listeners
;
295 struct listener
*s
, *tmp
, *s2
;
298 if (!cpumask_subset(mask
, cpu_possible_mask
))
302 if (isadd
== REGISTER
) {
303 for_each_cpu(cpu
, mask
) {
305 s
= kmalloc_node(sizeof(struct listener
),
306 GFP_KERNEL
, cpu_to_node(cpu
));
310 INIT_LIST_HEAD(&s
->list
);
313 listeners
= &per_cpu(listener_array
, cpu
);
314 down_write(&listeners
->sem
);
315 list_for_each_entry_safe(s2
, tmp
, &listeners
->list
, list
) {
319 list_add(&s
->list
, &listeners
->list
);
322 up_write(&listeners
->sem
);
328 /* Deregister or cleanup */
330 for_each_cpu(cpu
, mask
) {
331 listeners
= &per_cpu(listener_array
, cpu
);
332 down_write(&listeners
->sem
);
333 list_for_each_entry_safe(s
, tmp
, &listeners
->list
, list
) {
340 up_write(&listeners
->sem
);
345 static int parse(struct nlattr
*na
, struct cpumask
*mask
)
354 if (len
> TASKSTATS_CPUMASK_MAXLEN
)
358 data
= kmalloc(len
, GFP_KERNEL
);
361 nla_strlcpy(data
, na
, len
);
362 ret
= cpulist_parse(data
, mask
);
367 static struct taskstats
*mk_reply(struct sk_buff
*skb
, int type
, u32 pid
)
369 struct nlattr
*na
, *ret
;
372 aggr
= (type
== TASKSTATS_TYPE_PID
)
373 ? TASKSTATS_TYPE_AGGR_PID
374 : TASKSTATS_TYPE_AGGR_TGID
;
376 na
= nla_nest_start(skb
, aggr
);
379 if (nla_put(skb
, type
, sizeof(pid
), &pid
) < 0)
381 ret
= nla_reserve(skb
, TASKSTATS_TYPE_STATS
, sizeof(struct taskstats
));
384 nla_nest_end(skb
, na
);
386 return nla_data(ret
);
391 static int cgroupstats_user_cmd(struct sk_buff
*skb
, struct genl_info
*info
)
394 struct sk_buff
*rep_skb
;
395 struct cgroupstats
*stats
;
402 na
= info
->attrs
[CGROUPSTATS_CMD_ATTR_FD
];
406 fd
= nla_get_u32(info
->attrs
[CGROUPSTATS_CMD_ATTR_FD
]);
407 file
= fget_light(fd
, &fput_needed
);
411 size
= nla_total_size(sizeof(struct cgroupstats
));
413 rc
= prepare_reply(info
, CGROUPSTATS_CMD_NEW
, &rep_skb
,
418 na
= nla_reserve(rep_skb
, CGROUPSTATS_TYPE_CGROUP_STATS
,
419 sizeof(struct cgroupstats
));
420 stats
= nla_data(na
);
421 memset(stats
, 0, sizeof(*stats
));
423 rc
= cgroupstats_build(stats
, file
->f_dentry
);
429 rc
= send_reply(rep_skb
, info
);
432 fput_light(file
, fput_needed
);
436 static int taskstats_user_cmd(struct sk_buff
*skb
, struct genl_info
*info
)
439 struct sk_buff
*rep_skb
;
440 struct taskstats
*stats
;
444 if (!alloc_cpumask_var(&mask
, GFP_KERNEL
))
447 rc
= parse(info
->attrs
[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK
], mask
);
451 rc
= add_del_listener(info
->snd_pid
, mask
, REGISTER
);
455 rc
= parse(info
->attrs
[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK
], mask
);
459 rc
= add_del_listener(info
->snd_pid
, mask
, DEREGISTER
);
461 free_cpumask_var(mask
);
464 free_cpumask_var(mask
);
467 * Size includes space for nested attributes
469 size
= nla_total_size(sizeof(u32
)) +
470 nla_total_size(sizeof(struct taskstats
)) + nla_total_size(0);
472 rc
= prepare_reply(info
, TASKSTATS_CMD_NEW
, &rep_skb
, size
);
477 if (info
->attrs
[TASKSTATS_CMD_ATTR_PID
]) {
478 u32 pid
= nla_get_u32(info
->attrs
[TASKSTATS_CMD_ATTR_PID
]);
479 stats
= mk_reply(rep_skb
, TASKSTATS_TYPE_PID
, pid
);
483 rc
= fill_pid(pid
, NULL
, stats
);
486 } else if (info
->attrs
[TASKSTATS_CMD_ATTR_TGID
]) {
487 u32 tgid
= nla_get_u32(info
->attrs
[TASKSTATS_CMD_ATTR_TGID
]);
488 stats
= mk_reply(rep_skb
, TASKSTATS_TYPE_TGID
, tgid
);
492 rc
= fill_tgid(tgid
, NULL
, stats
);
498 return send_reply(rep_skb
, info
);
504 static struct taskstats
*taskstats_tgid_alloc(struct task_struct
*tsk
)
506 struct signal_struct
*sig
= tsk
->signal
;
507 struct taskstats
*stats
;
509 if (sig
->stats
|| thread_group_empty(tsk
))
512 /* No problem if kmem_cache_zalloc() fails */
513 stats
= kmem_cache_zalloc(taskstats_cache
, GFP_KERNEL
);
515 spin_lock_irq(&tsk
->sighand
->siglock
);
520 spin_unlock_irq(&tsk
->sighand
->siglock
);
523 kmem_cache_free(taskstats_cache
, stats
);
528 /* Send pid data out on exit */
529 void taskstats_exit(struct task_struct
*tsk
, int group_dead
)
532 struct listener_list
*listeners
;
533 struct taskstats
*stats
;
534 struct sk_buff
*rep_skb
;
538 if (!family_registered
)
542 * Size includes space for nested attributes
544 size
= nla_total_size(sizeof(u32
)) +
545 nla_total_size(sizeof(struct taskstats
)) + nla_total_size(0);
547 is_thread_group
= !!taskstats_tgid_alloc(tsk
);
548 if (is_thread_group
) {
549 /* PID + STATS + TGID + STATS */
551 /* fill the tsk->signal->stats structure */
555 listeners
= &__raw_get_cpu_var(listener_array
);
556 if (list_empty(&listeners
->list
))
559 rc
= prepare_reply(NULL
, TASKSTATS_CMD_NEW
, &rep_skb
, size
);
563 stats
= mk_reply(rep_skb
, TASKSTATS_TYPE_PID
, tsk
->pid
);
567 rc
= fill_pid(-1, tsk
, stats
);
572 * Doesn't matter if tsk is the leader or the last group member leaving
574 if (!is_thread_group
|| !group_dead
)
577 stats
= mk_reply(rep_skb
, TASKSTATS_TYPE_TGID
, tsk
->tgid
);
581 memcpy(stats
, tsk
->signal
->stats
, sizeof(*stats
));
584 send_cpu_listeners(rep_skb
, listeners
);
590 static struct genl_ops taskstats_ops
= {
591 .cmd
= TASKSTATS_CMD_GET
,
592 .doit
= taskstats_user_cmd
,
593 .policy
= taskstats_cmd_get_policy
,
594 .flags
= GENL_ADMIN_PERM
,
597 static struct genl_ops cgroupstats_ops
= {
598 .cmd
= CGROUPSTATS_CMD_GET
,
599 .doit
= cgroupstats_user_cmd
,
600 .policy
= cgroupstats_cmd_get_policy
,
603 /* Needed early in initialization */
604 void __init
taskstats_init_early(void)
608 taskstats_cache
= KMEM_CACHE(taskstats
, SLAB_PANIC
);
609 for_each_possible_cpu(i
) {
610 INIT_LIST_HEAD(&(per_cpu(listener_array
, i
).list
));
611 init_rwsem(&(per_cpu(listener_array
, i
).sem
));
615 static int __init
taskstats_init(void)
619 rc
= genl_register_family(&family
);
623 rc
= genl_register_ops(&family
, &taskstats_ops
);
627 rc
= genl_register_ops(&family
, &cgroupstats_ops
);
631 family_registered
= 1;
632 printk("registered taskstats version %d\n", TASKSTATS_GENL_VERSION
);
635 genl_unregister_ops(&family
, &taskstats_ops
);
637 genl_unregister_family(&family
);
642 * late initcall ensures initialization of statistics collection
643 * mechanisms precedes initialization of the taskstats interface
645 late_initcall(taskstats_init
);