[net-next-2.6.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_s64() is a signed version of read_u64()
	 */
	s64 (*read_s64) (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);
	/*
	 * write_s64() is a signed version of write_u64()
	 */
	int (*write_s64) (struct cgroup *cgrp, struct cftype *cft, s64 val);

	/*
	 * trigger() callback can be used to get some kick from the
	 * userspace, when the actual string written is not important
	 * at all. The private field can be used to determine the
	 * kick type for multiplexing.
	 */
	int (*trigger)(struct cgroup *cgrp, unsigned int event);

	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);
e73d2c61 PM	218	/*
	219	* read_s64() is a signed version of read_u64()
	220	*/
	221	s64 (read_s64) (struct cgroup cgrp, struct cftype *cft);
91796569 PM	222	/*
	223	* read_map() is used for defining a map of key/value
	224	* pairs. It should call cb->fill(cb, key, value) for each
	225	* entry. The key/value pairs (and their ordering) should not
	226	* change between reboots.
	227	*/
	228	int (read_map) (struct cgroup cont, struct cftype *cft,
	229	struct cgroup_map_cb *cb);
	230
ffd2d883	231	ssize_t (write) (struct cgroup cgrp, struct cftype *cft,
ddbcc7e8 PM	232	struct file *file,
ddbcc7e8 PM	233	const char __user buf, size_t nbytes, loff_t ppos);
355e0c48 PM	234
355e0c48 PM	235	/*
f4c753b7	236	* write_u64() is a shortcut for the common case of accepting
355e0c48 PM	237	* a single integer (as parsed by simple_strtoull) from
	238	* userspace. Use in place of write(); return 0 or error.
	239	*/
f4c753b7	240	int (write_u64) (struct cgroup cgrp, struct cftype *cft, u64 val);
e73d2c61 PM	241	/*
	242	* write_s64() is a signed version of write_u64()
	243	*/
	244	int (write_s64) (struct cgroup cgrp, struct cftype *cft, s64 val);
355e0c48	245
d447ea2f PE	246	/*
	247	* trigger() callback can be used to get some kick from the
	248	* userspace, when the actual string written is not important
	249	* at all. The private field can be used to determine the
	250	* kick type for multiplexing.
	251	*/
	252	int (trigger)(struct cgroup cgrp, unsigned int event);
	253
ddbcc7e8 PM	254	int (release) (struct inode inode, struct file *file);
	255	};
	256
31a7df01 CW	257	struct cgroup_scanner {
	258	struct cgroup *cg;
	259	int (test_task)(struct task_struct p, struct cgroup_scanner *scan);
	260	void (process_task)(struct task_struct p,
	261	struct cgroup_scanner *scan);
	262	struct ptr_heap *heap;
	263	};
	264
ddbcc7e8 PM	265	/* Add a new file to the given cgroup directory. Should only be
ddbcc7e8 PM	266	* called by subsystems from within a populate() method */
ffd2d883	267	int cgroup_add_file(struct cgroup cgrp, struct cgroup_subsys subsys,
ddbcc7e8 PM	268	const struct cftype *cft);
	269
	270	/* Add a set of new files to the given cgroup directory. Should
	271	* only be called by subsystems from within a populate() method */
ffd2d883	272	int cgroup_add_files(struct cgroup *cgrp,
ddbcc7e8 PM	273	struct cgroup_subsys *subsys,
	274	const struct cftype cft[],
	275	int count);
	276
