[deliverable/linux.git] / include / linux / cgroup.h

#ifndef _LINUX_CGROUP_H
#define _LINUX_CGROUP_H
/*
 *  cgroup interface
 *
 *  Copyright (C) 2003 BULL SA
 *  Copyright (C) 2004-2006 Silicon Graphics, Inc.
 *
 */

#include <linux/sched.h>
#include <linux/kref.h>
#include <linux/cpumask.h>
#include <linux/nodemask.h>
#include <linux/rcupdate.h>
#include <linux/cgroupstats.h>
#include <linux/prio_heap.h>

#ifdef CONFIG_CGROUPS

struct cgroupfs_root;
struct cgroup_subsys;
struct inode;

extern int cgroup_init_early(void);
extern int cgroup_init(void);
extern void cgroup_init_smp(void);
extern void cgroup_lock(void);
extern void cgroup_unlock(void);
extern void cgroup_fork(struct task_struct *p);
extern void cgroup_fork_callbacks(struct task_struct *p);
extern void cgroup_post_fork(struct task_struct *p);
extern void cgroup_exit(struct task_struct *p, int run_callbacks);
extern int cgroupstats_build(struct cgroupstats *stats,
				struct dentry *dentry);

extern struct file_operations proc_cgroup_operations;

/* Define the enumeration of all cgroup subsystems */
#define SUBSYS(_x) _x ## _subsys_id,
enum cgroup_subsys_id {
#include <linux/cgroup_subsys.h>
	CGROUP_SUBSYS_COUNT
};
#undef SUBSYS

/* Per-subsystem/per-cgroup state maintained by the system. */
struct cgroup_subsys_state {
	/* The cgroup that this subsystem is attached to. Useful
	 * for subsystems that want to know about the cgroup
	 * hierarchy structure */
	struct cgroup *cgroup;

	/* State maintained by the cgroup system to allow
	 * subsystems to be "busy". Should be accessed via css_get()
	 * and css_put() */

	atomic_t refcnt;

	unsigned long flags;
};

/* bits in struct cgroup_subsys_state flags field */
enum {
	CSS_ROOT, /* This CSS is the root of the subsystem */
};

/*
 * Call css_get() to hold a reference on the cgroup;
 *
 */

static inline void css_get(struct cgroup_subsys_state *css)
{
	/* We don't need to reference count the root state */
	if (!test_bit(CSS_ROOT, &css->flags))
		atomic_inc(&css->refcnt);
}
/*
 * css_put() should be called to release a reference taken by
 * css_get()
 */

extern void __css_put(struct cgroup_subsys_state *css);
static inline void css_put(struct cgroup_subsys_state *css)
{
	if (!test_bit(CSS_ROOT, &css->flags))
		__css_put(css);
}

/* bits in struct cgroup flags field */
enum {
	/* Control Group is dead */
	CGRP_REMOVED,
	/* Control Group has previously had a child cgroup or a task,
	 * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
	CGRP_RELEASABLE,
	/* Control Group requires release notifications to userspace */
	CGRP_NOTIFY_ON_RELEASE,
};

struct cgroup {
	unsigned long flags;		/* "unsigned long" so bitops work */

	/* count users of this cgroup. >0 means busy, but doesn't
	 * necessarily indicate the number of tasks in the
	 * cgroup */
	atomic_t count;

	/*
	 * We link our 'sibling' struct into our parent's 'children'.
	 * Our children link their 'sibling' into our 'children'.
	 */
	struct list_head sibling;	/* my parent's children */
	struct list_head children;	/* my children */

	struct cgroup *parent;	/* my parent */
	struct dentry *dentry;	  	/* cgroup fs entry */

