taskstats.c 15 KB

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