Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/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 <linux/pid_namespace.h>
 31 #include <net/genetlink.h>
 32 #include <linux/atomic.h>
 33 
 34 /*
 35  * Maximum length of a cpumask that can be specified in
 36  * the TASKSTATS_CMD_ATTR_REGISTER/DEREGISTER_CPUMASK attribute
 37  */
 38 #define TASKSTATS_CPUMASK_MAXLEN        (100+6*NR_CPUS)
 39 
 40 static DEFINE_PER_CPU(__u32, taskstats_seqnum);
 41 static int family_registered;
 42 struct kmem_cache *taskstats_cache;
 43 
 44 static struct genl_family family;
 45 
 46 static const struct nla_policy taskstats_cmd_get_policy[TASKSTATS_CMD_ATTR_MAX+1] = {
 47         [TASKSTATS_CMD_ATTR_PID]  = { .type = NLA_U32 },
 48         [TASKSTATS_CMD_ATTR_TGID] = { .type = NLA_U32 },
 49         [TASKSTATS_CMD_ATTR_REGISTER_CPUMASK] = { .type = NLA_STRING },
 50         [TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK] = { .type = NLA_STRING },};
 51 
 52 /*
 53  * We have to use TASKSTATS_CMD_ATTR_MAX here, it is the maxattr in the family.
 54  * Make sure they are always aligned.
 55  */
 56 static const struct nla_policy cgroupstats_cmd_get_policy[TASKSTATS_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 = this_cpu_inc_return(taskstats_seqnum) - 1;
 93 
 94                 reply = genlmsg_put(skb, 0, seq, &family, 0, cmd);
 95         } else
 96                 reply = genlmsg_put_reply(skb, info, &family, 0, cmd);
 97         if (reply == NULL) {
 98                 nlmsg_free(skb);
 99                 return -EINVAL;
100         }
101 
102         *skbp = skb;
103         return 0;
104 }
105 
106 /*
107  * Send taskstats data in @skb to listener with nl_pid @pid
108  */
109 static int send_reply(struct sk_buff *skb, struct genl_info *info)
110 {
111         struct genlmsghdr *genlhdr = nlmsg_data(nlmsg_hdr(skb));
112         void *reply = genlmsg_data(genlhdr);
113 
114         genlmsg_end(skb, reply);
115 
116         return genlmsg_reply(skb, info);
117 }
118 
119 /*
120  * Send taskstats data in @skb to listeners registered for @cpu's exit data
121  */
122 static void send_cpu_listeners(struct sk_buff *skb,
123                                         struct listener_list *listeners)
124 {
125         struct genlmsghdr *genlhdr = nlmsg_data(nlmsg_hdr(skb));
126         struct listener *s, *tmp;
127         struct sk_buff *skb_next, *skb_cur = skb;
128         void *reply = genlmsg_data(genlhdr);
129         int rc, delcount = 0;
130 
131         genlmsg_end(skb, reply);
132 
133         rc = 0;
134         down_read(&listeners->sem);
135         list_for_each_entry(s, &listeners->list, list) {
136                 skb_next = NULL;
137                 if (!list_is_last(&s->list, &listeners->list)) {
138                         skb_next = skb_clone(skb_cur, GFP_KERNEL);
139                         if (!skb_next)
140                                 break;
141                 }
142                 rc = genlmsg_unicast(&init_net, skb_cur, s->pid);
143                 if (rc == -ECONNREFUSED) {
144                         s->valid = 0;
145                         delcount++;
146                 }
147                 skb_cur = skb_next;
148         }
149         up_read(&listeners->sem);
150 
151         if (skb_cur)
152                 nlmsg_free(skb_cur);
153 
154         if (!delcount)
155                 return;
156 
157         /* Delete invalidated entries */
158         down_write(&listeners->sem);
159         list_for_each_entry_safe(s, tmp, &listeners->list, list) {
160                 if (!s->valid) {
161                         list_del(&s->list);
162                         kfree(s);
163                 }
164         }
165         up_write(&listeners->sem);
166 }
167 
168 static void fill_stats(struct user_namespace *user_ns,
169                        struct pid_namespace *pid_ns,
170                        struct task_struct *tsk, struct taskstats *stats)
171 {
172         memset(stats, 0, sizeof(*stats));
173         /*
174          * Each accounting subsystem adds calls to its functions to
175          * fill in relevant parts of struct taskstsats as follows
176          *
177          *      per-task-foo(stats, tsk);
178          */
179 
180         delayacct_add_tsk(stats, tsk);
181 
182         /* fill in basic acct fields */
183         stats->version = TASKSTATS_VERSION;
184         stats->nvcsw = tsk->nvcsw;
185         stats->nivcsw = tsk->nivcsw;
186         bacct_add_tsk(user_ns, pid_ns, stats, tsk);
187 
188         /* fill in extended acct fields */
189         xacct_add_tsk(stats, tsk);
190 }
191 
192 static int fill_stats_for_pid(pid_t pid, struct taskstats *stats)
193 {
194         struct task_struct *tsk;
195 
196         rcu_read_lock();
197         tsk = find_task_by_vpid(pid);
198         if (tsk)
199                 get_task_struct(tsk);
200         rcu_read_unlock();
201         if (!tsk)
202                 return -ESRCH;
203         fill_stats(current_user_ns(), task_active_pid_ns(current), tsk, stats);
204         put_task_struct(tsk);
205         return 0;
206 }
207 
208 static int fill_stats_for_tgid(pid_t tgid, struct taskstats *stats)
209 {
210         struct task_struct *tsk, *first;
211         unsigned long flags;
212         int rc = -ESRCH;
213 
214         /*
215          * Add additional stats from live tasks except zombie thread group
216          * leaders who are already counted with the dead tasks
217          */
218         rcu_read_lock();
219         first = find_task_by_vpid(tgid);
220 
221         if (!first || !lock_task_sighand(first, &flags))
222                 goto out;
223 
224         if (first->signal->stats)
225                 memcpy(stats, first->signal->stats, sizeof(*stats));
226         else
227                 memset(stats, 0, sizeof(*stats));
228 
229         tsk = first;
230         do {
231                 if (tsk->exit_state)
232                         continue;
233                 /*
234                  * Accounting subsystem can call its functions here to
235                  * fill in relevant parts of struct taskstsats as follows
236                  *
237                  *      per-task-foo(stats, tsk);
238                  */
239                 delayacct_add_tsk(stats, tsk);
240 
241                 stats->nvcsw += tsk->nvcsw;
242                 stats->nivcsw += tsk->nivcsw;
243         } while_each_thread(first, tsk);
244 
245         unlock_task_sighand(first, &flags);
246         rc = 0;
247 out:
248         rcu_read_unlock();
249 
250         stats->version = TASKSTATS_VERSION;
251         /*
252          * Accounting subsystems can also add calls here to modify
253          * fields of taskstats.
254          */
255         return rc;
256 }
257 
258 static void fill_tgid_exit(struct task_struct *tsk)
259 {
260         unsigned long flags;
261 
262         spin_lock_irqsave(&tsk->sighand->siglock, flags);
263         if (!tsk->signal->stats)
264                 goto ret;
265 
266         /*
267          * Each accounting subsystem calls its functions here to
268          * accumalate its per-task stats for tsk, into the per-tgid structure
269          *
270          *      per-task-foo(tsk->signal->stats, tsk);
271          */
272         delayacct_add_tsk(tsk->signal->stats, tsk);
273 ret:
274         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
275         return;
276 }
277 
278 static int add_del_listener(pid_t pid, const struct cpumask *mask, int isadd)
279 {
280         struct listener_list *listeners;
281         struct listener *s, *tmp, *s2;
282         unsigned int cpu;
283         int ret = 0;
284 
285         if (!cpumask_subset(mask, cpu_possible_mask))
286                 return -EINVAL;
287 
288         if (current_user_ns() != &init_user_ns)
289                 return -EINVAL;
290 
291         if (task_active_pid_ns(current) != &init_pid_ns)
292                 return -EINVAL;
293 
294         if (isadd == REGISTER) {
295                 for_each_cpu(cpu, mask) {
296                         s = kmalloc_node(sizeof(struct listener),
297                                         GFP_KERNEL, cpu_to_node(cpu));
298                         if (!s) {
299                                 ret = -ENOMEM;
300                                 goto cleanup;
301                         }
302                         s->pid = pid;
303                         s->valid = 1;
304 
305                         listeners = &per_cpu(listener_array, cpu);
306                         down_write(&listeners->sem);
307                         list_for_each_entry(s2, &listeners->list, list) {
308                                 if (s2->pid == pid && s2->valid)
309                                         goto exists;
310                         }
311                         list_add(&s->list, &listeners->list);
312                         s = NULL;
313 exists:
314                         up_write(&listeners->sem);
315                         kfree(s); /* nop if NULL */
316                 }
317                 return 0;
318         }
319 
320         /* Deregister or cleanup */
321 cleanup:
322         for_each_cpu(cpu, mask) {
323                 listeners = &per_cpu(listener_array, cpu);
324                 down_write(&listeners->sem);
325                 list_for_each_entry_safe(s, tmp, &listeners->list, list) {
326                         if (s->pid == pid) {
327                                 list_del(&s->list);
328                                 kfree(s);
329                                 break;
330                         }
331                 }
332                 up_write(&listeners->sem);
333         }
334         return ret;
335 }
336 
337 static int parse(struct nlattr *na, struct cpumask *mask)
338 {
339         char *data;
340         int len;
341         int ret;
342 
343         if (na == NULL)
344                 return 1;
345         len = nla_len(na);
346         if (len > TASKSTATS_CPUMASK_MAXLEN)
347                 return -E2BIG;
348         if (len < 1)
349                 return -EINVAL;
350         data = kmalloc(len, GFP_KERNEL);
351         if (!data)
352                 return -ENOMEM;
353         nla_strlcpy(data, na, len);
354         ret = cpulist_parse(data, mask);
355         kfree(data);
356         return ret;
357 }
358 
359 static struct taskstats *mk_reply(struct sk_buff *skb, int type, u32 pid)
360 {
361         struct nlattr *na, *ret;
362         int aggr;
363 
364         aggr = (type == TASKSTATS_TYPE_PID)
365                         ? TASKSTATS_TYPE_AGGR_PID
366                         : TASKSTATS_TYPE_AGGR_TGID;
367 
368         na = nla_nest_start(skb, aggr);
369         if (!na)
370                 goto err;
371 
372         if (nla_put(skb, type, sizeof(pid), &pid) < 0) {
373                 nla_nest_cancel(skb, na);
374                 goto err;
375         }
376         ret = nla_reserve_64bit(skb, TASKSTATS_TYPE_STATS,
377                                 sizeof(struct taskstats), TASKSTATS_TYPE_NULL);
378         if (!ret) {
379                 nla_nest_cancel(skb, na);
380                 goto err;
381         }
382         nla_nest_end(skb, na);
383 
384         return nla_data(ret);
385 err:
386         return NULL;
387 }
388 
389 static int cgroupstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
390 {
391         int rc = 0;
392         struct sk_buff *rep_skb;
393         struct cgroupstats *stats;
394         struct nlattr *na;
395         size_t size;
396         u32 fd;
397         struct fd f;
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         f = fdget(fd);
405         if (!f.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         if (na == NULL) {
418                 nlmsg_free(rep_skb);
419                 rc = -EMSGSIZE;
420                 goto err;
421         }
422 
423         stats = nla_data(na);
424         memset(stats, 0, sizeof(*stats));
425 
426         rc = cgroupstats_build(stats, f.file->f_path.dentry);
427         if (rc < 0) {
428                 nlmsg_free(rep_skb);
429                 goto err;
430         }
431 
432         rc = send_reply(rep_skb, info);
433 
434 err:
435         fdput(f);
436         return rc;
437 }
438 
439 static int cmd_attr_register_cpumask(struct genl_info *info)
440 {
441         cpumask_var_t mask;
442         int rc;
443 
444         if (!alloc_cpumask_var(&mask, GFP_KERNEL))
445                 return -ENOMEM;
446         rc = parse(info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK], mask);
447         if (rc < 0)
448                 goto out;
449         rc = add_del_listener(info->snd_portid, mask, REGISTER);
450 out:
451         free_cpumask_var(mask);
452         return rc;
453 }
454 
455 static int cmd_attr_deregister_cpumask(struct genl_info *info)
456 {
457         cpumask_var_t mask;
458         int rc;
459 
460         if (!alloc_cpumask_var(&mask, GFP_KERNEL))
461                 return -ENOMEM;
462         rc = parse(info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK], mask);
463         if (rc < 0)
464                 goto out;
465         rc = add_del_listener(info->snd_portid, mask, DEREGISTER);
466 out:
467         free_cpumask_var(mask);
468         return rc;
469 }
470 
471 static size_t taskstats_packet_size(void)
472 {
473         size_t size;
474 
475         size = nla_total_size(sizeof(u32)) +
476                 nla_total_size_64bit(sizeof(struct taskstats)) +
477                 nla_total_size(0);
478 
479         return size;
480 }
481 
482 static int cmd_attr_pid(struct genl_info *info)
483 {
484         struct taskstats *stats;
485         struct sk_buff *rep_skb;
486         size_t size;
487         u32 pid;
488         int rc;
489 
490         size = taskstats_packet_size();
491 
492         rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
493         if (rc < 0)
494                 return rc;
495 
496         rc = -EINVAL;
497         pid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_PID]);
498         stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID, pid);
499         if (!stats)
500                 goto err;
501 
502         rc = fill_stats_for_pid(pid, stats);
503         if (rc < 0)
504                 goto err;
505         return send_reply(rep_skb, info);
506 err:
507         nlmsg_free(rep_skb);
508         return rc;
509 }
510 
511 static int cmd_attr_tgid(struct genl_info *info)
512 {
513         struct taskstats *stats;
514         struct sk_buff *rep_skb;
515         size_t size;
516         u32 tgid;
517         int rc;
518 
519         size = taskstats_packet_size();
520 
521         rc = prepare_reply(info, TASKSTATS_CMD_NEW, &rep_skb, size);
522         if (rc < 0)
523                 return rc;
524 
525         rc = -EINVAL;
526         tgid = nla_get_u32(info->attrs[TASKSTATS_CMD_ATTR_TGID]);
527         stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID, tgid);
528         if (!stats)
529                 goto err;
530 
531         rc = fill_stats_for_tgid(tgid, stats);
532         if (rc < 0)
533                 goto err;
534         return send_reply(rep_skb, info);
535 err:
536         nlmsg_free(rep_skb);
537         return rc;
538 }
539 
540 static int taskstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
541 {
542         if (info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK])
543                 return cmd_attr_register_cpumask(info);
544         else if (info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK])
545                 return cmd_attr_deregister_cpumask(info);
546         else if (info->attrs[TASKSTATS_CMD_ATTR_PID])
547                 return cmd_attr_pid(info);
548         else if (info->attrs[TASKSTATS_CMD_ATTR_TGID])
549                 return cmd_attr_tgid(info);
550         else
551                 return -EINVAL;
552 }
553 
554 static struct taskstats *taskstats_tgid_alloc(struct task_struct *tsk)
555 {
556         struct signal_struct *sig = tsk->signal;
557         struct taskstats *stats;
558 
559         if (sig->stats || thread_group_empty(tsk))
560                 goto ret;
561 
562         /* No problem if kmem_cache_zalloc() fails */
563         stats = kmem_cache_zalloc(taskstats_cache, GFP_KERNEL);
564 
565         spin_lock_irq(&tsk->sighand->siglock);
566         if (!sig->stats) {
567                 sig->stats = stats;
568                 stats = NULL;
569         }
570         spin_unlock_irq(&tsk->sighand->siglock);
571 
572         if (stats)
573                 kmem_cache_free(taskstats_cache, stats);
574 ret:
575         return sig->stats;
576 }
577 
578 /* Send pid data out on exit */
579 void taskstats_exit(struct task_struct *tsk, int group_dead)
580 {
581         int rc;
582         struct listener_list *listeners;
583         struct taskstats *stats;
584         struct sk_buff *rep_skb;
585         size_t size;
586         int is_thread_group;
587 
588         if (!family_registered)
589                 return;
590 
591         /*
592          * Size includes space for nested attributes
593          */
594         size = taskstats_packet_size();
595 
596         is_thread_group = !!taskstats_tgid_alloc(tsk);
597         if (is_thread_group) {
598                 /* PID + STATS + TGID + STATS */
599                 size = 2 * size;
600                 /* fill the tsk->signal->stats structure */
601                 fill_tgid_exit(tsk);
602         }
603 
604         listeners = raw_cpu_ptr(&listener_array);
605         if (list_empty(&listeners->list))
606                 return;
607 
608         rc = prepare_reply(NULL, TASKSTATS_CMD_NEW, &rep_skb, size);
609         if (rc < 0)
610                 return;
611 
612         stats = mk_reply(rep_skb, TASKSTATS_TYPE_PID,
613                          task_pid_nr_ns(tsk, &init_pid_ns));
614         if (!stats)
615                 goto err;
616 
617         fill_stats(&init_user_ns, &init_pid_ns, tsk, stats);
618 
619         /*
620          * Doesn't matter if tsk is the leader or the last group member leaving
621          */
622         if (!is_thread_group || !group_dead)
623                 goto send;
624 
625         stats = mk_reply(rep_skb, TASKSTATS_TYPE_TGID,
626                          task_tgid_nr_ns(tsk, &init_pid_ns));
627         if (!stats)
628                 goto err;
629 
630         memcpy(stats, tsk->signal->stats, sizeof(*stats));
631 
632 send:
633         send_cpu_listeners(rep_skb, listeners);
634         return;
635 err:
636         nlmsg_free(rep_skb);
637 }
638 
639 static const struct genl_ops taskstats_ops[] = {
640         {
641                 .cmd            = TASKSTATS_CMD_GET,
642                 .doit           = taskstats_user_cmd,
643                 .policy         = taskstats_cmd_get_policy,
644                 .flags          = GENL_ADMIN_PERM,
645         },
646         {
647                 .cmd            = CGROUPSTATS_CMD_GET,
648                 .doit           = cgroupstats_user_cmd,
649                 .policy         = cgroupstats_cmd_get_policy,
650         },
651 };
652 
653 static struct genl_family family __ro_after_init = {
654         .name           = TASKSTATS_GENL_NAME,
655         .version        = TASKSTATS_GENL_VERSION,
656         .maxattr        = TASKSTATS_CMD_ATTR_MAX,
657         .module         = THIS_MODULE,
658         .ops            = taskstats_ops,
659         .n_ops          = ARRAY_SIZE(taskstats_ops),
660 };
661 
662 /* Needed early in initialization */
663 void __init taskstats_init_early(void)
664 {
665         unsigned int i;
666 
667         taskstats_cache = KMEM_CACHE(taskstats, SLAB_PANIC);
668         for_each_possible_cpu(i) {
669                 INIT_LIST_HEAD(&(per_cpu(listener_array, i).list));
670                 init_rwsem(&(per_cpu(listener_array, i).sem));
671         }
672 }
673 
674 static int __init taskstats_init(void)
675 {
676         int rc;
677 
678         rc = genl_register_family(&family);
679         if (rc)
680                 return rc;
681 
682         family_registered = 1;
683         pr_info("registered taskstats version %d\n", TASKSTATS_GENL_VERSION);
684         return 0;
685 }
686 
687 /*
688  * late initcall ensures initialization of statistics collection
689  * mechanisms precedes initialization of the taskstats interface
690  */
691 late_initcall(taskstats_init);
692 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us