	/* Private pointers for each registered subsystem */
	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];

	struct cgroupfs_root *root;
	struct cgroup *top_cgroup;

	/*
	 * List of cg_cgroup_links pointing at css_sets with
	 * tasks in this cgroup. Protected by css_set_lock
	 */
	struct list_head css_sets;

	/*
	 * Linked list running through all cgroups that can
	 * potentially be reaped by the release agent. Protected by
	 * release_list_lock
	 */
	struct list_head release_list;
};

/* A css_set is a structure holding pointers to a set of
 * cgroup_subsys_state objects. This saves space in the task struct
 * object and speeds up fork()/exit(), since a single inc/dec and a
 * list_add()/del() can bump the reference count on the entire
 * cgroup set for a task.
 */

struct css_set {

	/* Reference count */
	struct kref ref;

	/*
	 * List running through all cgroup groups. Protected by
	 * css_set_lock
	 */
	struct list_head list;

	/*
	 * List running through all tasks using this cgroup
	 * group. Protected by css_set_lock
	 */
	struct list_head tasks;

	/*
	 * List of cg_cgroup_link objects on link chains from
	 * cgroups referenced from this css_set. Protected by
	 * css_set_lock
	 */
	struct list_head cg_links;

	/*
	 * Set of subsystem states, one for each subsystem. This array
	 * is immutable after creation apart from the init_css_set
	 * during subsystem registration (at boot time).
	 */
	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];

};

/*
 * cgroup_map_cb is an abstract callback API for reporting map-valued
 * control files
 */

struct cgroup_map_cb {
	int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
	void *state;
};

/* struct cftype:
 *
 * The files in the cgroup filesystem mostly have a very simple read/write
 * handling, some common function will take care of it. Nevertheless some cases
 * (read tasks) are special and therefore I define this structure for every
 * kind of file.
 *
 *
 * When reading/writing to a file:
 *	- the cgroup to use is file->f_dentry->d_parent->d_fsdata
 *	- the 'cftype' of the file is file->f_dentry->d_fsdata
 */

#define MAX_CFTYPE_NAME 64
struct cftype {
	/* By convention, the name should begin with the name of the
	 * subsystem, followed by a period */
	char name[MAX_CFTYPE_NAME];
	int private;
	int (*open) (struct inode *inode, struct file *file);
	ssize_t (*read) (struct cgroup *cgrp, struct cftype *cft,
			 struct file *file,
			 char __user *buf, size_t nbytes, loff_t *ppos);
	/*
	 * read_u64() is a shortcut for the common case of returning a
	 * single integer. Use it in place of read()
	 */
	u64 (*read_u64) (struct cgroup *cgrp, struct cftype *cft);
	/*
	 * read_map() is used for defining a map of key/value
	 * pairs. It should call cb->fill(cb, key, value) for each
	 * entry. The key/value pairs (and their ordering) should not
	 * change between reboots.
	 */
	int (*read_map) (struct cgroup *cont, struct cftype *cft,
			 struct cgroup_map_cb *cb);

	ssize_t (*write) (struct cgroup *cgrp, struct cftype *cft,
			  struct file *file,
			  const char __user *buf, size_t nbytes, loff_t *ppos);

	/*
	 * write_u64() is a shortcut for the common case of accepting
	 * a single integer (as parsed by simple_strtoull) from
	 * userspace. Use in place of write(); return 0 or error.
	 */
	int (*write_u64) (struct cgroup *cgrp, struct cftype *cft, u64 val);

	int (*release) (struct inode *inode, struct file *file);
};

struct cgroup_scanner {
	struct cgroup *cg;
	int (*test_task)(struct task_struct *p, struct cgroup_scanner *scan);
	void (*process_task)(struct task_struct *p,
			struct cgroup_scanner *scan);
	struct ptr_heap *heap;
};

/* Add a new file to the given cgroup directory. Should only be
 * called by subsystems from within a populate() method */
int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
		       const struct cftype *cft);

/* Add a set of new files to the given cgroup directory. Should
 * only be called by subsystems from within a populate() method */
