cgroup: create directory before linking while creating a new cgroup
[deliverable/linux.git] / include / linux / cgroup.h
... / ...
CommitLineData
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
11#include <linux/sched.h>
12#include <linux/cpumask.h>
13#include <linux/nodemask.h>
14#include <linux/rcupdate.h>
15#include <linux/rculist.h>
16#include <linux/cgroupstats.h>
17#include <linux/prio_heap.h>
18#include <linux/rwsem.h>
19#include <linux/idr.h>
20#include <linux/workqueue.h>
21#include <linux/xattr.h>
22
23#ifdef CONFIG_CGROUPS
24
25struct cgroupfs_root;
26struct cgroup_subsys;
27struct inode;
28struct cgroup;
29struct css_id;
30
31extern int cgroup_init_early(void);
32extern int cgroup_init(void);
33extern void cgroup_lock(void);
34extern int cgroup_lock_is_held(void);
35extern bool cgroup_lock_live_group(struct cgroup *cgrp);
36extern void cgroup_unlock(void);
37extern void cgroup_fork(struct task_struct *p);
38extern void cgroup_post_fork(struct task_struct *p);
39extern void cgroup_exit(struct task_struct *p, int run_callbacks);
40extern int cgroupstats_build(struct cgroupstats *stats,
41 struct dentry *dentry);
42extern int cgroup_load_subsys(struct cgroup_subsys *ss);
43extern void cgroup_unload_subsys(struct cgroup_subsys *ss);
44
45extern const struct file_operations proc_cgroup_operations;
46
47/* Define the enumeration of all builtin cgroup subsystems */
48#define SUBSYS(_x) _x ## _subsys_id,
49#define IS_SUBSYS_ENABLED(option) IS_ENABLED(option)
50enum cgroup_subsys_id {
51#include <linux/cgroup_subsys.h>
52 CGROUP_SUBSYS_COUNT,
53};
54#undef IS_SUBSYS_ENABLED
55#undef SUBSYS
56
57/* Per-subsystem/per-cgroup state maintained by the system. */
58struct cgroup_subsys_state {
59 /*
60 * The cgroup that this subsystem is attached to. Useful
61 * for subsystems that want to know about the cgroup
62 * hierarchy structure
63 */
64 struct cgroup *cgroup;
65
66 /*
67 * State maintained by the cgroup system to allow subsystems
68 * to be "busy". Should be accessed via css_get(),
69 * css_tryget() and and css_put().
70 */
71
72 atomic_t refcnt;
73
74 unsigned long flags;
75 /* ID for this css, if possible */
76 struct css_id __rcu *id;
77
78 /* Used to put @cgroup->dentry on the last css_put() */
79 struct work_struct dput_work;
80};
81
82/* bits in struct cgroup_subsys_state flags field */
83enum {
84 CSS_ROOT, /* This CSS is the root of the subsystem */
85};
86
87/* Caller must verify that the css is not for root cgroup */
88static inline void __css_get(struct cgroup_subsys_state *css, int count)
89{
90 atomic_add(count, &css->refcnt);
91}
92
93/*
94 * Call css_get() to hold a reference on the css; it can be used
95 * for a reference obtained via:
96 * - an existing ref-counted reference to the css
97 * - task->cgroups for a locked task
98 */
99
100static inline void css_get(struct cgroup_subsys_state *css)
101{
102 /* We don't need to reference count the root state */
103 if (!test_bit(CSS_ROOT, &css->flags))
104 __css_get(css, 1);
105}
106
107/*
108 * Call css_tryget() to take a reference on a css if your existing
109 * (known-valid) reference isn't already ref-counted. Returns false if
110 * the css has been destroyed.
111 */
112
113extern bool __css_tryget(struct cgroup_subsys_state *css);
114static inline bool css_tryget(struct cgroup_subsys_state *css)
115{
116 if (test_bit(CSS_ROOT, &css->flags))
117 return true;
118 return __css_tryget(css);
119}
120
121/*
122 * css_put() should be called to release a reference taken by
123 * css_get() or css_tryget()
124 */
125
126extern void __css_put(struct cgroup_subsys_state *css);
127static inline void css_put(struct cgroup_subsys_state *css)
128{
129 if (!test_bit(CSS_ROOT, &css->flags))
130 __css_put(css);
131}
132
133/* bits in struct cgroup flags field */
134enum {
135 /* Control Group is dead */
136 CGRP_REMOVED,
137 /*
138 * Control Group has previously had a child cgroup or a task,
139 * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
140 */
141 CGRP_RELEASABLE,
142 /* Control Group requires release notifications to userspace */
143 CGRP_NOTIFY_ON_RELEASE,
144 /*
145 * Clone cgroup values when creating a new child cgroup
146 */
147 CGRP_CLONE_CHILDREN,
148};
149
150struct cgroup {
151 unsigned long flags; /* "unsigned long" so bitops work */
152
153 /*
154 * count users of this cgroup. >0 means busy, but doesn't
155 * necessarily indicate the number of tasks in the cgroup
156 */
157 atomic_t count;
158
159 /*
160 * We link our 'sibling' struct into our parent's 'children'.
161 * Our children link their 'sibling' into our 'children'.
162 */
163 struct list_head sibling; /* my parent's children */
164 struct list_head children; /* my children */
165 struct list_head files; /* my files */
166
167 struct cgroup *parent; /* my parent */
168 struct dentry __rcu *dentry; /* cgroup fs entry, RCU protected */
169
170 /* Private pointers for each registered subsystem */
171 struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
172
173 struct cgroupfs_root *root;
174 struct cgroup *top_cgroup;
175
176 /*
177 * List of cg_cgroup_links pointing at css_sets with
178 * tasks in this cgroup. Protected by css_set_lock
179 */
180 struct list_head css_sets;
181
182 struct list_head allcg_node; /* cgroupfs_root->allcg_list */
183 struct list_head cft_q_node; /* used during cftype add/rm */
184
185 /*
186 * Linked list running through all cgroups that can
187 * potentially be reaped by the release agent. Protected by
188 * release_list_lock
189 */
190 struct list_head release_list;
191
192 /*
193 * list of pidlists, up to two for each namespace (one for procs, one
194 * for tasks); created on demand.
195 */
196 struct list_head pidlists;
197 struct mutex pidlist_mutex;
198
199 /* For RCU-protected deletion */
200 struct rcu_head rcu_head;
201
202 /* List of events which userspace want to receive */
203 struct list_head event_list;
204 spinlock_t event_list_lock;
205
206 /* directory xattrs */
207 struct simple_xattrs xattrs;
208};
209
210/*
211 * A css_set is a structure holding pointers to a set of
212 * cgroup_subsys_state objects. This saves space in the task struct
213 * object and speeds up fork()/exit(), since a single inc/dec and a
214 * list_add()/del() can bump the reference count on the entire cgroup
215 * set for a task.
216 */
217
218struct css_set {
219
220 /* Reference count */
221 atomic_t refcount;
222
223 /*
224 * List running through all cgroup groups in the same hash
225 * slot. Protected by css_set_lock
226 */
227 struct hlist_node hlist;
228
229 /*
230 * List running through all tasks using this cgroup
231 * group. Protected by css_set_lock
232 */
233 struct list_head tasks;
234
235 /*
236 * List of cg_cgroup_link objects on link chains from
237 * cgroups referenced from this css_set. Protected by
238 * css_set_lock
239 */
240 struct list_head cg_links;
241
242 /*
243 * Set of subsystem states, one for each subsystem. This array
244 * is immutable after creation apart from the init_css_set
245 * during subsystem registration (at boot time) and modular subsystem
246 * loading/unloading.
247 */
248 struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
249
250 /* For RCU-protected deletion */
251 struct rcu_head rcu_head;
252};
253
254/*
255 * cgroup_map_cb is an abstract callback API for reporting map-valued
256 * control files
257 */
258
259struct cgroup_map_cb {
260 int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
261 void *state;
262};
263
264/*
265 * struct cftype: handler definitions for cgroup control files
266 *
267 * When reading/writing to a file:
268 * - the cgroup to use is file->f_dentry->d_parent->d_fsdata
269 * - the 'cftype' of the file is file->f_dentry->d_fsdata
270 */
271
272/* cftype->flags */
273#define CFTYPE_ONLY_ON_ROOT (1U << 0) /* only create on root cg */
274#define CFTYPE_NOT_ON_ROOT (1U << 1) /* don't create onp root cg */
275
276#define MAX_CFTYPE_NAME 64
277
278struct cftype {
279 /*
280 * By convention, the name should begin with the name of the
281 * subsystem, followed by a period. Zero length string indicates
282 * end of cftype array.
283 */
284 char name[MAX_CFTYPE_NAME];
285 int private;
286 /*
287 * If not 0, file mode is set to this value, otherwise it will
288 * be figured out automatically
289 */
290 umode_t mode;
291
292 /*
293 * If non-zero, defines the maximum length of string that can
294 * be passed to write_string; defaults to 64
295 */
296 size_t max_write_len;
297
298 /* CFTYPE_* flags */
299 unsigned int flags;
300
301 /* file xattrs */
302 struct simple_xattrs xattrs;
303
304 int (*open)(struct inode *inode, struct file *file);
305 ssize_t (*read)(struct cgroup *cgrp, struct cftype *cft,
306 struct file *file,
307 char __user *buf, size_t nbytes, loff_t *ppos);
308 /*
309 * read_u64() is a shortcut for the common case of returning a
310 * single integer. Use it in place of read()
311 */
312 u64 (*read_u64)(struct cgroup *cgrp, struct cftype *cft);
313 /*
314 * read_s64() is a signed version of read_u64()
315 */
316 s64 (*read_s64)(struct cgroup *cgrp, struct cftype *cft);
317 /*
318 * read_map() is used for defining a map of key/value
319 * pairs. It should call cb->fill(cb, key, value) for each
320 * entry. The key/value pairs (and their ordering) should not
321 * change between reboots.
322 */
323 int (*read_map)(struct cgroup *cont, struct cftype *cft,
324 struct cgroup_map_cb *cb);
325 /*
326 * read_seq_string() is used for outputting a simple sequence
327 * using seqfile.
328 */
329 int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
330 struct seq_file *m);
331
332 ssize_t (*write)(struct cgroup *cgrp, struct cftype *cft,
333 struct file *file,
334 const char __user *buf, size_t nbytes, loff_t *ppos);
335
336 /*
337 * write_u64() is a shortcut for the common case of accepting
338 * a single integer (as parsed by simple_strtoull) from
339 * userspace. Use in place of write(); return 0 or error.
340 */
341 int (*write_u64)(struct cgroup *cgrp, struct cftype *cft, u64 val);
342 /*
343 * write_s64() is a signed version of write_u64()
344 */
345 int (*write_s64)(struct cgroup *cgrp, struct cftype *cft, s64 val);
346
347 /*
348 * write_string() is passed a nul-terminated kernelspace
349 * buffer of maximum length determined by max_write_len.
350 * Returns 0 or -ve error code.
351 */
352 int (*write_string)(struct cgroup *cgrp, struct cftype *cft,
353 const char *buffer);
354 /*
355 * trigger() callback can be used to get some kick from the
356 * userspace, when the actual string written is not important
357 * at all. The private field can be used to determine the
358 * kick type for multiplexing.
359 */
360 int (*trigger)(struct cgroup *cgrp, unsigned int event);
361
362 int (*release)(struct inode *inode, struct file *file);
363
364 /*
365 * register_event() callback will be used to add new userspace
366 * waiter for changes related to the cftype. Implement it if
367 * you want to provide this functionality. Use eventfd_signal()
368 * on eventfd to send notification to userspace.
369 */
370 int (*register_event)(struct cgroup *cgrp, struct cftype *cft,
371 struct eventfd_ctx *eventfd, const char *args);
372 /*
373 * unregister_event() callback will be called when userspace
374 * closes the eventfd or on cgroup removing.
375 * This callback must be implemented, if you want provide
376 * notification functionality.
377 */
378 void (*unregister_event)(struct cgroup *cgrp, struct cftype *cft,
379 struct eventfd_ctx *eventfd);
380};
381
382/*
383 * cftype_sets describe cftypes belonging to a subsystem and are chained at
384 * cgroup_subsys->cftsets. Each cftset points to an array of cftypes
385 * terminated by zero length name.
386 */
387struct cftype_set {
388 struct list_head node; /* chained at subsys->cftsets */
389 struct cftype *cfts;
390};
391
392struct cgroup_scanner {
393 struct cgroup *cg;
394 int (*test_task)(struct task_struct *p, struct cgroup_scanner *scan);
395 void (*process_task)(struct task_struct *p,
396 struct cgroup_scanner *scan);
397 struct ptr_heap *heap;
398 void *data;
399};
400
401int cgroup_add_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
402int cgroup_rm_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
403
404int cgroup_is_removed(const struct cgroup *cgrp);
405
406int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
407
408int cgroup_task_count(const struct cgroup *cgrp);
409
410/* Return true if cgrp is a descendant of the task's cgroup */
411int cgroup_is_descendant(const struct cgroup *cgrp, struct task_struct *task);
412
413/*
414 * Control Group taskset, used to pass around set of tasks to cgroup_subsys
415 * methods.
416 */
417struct cgroup_taskset;
418struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
419struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
420struct cgroup *cgroup_taskset_cur_cgroup(struct cgroup_taskset *tset);
421int cgroup_taskset_size(struct cgroup_taskset *tset);
422
423/**
424 * cgroup_taskset_for_each - iterate cgroup_taskset
425 * @task: the loop cursor
426 * @skip_cgrp: skip if task's cgroup matches this, %NULL to iterate through all
427 * @tset: taskset to iterate
428 */
429#define cgroup_taskset_for_each(task, skip_cgrp, tset) \
430 for ((task) = cgroup_taskset_first((tset)); (task); \
431 (task) = cgroup_taskset_next((tset))) \
432 if (!(skip_cgrp) || \
433 cgroup_taskset_cur_cgroup((tset)) != (skip_cgrp))
434
435/*
436 * Control Group subsystem type.
437 * See Documentation/cgroups/cgroups.txt for details
438 */
439
440struct cgroup_subsys {
441 struct cgroup_subsys_state *(*create)(struct cgroup *cgrp);
442 void (*post_create)(struct cgroup *cgrp);
443 void (*pre_destroy)(struct cgroup *cgrp);
444 void (*destroy)(struct cgroup *cgrp);
445 int (*can_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
446 void (*cancel_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
447 void (*attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
448 void (*fork)(struct task_struct *task);
449 void (*exit)(struct cgroup *cgrp, struct cgroup *old_cgrp,
450 struct task_struct *task);
451 void (*post_clone)(struct cgroup *cgrp);
452 void (*bind)(struct cgroup *root);
453
454 int subsys_id;
455 int active;
456 int disabled;
457 int early_init;
458 /*
459 * True if this subsys uses ID. ID is not available before cgroup_init()
460 * (not available in early_init time.)
461 */
462 bool use_id;
463
464 /*
465 * If %false, this subsystem is properly hierarchical -
466 * configuration, resource accounting and restriction on a parent
467 * cgroup cover those of its children. If %true, hierarchy support
468 * is broken in some ways - some subsystems ignore hierarchy
469 * completely while others are only implemented half-way.
470 *
471 * It's now disallowed to create nested cgroups if the subsystem is
472 * broken and cgroup core will emit a warning message on such
473 * cases. Eventually, all subsystems will be made properly
474 * hierarchical and this will go away.
475 */
476 bool broken_hierarchy;
477 bool warned_broken_hierarchy;
478
479#define MAX_CGROUP_TYPE_NAMELEN 32
480 const char *name;
481
482 /*
483 * Link to parent, and list entry in parent's children.
484 * Protected by cgroup_lock()
485 */
486 struct cgroupfs_root *root;
487 struct list_head sibling;
488 /* used when use_id == true */
489 struct idr idr;
490 spinlock_t id_lock;
491
492 /* list of cftype_sets */
493 struct list_head cftsets;
494
495 /* base cftypes, automatically [de]registered with subsys itself */
496 struct cftype *base_cftypes;
497 struct cftype_set base_cftset;
498
499 /* should be defined only by modular subsystems */
500 struct module *module;
501};
502
503#define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
504#define IS_SUBSYS_ENABLED(option) IS_BUILTIN(option)
505#include <linux/cgroup_subsys.h>
506#undef IS_SUBSYS_ENABLED
507#undef SUBSYS
508
509static inline struct cgroup_subsys_state *cgroup_subsys_state(
510 struct cgroup *cgrp, int subsys_id)
511{
512 return cgrp->subsys[subsys_id];
513}
514
515/*
516 * function to get the cgroup_subsys_state which allows for extra
517 * rcu_dereference_check() conditions, such as locks used during the
518 * cgroup_subsys::attach() methods.
519 */
520#define task_subsys_state_check(task, subsys_id, __c) \
521 rcu_dereference_check(task->cgroups->subsys[subsys_id], \
522 lockdep_is_held(&task->alloc_lock) || \
523 cgroup_lock_is_held() || (__c))
524
525static inline struct cgroup_subsys_state *
526task_subsys_state(struct task_struct *task, int subsys_id)
527{
528 return task_subsys_state_check(task, subsys_id, false);
529}
530
531static inline struct cgroup* task_cgroup(struct task_struct *task,
532 int subsys_id)
533{
534 return task_subsys_state(task, subsys_id)->cgroup;
535}
536
537/**
538 * cgroup_for_each_child - iterate through children of a cgroup
539 * @pos: the cgroup * to use as the loop cursor
540 * @cgroup: cgroup whose children to walk
541 *
542 * Walk @cgroup's children. Must be called under rcu_read_lock(). A child
543 * cgroup which hasn't finished ->post_create() or already has finished
544 * ->pre_destroy() may show up during traversal and it's each subsystem's
545 * responsibility to verify that each @pos is alive.
546 *
547 * If a subsystem synchronizes against the parent in its ->post_create()
548 * and before starting iterating, a cgroup which finished ->post_create()
549 * is guaranteed to be visible in the future iterations.
550 */
551#define cgroup_for_each_child(pos, cgroup) \
552 list_for_each_entry_rcu(pos, &(cgroup)->children, sibling)
553
554struct cgroup *cgroup_next_descendant_pre(struct cgroup *pos,
555 struct cgroup *cgroup);
556
557/**
558 * cgroup_for_each_descendant_pre - pre-order walk of a cgroup's descendants
559 * @pos: the cgroup * to use as the loop cursor
560 * @cgroup: cgroup whose descendants to walk
561 *
562 * Walk @cgroup's descendants. Must be called under rcu_read_lock(). A
563 * descendant cgroup which hasn't finished ->post_create() or already has
564 * finished ->pre_destroy() may show up during traversal and it's each
565 * subsystem's responsibility to verify that each @pos is alive.
566 *
567 * If a subsystem synchronizes against the parent in its ->post_create()
568 * and before starting iterating, and synchronizes against @pos on each
569 * iteration, any descendant cgroup which finished ->post_create() is
570 * guaranteed to be visible in the future iterations.
571 *
572 * In other words, the following guarantees that a descendant can't escape
573 * state updates of its ancestors.
574 *
575 * my_post_create(@cgrp)
576 * {
577 * Lock @cgrp->parent and @cgrp;
578 * Inherit state from @cgrp->parent;
579 * Unlock both.
580 * }
581 *
582 * my_update_state(@cgrp)
583 * {
584 * Lock @cgrp;
585 * Update @cgrp's state;
586 * Unlock @cgrp;
587 *
588 * cgroup_for_each_descendant_pre(@pos, @cgrp) {
589 * Lock @pos;
590 * Verify @pos is alive and inherit state from @pos->parent;
591 * Unlock @pos;
592 * }
593 * }
594 *
595 * As long as the inheriting step, including checking the parent state, is
596 * enclosed inside @pos locking, double-locking the parent isn't necessary
597 * while inheriting. The state update to the parent is guaranteed to be
598 * visible by walking order and, as long as inheriting operations to the
599 * same @pos are atomic to each other, multiple updates racing each other
600 * still result in the correct state. It's guaranateed that at least one
601 * inheritance happens for any cgroup after the latest update to its
602 * parent.
603 *
604 * If checking parent's state requires locking the parent, each inheriting
605 * iteration should lock and unlock both @pos->parent and @pos.
606 *
607 * Alternatively, a subsystem may choose to use a single global lock to
608 * synchronize ->post_create() and ->pre_destroy() against tree-walking
609 * operations.
610 */
611#define cgroup_for_each_descendant_pre(pos, cgroup) \
612 for (pos = cgroup_next_descendant_pre(NULL, (cgroup)); (pos); \
613 pos = cgroup_next_descendant_pre((pos), (cgroup)))
614
615struct cgroup *cgroup_next_descendant_post(struct cgroup *pos,
616 struct cgroup *cgroup);
617
618/**
619 * cgroup_for_each_descendant_post - post-order walk of a cgroup's descendants
620 * @pos: the cgroup * to use as the loop cursor
621 * @cgroup: cgroup whose descendants to walk
622 *
623 * Similar to cgroup_for_each_descendant_pre() but performs post-order
624 * traversal instead. Note that the walk visibility guarantee described in
625 * pre-order walk doesn't apply the same to post-order walks.
626 */
627#define cgroup_for_each_descendant_post(pos, cgroup) \
628 for (pos = cgroup_next_descendant_post(NULL, (cgroup)); (pos); \
629 pos = cgroup_next_descendant_post((pos), (cgroup)))
630
631/* A cgroup_iter should be treated as an opaque object */
632struct cgroup_iter {
633 struct list_head *cg_link;
634 struct list_head *task;
635};
636
637/*
638 * To iterate across the tasks in a cgroup:
639 *
640 * 1) call cgroup_iter_start to initialize an iterator
641 *
642 * 2) call cgroup_iter_next() to retrieve member tasks until it
643 * returns NULL or until you want to end the iteration
644 *
645 * 3) call cgroup_iter_end() to destroy the iterator.
646 *
647 * Or, call cgroup_scan_tasks() to iterate through every task in a
648 * cgroup - cgroup_scan_tasks() holds the css_set_lock when calling
649 * the test_task() callback, but not while calling the process_task()
650 * callback.
651 */
652void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
653struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
654 struct cgroup_iter *it);
655void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
656int cgroup_scan_tasks(struct cgroup_scanner *scan);
657int cgroup_attach_task(struct cgroup *, struct task_struct *);
658int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
659
660/*
661 * CSS ID is ID for cgroup_subsys_state structs under subsys. This only works
662 * if cgroup_subsys.use_id == true. It can be used for looking up and scanning.
663 * CSS ID is assigned at cgroup allocation (create) automatically
664 * and removed when subsys calls free_css_id() function. This is because
665 * the lifetime of cgroup_subsys_state is subsys's matter.
666 *
667 * Looking up and scanning function should be called under rcu_read_lock().
668 * Taking cgroup_mutex is not necessary for following calls.
669 * But the css returned by this routine can be "not populated yet" or "being
670 * destroyed". The caller should check css and cgroup's status.
671 */
672
673/*
674 * Typically Called at ->destroy(), or somewhere the subsys frees
675 * cgroup_subsys_state.
676 */
677void free_css_id(struct cgroup_subsys *ss, struct cgroup_subsys_state *css);
678
679/* Find a cgroup_subsys_state which has given ID */
680
681struct cgroup_subsys_state *css_lookup(struct cgroup_subsys *ss, int id);
682
683/*
684 * Get a cgroup whose id is greater than or equal to id under tree of root.
685 * Returning a cgroup_subsys_state or NULL.
686 */
687struct cgroup_subsys_state *css_get_next(struct cgroup_subsys *ss, int id,
688 struct cgroup_subsys_state *root, int *foundid);
689
690/* Returns true if root is ancestor of cg */
691bool css_is_ancestor(struct cgroup_subsys_state *cg,
692 const struct cgroup_subsys_state *root);
693
694/* Get id and depth of css */
695unsigned short css_id(struct cgroup_subsys_state *css);
696unsigned short css_depth(struct cgroup_subsys_state *css);
697struct cgroup_subsys_state *cgroup_css_from_dir(struct file *f, int id);
698
699#else /* !CONFIG_CGROUPS */
700
701static inline int cgroup_init_early(void) { return 0; }
702static inline int cgroup_init(void) { return 0; }
703static inline void cgroup_fork(struct task_struct *p) {}
704static inline void cgroup_fork_callbacks(struct task_struct *p) {}
705static inline void cgroup_post_fork(struct task_struct *p) {}
706static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
707
708static inline void cgroup_lock(void) {}
709static inline void cgroup_unlock(void) {}
710static inline int cgroupstats_build(struct cgroupstats *stats,
711 struct dentry *dentry)
712{
713 return -EINVAL;
714}
715
716/* No cgroups - nothing to do */
717static inline int cgroup_attach_task_all(struct task_struct *from,
718 struct task_struct *t)
719{
720 return 0;
721}
722
723#endif /* !CONFIG_CGROUPS */
724
725#endif /* _LINUX_CGROUP_H */
This page took 0.02823 seconds and 5 git commands to generate.