[mirror_ubuntu-artful-kernel.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>

#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 in 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 *cont, struct cftype *cft,
			 struct file *file,
			 char __user *buf, size_t nbytes, loff_t *ppos);
	/*
	 * read_uint() is a shortcut for the common case of returning a
	 * single integer. Use it in place of read()
	 */
	u64 (*read_uint) (struct cgroup *cont, struct cftype *cft);
	ssize_t (*write) (struct cgroup *cont, struct cftype *cft,
			  struct file *file,
			  const char __user *buf, size_t nbytes, loff_t *ppos);

	/*
	 * write_uint() 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_uint) (struct cgroup *cont, struct cftype *cft, u64 val);

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

/* 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 *cont, 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 *cont,
			struct cgroup_subsys *subsys,
			const struct cftype cft[],
			int count);

int cgroup_is_removed(const struct cgroup *cont);

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

int cgroup_task_count(const struct cgroup *cont);

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

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

struct cgroup_subsys {
	struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
						  struct cgroup *cont);
	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cont);
	int (*can_attach)(struct cgroup_subsys *ss,
			  struct cgroup *cont, struct task_struct *tsk);
	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cont,
			struct cgroup *old_cont, 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 *cont);
	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cont);
	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
	int subsys_id;
	int active;
	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 *cont, int subsys_id)
{
	return cont->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_path(const struct cgroup *cont, char *buf, int buflen);

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.
 */
void cgroup_iter_start(struct cgroup *cont, struct cgroup_iter *it);
struct task_struct *cgroup_iter_next(struct cgroup *cont,
					struct cgroup_iter *it);
void cgroup_iter_end(struct cgroup *cont, struct cgroup_iter *it);

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