int cgroup_add_files(struct cgroup *cgrp,
			struct cgroup_subsys *subsys,
			const struct cftype cft[],
			int count);

int cgroup_is_removed(const struct cgroup *cgrp);

int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);

int cgroup_task_count(const struct cgroup *cgrp);

/* Return true if the cgroup is a descendant of the current cgroup */
int cgroup_is_descendant(const struct cgroup *cgrp);

/* Control Group subsystem type. See Documentation/cgroups.txt for details */

struct cgroup_subsys {
	struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
						  struct cgroup *cgrp);
	void (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
	int (*can_attach)(struct cgroup_subsys *ss,
			  struct cgroup *cgrp, struct task_struct *tsk);
	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
			struct cgroup *old_cgrp, struct task_struct *tsk);
	void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);
	void (*exit)(struct cgroup_subsys *ss, struct task_struct *task);
	int (*populate)(struct cgroup_subsys *ss,
			struct cgroup *cgrp);
	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
	int subsys_id;
	int active;
	int disabled;
	int early_init;
#define MAX_CGROUP_TYPE_NAMELEN 32
	const char *name;

	/* Protected by RCU */
	struct cgroupfs_root *root;

	struct list_head sibling;

	void *private;
};

#define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
#include <linux/cgroup_subsys.h>
#undef SUBSYS

static inline struct cgroup_subsys_state *cgroup_subsys_state(
	struct cgroup *cgrp, int subsys_id)
{
	return cgrp->subsys[subsys_id];
}

static inline struct cgroup_subsys_state *task_subsys_state(
	struct task_struct *task, int subsys_id)
{
	return rcu_dereference(task->cgroups->subsys[subsys_id]);
}

static inline struct cgroup* task_cgroup(struct task_struct *task,
					       int subsys_id)
{
	return task_subsys_state(task, subsys_id)->cgroup;
}

int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *ss);

/* A cgroup_iter should be treated as an opaque object */
struct cgroup_iter {
	struct list_head *cg_link;
	struct list_head *task;
};

/* To iterate across the tasks in a cgroup:
 *
 * 1) call cgroup_iter_start to intialize an iterator
 *
 * 2) call cgroup_iter_next() to retrieve member tasks until it
 *    returns NULL or until you want to end the iteration
 *
 * 3) call cgroup_iter_end() to destroy the iterator.
 *
 * Or, call cgroup_scan_tasks() to iterate through every task in a cpuset.
 *    - cgroup_scan_tasks() holds the css_set_lock when calling the test_task()
 *      callback, but not while calling the process_task() callback.
 */
void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
					struct cgroup_iter *it);
void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
int cgroup_scan_tasks(struct cgroup_scanner *scan);
int cgroup_attach_task(struct cgroup *, struct task_struct *);

#else /* !CONFIG_CGROUPS */

static inline int cgroup_init_early(void) { return 0; }
static inline int cgroup_init(void) { return 0; }
static inline void cgroup_init_smp(void) {}
static inline void cgroup_fork(struct task_struct *p) {}
static inline void cgroup_fork_callbacks(struct task_struct *p) {}
static inline void cgroup_post_fork(struct task_struct *p) {}
static inline void cgroup_exit(struct task_struct *p, int callbacks) {}

static inline void cgroup_lock(void) {}
static inline void cgroup_unlock(void) {}
static inline int cgroupstats_build(struct cgroupstats *stats,
					struct dentry *dentry)
{
	return -EINVAL;
}

#endif /* !CONFIG_CGROUPS */

#endif /* _LINUX_CGROUP_H */
Commit	Line	Data
ddbcc7e8 PM	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/kref.h>
	13	#include <linux/cpumask.h>
	14	#include <linux/nodemask.h>
	15	#include <linux/rcupdate.h>
