/include/linux/cgroup.h

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t · C Header · 654 lines · 284 code · 87 blank · 283 comment · 6 complexity · 99c53134e4dbf9d657c546e9bd5613ab MD5 · raw file

  1. #ifndef _LINUX_CGROUP_H
  2. #define _LINUX_CGROUP_H
  3. /*
  4. * cgroup interface
  5. *
  6. * Copyright (C) 2003 BULL SA
  7. * Copyright (C) 2004-2006 Silicon Graphics, Inc.
  8. *
  9. */
  10. #include <linux/sched.h>
  11. #include <linux/cpumask.h>
  12. #include <linux/nodemask.h>
  13. #include <linux/rcupdate.h>
  14. #include <linux/cgroupstats.h>
  15. #include <linux/prio_heap.h>
  16. #include <linux/rwsem.h>
  17. #include <linux/idr.h>
  18. #ifdef CONFIG_CGROUPS
  19. struct cgroupfs_root;
  20. struct cgroup_subsys;
  21. struct inode;
  22. struct cgroup;
  23. struct css_id;
  24. extern int cgroup_init_early(void);
  25. extern int cgroup_init(void);
  26. extern void cgroup_lock(void);
  27. extern int cgroup_lock_is_held(void);
  28. extern bool cgroup_lock_live_group(struct cgroup *cgrp);
  29. extern void cgroup_unlock(void);
  30. extern void cgroup_fork(struct task_struct *p);
  31. extern void cgroup_fork_callbacks(struct task_struct *p);
  32. extern void cgroup_post_fork(struct task_struct *p);
  33. extern void cgroup_exit(struct task_struct *p, int run_callbacks);
  34. extern int cgroupstats_build(struct cgroupstats *stats,
  35. struct dentry *dentry);
  36. extern int cgroup_load_subsys(struct cgroup_subsys *ss);
  37. extern void cgroup_unload_subsys(struct cgroup_subsys *ss);
  38. extern const struct file_operations proc_cgroup_operations;
  39. /* Define the enumeration of all builtin cgroup subsystems */
  40. #define SUBSYS(_x) _x ## _subsys_id,
  41. enum cgroup_subsys_id {
  42. #include <linux/cgroup_subsys.h>
  43. CGROUP_BUILTIN_SUBSYS_COUNT
  44. };
  45. #undef SUBSYS
  46. /*
  47. * This define indicates the maximum number of subsystems that can be loaded
  48. * at once. We limit to this many since cgroupfs_root has subsys_bits to keep
  49. * track of all of them.
  50. */
  51. #define CGROUP_SUBSYS_COUNT (BITS_PER_BYTE*sizeof(unsigned long))
  52. /* Per-subsystem/per-cgroup state maintained by the system. */
  53. struct cgroup_subsys_state {
  54. /*
  55. * The cgroup that this subsystem is attached to. Useful
  56. * for subsystems that want to know about the cgroup
  57. * hierarchy structure
  58. */
  59. struct cgroup *cgroup;
  60. /*
  61. * State maintained by the cgroup system to allow subsystems
  62. * to be "busy". Should be accessed via css_get(),
  63. * css_tryget() and and css_put().
  64. */
  65. atomic_t refcnt;
  66. unsigned long flags;
  67. /* ID for this css, if possible */
  68. struct css_id __rcu *id;
  69. };
  70. /* bits in struct cgroup_subsys_state flags field */
  71. enum {
  72. CSS_ROOT, /* This CSS is the root of the subsystem */
  73. CSS_REMOVED, /* This CSS is dead */
  74. };
  75. /*
  76. * Call css_get() to hold a reference on the css; it can be used
  77. * for a reference obtained via:
  78. * - an existing ref-counted reference to the css
  79. * - task->cgroups for a locked task
  80. */
  81. extern void __css_get(struct cgroup_subsys_state *css, int count);
  82. static inline void css_get(struct cgroup_subsys_state *css)
  83. {
  84. /* We don't need to reference count the root state */
  85. if (!test_bit(CSS_ROOT, &css->flags))
  86. __css_get(css, 1);
  87. }
  88. static inline bool css_is_removed(struct cgroup_subsys_state *css)
  89. {
  90. return test_bit(CSS_REMOVED, &css->flags);
  91. }
  92. /*
  93. * Call css_tryget() to take a reference on a css if your existing
  94. * (known-valid) reference isn't already ref-counted. Returns false if
  95. * the css has been destroyed.
  96. */
  97. static inline bool css_tryget(struct cgroup_subsys_state *css)
  98. {
  99. if (test_bit(CSS_ROOT, &css->flags))
  100. return true;
  101. while (!atomic_inc_not_zero(&css->refcnt)) {
  102. if (test_bit(CSS_REMOVED, &css->flags))
  103. return false;
  104. cpu_relax();
  105. }
  106. return true;
  107. }
  108. /*
  109. * css_put() should be called to release a reference taken by
  110. * css_get() or css_tryget()
  111. */
  112. extern void __css_put(struct cgroup_subsys_state *css, int count);
  113. static inline void css_put(struct cgroup_subsys_state *css)
  114. {
  115. if (!test_bit(CSS_ROOT, &css->flags))
  116. __css_put(css, 1);
  117. }
  118. /* bits in struct cgroup flags field */
  119. enum {
  120. /* Control Group is dead */
  121. CGRP_REMOVED,
  122. /* Control Group has ever had a child cgroup or a task */
  123. CGRP_RELEASABLE,
  124. /* Control Group requires release notifications to userspace */
  125. CGRP_NOTIFY_ON_RELEASE,
  126. /*
  127. * A thread in rmdir() is wating for this cgroup.
  128. */
  129. CGRP_WAIT_ON_RMDIR,
  130. /*
  131. * Clone cgroup values when creating a new child cgroup
  132. */
  133. CGRP_CLONE_CHILDREN,
  134. };
  135. /* which pidlist file are we talking about? */
  136. enum cgroup_filetype {
  137. CGROUP_FILE_PROCS,
  138. CGROUP_FILE_TASKS,
  139. };
  140. /*
  141. * A pidlist is a list of pids that virtually represents the contents of one
  142. * of the cgroup files ("procs" or "tasks"). We keep a list of such pidlists,
  143. * a pair (one each for procs, tasks) for each pid namespace that's relevant
  144. * to the cgroup.
  145. */
  146. struct cgroup_pidlist {
  147. /*
  148. * used to find which pidlist is wanted. doesn't change as long as
  149. * this particular list stays in the list.
  150. */
  151. struct { enum cgroup_filetype type; struct pid_namespace *ns; } key;
  152. /* array of xids */
  153. pid_t *list;
  154. /* how many elements the above list has */
  155. int length;
  156. /* how many files are using the current array */
  157. int use_count;
  158. /* each of these stored in a list by its cgroup */
  159. struct list_head links;
  160. /* pointer to the cgroup we belong to, for list removal purposes */
  161. struct cgroup *owner;
  162. /* protects the other fields */
  163. struct rw_semaphore mutex;
  164. };
  165. struct cgroup {
  166. unsigned long flags; /* "unsigned long" so bitops work */
  167. /*
  168. * count users of this cgroup. >0 means busy, but doesn't
  169. * necessarily indicate the number of tasks in the cgroup
  170. */
  171. atomic_t count;
  172. /*
  173. * We link our 'sibling' struct into our parent's 'children'.
  174. * Our children link their 'sibling' into our 'children'.
  175. */
  176. struct list_head sibling; /* my parent's children */
  177. struct list_head children; /* my children */
  178. struct cgroup *parent; /* my parent */
  179. struct dentry __rcu *dentry; /* cgroup fs entry, RCU protected */
  180. /* Private pointers for each registered subsystem */
  181. struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
  182. struct cgroupfs_root *root;
  183. struct cgroup *top_cgroup;
  184. /*
  185. * List of cg_cgroup_links pointing at css_sets with
  186. * tasks in this cgroup. Protected by css_set_lock
  187. */
  188. struct list_head css_sets;
  189. /*
  190. * Linked list running through all cgroups that can
  191. * potentially be reaped by the release agent. Protected by
  192. * release_list_lock
  193. */
  194. struct list_head release_list;
  195. /*
  196. * list of pidlists, up to two for each namespace (one for procs, one
  197. * for tasks); created on demand.
  198. */
  199. struct list_head pidlists;
  200. struct mutex pidlist_mutex;
  201. /* For RCU-protected deletion */
  202. struct rcu_head rcu_head;
  203. /* List of events which userspace want to receive */
  204. struct list_head event_list;
  205. spinlock_t event_list_lock;
  206. };
  207. /*
  208. * A css_set is a structure holding pointers to a set of
  209. * cgroup_subsys_state objects. This saves space in the task struct
  210. * object and speeds up fork()/exit(), since a single inc/dec and a
  211. * list_add()/del() can bump the reference count on the entire cgroup
  212. * set for a task.
  213. */
  214. struct css_set {
  215. /* Reference count */
  216. atomic_t refcount;
  217. /*
  218. * List running through all cgroup groups in the same hash
  219. * slot. Protected by css_set_lock
  220. */
  221. struct hlist_node hlist;
  222. /*
  223. * List running through all tasks using this cgroup
  224. * group. Protected by css_set_lock
  225. */
  226. struct list_head tasks;
  227. /*
  228. * List of cg_cgroup_link objects on link chains from
  229. * cgroups referenced from this css_set. Protected by
  230. * css_set_lock
  231. */
  232. struct list_head cg_links;
  233. /*
  234. * Set of subsystem states, one for each subsystem. This array
  235. * is immutable after creation apart from the init_css_set
  236. * during subsystem registration (at boot time) and modular subsystem
  237. * loading/unloading.
  238. */
  239. struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
  240. /* For RCU-protected deletion */
  241. struct rcu_head rcu_head;
  242. struct work_struct work;
  243. };
  244. /*
  245. * cgroup_map_cb is an abstract callback API for reporting map-valued
  246. * control files
  247. */
  248. struct cgroup_map_cb {
  249. int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
  250. void *state;
  251. };
  252. /*
  253. * struct cftype: handler definitions for cgroup control files
  254. *
  255. * When reading/writing to a file:
  256. * - the cgroup to use is file->f_dentry->d_parent->d_fsdata
  257. * - the 'cftype' of the file is file->f_dentry->d_fsdata
  258. */
  259. #define MAX_CFTYPE_NAME 64
  260. struct cftype {
  261. /*
  262. * By convention, the name should begin with the name of the
  263. * subsystem, followed by a period
  264. */
  265. char name[MAX_CFTYPE_NAME];
  266. int private;
  267. /*
  268. * If not 0, file mode is set to this value, otherwise it will
  269. * be figured out automatically
  270. */
  271. mode_t mode;
  272. /*
  273. * If non-zero, defines the maximum length of string that can
  274. * be passed to write_string; defaults to 64
  275. */
  276. size_t max_write_len;
  277. int (*open)(struct inode *inode, struct file *file);
  278. ssize_t (*read)(struct cgroup *cgrp, struct cftype *cft,
  279. struct file *file,
  280. char __user *buf, size_t nbytes, loff_t *ppos);
  281. /*
  282. * read_u64() is a shortcut for the common case of returning a
  283. * single integer. Use it in place of read()
  284. */
  285. u64 (*read_u64)(struct cgroup *cgrp, struct cftype *cft);
  286. /*
  287. * read_s64() is a signed version of read_u64()
  288. */
  289. s64 (*read_s64)(struct cgroup *cgrp, struct cftype *cft);
  290. /*
  291. * read_map() is used for defining a map of key/value
  292. * pairs. It should call cb->fill(cb, key, value) for each
  293. * entry. The key/value pairs (and their ordering) should not
  294. * change between reboots.
  295. */
  296. int (*read_map)(struct cgroup *cont, struct cftype *cft,
  297. struct cgroup_map_cb *cb);
  298. /*
  299. * read_seq_string() is used for outputting a simple sequence
  300. * using seqfile.
  301. */
  302. int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
  303. struct seq_file *m);
  304. ssize_t (*write)(struct cgroup *cgrp, struct cftype *cft,
  305. struct file *file,
  306. const char __user *buf, size_t nbytes, loff_t *ppos);
  307. /*
  308. * write_u64() is a shortcut for the common case of accepting
  309. * a single integer (as parsed by simple_strtoull) from
  310. * userspace. Use in place of write(); return 0 or error.
  311. */
  312. int (*write_u64)(struct cgroup *cgrp, struct cftype *cft, u64 val);
  313. /*
  314. * write_s64() is a signed version of write_u64()
  315. */
  316. int (*write_s64)(struct cgroup *cgrp, struct cftype *cft, s64 val);
  317. /*
  318. * write_string() is passed a nul-terminated kernelspace
  319. * buffer of maximum length determined by max_write_len.
  320. * Returns 0 or -ve error code.
  321. */
  322. int (*write_string)(struct cgroup *cgrp, struct cftype *cft,
  323. const char *buffer);
  324. /*
  325. * trigger() callback can be used to get some kick from the
  326. * userspace, when the actual string written is not important
  327. * at all. The private field can be used to determine the
  328. * kick type for multiplexing.
  329. */
  330. int (*trigger)(struct cgroup *cgrp, unsigned int event);
  331. int (*release)(struct inode *inode, struct file *file);
  332. /*
  333. * register_event() callback will be used to add new userspace
  334. * waiter for changes related to the cftype. Implement it if
  335. * you want to provide this functionality. Use eventfd_signal()
  336. * on eventfd to send notification to userspace.
  337. */
  338. int (*register_event)(struct cgroup *cgrp, struct cftype *cft,
  339. struct eventfd_ctx *eventfd, const char *args);
  340. /*
  341. * unregister_event() callback will be called when userspace
  342. * closes the eventfd or on cgroup removing.
  343. * This callback must be implemented, if you want provide
  344. * notification functionality.
  345. */
  346. void (*unregister_event)(struct cgroup *cgrp, struct cftype *cft,
  347. struct eventfd_ctx *eventfd);
  348. };
  349. struct cgroup_scanner {
  350. struct cgroup *cg;
  351. int (*test_task)(struct task_struct *p, struct cgroup_scanner *scan);
  352. void (*process_task)(struct task_struct *p,
  353. struct cgroup_scanner *scan);
  354. struct ptr_heap *heap;
  355. void *data;
  356. };
  357. /*
  358. * Add a new file to the given cgroup directory. Should only be
  359. * called by subsystems from within a populate() method
  360. */
  361. int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
  362. const struct cftype *cft);
  363. /*
  364. * Add a set of new files to the given cgroup directory. Should
  365. * only be called by subsystems from within a populate() method
  366. */
  367. int cgroup_add_files(struct cgroup *cgrp,
  368. struct cgroup_subsys *subsys,
  369. const struct cftype cft[],
  370. int count);
  371. int cgroup_is_removed(const struct cgroup *cgrp);
  372. int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
  373. int cgroup_task_count(const struct cgroup *cgrp);
  374. /* Return true if cgrp is a descendant of the task's cgroup */
  375. int cgroup_is_descendant(const struct cgroup *cgrp, struct task_struct *task);
  376. /*
  377. * When the subsys has to access css and may add permanent refcnt to css,
  378. * it should take care of racy conditions with rmdir(). Following set of
  379. * functions, is for stop/restart rmdir if necessary.
  380. * Because these will call css_get/put, "css" should be alive css.
  381. *
  382. * cgroup_exclude_rmdir();
  383. * ...do some jobs which may access arbitrary empty cgroup
  384. * cgroup_release_and_wakeup_rmdir();
  385. *
  386. * When someone removes a cgroup while cgroup_exclude_rmdir() holds it,
  387. * it sleeps and cgroup_release_and_wakeup_rmdir() will wake him up.
  388. */
  389. void cgroup_exclude_rmdir(struct cgroup_subsys_state *css);
  390. void cgroup_release_and_wakeup_rmdir(struct cgroup_subsys_state *css);
  391. /*
  392. * Control Group subsystem type.
  393. * See Documentation/cgroups/cgroups.txt for details
  394. */
  395. struct cgroup_subsys {
  396. struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
  397. struct cgroup *cgrp);
  398. int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
  399. void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
  400. int (*allow_attach)(struct cgroup *cgrp, struct task_struct *tsk);
  401. int (*can_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
  402. struct task_struct *tsk);
  403. int (*can_attach_task)(struct cgroup *cgrp, struct task_struct *tsk);
  404. void (*cancel_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
  405. struct task_struct *tsk);
  406. void (*pre_attach)(struct cgroup *cgrp);
  407. void (*attach_task)(struct cgroup *cgrp, struct task_struct *tsk);
  408. void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
  409. struct cgroup *old_cgrp, struct task_struct *tsk);
  410. void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);
  411. void (*exit)(struct cgroup_subsys *ss, struct cgroup *cgrp,
  412. struct cgroup *old_cgrp, struct task_struct *task);
  413. int (*populate)(struct cgroup_subsys *ss,
  414. struct cgroup *cgrp);
  415. void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
  416. void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
  417. int subsys_id;
  418. int active;
  419. int disabled;
  420. int early_init;
  421. /*
  422. * True if this subsys uses ID. ID is not available before cgroup_init()
  423. * (not available in early_init time.)
  424. */
  425. bool use_id;
  426. #define MAX_CGROUP_TYPE_NAMELEN 32
  427. const char *name;
  428. /*
  429. * Protects sibling/children links of cgroups in this
  430. * hierarchy, plus protects which hierarchy (or none) the
  431. * subsystem is a part of (i.e. root/sibling). To avoid
  432. * potential deadlocks, the following operations should not be
  433. * undertaken while holding any hierarchy_mutex:
  434. *
  435. * - allocating memory
  436. * - initiating hotplug events
  437. */
  438. struct mutex hierarchy_mutex;
  439. struct lock_class_key subsys_key;
  440. /*
  441. * Link to parent, and list entry in parent's children.
  442. * Protected by this->hierarchy_mutex and cgroup_lock()
  443. */
  444. struct cgroupfs_root *root;
  445. struct list_head sibling;
  446. /* used when use_id == true */
  447. struct idr idr;
  448. spinlock_t id_lock;
  449. /* should be defined only by modular subsystems */
  450. struct module *module;
  451. };
  452. #define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
  453. #include <linux/cgroup_subsys.h>
  454. #undef SUBSYS
  455. static inline struct cgroup_subsys_state *cgroup_subsys_state(
  456. struct cgroup *cgrp, int subsys_id)
  457. {
  458. return cgrp->subsys[subsys_id];
  459. }
  460. /*
  461. * function to get the cgroup_subsys_state which allows for extra
  462. * rcu_dereference_check() conditions, such as locks used during the
  463. * cgroup_subsys::attach() methods.
  464. */
  465. #define task_subsys_state_check(task, subsys_id, __c) \
  466. rcu_dereference_check(task->cgroups->subsys[subsys_id], \
  467. lockdep_is_held(&task->alloc_lock) || \
  468. cgroup_lock_is_held() || (__c))
  469. static inline struct cgroup_subsys_state *
  470. task_subsys_state(struct task_struct *task, int subsys_id)
  471. {
  472. return task_subsys_state_check(task, subsys_id, false);
  473. }
  474. static inline struct cgroup* task_cgroup(struct task_struct *task,
  475. int subsys_id)
  476. {
  477. return task_subsys_state(task, subsys_id)->cgroup;
  478. }
  479. /* A cgroup_iter should be treated as an opaque object */
  480. struct cgroup_iter {
  481. struct list_head *cg_link;
  482. struct list_head *task;
  483. };
  484. /*
  485. * To iterate across the tasks in a cgroup:
  486. *
  487. * 1) call cgroup_iter_start to initialize an iterator
  488. *
  489. * 2) call cgroup_iter_next() to retrieve member tasks until it
  490. * returns NULL or until you want to end the iteration
  491. *
  492. * 3) call cgroup_iter_end() to destroy the iterator.
  493. *
  494. * Or, call cgroup_scan_tasks() to iterate through every task in a
  495. * cgroup - cgroup_scan_tasks() holds the css_set_lock when calling
  496. * the test_task() callback, but not while calling the process_task()
  497. * callback.
  498. */
  499. void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
  500. struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
  501. struct cgroup_iter *it);
  502. void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
  503. int cgroup_scan_tasks(struct cgroup_scanner *scan);
  504. int cgroup_attach_task(struct cgroup *, struct task_struct *);
  505. int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
  506. static inline int cgroup_attach_task_current_cg(struct task_struct *tsk)
  507. {
  508. return cgroup_attach_task_all(current, tsk);
  509. }
  510. /*
  511. * CSS ID is ID for cgroup_subsys_state structs under subsys. This only works
  512. * if cgroup_subsys.use_id == true. It can be used for looking up and scanning.
  513. * CSS ID is assigned at cgroup allocation (create) automatically
  514. * and removed when subsys calls free_css_id() function. This is because
  515. * the lifetime of cgroup_subsys_state is subsys's matter.
  516. *
  517. * Looking up and scanning function should be called under rcu_read_lock().
  518. * Taking cgroup_mutex()/hierarchy_mutex() is not necessary for following calls.
  519. * But the css returned by this routine can be "not populated yet" or "being
  520. * destroyed". The caller should check css and cgroup's status.
  521. */
  522. /*
  523. * Typically Called at ->destroy(), or somewhere the subsys frees
  524. * cgroup_subsys_state.
  525. */
  526. void free_css_id(struct cgroup_subsys *ss, struct cgroup_subsys_state *css);
  527. /* Find a cgroup_subsys_state which has given ID */
  528. struct cgroup_subsys_state *css_lookup(struct cgroup_subsys *ss, int id);
  529. /*
  530. * Get a cgroup whose id is greater than or equal to id under tree of root.
  531. * Returning a cgroup_subsys_state or NULL.
  532. */
  533. struct cgroup_subsys_state *css_get_next(struct cgroup_subsys *ss, int id,
  534. struct cgroup_subsys_state *root, int *foundid);
  535. /* Returns true if root is ancestor of cg */
  536. bool css_is_ancestor(struct cgroup_subsys_state *cg,
  537. const struct cgroup_subsys_state *root);
  538. /* Get id and depth of css */
  539. unsigned short css_id(struct cgroup_subsys_state *css);
  540. unsigned short css_depth(struct cgroup_subsys_state *css);
  541. struct cgroup_subsys_state *cgroup_css_from_dir(struct file *f, int id);
  542. #else /* !CONFIG_CGROUPS */
  543. static inline int cgroup_init_early(void) { return 0; }
  544. static inline int cgroup_init(void) { return 0; }
  545. static inline void cgroup_fork(struct task_struct *p) {}
  546. static inline void cgroup_fork_callbacks(struct task_struct *p) {}
  547. static inline void cgroup_post_fork(struct task_struct *p) {}
  548. static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
  549. static inline void cgroup_lock(void) {}
  550. static inline void cgroup_unlock(void) {}
  551. static inline int cgroupstats_build(struct cgroupstats *stats,
  552. struct dentry *dentry)
  553. {
  554. return -EINVAL;
  555. }
  556. /* No cgroups - nothing to do */
  557. static inline int cgroup_attach_task_all(struct task_struct *from,
  558. struct task_struct *t)
  559. {
  560. return 0;
  561. }
  562. static inline int cgroup_attach_task_current_cg(struct task_struct *t)
  563. {
  564. return 0;
  565. }
  566. #endif /* !CONFIG_CGROUPS */
  567. #endif /* _LINUX_CGROUP_H */