delayacct: align to 8 byte boundary on 64-bit systems
[linux-2.6.git] / kernel / taskstats.c
1 /*
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>
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>
28 #include <linux/fs.h>
29 #include <linux/file.h>
30 #include <net/genetlink.h>
31 #include <asm/atomic.h>
32
33 /*
34  * Maximum length of a cpumask that can be specified in
35  * the TASKSTATS_CMD_ATTR_REGISTER/DEREGISTER_CPUMASK attribute
36  */
37 #define TASKSTATS_CPUMASK_MAXLEN        (100+6*NR_CPUS)
38
39 static DEFINE_PER_CPU(__u32, taskstats_seqnum);
40 static int family_registered;
41 struct kmem_cache *taskstats_cache;
42
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,
48 };
49
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 },};
55
56 static const struct nla_policy cgroupstats_cmd_get_policy[CGROUPSTATS_CMD_ATTR_MAX+1] = {
57         [CGROUPSTATS_CMD_ATTR_FD] = { .type = NLA_U32 },
58 };
59
60 struct listener {
61         struct list_head list;
62         pid_t pid;
63         char valid;
64 };
65
66 struct listener_list {
67         struct rw_semaphore sem;
68         struct list_head list;
69 };
70 static DEFINE_PER_CPU(struct listener_list, listener_array);
71
72 enum actions {
73         REGISTER,
74         DEREGISTER,
75         CPU_DONT_CARE
76 };
77
78 static int prepare_reply(struct genl_info *info, u8 cmd, struct sk_buff **skbp,
79                                 size_t size)
80 {
81         struct sk_buff *skb;
82         void *reply;
83
84         /*
85          * If new attributes are added, please revisit this allocation
86          */
87         skb = genlmsg_new(size, GFP_KERNEL);
88         if (!skb)
89                 return -ENOMEM;
90
91         if (!info) {
92                 int seq = get_cpu_var(taskstats_seqnum)++;
93                 put_cpu_var(taskstats_seqnum);
94
95                 reply = genlmsg_put(skb, 0, seq, &family, 0, cmd);
96         } else
97                 reply = genlmsg_put_reply(skb, info, &family, 0, cmd);
98         if (reply == NULL) {
99                 nlmsg_free(skb);
100                 return -EINVAL;
101         }
102
103         *skbp = skb;
104         return 0;
105 }
106
107 /*
108  * Send taskstats data in @skb to listener with nl_pid @pid
109  */
110 static int send_reply(struct sk_buff *skb, struct genl_info *info)
111 {
112         struct genlmsghdr *genlhdr = nlmsg_data(nlmsg_hdr(skb));
113         void *reply = genlmsg_data(genlhdr);
114         int rc;
115
116         rc = genlmsg_end(skb, reply);
117         if (rc < 0) {
118                 nlmsg_free(skb);
119                 return rc;
120         }
121
122         return genlmsg_reply(skb, info);
123 }
124
125 /*
126  * Send taskstats data in @skb to listeners registered for @cpu's exit data
127  */
128 static void send_cpu_listeners(struct sk_buff *skb,
129                                         struct listener_list *listeners)
130 {
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;
136
137         rc = genlmsg_end(skb, reply);
138         if (rc < 0) {
139                 nlmsg_free(skb);
140                 return;
141         }
142
143         rc = 0;
144         down_read(&listeners->sem);
145         list_for_each_entry(s, &listeners->list, list) {
146                 skb_next = NULL;
147                 if (!list_is_last(&s->list, &listeners->list)) {
148                         skb_next = skb_clone(skb_cur, GFP_KERNEL);
149                         if (!skb_next)
150                                 break;
151                 }
152                 rc = genlmsg_unicast(&init_net, skb_cur, s->pid);
153                 if (rc == -ECONNREFUSED) {
154                         s->valid = 0;
155                         delcount++;
156                 }
157                 skb_cur = skb_next;
158         }
159         up_read(&listeners->sem);
160
161         if (skb_cur)
162                 nlmsg_free(skb_cur);
163
164         if (!delcount)
165                 return;
166
167         /* Delete invalidated entries */
168         down_write(&listeners->sem);
169         list_for_each_entry_safe(s, tmp, &listeners->list, list) {
170                 if (!s->valid) {
171                         list_del(&s->list);
172                         kfree(s);
173                 }
174         }
175         up_write(&listeners->sem);
176 }
177
178 static int fill_pid(pid_t pid, struct task_struct *tsk,
179                 struct taskstats *stats)
180 {
181         int rc = 0;
182
183         if (!tsk) {
184                 rcu_read_lock();
185                 tsk = find_task_by_vpid(pid);
186                 if (tsk)
187                         get_task_struct(tsk);
188                 rcu_read_unlock();
189                 if (!tsk)
190                         return -ESRCH;
191         } else
192                 get_task_struct(tsk);
193
194         memset(stats, 0, sizeof(*stats));
195         /*
196          * Each accounting subsystem adds calls to its functions to
197          * fill in relevant parts of struct taskstsats as follows
198          *
199          *      per-task-foo(stats, tsk);
200          */
201
202         delayacct_add_tsk(stats, tsk);
203
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);
209
210         /* fill in extended acct fields */
211         xacct_add_tsk(stats, tsk);
212
213         /* Define err: label here if needed */
214         put_task_struct(tsk);
215         return rc;
216
217 }
218
219 static int fill_tgid(pid_t tgid, struct task_struct *first,
220                 struct taskstats *stats)
221 {
222         struct task_struct *tsk;
223         unsigned long flags;
224         int rc = -ESRCH;
225
226         /*
227          * Add additional stats from live tasks except zombie thread group
228          * leaders who are already counted with the dead tasks
229          */
230         rcu_read_lock();
231         if (!first)
232                 first = find_task_by_vpid(tgid);
233
234         if (!first || !lock_task_sighand(first, &flags))
235                 goto out;
236
237         if (first->signal->stats)
238                 memcpy(stats, first->signal->stats, sizeof(*stats));
239         else
240                 memset(stats, 0, sizeof(*stats));
241
242         tsk = first;
243         do {
244                 if (tsk->exit_state)
245                         continue;
246                 /*
247                  * Accounting subsystem can call its functions here to
248                  * fill in relevant parts of struct taskstsats as follows
249                  *
250                  *      per-task-foo(stats, tsk);
251                  */
252                 delayacct_add_tsk(stats, tsk);
253
254                 stats->nvcsw += tsk->nvcsw;
255                 stats->nivcsw += tsk->nivcsw;
256         } while_each_thread(first, tsk);
257
258         unlock_task_sighand(first, &flags);
259         rc = 0;
260 out:
261         rcu_read_unlock();
262
263         stats->version = TASKSTATS_VERSION;
264         /*
265          * Accounting subsystems can also add calls here to modify
266          * fields of taskstats.
267          */
268         return rc;
269 }
270
271
272 static void fill_tgid_exit(struct task_struct *tsk)
273 {
274         unsigned long flags;
275
276         spin_lock_irqsave(&tsk->sighand->siglock, flags);
277         if (!tsk->signal->stats)
278                 goto ret;
279
280         /*
281          * Each accounting subsystem calls its functions here to
282          * accumalate its per-task stats for tsk, into the per-tgid structure
283          *
284          *      per-task-foo(tsk->signal->stats, tsk);
285          */
286         delayacct_add_tsk(tsk->signal->stats, tsk);
287 ret:
288         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
289         return;
290 }
291
292 static int add_del_listener(pid_t pid, const struct cpumask *mask, int isadd)
293 {
294         struct listener_list *listeners;
295         struct listener *s, *tmp;
296         unsigned int cpu;
297
298         if (!cpumask_subset(mask, cpu_possible_mask))
299                 return -EINVAL;
300
301         if (isadd == REGISTER) {
302                 for_each_cpu(cpu, mask) {
303                         s = kmalloc_node(sizeof(struct listener), GFP_KERNEL,
304                                          cpu_to_node(cpu));
305                         if (!s)
306                                 goto cleanup;
307                         s->pid = pid;
308                         INIT_LIST_HEAD(&s->list);
309                         s->valid = 1;
310
311                         listeners = &per_cpu(listener_array, cpu);
312                         down_write(&listeners->sem);
313                         list_add(&s->list, &listeners->list);
314                         up_write(&listeners->sem);
315                 }
316                 return 0;
317         }
318
319         /* Deregister or cleanup */
320 cleanup:
321         for_each_cpu(cpu, mask) {
322                 listeners = &per_cpu(listener_array, cpu);
323                 down_write(&listeners->sem);
324                 list_for_each_entry_safe(s, tmp, &listeners->list, list) {
325                         if (s->pid == pid) {
326                                 list_del(&s->list);
327                                 kfree(s);
328                                 break;
329                         }
330                 }
331                 up_write(&listeners->sem);
332         }
333         return 0;
334 }
335
336 static int parse(struct nlattr *na, struct cpumask *mask)
337 {
338         char *data;
339         int len;
340         int ret;
341
342         if (na == NULL)
343                 return 1;
344         len = nla_len(na);
345         if (len > TASKSTATS_CPUMASK_MAXLEN)
346                 return -E2BIG;
347         if (len < 1)
348                 return -EINVAL;
349         data = kmalloc(len, GFP_KERNEL);
350         if (!data)
351                 return -ENOMEM;
352         nla_strlcpy(data, na, len);
353         ret = cpulist_parse(data, mask);
354         kfree(data);
355         return ret;
356 }
357
358 static struct taskstats *mk_reply(struct sk_buff *skb, int type, u32 pid)
359 {
360         struct nlattr *na, *ret;
361         int aggr;
362
363         /* If we don't pad, we end up with alignment on a 4 byte boundary.
364          * This causes lots of runtime warnings on systems requiring 8 byte
365          * alignment */
366         u32 pids[2] = { pid, 0 };
367         int pid_size = ALIGN(sizeof(pid), sizeof(long));
368
369         aggr = (type == TASKSTATS_TYPE_PID)
370                         ? TASKSTATS_TYPE_AGGR_PID
371                         : TASKSTATS_TYPE_AGGR_TGID;
372
373         na = nla_nest_start(skb, aggr);
374         if (!na)
375                 goto err;
376         if (nla_put(skb, type, pid_size, pids) < 0)
377                 goto err;
378         ret = nla_reserve(skb, TASKSTATS_TYPE_STATS, sizeof(struct taskstats));
379         if (!ret)
380                 goto err;
381         nla_nest_end(skb, na);
382
383         return nla_data(ret);
384 err:
385         return NULL;
386 }
387
388 static int cgroupstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
389 {
390         int rc = 0;
391         struct sk_buff *rep_skb;
392         struct cgroupstats *stats;
393         struct nlattr *na;
394         size_t size;
395         u32 fd;
396         struct file *file;
397         int fput_needed;
398
399         na = info->attrs[CGROUPSTATS_CMD_ATTR_FD];
400         if (!na)
401                 return -EINVAL;
402
403         fd = nla_get_u32(info->attrs[CGROUPSTATS_CMD_ATTR_FD]);
404         file = fget_light(fd, &fput_needed);
405         if (!file)
406                 return 0;
407
408         size = nla_total_size(sizeof(struct cgroupstats));
409
410         rc = prepare_reply(info, CGROUPSTATS_CMD_NEW, &rep_skb,
411                                 size);
412         if (rc < 0)
413                 goto err;
414
415         na = nla_reserve(rep_skb, CGROUPSTATS_TYPE_CGROUP_STATS,
416                                 sizeof(struct cgroupstats));
417         stats = nla_data(na);
418         memset(stats, 0, sizeof(*stats));
419
420         rc = cgroupstats_build(stats, file->f_dentry);
421         if (rc < 0) {
422                 nlmsg_free(rep_skb);
423                 goto err;
424         }
425
426         rc = send_reply(rep_skb, info);
427
428 err:
429         fput_light(file, fput_needed);
430         return rc;
431 }
432
433 static int taskstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
434 {
435         int rc;
436         struct sk_buff *rep_skb;
437         struct taskstats *stats;
438         size_t size;
439         cpumask_var_t mask;
440
441         if (!alloc_cpumask_var(&mask, GFP_KERNEL))
442                 return -ENOMEM;
443
444         rc = parse(info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK], mask);
445         if (rc < 0)
446                 goto free_return_rc;
447         if (rc == 0) {
448                 rc = add_del_listener(info->snd_pid, mask, REGISTER);
449                 goto free_return_rc;
450         }
451
452         rc = parse(info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK], mask);
453         if (rc < 0)
454                 goto free_return_rc;
455         if (rc == 0) {
456                 rc = add_del_listener(info->snd_pid, mask, DEREGISTER);
457 free_return_rc:
458                 free_cpumask_var(mask);
459                 return rc;
460         }
461         free_cpumask_var(mask);
462
463         /*
464          * Size includes space for nested attributes
465          */
466         size = nla_total_size(sizeof(u32)) +
467                 nla_total_size(sizeof(struct taskstats)) + nla_total_size(0);
468
469         rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
470         if (rc < 0)
471                 return rc;
472
473         rc = -EINVAL;
474         if (info->attrs[TASKSTATS_CMD_ATTR_PID]) {
475                 u32 pid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_PID]);
476                 stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID, pid);
477                 if (!stats)
478                         goto err;
479
480                 rc = fill_pid(pid, NULL, stats);
481                 if (rc < 0)
482                         goto err;
483         } else if (info->attrs[TASKSTATS_CMD_ATTR_TGID]) {
484                 u32 tgid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_TGID]);
485                 stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID, tgid);
486                 if (!stats)
487                         goto err;
488
489                 rc = fill_tgid(tgid, NULL, stats);
490                 if (rc < 0)
491                         goto err;
492         } else
493                 goto err;
494
495         return send_reply(rep_skb, info);
496 err:
497         nlmsg_free(rep_skb);
498         return rc;
499 }
500
501 static struct taskstats *taskstats_tgid_alloc(struct task_struct *tsk)
502 {
503         struct signal_struct *sig = tsk->signal;
504         struct taskstats *stats;
505
506         if (sig->stats || thread_group_empty(tsk))
507                 goto ret;
508
509         /* No problem if kmem_cache_zalloc() fails */
510         stats = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
511
512         spin_lock_irq(&tsk->sighand->siglock);
513         if (!sig->stats) {
514                 sig->stats = stats;
515                 stats = NULL;
516         }
517         spin_unlock_irq(&tsk->sighand->siglock);
518
519         if (stats)
520                 kmem_cache_free(taskstats_cache, stats);
521 ret:
522         return sig->stats;
523 }
524
525 /* Send pid data out on exit */
526 void taskstats_exit(struct task_struct *tsk, int group_dead)
527 {
528         int rc;
529         struct listener_list *listeners;
530         struct taskstats *stats;
531         struct sk_buff *rep_skb;
532         size_t size;
533         int is_thread_group;
534
535         if (!family_registered)
536                 return;
537
538         /*
539          * Size includes space for nested attributes
540          */
541         size = nla_total_size(sizeof(u32)) +
542                 nla_total_size(sizeof(struct taskstats)) + nla_total_size(0);
543
544         is_thread_group = !!taskstats_tgid_alloc(tsk);
545         if (is_thread_group) {
546                 /* PID + STATS + TGID + STATS */
547                 size = 2 * size;
548                 /* fill the tsk->signal->stats structure */
549                 fill_tgid_exit(tsk);
550         }
551
552         listeners = &__raw_get_cpu_var(listener_array);
553         if (list_empty(&listeners->list))
554                 return;
555
556         rc = prepare_reply(NULL, TASKSTATS_CMD_NEW, &rep_skb, size);
557         if (rc < 0)
558                 return;
559
560         stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID, tsk->pid);
561         if (!stats)
562                 goto err;
563
564         rc = fill_pid(-1, tsk, stats);
565         if (rc < 0)
566                 goto err;
567
568         /*
569          * Doesn't matter if tsk is the leader or the last group member leaving
570          */
571         if (!is_thread_group || !group_dead)
572                 goto send;
573
574         stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID, tsk->tgid);
575         if (!stats)
576                 goto err;
577
578         memcpy(stats, tsk->signal->stats, sizeof(*stats));
579
580 send:
581         send_cpu_listeners(rep_skb, listeners);
582         return;
583 err:
584         nlmsg_free(rep_skb);
585 }
586
587 static struct genl_ops taskstats_ops = {
588         .cmd            = TASKSTATS_CMD_GET,
589         .doit           = taskstats_user_cmd,
590         .policy         = taskstats_cmd_get_policy,
591 };
592
593 static struct genl_ops cgroupstats_ops = {
594         .cmd            = CGROUPSTATS_CMD_GET,
595         .doit           = cgroupstats_user_cmd,
596         .policy         = cgroupstats_cmd_get_policy,
597 };
598
599 /* Needed early in initialization */
600 void __init taskstats_init_early(void)
601 {
602         unsigned int i;
603
604         taskstats_cache = KMEM_CACHE(taskstats, SLAB_PANIC);
605         for_each_possible_cpu(i) {
606                 INIT_LIST_HEAD(&(per_cpu(listener_array, i).list));
607                 init_rwsem(&(per_cpu(listener_array, i).sem));
608         }
609 }
610
611 static int __init taskstats_init(void)
612 {
613         int rc;
614
615         rc = genl_register_family(&family);
616         if (rc)
617                 return rc;
618
619         rc = genl_register_ops(&family, &taskstats_ops);
620         if (rc < 0)
621                 goto err;
622
623         rc = genl_register_ops(&family, &cgroupstats_ops);
624         if (rc < 0)
625                 goto err_cgroup_ops;
626
627         family_registered = 1;
628         printk("registered taskstats version %d\n", TASKSTATS_GENL_VERSION);
629         return 0;
630 err_cgroup_ops:
631         genl_unregister_ops(&family, &taskstats_ops);
632 err:
633         genl_unregister_family(&family);
634         return rc;
635 }
636
637 /*
638  * late initcall ensures initialization of statistics collection
639  * mechanisms precedes initialization of the taskstats interface
640  */
641 late_initcall(taskstats_init);