846c7bb0	16	#include <linux/cgroupstats.h>
31a7df01	17	#include <linux/prio_heap.h>
ddbcc7e8 PM	18
	19	#ifdef CONFIG_CGROUPS
	20
	21	struct cgroupfs_root;
	22	struct cgroup_subsys;
	23	struct inode;
	24
	25	extern int cgroup_init_early(void);
	26	extern int cgroup_init(void);
	27	extern void cgroup_init_smp(void);
	28	extern void cgroup_lock(void);
	29	extern void cgroup_unlock(void);
b4f48b63 PM	30	extern void cgroup_fork(struct task_struct *p);
b4f48b63 PM	31	extern void cgroup_fork_callbacks(struct task_struct *p);
817929ec	32	extern void cgroup_post_fork(struct task_struct *p);
b4f48b63	33	extern void cgroup_exit(struct task_struct *p, int run_callbacks);
846c7bb0 BS	34	extern int cgroupstats_build(struct cgroupstats *stats,
846c7bb0 BS	35	struct dentry *dentry);
ddbcc7e8	36
a424316c PM	37	extern struct file_operations proc_cgroup_operations;
a424316c PM	38
817929ec PM	39	/* Define the enumeration of all cgroup subsystems */
	40	#define SUBSYS(_x) _x ## _subsys_id,
	41	enum cgroup_subsys_id {
	42	#include <linux/cgroup_subsys.h>
	43	CGROUP_SUBSYS_COUNT
	44	};
	45	#undef SUBSYS
	46
ddbcc7e8 PM	47	/* Per-subsystem/per-cgroup state maintained by the system. */
	48	struct cgroup_subsys_state {
	49	/* The cgroup that this subsystem is attached to. Useful
	50	* for subsystems that want to know about the cgroup
	51	* hierarchy structure */
	52	struct cgroup *cgroup;
	53
	54	/* State maintained by the cgroup system to allow
	55	* subsystems to be "busy". Should be accessed via css_get()
	56	* and css_put() */
	57
	58	atomic_t refcnt;
	59
	60	unsigned long flags;
	61	};
	62
	63	/* bits in struct cgroup_subsys_state flags field */
	64	enum {
	65	CSS_ROOT, /* This CSS is the root of the subsystem */
	66	};
	67
	68	/*
	69	* Call css_get() to hold a reference on the cgroup;
	70	*
	71	*/
	72
	73	static inline void css_get(struct cgroup_subsys_state *css)
	74	{
	75	/* We don't need to reference count the root state */
	76	if (!test_bit(CSS_ROOT, &css->flags))
	77	atomic_inc(&css->refcnt);
	78	}
	79	/*
	80	* css_put() should be called to release a reference taken by
	81	* css_get()
	82	*/
	83
81a6a5cd	84	extern void __css_put(struct cgroup_subsys_state *css);
ddbcc7e8 PM	85	static inline void css_put(struct cgroup_subsys_state *css)
	86	{
	87	if (!test_bit(CSS_ROOT, &css->flags))
81a6a5cd	88	__css_put(css);
ddbcc7e8 PM	89	}
ddbcc7e8 PM	90
3116f0e3 PM	91	/* bits in struct cgroup flags field */
	92	enum {
	93	/* Control Group is dead */
	94	CGRP_REMOVED,
	95	/* Control Group has previously had a child cgroup or a task,
	96	* but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
	97	CGRP_RELEASABLE,
	98	/* Control Group requires release notifications to userspace */
	99	CGRP_NOTIFY_ON_RELEASE,
	100	};
	101