ffd2d883	277	int cgroup_is_removed(const struct cgroup *cgrp);
ddbcc7e8	278
ffd2d883	279	int cgroup_path(const struct cgroup cgrp, char buf, int buflen);
ddbcc7e8	280
ffd2d883	281	int cgroup_task_count(const struct cgroup *cgrp);
bbcb81d0	282
ddbcc7e8	283	/* Return true if the cgroup is a descendant of the current cgroup */
ffd2d883	284	int cgroup_is_descendant(const struct cgroup *cgrp);
ddbcc7e8 PM	285
	286	/* Control Group subsystem type. See Documentation/cgroups.txt for details */
	287
	288	struct cgroup_subsys {
	289	struct cgroup_subsys_state (create)(struct cgroup_subsys *ss,
ffd2d883 LZ	290	struct cgroup *cgrp);
	291	void (pre_destroy)(struct cgroup_subsys ss, struct cgroup *cgrp);
	292	void (destroy)(struct cgroup_subsys ss, struct cgroup *cgrp);
ddbcc7e8	293	int (can_attach)(struct cgroup_subsys ss,
ffd2d883 LZ	294	struct cgroup cgrp, struct task_struct tsk);
	295	void (attach)(struct cgroup_subsys ss, struct cgroup *cgrp,
	296	struct cgroup old_cgrp, struct task_struct tsk);
ddbcc7e8 PM	297	void (fork)(struct cgroup_subsys ss, struct task_struct *task);
	298	void (exit)(struct cgroup_subsys ss, struct task_struct *task);
	299	int (populate)(struct cgroup_subsys ss,
ffd2d883 LZ	300	struct cgroup *cgrp);
ffd2d883 LZ	301	void (post_clone)(struct cgroup_subsys ss, struct cgroup *cgrp);
ddbcc7e8 PM	302	void (bind)(struct cgroup_subsys ss, struct cgroup *root);
	303	int subsys_id;
	304	int active;
8bab8dde	305	int disabled;
ddbcc7e8 PM	306	int early_init;
	307	#define MAX_CGROUP_TYPE_NAMELEN 32
	308	const char *name;
	309
	310	/* Protected by RCU */
	311	struct cgroupfs_root *root;
	312
	313	struct list_head sibling;
	314
	315	void *private;
	316	};
	317
	318	#define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
	319	#include <linux/cgroup_subsys.h>
	320	#undef SUBSYS
	321
	322	static inline struct cgroup_subsys_state *cgroup_subsys_state(
ffd2d883	323	struct cgroup *cgrp, int subsys_id)
ddbcc7e8	324	{
ffd2d883	325	return cgrp->subsys[subsys_id];
ddbcc7e8 PM	326	}
	327
	328	static inline struct cgroup_subsys_state *task_subsys_state(
	329	struct task_struct *task, int subsys_id)
	330	{
817929ec	331	return rcu_dereference(task->cgroups->subsys[subsys_id]);
ddbcc7e8 PM	332	}
	333
	334	static inline struct cgroup* task_cgroup(struct task_struct *task,
	335	int subsys_id)
	336	{
	337	return task_subsys_state(task, subsys_id)->cgroup;
	338	}
	339
697f4161 PM	340	int cgroup_clone(struct task_struct tsk, struct cgroup_subsys ss);
697f4161 PM	341
817929ec PM	342	/* A cgroup_iter should be treated as an opaque object */
	343	struct cgroup_iter {
	344	struct list_head *cg_link;
	345	struct list_head *task;
	346	};
	347
	348	/* To iterate across the tasks in a cgroup:
	349	*
	350	* 1) call cgroup_iter_start to intialize an iterator
	351	*
	352	* 2) call cgroup_iter_next() to retrieve member tasks until it
	353	* returns NULL or until you want to end the iteration
	354	*
	355	* 3) call cgroup_iter_end() to destroy the iterator.
31a7df01 CW	356	*
	357	* Or, call cgroup_scan_tasks() to iterate through every task in a cpuset.
	358	* - cgroup_scan_tasks() holds the css_set_lock when calling the test_task()
	359	* callback, but not while calling the process_task() callback.
817929ec	360	*/
ffd2d883 LZ	361	void cgroup_iter_start(struct cgroup cgrp, struct cgroup_iter it);
ffd2d883 LZ	362	struct task_struct cgroup_iter_next(struct cgroup cgrp,
817929ec	363	struct cgroup_iter *it);
ffd2d883	364	void cgroup_iter_end(struct cgroup cgrp, struct cgroup_iter it);
31a7df01	365	int cgroup_scan_tasks(struct cgroup_scanner *scan);
956db3ca	366	int cgroup_attach_task(struct cgroup , struct task_struct );
817929ec	367
ddbcc7e8 PM	368	#else /* !CONFIG_CGROUPS */
	369
	370	static inline int cgroup_init_early(void) { return 0; }
	371	static inline int cgroup_init(void) { return 0; }
	372	static inline void cgroup_init_smp(void) {}
b4f48b63 PM	373	static inline void cgroup_fork(struct task_struct *p) {}
b4f48b63 PM	374	static inline void cgroup_fork_callbacks(struct task_struct *p) {}
817929ec	375	static inline void cgroup_post_fork(struct task_struct *p) {}
b4f48b63	376	static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
ddbcc7e8 PM	377
	378	static inline void cgroup_lock(void) {}
	379	static inline void cgroup_unlock(void) {}
846c7bb0 BS	380	static inline int cgroupstats_build(struct cgroupstats *stats,
	381	struct dentry *dentry)
	382	{
	383	return -EINVAL;
	384	}
ddbcc7e8 PM	385
	386	#endif /* !CONFIG_CGROUPS */
	387
	388	#endif /* _LINUX_CGROUP_H */