blob: 4c3476fa058d5627650779f0559dc17c3a7cb1b8 [file] [log] [blame]
Shailabh Nagarc7572492006-07-14 00:24:40 -07001/*
2 * taskstats.c - Export per-task statistics to userland
3 *
4 * Copyright (C) Shailabh Nagar, IBM Corp. 2006
5 * (C) Balbir Singh, IBM Corp. 2006
6 *
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.
11 *
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.
16 *
17 */
18
19#include <linux/kernel.h>
20#include <linux/taskstats_kern.h>
Jay Lanf3cef7a2006-09-30 23:28:55 -070021#include <linux/tsacct_kern.h>
Shailabh Nagar6f449932006-07-14 00:24:41 -070022#include <linux/delayacct.h>
Jay Lan9acc1852006-09-30 23:28:58 -070023#include <linux/tsacct_kern.h>
Shailabh Nagarf9fd8912006-07-14 00:24:47 -070024#include <linux/cpumask.h>
25#include <linux/percpu.h>
Shailabh Nagarc7572492006-07-14 00:24:40 -070026#include <net/genetlink.h>
27#include <asm/atomic.h>
28
Shailabh Nagarf9fd8912006-07-14 00:24:47 -070029/*
30 * Maximum length of a cpumask that can be specified in
31 * the TASKSTATS_CMD_ATTR_REGISTER/DEREGISTER_CPUMASK attribute
32 */
33#define TASKSTATS_CPUMASK_MAXLEN (100+6*NR_CPUS)
34
Shailabh Nagarc7572492006-07-14 00:24:40 -070035static DEFINE_PER_CPU(__u32, taskstats_seqnum) = { 0 };
36static int family_registered;
Christoph Lametere18b8902006-12-06 20:33:20 -080037struct kmem_cache *taskstats_cache;
Shailabh Nagarc7572492006-07-14 00:24:40 -070038
39static struct genl_family family = {
40 .id = GENL_ID_GENERATE,
41 .name = TASKSTATS_GENL_NAME,
42 .version = TASKSTATS_GENL_VERSION,
43 .maxattr = TASKSTATS_CMD_ATTR_MAX,
44};
45
46static struct nla_policy taskstats_cmd_get_policy[TASKSTATS_CMD_ATTR_MAX+1]
47__read_mostly = {
48 [TASKSTATS_CMD_ATTR_PID] = { .type = NLA_U32 },
49 [TASKSTATS_CMD_ATTR_TGID] = { .type = NLA_U32 },
Shailabh Nagarf9fd8912006-07-14 00:24:47 -070050 [TASKSTATS_CMD_ATTR_REGISTER_CPUMASK] = { .type = NLA_STRING },
51 [TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK] = { .type = NLA_STRING },};
52
53struct listener {
54 struct list_head list;
55 pid_t pid;
Shailabh Nagarbb129992006-07-14 00:24:47 -070056 char valid;
Shailabh Nagarc7572492006-07-14 00:24:40 -070057};
58
Shailabh Nagarf9fd8912006-07-14 00:24:47 -070059struct listener_list {
60 struct rw_semaphore sem;
61 struct list_head list;
62};
63static DEFINE_PER_CPU(struct listener_list, listener_array);
64
65enum actions {
66 REGISTER,
67 DEREGISTER,
68 CPU_DONT_CARE
69};
Shailabh Nagarc7572492006-07-14 00:24:40 -070070
71static int prepare_reply(struct genl_info *info, u8 cmd, struct sk_buff **skbp,
Oleg Nesterov37167482006-12-06 20:36:55 -080072 size_t size)
Shailabh Nagarc7572492006-07-14 00:24:40 -070073{
74 struct sk_buff *skb;
75 void *reply;
76
77 /*
78 * If new attributes are added, please revisit this allocation
79 */
Thomas Graf3dabc712006-11-14 19:44:52 -080080 skb = genlmsg_new(size, GFP_KERNEL);
Shailabh Nagarc7572492006-07-14 00:24:40 -070081 if (!skb)
82 return -ENOMEM;
83
84 if (!info) {
85 int seq = get_cpu_var(taskstats_seqnum)++;
86 put_cpu_var(taskstats_seqnum);
87
Thomas Graf17c157c2006-11-14 19:46:02 -080088 reply = genlmsg_put(skb, 0, seq, &family, 0, cmd);
Shailabh Nagarc7572492006-07-14 00:24:40 -070089 } else
Thomas Graf17c157c2006-11-14 19:46:02 -080090 reply = genlmsg_put_reply(skb, info, &family, 0, cmd);
Shailabh Nagarc7572492006-07-14 00:24:40 -070091 if (reply == NULL) {
92 nlmsg_free(skb);
93 return -EINVAL;
94 }
95
96 *skbp = skb;
Shailabh Nagarc7572492006-07-14 00:24:40 -070097 return 0;
98}
99
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700100/*
101 * Send taskstats data in @skb to listener with nl_pid @pid
102 */
103static int send_reply(struct sk_buff *skb, pid_t pid)
Shailabh Nagarc7572492006-07-14 00:24:40 -0700104{
105 struct genlmsghdr *genlhdr = nlmsg_data((struct nlmsghdr *)skb->data);
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700106 void *reply = genlmsg_data(genlhdr);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700107 int rc;
108
Shailabh Nagarc7572492006-07-14 00:24:40 -0700109 rc = genlmsg_end(skb, reply);
110 if (rc < 0) {
111 nlmsg_free(skb);
112 return rc;
113 }
114
Shailabh Nagarc7572492006-07-14 00:24:40 -0700115 return genlmsg_unicast(skb, pid);
116}
117
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700118/*
119 * Send taskstats data in @skb to listeners registered for @cpu's exit data
120 */
Oleg Nesterov115085e2006-12-06 20:36:51 -0800121static void send_cpu_listeners(struct sk_buff *skb,
122 struct listener_list *listeners)
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700123{
124 struct genlmsghdr *genlhdr = nlmsg_data((struct nlmsghdr *)skb->data);
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700125 struct listener *s, *tmp;
126 struct sk_buff *skb_next, *skb_cur = skb;
127 void *reply = genlmsg_data(genlhdr);
Shailabh Nagard94a0412006-07-30 03:03:11 -0700128 int rc, delcount = 0;
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700129
130 rc = genlmsg_end(skb, reply);
131 if (rc < 0) {
132 nlmsg_free(skb);
Shailabh Nagard94a0412006-07-30 03:03:11 -0700133 return;
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700134 }
135
136 rc = 0;
Shailabh Nagarbb129992006-07-14 00:24:47 -0700137 down_read(&listeners->sem);
Shailabh Nagard94a0412006-07-30 03:03:11 -0700138 list_for_each_entry(s, &listeners->list, list) {
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700139 skb_next = NULL;
140 if (!list_is_last(&s->list, &listeners->list)) {
141 skb_next = skb_clone(skb_cur, GFP_KERNEL);
Shailabh Nagard94a0412006-07-30 03:03:11 -0700142 if (!skb_next)
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700143 break;
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700144 }
Shailabh Nagard94a0412006-07-30 03:03:11 -0700145 rc = genlmsg_unicast(skb_cur, s->pid);
146 if (rc == -ECONNREFUSED) {
Shailabh Nagarbb129992006-07-14 00:24:47 -0700147 s->valid = 0;
148 delcount++;
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700149 }
150 skb_cur = skb_next;
151 }
Shailabh Nagarbb129992006-07-14 00:24:47 -0700152 up_read(&listeners->sem);
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700153
Shailabh Nagard94a0412006-07-30 03:03:11 -0700154 if (skb_cur)
155 nlmsg_free(skb_cur);
156
Shailabh Nagarbb129992006-07-14 00:24:47 -0700157 if (!delcount)
Shailabh Nagard94a0412006-07-30 03:03:11 -0700158 return;
Shailabh Nagarbb129992006-07-14 00:24:47 -0700159
160 /* Delete invalidated entries */
161 down_write(&listeners->sem);
162 list_for_each_entry_safe(s, tmp, &listeners->list, list) {
163 if (!s->valid) {
164 list_del(&s->list);
165 kfree(s);
166 }
167 }
168 up_write(&listeners->sem);
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700169}
170
Oleg Nesterova98b6092006-10-28 10:38:54 -0700171static int fill_pid(pid_t pid, struct task_struct *tsk,
Shailabh Nagarc7572492006-07-14 00:24:40 -0700172 struct taskstats *stats)
173{
Shailabh Nagar7d94ddd2006-07-30 03:03:10 -0700174 int rc = 0;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700175
Oleg Nesterova98b6092006-10-28 10:38:54 -0700176 if (!tsk) {
177 rcu_read_lock();
Shailabh Nagarc7572492006-07-14 00:24:40 -0700178 tsk = find_task_by_pid(pid);
Oleg Nesterova98b6092006-10-28 10:38:54 -0700179 if (tsk)
180 get_task_struct(tsk);
181 rcu_read_unlock();
182 if (!tsk)
Shailabh Nagarc7572492006-07-14 00:24:40 -0700183 return -ESRCH;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700184 } else
185 get_task_struct(tsk);
186
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800187 memset(stats, 0, sizeof(*stats));
Shailabh Nagarc7572492006-07-14 00:24:40 -0700188 /*
189 * Each accounting subsystem adds calls to its functions to
190 * fill in relevant parts of struct taskstsats as follows
191 *
Shailabh Nagar7d94ddd2006-07-30 03:03:10 -0700192 * per-task-foo(stats, tsk);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700193 */
194
Shailabh Nagar7d94ddd2006-07-30 03:03:10 -0700195 delayacct_add_tsk(stats, tsk);
Jay Lanf3cef7a2006-09-30 23:28:55 -0700196
197 /* fill in basic acct fields */
Shailabh Nagar6f449932006-07-14 00:24:41 -0700198 stats->version = TASKSTATS_VERSION;
Jay Lanf3cef7a2006-09-30 23:28:55 -0700199 bacct_add_tsk(stats, tsk);
Shailabh Nagar6f449932006-07-14 00:24:41 -0700200
Jay Lan9acc1852006-09-30 23:28:58 -0700201 /* fill in extended acct fields */
202 xacct_add_tsk(stats, tsk);
203
Shailabh Nagar6f449932006-07-14 00:24:41 -0700204 /* Define err: label here if needed */
Shailabh Nagarc7572492006-07-14 00:24:40 -0700205 put_task_struct(tsk);
206 return rc;
207
208}
209
Oleg Nesterova98b6092006-10-28 10:38:54 -0700210static int fill_tgid(pid_t tgid, struct task_struct *first,
Shailabh Nagarc7572492006-07-14 00:24:40 -0700211 struct taskstats *stats)
212{
Oleg Nesterova98b6092006-10-28 10:38:54 -0700213 struct task_struct *tsk;
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700214 unsigned long flags;
Oleg Nesterova98b6092006-10-28 10:38:54 -0700215 int rc = -ESRCH;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700216
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700217 /*
218 * Add additional stats from live tasks except zombie thread group
219 * leaders who are already counted with the dead tasks
220 */
Oleg Nesterova98b6092006-10-28 10:38:54 -0700221 rcu_read_lock();
222 if (!first)
Shailabh Nagarc7572492006-07-14 00:24:40 -0700223 first = find_task_by_pid(tgid);
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700224
Oleg Nesterova98b6092006-10-28 10:38:54 -0700225 if (!first || !lock_task_sighand(first, &flags))
226 goto out;
227
228 if (first->signal->stats)
229 memcpy(stats, first->signal->stats, sizeof(*stats));
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800230 else
231 memset(stats, 0, sizeof(*stats));
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700232
Shailabh Nagarc7572492006-07-14 00:24:40 -0700233 tsk = first;
234 do {
Oleg Nesterovd7c3f5f2006-10-28 10:38:54 -0700235 if (tsk->exit_state)
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700236 continue;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700237 /*
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700238 * Accounting subsystem can call its functions here to
Shailabh Nagarc7572492006-07-14 00:24:40 -0700239 * fill in relevant parts of struct taskstsats as follows
240 *
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700241 * per-task-foo(stats, tsk);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700242 */
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700243 delayacct_add_tsk(stats, tsk);
Shailabh Nagar6f449932006-07-14 00:24:41 -0700244
Shailabh Nagarc7572492006-07-14 00:24:40 -0700245 } while_each_thread(first, tsk);
Shailabh Nagar6f449932006-07-14 00:24:41 -0700246
Oleg Nesterova98b6092006-10-28 10:38:54 -0700247 unlock_task_sighand(first, &flags);
248 rc = 0;
249out:
250 rcu_read_unlock();
251
252 stats->version = TASKSTATS_VERSION;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700253 /*
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700254 * Accounting subsytems can also add calls here to modify
255 * fields of taskstats.
Shailabh Nagarc7572492006-07-14 00:24:40 -0700256 */
Oleg Nesterova98b6092006-10-28 10:38:54 -0700257 return rc;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700258}
259
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700260
261static void fill_tgid_exit(struct task_struct *tsk)
262{
263 unsigned long flags;
264
Oleg Nesterovb8534d72006-10-28 10:38:53 -0700265 spin_lock_irqsave(&tsk->sighand->siglock, flags);
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700266 if (!tsk->signal->stats)
267 goto ret;
268
269 /*
270 * Each accounting subsystem calls its functions here to
271 * accumalate its per-task stats for tsk, into the per-tgid structure
272 *
273 * per-task-foo(tsk->signal->stats, tsk);
274 */
275 delayacct_add_tsk(tsk->signal->stats, tsk);
276ret:
Oleg Nesterovb8534d72006-10-28 10:38:53 -0700277 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700278 return;
279}
280
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700281static int add_del_listener(pid_t pid, cpumask_t *maskp, int isadd)
282{
283 struct listener_list *listeners;
284 struct listener *s, *tmp;
285 unsigned int cpu;
286 cpumask_t mask = *maskp;
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700287
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700288 if (!cpus_subset(mask, cpu_possible_map))
289 return -EINVAL;
290
291 if (isadd == REGISTER) {
292 for_each_cpu_mask(cpu, mask) {
293 s = kmalloc_node(sizeof(struct listener), GFP_KERNEL,
294 cpu_to_node(cpu));
295 if (!s)
296 goto cleanup;
297 s->pid = pid;
298 INIT_LIST_HEAD(&s->list);
Shailabh Nagarbb129992006-07-14 00:24:47 -0700299 s->valid = 1;
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700300
301 listeners = &per_cpu(listener_array, cpu);
302 down_write(&listeners->sem);
303 list_add(&s->list, &listeners->list);
304 up_write(&listeners->sem);
305 }
306 return 0;
307 }
308
309 /* Deregister or cleanup */
310cleanup:
311 for_each_cpu_mask(cpu, mask) {
312 listeners = &per_cpu(listener_array, cpu);
313 down_write(&listeners->sem);
314 list_for_each_entry_safe(s, tmp, &listeners->list, list) {
315 if (s->pid == pid) {
316 list_del(&s->list);
317 kfree(s);
318 break;
319 }
320 }
321 up_write(&listeners->sem);
322 }
323 return 0;
324}
325
326static int parse(struct nlattr *na, cpumask_t *mask)
327{
328 char *data;
329 int len;
330 int ret;
331
332 if (na == NULL)
333 return 1;
334 len = nla_len(na);
335 if (len > TASKSTATS_CPUMASK_MAXLEN)
336 return -E2BIG;
337 if (len < 1)
338 return -EINVAL;
339 data = kmalloc(len, GFP_KERNEL);
340 if (!data)
341 return -ENOMEM;
342 nla_strlcpy(data, na, len);
343 ret = cpulist_parse(data, *mask);
344 kfree(data);
345 return ret;
346}
347
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800348static struct taskstats *mk_reply(struct sk_buff *skb, int type, u32 pid)
Oleg Nesterov68062b82006-12-06 20:36:53 -0800349{
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800350 struct nlattr *na, *ret;
Oleg Nesterov68062b82006-12-06 20:36:53 -0800351 int aggr;
352
Oleg Nesterov37167482006-12-06 20:36:55 -0800353 aggr = (type == TASKSTATS_TYPE_PID)
354 ? TASKSTATS_TYPE_AGGR_PID
355 : TASKSTATS_TYPE_AGGR_TGID;
Oleg Nesterov68062b82006-12-06 20:36:53 -0800356
357 na = nla_nest_start(skb, aggr);
Oleg Nesterov37167482006-12-06 20:36:55 -0800358 if (!na)
359 goto err;
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800360 if (nla_put(skb, type, sizeof(pid), &pid) < 0)
361 goto err;
362 ret = nla_reserve(skb, TASKSTATS_TYPE_STATS, sizeof(struct taskstats));
363 if (!ret)
364 goto err;
Oleg Nesterov68062b82006-12-06 20:36:53 -0800365 nla_nest_end(skb, na);
366
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800367 return nla_data(ret);
368err:
369 return NULL;
Oleg Nesterov68062b82006-12-06 20:36:53 -0800370}
371
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700372static int taskstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
Shailabh Nagarc7572492006-07-14 00:24:40 -0700373{
374 int rc = 0;
375 struct sk_buff *rep_skb;
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800376 struct taskstats *stats;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700377 size_t size;
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700378 cpumask_t mask;
379
380 rc = parse(info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK], &mask);
381 if (rc < 0)
382 return rc;
383 if (rc == 0)
384 return add_del_listener(info->snd_pid, &mask, REGISTER);
385
386 rc = parse(info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK], &mask);
387 if (rc < 0)
388 return rc;
389 if (rc == 0)
390 return add_del_listener(info->snd_pid, &mask, DEREGISTER);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700391
392 /*
393 * Size includes space for nested attributes
394 */
395 size = nla_total_size(sizeof(u32)) +
396 nla_total_size(sizeof(struct taskstats)) + nla_total_size(0);
397
Oleg Nesterov37167482006-12-06 20:36:55 -0800398 rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700399 if (rc < 0)
400 return rc;
401
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800402 rc = -EINVAL;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700403 if (info->attrs[TASKSTATS_CMD_ATTR_PID]) {
404 u32 pid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_PID]);
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800405 stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID, pid);
406 if (!stats)
Oleg Nesterov37167482006-12-06 20:36:55 -0800407 goto err;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700408
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800409 rc = fill_pid(pid, NULL, stats);
410 if (rc < 0)
Oleg Nesterov37167482006-12-06 20:36:55 -0800411 goto err;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700412 } else if (info->attrs[TASKSTATS_CMD_ATTR_TGID]) {
413 u32 tgid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_TGID]);
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800414 stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID, tgid);
415 if (!stats)
Oleg Nesterov37167482006-12-06 20:36:55 -0800416 goto err;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700417
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800418 rc = fill_tgid(tgid, NULL, stats);
419 if (rc < 0)
Oleg Nesterov37167482006-12-06 20:36:55 -0800420 goto err;
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800421 } else
Shailabh Nagarc7572492006-07-14 00:24:40 -0700422 goto err;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700423
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700424 return send_reply(rep_skb, info->snd_pid);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700425err:
426 nlmsg_free(rep_skb);
427 return rc;
428}
429
Oleg Nesterov34ec1232006-12-06 20:36:52 -0800430static struct taskstats *taskstats_tgid_alloc(struct task_struct *tsk)
431{
432 struct signal_struct *sig = tsk->signal;
433 struct taskstats *stats;
434
435 if (sig->stats || thread_group_empty(tsk))
436 goto ret;
437
438 /* No problem if kmem_cache_zalloc() fails */
439 stats = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
440
441 spin_lock_irq(&tsk->sighand->siglock);
442 if (!sig->stats) {
443 sig->stats = stats;
444 stats = NULL;
445 }
446 spin_unlock_irq(&tsk->sighand->siglock);
447
448 if (stats)
449 kmem_cache_free(taskstats_cache, stats);
450ret:
451 return sig->stats;
452}
453
Shailabh Nagarc7572492006-07-14 00:24:40 -0700454/* Send pid data out on exit */
Oleg Nesterov115085e2006-12-06 20:36:51 -0800455void taskstats_exit(struct task_struct *tsk, int group_dead)
Shailabh Nagarc7572492006-07-14 00:24:40 -0700456{
457 int rc;
Oleg Nesterov115085e2006-12-06 20:36:51 -0800458 struct listener_list *listeners;
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800459 struct taskstats *stats;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700460 struct sk_buff *rep_skb;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700461 size_t size;
462 int is_thread_group;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700463
Oleg Nesterov4a279ff2006-10-30 22:07:15 -0800464 if (!family_registered)
Shailabh Nagarc7572492006-07-14 00:24:40 -0700465 return;
466
Shailabh Nagarc7572492006-07-14 00:24:40 -0700467 /*
468 * Size includes space for nested attributes
469 */
470 size = nla_total_size(sizeof(u32)) +
471 nla_total_size(sizeof(struct taskstats)) + nla_total_size(0);
472
Oleg Nesterov34ec1232006-12-06 20:36:52 -0800473 is_thread_group = !!taskstats_tgid_alloc(tsk);
Oleg Nesterov4a279ff2006-10-30 22:07:15 -0800474 if (is_thread_group) {
475 /* PID + STATS + TGID + STATS */
476 size = 2 * size;
477 /* fill the tsk->signal->stats structure */
478 fill_tgid_exit(tsk);
479 }
480
Oleg Nesterov115085e2006-12-06 20:36:51 -0800481 listeners = &__raw_get_cpu_var(listener_array);
482 if (list_empty(&listeners->list))
483 return;
484
Oleg Nesterov37167482006-12-06 20:36:55 -0800485 rc = prepare_reply(NULL, TASKSTATS_CMD_NEW, &rep_skb, size);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700486 if (rc < 0)
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800487 return;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700488
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800489 stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID, tsk->pid);
490 if (!stats)
Oleg Nesterov37167482006-12-06 20:36:55 -0800491 goto err;
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800492
493 rc = fill_pid(tsk->pid, tsk, stats);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700494 if (rc < 0)
Oleg Nesterov37167482006-12-06 20:36:55 -0800495 goto err;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700496
Shailabh Nagarc7572492006-07-14 00:24:40 -0700497 /*
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700498 * Doesn't matter if tsk is the leader or the last group member leaving
Shailabh Nagarc7572492006-07-14 00:24:40 -0700499 */
Oleg Nesterov68062b82006-12-06 20:36:53 -0800500 if (!is_thread_group || !group_dead)
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700501 goto send;
Shailabh Nagarc7572492006-07-14 00:24:40 -0700502
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800503 stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID, tsk->tgid);
504 if (!stats)
Oleg Nesterov37167482006-12-06 20:36:55 -0800505 goto err;
Oleg Nesterov51de4d92006-12-06 20:36:54 -0800506
507 memcpy(stats, tsk->signal->stats, sizeof(*stats));
Shailabh Nagarc7572492006-07-14 00:24:40 -0700508
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700509send:
Oleg Nesterov115085e2006-12-06 20:36:51 -0800510 send_cpu_listeners(rep_skb, listeners);
Shailabh Nagarad4ecbc2006-07-14 00:24:44 -0700511 return;
Oleg Nesterov37167482006-12-06 20:36:55 -0800512err:
Shailabh Nagarc7572492006-07-14 00:24:40 -0700513 nlmsg_free(rep_skb);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700514}
515
516static struct genl_ops taskstats_ops = {
517 .cmd = TASKSTATS_CMD_GET,
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700518 .doit = taskstats_user_cmd,
Shailabh Nagarc7572492006-07-14 00:24:40 -0700519 .policy = taskstats_cmd_get_policy,
520};
521
522/* Needed early in initialization */
523void __init taskstats_init_early(void)
524{
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700525 unsigned int i;
526
Shailabh Nagarc7572492006-07-14 00:24:40 -0700527 taskstats_cache = kmem_cache_create("taskstats_cache",
528 sizeof(struct taskstats),
529 0, SLAB_PANIC, NULL, NULL);
Shailabh Nagarf9fd8912006-07-14 00:24:47 -0700530 for_each_possible_cpu(i) {
531 INIT_LIST_HEAD(&(per_cpu(listener_array, i).list));
532 init_rwsem(&(per_cpu(listener_array, i).sem));
533 }
Shailabh Nagarc7572492006-07-14 00:24:40 -0700534}
535
536static int __init taskstats_init(void)
537{
538 int rc;
539
540 rc = genl_register_family(&family);
541 if (rc)
542 return rc;
543
544 rc = genl_register_ops(&family, &taskstats_ops);
545 if (rc < 0)
546 goto err;
547
548 family_registered = 1;
549 return 0;
550err:
551 genl_unregister_family(&family);
552 return rc;
553}
554
555/*
556 * late initcall ensures initialization of statistics collection
557 * mechanisms precedes initialization of the taskstats interface
558 */
559late_initcall(taskstats_init);