ddbcc7e8 PM	102	struct cgroup {
	103	unsigned long flags; /* "unsigned long" so bitops work */
	104
	105	/* count users of this cgroup. >0 means busy, but doesn't
	106	* necessarily indicate the number of tasks in the
	107	* cgroup */
	108	atomic_t count;
	109
	110	/*
	111	* We link our 'sibling' struct into our parent's 'children'.
	112	* Our children link their 'sibling' into our 'children'.
	113	*/
	114	struct list_head sibling; /* my parent's children */
	115	struct list_head children; /* my children */
	116
	117	struct cgroup parent; / my parent */
	118	struct dentry dentry; / cgroup fs entry */
	119
	120	/* Private pointers for each registered subsystem */
	121	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
	122
	123	struct cgroupfs_root *root;
	124	struct cgroup *top_cgroup;
817929ec PM	125
	126	/*
	127	* List of cg_cgroup_links pointing at css_sets with
	128	* tasks in this cgroup. Protected by css_set_lock
	129	*/
	130	struct list_head css_sets;
81a6a5cd PM	131
	132	/*
	133	* Linked list running through all cgroups that can
	134	* potentially be reaped by the release agent. Protected by
	135	* release_list_lock
	136	*/
	137	struct list_head release_list;
817929ec PM	138	};
	139
	140	/* A css_set is a structure holding pointers to a set of
	141	* cgroup_subsys_state objects. This saves space in the task struct
	142	* object and speeds up fork()/exit(), since a single inc/dec and a
	143	* list_add()/del() can bump the reference count on the entire
	144	* cgroup set for a task.
	145	*/
	146
	147	struct css_set {
	148
	149	/* Reference count */
	150	struct kref ref;
	151
	152	/*
	153	* List running through all cgroup groups. Protected by
	154	* css_set_lock
	155	*/
	156	struct list_head list;
	157
	158	/*
	159	* List running through all tasks using this cgroup
	160	* group. Protected by css_set_lock
	161	*/
	162	struct list_head tasks;
	163
	164	/*
	165	* List of cg_cgroup_link objects on link chains from
	166	* cgroups referenced from this css_set. Protected by
	167	* css_set_lock
	168	*/
	169	struct list_head cg_links;
	170
	171	/*
	172	* Set of subsystem states, one for each subsystem. This array
	173	* is immutable after creation apart from the init_css_set
	174	* during subsystem registration (at boot time).
	175	*/
	176	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
	177
ddbcc7e8 PM	178	};
ddbcc7e8 PM	179
91796569 PM	180	/*
	181	* cgroup_map_cb is an abstract callback API for reporting map-valued
	182	* control files
	183	*/
	184
	185	struct cgroup_map_cb {
	186	int (fill)(struct cgroup_map_cb cb, const char *key, u64 value);
	187	void *state;
	188	};
	189
ddbcc7e8 PM	190	/* struct cftype:
	191	*
	192	* The files in the cgroup filesystem mostly have a very simple read/write
	193	* handling, some common function will take care of it. Nevertheless some cases
	194	* (read tasks) are special and therefore I define this structure for every
	195	* kind of file.
	196	*
	197	*
	198	* When reading/writing to a file:
a043e3b2	199	* - the cgroup to use is file->f_dentry->d_parent->d_fsdata
ddbcc7e8 PM	200	* - the 'cftype' of the file is file->f_dentry->d_fsdata
	201	*/
	202
	203	#define MAX_CFTYPE_NAME 64
	204	struct cftype {
	205	/* By convention, the name should begin with the name of the
	206	* subsystem, followed by a period */
	207	char name[MAX_CFTYPE_NAME];
	208	int private;
	209	int (open) (struct inode inode, struct file *file);
ffd2d883	210	ssize_t (read) (struct cgroup cgrp, struct cftype *cft,
ddbcc7e8 PM	211	struct file *file,
	212	char __user buf, size_t nbytes, loff_t ppos);
	213	/*
f4c753b7	214	* read_u64() is a shortcut for the common case of returning a
ddbcc7e8 PM	215	* single integer. Use it in place of read()
ddbcc7e8 PM	216	*/
f4c753b7	217	u64 (read_u64) (struct cgroup cgrp, struct cftype *cft);
91796569 PM	218	/*
	219	* read_map() is used for defining a map of key/value
	220	* pairs. It should call cb->fill(cb, key, value) for each
	221	* entry. The key/value pairs (and their ordering) should not
	222	* change between reboots.
	223	*/
	224	int (read_map) (struct cgroup cont, struct cftype *cft,
	225	struct cgroup_map_cb *cb);
	226
ffd2d883	227	ssize_t (write) (struct cgroup cgrp, struct cftype *cft,
ddbcc7e8 PM	228	struct file *file,
ddbcc7e8 PM	229	const char __user buf, size_t nbytes, loff_t ppos);
355e0c48 PM	230
355e0c48 PM	231	/*
f4c753b7	232	* write_u64() is a shortcut for the common case of accepting
355e0c48 PM	233	* a single integer (as parsed by simple_strtoull) from
	234	* userspace. Use in place of write(); return 0 or error.
	235	*/
f4c753b7	236	int (write_u64) (struct cgroup cgrp, struct cftype *cft, u64 val);
355e0c48	237
ddbcc7e8 PM	238	int (release) (struct inode inode, struct file *file);
	239	};
	240
