[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);
}

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];

};

/* 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);
	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	}
	90
	91	struct cgroup {
	92	unsigned long flags; /* "unsigned long" so bitops work */
	93
	94	/* count users of this cgroup. >0 means busy, but doesn't
	95	* necessarily indicate the number of tasks in the
	96	* cgroup */
	97	atomic_t count;
	98
	99	/*
	100	* We link our 'sibling' struct into our parent's 'children'.
	101	* Our children link their 'sibling' into our 'children'.
	102	*/
	103	struct list_head sibling; /* my parent's children */
	104	struct list_head children; /* my children */
	105
	106	struct cgroup parent; / my parent */
	107	struct dentry dentry; / cgroup fs entry */
	108
	109	/* Private pointers for each registered subsystem */
	110	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
	111
	112	struct cgroupfs_root *root;
	113	struct cgroup *top_cgroup;
817929ec PM	114
	115	/*
	116	* List of cg_cgroup_links pointing at css_sets with
	117	* tasks in this cgroup. Protected by css_set_lock
	118	*/
	119	struct list_head css_sets;
81a6a5cd PM	120
	121	/*
	122	* Linked list running through all cgroups that can
	123	* potentially be reaped by the release agent. Protected by
	124	* release_list_lock
	125	*/
	126	struct list_head release_list;
817929ec PM	127	};
	128
	129	/* A css_set is a structure holding pointers to a set of
	130	* cgroup_subsys_state objects. This saves space in the task struct
	131	* object and speeds up fork()/exit(), since a single inc/dec and a
	132	* list_add()/del() can bump the reference count on the entire
	133	* cgroup set for a task.
	134	*/
	135
	136	struct css_set {
	137
	138	/* Reference count */
	139	struct kref ref;
	140
	141	/*
	142	* List running through all cgroup groups. Protected by
	143	* css_set_lock
	144	*/
	145	struct list_head list;
	146
	147	/*
	148	* List running through all tasks using this cgroup
	149	* group. Protected by css_set_lock
	150	*/
	151	struct list_head tasks;
	152
	153	/*
	154	* List of cg_cgroup_link objects on link chains from
	155	* cgroups referenced from this css_set. Protected by
	156	* css_set_lock
	157	*/
	158	struct list_head cg_links;
	159
	160	/*
	161	* Set of subsystem states, one for each subsystem. This array
	162	* is immutable after creation apart from the init_css_set
	163	* during subsystem registration (at boot time).
	164	*/
	165	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
	166
ddbcc7e8 PM	167	};
	168
	169	/* struct cftype:
	170	*
	171	* The files in the cgroup filesystem mostly have a very simple read/write
	172	* handling, some common function will take care of it. Nevertheless some cases
	173	* (read tasks) are special and therefore I define this structure for every
	174	* kind of file.
	175	*
	176	*
	177	* When reading/writing to a file:
a043e3b2	178	* - the cgroup to use is file->f_dentry->d_parent->d_fsdata
ddbcc7e8 PM	179	* - the 'cftype' of the file is file->f_dentry->d_fsdata
	180	*/
	181
	182	#define MAX_CFTYPE_NAME 64
	183	struct cftype {
	184	/* By convention, the name should begin with the name of the
	185	* subsystem, followed by a period */
	186	char name[MAX_CFTYPE_NAME];
	187	int private;
	188	int (open) (struct inode inode, struct file *file);
ffd2d883	189	ssize_t (read) (struct cgroup cgrp, struct cftype *cft,
ddbcc7e8 PM	190	struct file *file,
	191	char __user buf, size_t nbytes, loff_t ppos);
	192	/*
f4c753b7	193	* read_u64() is a shortcut for the common case of returning a
ddbcc7e8 PM	194	* single integer. Use it in place of read()
ddbcc7e8 PM	195	*/
f4c753b7	196	u64 (read_u64) (struct cgroup cgrp, struct cftype *cft);
ffd2d883	197	ssize_t (write) (struct cgroup cgrp, struct cftype *cft,
ddbcc7e8 PM	198	struct file *file,
ddbcc7e8 PM	199	const char __user buf, size_t nbytes, loff_t ppos);
355e0c48 PM	200
355e0c48 PM	201	/*
f4c753b7	202	* write_u64() is a shortcut for the common case of accepting
355e0c48 PM	203	* a single integer (as parsed by simple_strtoull) from
	204	* userspace. Use in place of write(); return 0 or error.
	205	*/
f4c753b7	206	int (write_u64) (struct cgroup cgrp, struct cftype *cft, u64 val);
355e0c48	207
ddbcc7e8 PM	208	int (release) (struct inode inode, struct file *file);
	209	};
	210
31a7df01 CW	211	struct cgroup_scanner {
	212	struct cgroup *cg;
	213	int (test_task)(struct task_struct p, struct cgroup_scanner *scan);
	214	void (process_task)(struct task_struct p,
	215	struct cgroup_scanner *scan);
	216	struct ptr_heap *heap;
	217	};
	218
ddbcc7e8 PM	219	/* Add a new file to the given cgroup directory. Should only be
ddbcc7e8 PM	220	* called by subsystems from within a populate() method */
ffd2d883	221	int cgroup_add_file(struct cgroup cgrp, struct cgroup_subsys subsys,
ddbcc7e8 PM	222	const struct cftype *cft);
	223
	224	/* Add a set of new files to the given cgroup directory. Should
	225	* only be called by subsystems from within a populate() method */
ffd2d883	226	int cgroup_add_files(struct cgroup *cgrp,
ddbcc7e8 PM	227	struct cgroup_subsys *subsys,
	228	const struct cftype cft[],
	229	int count);
	230
