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/delayacct.h>
22 #include <linux/cpumask.h>
23 #include <linux/percpu.h>
24 #include <net/genetlink.h>
25 #include <asm/atomic.h>
28 * Maximum length of a cpumask that can be specified in
29 * the TASKSTATS_CMD_ATTR_REGISTER/DEREGISTER_CPUMASK attribute
31 #define TASKSTATS_CPUMASK_MAXLEN (100+6*NR_CPUS)
33 static DEFINE_PER_CPU(__u32
, taskstats_seqnum
) = { 0 };
34 static int family_registered
;
35 kmem_cache_t
*taskstats_cache
;
37 static struct genl_family family
= {
38 .id
= GENL_ID_GENERATE
,
39 .name
= TASKSTATS_GENL_NAME
,
40 .version
= TASKSTATS_GENL_VERSION
,
41 .maxattr
= TASKSTATS_CMD_ATTR_MAX
,
44 static struct nla_policy taskstats_cmd_get_policy
[TASKSTATS_CMD_ATTR_MAX
+1]
46 [TASKSTATS_CMD_ATTR_PID
] = { .type
= NLA_U32
},
47 [TASKSTATS_CMD_ATTR_TGID
] = { .type
= NLA_U32
},
48 [TASKSTATS_CMD_ATTR_REGISTER_CPUMASK
] = { .type
= NLA_STRING
},
49 [TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK
] = { .type
= NLA_STRING
},};
52 struct list_head list
;
57 struct listener_list
{
58 struct rw_semaphore sem
;
59 struct list_head list
;
61 static DEFINE_PER_CPU(struct listener_list
, listener_array
);
69 static int prepare_reply(struct genl_info
*info
, u8 cmd
, struct sk_buff
**skbp
,
70 void **replyp
, size_t size
)
76 * If new attributes are added, please revisit this allocation
78 skb
= nlmsg_new(size
);
83 int seq
= get_cpu_var(taskstats_seqnum
)++;
84 put_cpu_var(taskstats_seqnum
);
86 reply
= genlmsg_put(skb
, 0, seq
,
90 reply
= genlmsg_put(skb
, info
->snd_pid
, info
->snd_seq
,
104 * Send taskstats data in @skb to listener with nl_pid @pid
106 static int send_reply(struct sk_buff
*skb
, pid_t pid
)
108 struct genlmsghdr
*genlhdr
= nlmsg_data((struct nlmsghdr
*)skb
->data
);
109 void *reply
= genlmsg_data(genlhdr
);
112 rc
= genlmsg_end(skb
, reply
);
118 return genlmsg_unicast(skb
, pid
);
122 * Send taskstats data in @skb to listeners registered for @cpu's exit data
124 static void send_cpu_listeners(struct sk_buff
*skb
, unsigned int cpu
)
126 struct genlmsghdr
*genlhdr
= nlmsg_data((struct nlmsghdr
*)skb
->data
);
127 struct listener_list
*listeners
;
128 struct listener
*s
, *tmp
;
129 struct sk_buff
*skb_next
, *skb_cur
= skb
;
130 void *reply
= genlmsg_data(genlhdr
);
131 int rc
, delcount
= 0;
133 rc
= genlmsg_end(skb
, reply
);
140 listeners
= &per_cpu(listener_array
, cpu
);
141 down_read(&listeners
->sem
);
142 list_for_each_entry(s
, &listeners
->list
, list
) {
144 if (!list_is_last(&s
->list
, &listeners
->list
)) {
145 skb_next
= skb_clone(skb_cur
, GFP_KERNEL
);
149 rc
= genlmsg_unicast(skb_cur
, s
->pid
);
150 if (rc
== -ECONNREFUSED
) {
156 up_read(&listeners
->sem
);
164 /* Delete invalidated entries */
165 down_write(&listeners
->sem
);
166 list_for_each_entry_safe(s
, tmp
, &listeners
->list
, list
) {
172 up_write(&listeners
->sem
);
175 static int fill_pid(pid_t pid
, struct task_struct
*pidtsk
,
176 struct taskstats
*stats
)
179 struct task_struct
*tsk
= pidtsk
;
182 read_lock(&tasklist_lock
);
183 tsk
= find_task_by_pid(pid
);
185 read_unlock(&tasklist_lock
);
188 get_task_struct(tsk
);
189 read_unlock(&tasklist_lock
);
191 get_task_struct(tsk
);
194 * Each accounting subsystem adds calls to its functions to
195 * fill in relevant parts of struct taskstsats as follows
197 * per-task-foo(stats, tsk);
200 delayacct_add_tsk(stats
, tsk
);
201 stats
->version
= TASKSTATS_VERSION
;
203 /* Define err: label here if needed */
204 put_task_struct(tsk
);
209 static int fill_tgid(pid_t tgid
, struct task_struct
*tgidtsk
,
210 struct taskstats
*stats
)
212 struct task_struct
*tsk
, *first
;
216 * Add additional stats from live tasks except zombie thread group
217 * leaders who are already counted with the dead tasks
221 read_lock(&tasklist_lock
);
222 first
= find_task_by_pid(tgid
);
224 read_unlock(&tasklist_lock
);
227 get_task_struct(first
);
228 read_unlock(&tasklist_lock
);
230 get_task_struct(first
);
234 read_lock(&tasklist_lock
);
235 /* Start with stats from dead tasks */
237 spin_lock_irqsave(&first
->signal
->stats_lock
, flags
);
238 if (first
->signal
->stats
)
239 memcpy(stats
, first
->signal
->stats
, sizeof(*stats
));
240 spin_unlock_irqrestore(&first
->signal
->stats_lock
, flags
);
244 if (tsk
->exit_state
== EXIT_ZOMBIE
&& thread_group_leader(tsk
))
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 } while_each_thread(first
, tsk
);
255 read_unlock(&tasklist_lock
);
256 stats
->version
= TASKSTATS_VERSION
;
259 * Accounting subsytems can also add calls here to modify
260 * fields of taskstats.
262 put_task_struct(first
);
267 static void fill_tgid_exit(struct task_struct
*tsk
)
271 spin_lock_irqsave(&tsk
->signal
->stats_lock
, flags
);
272 if (!tsk
->signal
->stats
)
276 * Each accounting subsystem calls its functions here to
277 * accumalate its per-task stats for tsk, into the per-tgid structure
279 * per-task-foo(tsk->signal->stats, tsk);
281 delayacct_add_tsk(tsk
->signal
->stats
, tsk
);
283 spin_unlock_irqrestore(&tsk
->signal
->stats_lock
, flags
);
287 static int add_del_listener(pid_t pid
, cpumask_t
*maskp
, int isadd
)
289 struct listener_list
*listeners
;
290 struct listener
*s
, *tmp
;
292 cpumask_t mask
= *maskp
;
294 if (!cpus_subset(mask
, cpu_possible_map
))
297 if (isadd
== REGISTER
) {
298 for_each_cpu_mask(cpu
, mask
) {
299 s
= kmalloc_node(sizeof(struct listener
), GFP_KERNEL
,
304 INIT_LIST_HEAD(&s
->list
);
307 listeners
= &per_cpu(listener_array
, cpu
);
308 down_write(&listeners
->sem
);
309 list_add(&s
->list
, &listeners
->list
);
310 up_write(&listeners
->sem
);
315 /* Deregister or cleanup */
317 for_each_cpu_mask(cpu
, mask
) {
318 listeners
= &per_cpu(listener_array
, cpu
);
319 down_write(&listeners
->sem
);
320 list_for_each_entry_safe(s
, tmp
, &listeners
->list
, list
) {
327 up_write(&listeners
->sem
);
332 static int parse(struct nlattr
*na
, cpumask_t
*mask
)
341 if (len
> TASKSTATS_CPUMASK_MAXLEN
)
345 data
= kmalloc(len
, GFP_KERNEL
);
348 nla_strlcpy(data
, na
, len
);
349 ret
= cpulist_parse(data
, *mask
);
354 static int taskstats_user_cmd(struct sk_buff
*skb
, struct genl_info
*info
)
357 struct sk_buff
*rep_skb
;
358 struct taskstats stats
;
364 rc
= parse(info
->attrs
[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK
], &mask
);
368 return add_del_listener(info
->snd_pid
, &mask
, REGISTER
);
370 rc
= parse(info
->attrs
[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK
], &mask
);
374 return add_del_listener(info
->snd_pid
, &mask
, DEREGISTER
);
377 * Size includes space for nested attributes
379 size
= nla_total_size(sizeof(u32
)) +
380 nla_total_size(sizeof(struct taskstats
)) + nla_total_size(0);
382 memset(&stats
, 0, sizeof(stats
));
383 rc
= prepare_reply(info
, TASKSTATS_CMD_NEW
, &rep_skb
, &reply
, size
);
387 if (info
->attrs
[TASKSTATS_CMD_ATTR_PID
]) {
388 u32 pid
= nla_get_u32(info
->attrs
[TASKSTATS_CMD_ATTR_PID
]);
389 rc
= fill_pid(pid
, NULL
, &stats
);
393 na
= nla_nest_start(rep_skb
, TASKSTATS_TYPE_AGGR_PID
);
394 NLA_PUT_U32(rep_skb
, TASKSTATS_TYPE_PID
, pid
);
395 NLA_PUT_TYPE(rep_skb
, struct taskstats
, TASKSTATS_TYPE_STATS
,
397 } else if (info
->attrs
[TASKSTATS_CMD_ATTR_TGID
]) {
398 u32 tgid
= nla_get_u32(info
->attrs
[TASKSTATS_CMD_ATTR_TGID
]);
399 rc
= fill_tgid(tgid
, NULL
, &stats
);
403 na
= nla_nest_start(rep_skb
, TASKSTATS_TYPE_AGGR_TGID
);
404 NLA_PUT_U32(rep_skb
, TASKSTATS_TYPE_TGID
, tgid
);
405 NLA_PUT_TYPE(rep_skb
, struct taskstats
, TASKSTATS_TYPE_STATS
,
412 nla_nest_end(rep_skb
, na
);
414 return send_reply(rep_skb
, info
->snd_pid
);
417 return genlmsg_cancel(rep_skb
, reply
);
423 void taskstats_exit_alloc(struct taskstats
**ptidstats
, unsigned int *mycpu
)
425 struct listener_list
*listeners
;
426 struct taskstats
*tmp
;
428 * This is the cpu on which the task is exiting currently and will
429 * be the one for which the exit event is sent, even if the cpu
430 * on which this function is running changes later.
432 *mycpu
= raw_smp_processor_id();
435 tmp
= kmem_cache_zalloc(taskstats_cache
, SLAB_KERNEL
);
439 listeners
= &per_cpu(listener_array
, *mycpu
);
440 down_read(&listeners
->sem
);
441 if (!list_empty(&listeners
->list
)) {
445 up_read(&listeners
->sem
);
449 /* Send pid data out on exit */
450 void taskstats_exit_send(struct task_struct
*tsk
, struct taskstats
*tidstats
,
451 int group_dead
, unsigned int mycpu
)
454 struct sk_buff
*rep_skb
;
461 if (!family_registered
|| !tidstats
)
464 spin_lock_irqsave(&tsk
->signal
->stats_lock
, flags
);
465 is_thread_group
= tsk
->signal
->stats
? 1 : 0;
466 spin_unlock_irqrestore(&tsk
->signal
->stats_lock
, flags
);
470 * Size includes space for nested attributes
472 size
= nla_total_size(sizeof(u32
)) +
473 nla_total_size(sizeof(struct taskstats
)) + nla_total_size(0);
476 size
= 2 * size
; /* PID + STATS + TGID + STATS */
478 rc
= prepare_reply(NULL
, TASKSTATS_CMD_NEW
, &rep_skb
, &reply
, size
);
482 rc
= fill_pid(tsk
->pid
, tsk
, tidstats
);
486 na
= nla_nest_start(rep_skb
, TASKSTATS_TYPE_AGGR_PID
);
487 NLA_PUT_U32(rep_skb
, TASKSTATS_TYPE_PID
, (u32
)tsk
->pid
);
488 NLA_PUT_TYPE(rep_skb
, struct taskstats
, TASKSTATS_TYPE_STATS
,
490 nla_nest_end(rep_skb
, na
);
492 if (!is_thread_group
)
496 * tsk has/had a thread group so fill the tsk->signal->stats structure
497 * Doesn't matter if tsk is the leader or the last group member leaving
504 na
= nla_nest_start(rep_skb
, TASKSTATS_TYPE_AGGR_TGID
);
505 NLA_PUT_U32(rep_skb
, TASKSTATS_TYPE_TGID
, (u32
)tsk
->tgid
);
506 /* No locking needed for tsk->signal->stats since group is dead */
507 NLA_PUT_TYPE(rep_skb
, struct taskstats
, TASKSTATS_TYPE_STATS
,
508 *tsk
->signal
->stats
);
509 nla_nest_end(rep_skb
, na
);
512 send_cpu_listeners(rep_skb
, mycpu
);
516 genlmsg_cancel(rep_skb
, reply
);
524 static struct genl_ops taskstats_ops
= {
525 .cmd
= TASKSTATS_CMD_GET
,
526 .doit
= taskstats_user_cmd
,
527 .policy
= taskstats_cmd_get_policy
,
530 /* Needed early in initialization */
531 void __init
taskstats_init_early(void)
535 taskstats_cache
= kmem_cache_create("taskstats_cache",
536 sizeof(struct taskstats
),
537 0, SLAB_PANIC
, NULL
, NULL
);
538 for_each_possible_cpu(i
) {
539 INIT_LIST_HEAD(&(per_cpu(listener_array
, i
).list
));
540 init_rwsem(&(per_cpu(listener_array
, i
).sem
));
544 static int __init
taskstats_init(void)
548 rc
= genl_register_family(&family
);
552 rc
= genl_register_ops(&family
, &taskstats_ops
);
556 family_registered
= 1;
559 genl_unregister_family(&family
);
564 * late initcall ensures initialization of statistics collection
565 * mechanisms precedes initialization of the taskstats interface
567 late_initcall(taskstats_init
);