31a7df01 CW	241	struct cgroup_scanner {
	242	struct cgroup *cg;
	243	int (test_task)(struct task_struct p, struct cgroup_scanner *scan);
	244	void (process_task)(struct task_struct p,
	245	struct cgroup_scanner *scan);
	246	struct ptr_heap *heap;
	247	};
	248
ddbcc7e8 PM	249	/* Add a new file to the given cgroup directory. Should only be
ddbcc7e8 PM	250	* called by subsystems from within a populate() method */
ffd2d883	251	int cgroup_add_file(struct cgroup cgrp, struct cgroup_subsys subsys,
ddbcc7e8 PM	252	const struct cftype *cft);
	253
	254	/* Add a set of new files to the given cgroup directory. Should
	255	* only be called by subsystems from within a populate() method */
ffd2d883	256	int cgroup_add_files(struct cgroup *cgrp,
ddbcc7e8 PM	257	struct cgroup_subsys *subsys,
	258	const struct cftype cft[],
	259	int count);
	260
ffd2d883	261	int cgroup_is_removed(const struct cgroup *cgrp);
ddbcc7e8	262
ffd2d883	263	int cgroup_path(const struct cgroup cgrp, char buf, int buflen);
ddbcc7e8	264
ffd2d883	265	int cgroup_task_count(const struct cgroup *cgrp);
bbcb81d0	266
ddbcc7e8	267	/* Return true if the cgroup is a descendant of the current cgroup */
ffd2d883	268	int cgroup_is_descendant(const struct cgroup *cgrp);
ddbcc7e8 PM	269
	270	/* Control Group subsystem type. See Documentation/cgroups.txt for details */
	271
	272	struct cgroup_subsys {
	273	struct cgroup_subsys_state (create)(struct cgroup_subsys *ss,
ffd2d883 LZ	274	struct cgroup *cgrp);
	275	void (pre_destroy)(struct cgroup_subsys ss, struct cgroup *cgrp);
	276	void (destroy)(struct cgroup_subsys ss, struct cgroup *cgrp);
ddbcc7e8	277	int (can_attach)(struct cgroup_subsys ss,
ffd2d883 LZ	278	struct cgroup cgrp, struct task_struct tsk);
	279	void (attach)(struct cgroup_subsys ss, struct cgroup *cgrp,
	280	struct cgroup old_cgrp, struct task_struct tsk);
ddbcc7e8 PM	281	void (fork)(struct cgroup_subsys ss, struct task_struct *task);
	282	void (exit)(struct cgroup_subsys ss, struct task_struct *task);
	283	int (populate)(struct cgroup_subsys ss,
ffd2d883 LZ	284	struct cgroup *cgrp);
ffd2d883 LZ	285	void (post_clone)(struct cgroup_subsys ss, struct cgroup *cgrp);
ddbcc7e8 PM	286	void (bind)(struct cgroup_subsys ss, struct cgroup *root);
	287	int subsys_id;
	288	int active;
8bab8dde	289	int disabled;
ddbcc7e8 PM	290	int early_init;
	291	#define MAX_CGROUP_TYPE_NAMELEN 32
	292	const char *name;
	293
	294	/* Protected by RCU */
	295	struct cgroupfs_root *root;
	296
	297	struct list_head sibling;
	298
	299	void *private;
	300	};
	301
	302	#define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
	303	#include <linux/cgroup_subsys.h>
	304	#undef SUBSYS
	305
	306	static inline struct cgroup_subsys_state *cgroup_subsys_state(
ffd2d883	307	struct cgroup *cgrp, int subsys_id)
ddbcc7e8	308	{
ffd2d883	309	return cgrp->subsys[subsys_id];
ddbcc7e8 PM	310	}
	311
	312	static inline struct cgroup_subsys_state *task_subsys_state(
	313	struct task_struct *task, int subsys_id)
	314	{
817929ec	315	return rcu_dereference(task->cgroups->subsys[subsys_id]);
ddbcc7e8 PM	316	}
	317
	318	static inline struct cgroup* task_cgroup(struct task_struct *task,
	319	int subsys_id)
	320	{
	321	return task_subsys_state(task, subsys_id)->cgroup;
	322	}
	323