ffd2d883	231	int cgroup_is_removed(const struct cgroup *cgrp);
ddbcc7e8	232
ffd2d883	233	int cgroup_path(const struct cgroup cgrp, char buf, int buflen);
ddbcc7e8	234
ffd2d883	235	int cgroup_task_count(const struct cgroup *cgrp);
bbcb81d0	236
ddbcc7e8	237	/* Return true if the cgroup is a descendant of the current cgroup */
ffd2d883	238	int cgroup_is_descendant(const struct cgroup *cgrp);
ddbcc7e8 PM	239
	240	/* Control Group subsystem type. See Documentation/cgroups.txt for details */
	241
	242	struct cgroup_subsys {
	243	struct cgroup_subsys_state (create)(struct cgroup_subsys *ss,
ffd2d883 LZ	244	struct cgroup *cgrp);
	245	void (pre_destroy)(struct cgroup_subsys ss, struct cgroup *cgrp);
	246	void (destroy)(struct cgroup_subsys ss, struct cgroup *cgrp);
ddbcc7e8	247	int (can_attach)(struct cgroup_subsys ss,
ffd2d883 LZ	248	struct cgroup cgrp, struct task_struct tsk);
	249	void (attach)(struct cgroup_subsys ss, struct cgroup *cgrp,
	250	struct cgroup old_cgrp, struct task_struct tsk);
ddbcc7e8 PM	251	void (fork)(struct cgroup_subsys ss, struct task_struct *task);
	252	void (exit)(struct cgroup_subsys ss, struct task_struct *task);
	253	int (populate)(struct cgroup_subsys ss,
ffd2d883 LZ	254	struct cgroup *cgrp);
ffd2d883 LZ	255	void (post_clone)(struct cgroup_subsys ss, struct cgroup *cgrp);
ddbcc7e8 PM	256	void (bind)(struct cgroup_subsys ss, struct cgroup *root);
	257	int subsys_id;
	258	int active;
8bab8dde	259	int disabled;
ddbcc7e8 PM	260	int early_init;
	261	#define MAX_CGROUP_TYPE_NAMELEN 32
	262	const char *name;
	263
	264	/* Protected by RCU */
	265	struct cgroupfs_root *root;
	266
	267	struct list_head sibling;
	268
	269	void *private;
	270	};
	271
	272	#define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
	273	#include <linux/cgroup_subsys.h>
	274	#undef SUBSYS
	275
	276	static inline struct cgroup_subsys_state *cgroup_subsys_state(
ffd2d883	277	struct cgroup *cgrp, int subsys_id)
ddbcc7e8	278	{
ffd2d883	279	return cgrp->subsys[subsys_id];
ddbcc7e8 PM	280	}
	281
	282	static inline struct cgroup_subsys_state *task_subsys_state(
	283	struct task_struct *task, int subsys_id)
	284	{
817929ec	285	return rcu_dereference(task->cgroups->subsys[subsys_id]);
ddbcc7e8 PM	286	}
	287
	288	static inline struct cgroup* task_cgroup(struct task_struct *task,
	289	int subsys_id)
	290	{
	291	return task_subsys_state(task, subsys_id)->cgroup;
	292	}
	293
697f4161 PM	294	int cgroup_clone(struct task_struct tsk, struct cgroup_subsys ss);
697f4161 PM	295
817929ec PM	296	/* A cgroup_iter should be treated as an opaque object */
	297	struct cgroup_iter {
	298	struct list_head *cg_link;
	299	struct list_head *task;
	300	};
	301
	302	/* To iterate across the tasks in a cgroup:
	303	*
	304	* 1) call cgroup_iter_start to intialize an iterator
	305	*
	306	* 2) call cgroup_iter_next() to retrieve member tasks until it
	307	* returns NULL or until you want to end the iteration
	308	*
	309	* 3) call cgroup_iter_end() to destroy the iterator.
31a7df01 CW	310	*
	311	* Or, call cgroup_scan_tasks() to iterate through every task in a cpuset.
	312	* - cgroup_scan_tasks() holds the css_set_lock when calling the test_task()
	313	* callback, but not while calling the process_task() callback.
817929ec	314	*/
ffd2d883 LZ	315	void cgroup_iter_start(struct cgroup cgrp, struct cgroup_iter it);
ffd2d883 LZ	316	struct task_struct cgroup_iter_next(struct cgroup cgrp,
817929ec	317	struct cgroup_iter *it);
ffd2d883	318	void cgroup_iter_end(struct cgroup cgrp, struct cgroup_iter it);
31a7df01	319	int cgroup_scan_tasks(struct cgroup_scanner *scan);
956db3ca	320	int cgroup_attach_task(struct cgroup , struct task_struct );
817929ec	321
ddbcc7e8 PM	322	#else /* !CONFIG_CGROUPS */
	323
	324	static inline int cgroup_init_early(void) { return 0; }
	325	static inline int cgroup_init(void) { return 0; }
	326	static inline void cgroup_init_smp(void) {}
b4f48b63 PM	327	static inline void cgroup_fork(struct task_struct *p) {}
b4f48b63 PM	328	static inline void cgroup_fork_callbacks(struct task_struct *p) {}
817929ec	329	static inline void cgroup_post_fork(struct task_struct *p) {}
b4f48b63	330	static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
ddbcc7e8 PM	331
	332	static inline void cgroup_lock(void) {}
	333	static inline void cgroup_unlock(void) {}
846c7bb0 BS	334	static inline int cgroupstats_build(struct cgroupstats *stats,
	335	struct dentry *dentry)
	336	{
	337	return -EINVAL;
	338	}
ddbcc7e8 PM	339
	340	#endif /* !CONFIG_CGROUPS */
	341
	342	#endif /* _LINUX_CGROUP_H */