taskstats.c 16 KB

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