697f4161 PM	324	int cgroup_clone(struct task_struct tsk, struct cgroup_subsys ss);
697f4161 PM	325
817929ec PM	326	/* A cgroup_iter should be treated as an opaque object */
	327	struct cgroup_iter {
	328	struct list_head *cg_link;
	329	struct list_head *task;
	330	};
	331
	332	/* To iterate across the tasks in a cgroup:
	333	*
	334	* 1) call cgroup_iter_start to intialize an iterator
	335	*
	336	* 2) call cgroup_iter_next() to retrieve member tasks until it
	337	* returns NULL or until you want to end the iteration
	338	*
	339	* 3) call cgroup_iter_end() to destroy the iterator.
31a7df01 CW	340	*
	341	* Or, call cgroup_scan_tasks() to iterate through every task in a cpuset.
	342	* - cgroup_scan_tasks() holds the css_set_lock when calling the test_task()
	343	* callback, but not while calling the process_task() callback.
817929ec	344	*/
ffd2d883 LZ	345	void cgroup_iter_start(struct cgroup cgrp, struct cgroup_iter it);
ffd2d883 LZ	346	struct task_struct cgroup_iter_next(struct cgroup cgrp,
817929ec	347	struct cgroup_iter *it);
ffd2d883	348	void cgroup_iter_end(struct cgroup cgrp, struct cgroup_iter it);
31a7df01	349	int cgroup_scan_tasks(struct cgroup_scanner *scan);
956db3ca	350	int cgroup_attach_task(struct cgroup , struct task_struct );
817929ec	351
ddbcc7e8 PM	352	#else /* !CONFIG_CGROUPS */
	353
	354	static inline int cgroup_init_early(void) { return 0; }
	355	static inline int cgroup_init(void) { return 0; }
	356	static inline void cgroup_init_smp(void) {}
b4f48b63 PM	357	static inline void cgroup_fork(struct task_struct *p) {}
b4f48b63 PM	358	static inline void cgroup_fork_callbacks(struct task_struct *p) {}
817929ec	359	static inline void cgroup_post_fork(struct task_struct *p) {}
b4f48b63	360	static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
ddbcc7e8 PM	361
	362	static inline void cgroup_lock(void) {}
	363	static inline void cgroup_unlock(void) {}
846c7bb0 BS	364	static inline int cgroupstats_build(struct cgroupstats *stats,
	365	struct dentry *dentry)
	366	{
	367	return -EINVAL;
	368	}
ddbcc7e8 PM	369
	370	#endif /* !CONFIG_CGROUPS */
	371
	372	#endif /* _LINUX_CGROUP_H */