cgroup.h 12.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
#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/cpumask.h>
#include <linux/nodemask.h>
#include <linux/rcupdate.h>
B
Balbir Singh 已提交
15
#include <linux/cgroupstats.h>
16
#include <linux/prio_heap.h>
17 18 19 20 21 22

#ifdef CONFIG_CGROUPS

struct cgroupfs_root;
struct cgroup_subsys;
struct inode;
23
struct cgroup;
24 25 26 27 28

extern int cgroup_init_early(void);
extern int cgroup_init(void);
extern void cgroup_init_smp(void);
extern void cgroup_lock(void);
29
extern bool cgroup_lock_live_group(struct cgroup *cgrp);
30
extern void cgroup_unlock(void);
31 32
extern void cgroup_fork(struct task_struct *p);
extern void cgroup_fork_callbacks(struct task_struct *p);
33
extern void cgroup_post_fork(struct task_struct *p);
34
extern void cgroup_exit(struct task_struct *p, int run_callbacks);
B
Balbir Singh 已提交
35 36
extern int cgroupstats_build(struct cgroupstats *stats,
				struct dentry *dentry);
37

38 39
extern struct file_operations proc_cgroup_operations;

40 41 42 43 44 45 46 47
/* 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

48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
/* 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()
 */

85
extern void __css_put(struct cgroup_subsys_state *css);
86 87 88
static inline void css_put(struct cgroup_subsys_state *css)
{
	if (!test_bit(CSS_ROOT, &css->flags))
89
		__css_put(css);
90 91
}

92 93 94 95 96 97 98 99 100 101 102
/* 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,
};

103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
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;
126 127 128 129 130 131

	/*
	 * List of cg_cgroup_links pointing at css_sets with
	 * tasks in this cgroup. Protected by css_set_lock
	 */
	struct list_head css_sets;
132 133 134 135 136 137 138

	/*
	 * 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;
139 140 141 142 143 144 145 146 147 148 149 150
};

/* 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 */
151
	atomic_t refcount;
152

153 154 155 156 157 158
	/*
	 * List running through all cgroup groups in the same hash
	 * slot. Protected by css_set_lock
	 */
	struct hlist_node hlist;

159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
	/*
	 * 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];
178 179
};

180 181 182 183 184 185 186 187 188 189
/*
 * 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;
};

190 191 192 193 194 195 196 197 198
/* 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:
L
Li Zefan 已提交
199
 *	- the cgroup to use is file->f_dentry->d_parent->d_fsdata
200 201 202 203 204 205 206 207 208
 *	- 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;
209 210 211 212 213 214 215

	/*
	 * If non-zero, defines the maximum length of string that can
	 * be passed to write_string; defaults to 64
	 */
	size_t max_write_len;

216 217 218 219
	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);
220
	/*
221
	 * read_u64() is a shortcut for the common case of returning a
222 223
	 * single integer. Use it in place of read()
	 */
224
	u64 (*read_u64)(struct cgroup *cgrp, struct cftype *cft);
225 226 227
	/*
	 * read_s64() is a signed version of read_u64()
	 */
228
	s64 (*read_s64)(struct cgroup *cgrp, struct cftype *cft);
229 230 231 232 233 234
	/*
	 * 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.
	 */
235 236
	int (*read_map)(struct cgroup *cont, struct cftype *cft,
			struct cgroup_map_cb *cb);
237 238 239 240
	/*
	 * read_seq_string() is used for outputting a simple sequence
	 * using seqfile.
	 */
241 242
	int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
			       struct seq_file *m);
243

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

	/*
249
	 * write_u64() is a shortcut for the common case of accepting
250 251 252
	 * a single integer (as parsed by simple_strtoull) from
	 * userspace. Use in place of write(); return 0 or error.
	 */
253
	int (*write_u64)(struct cgroup *cgrp, struct cftype *cft, u64 val);
254 255 256
	/*
	 * write_s64() is a signed version of write_u64()
	 */
257
	int (*write_s64)(struct cgroup *cgrp, struct cftype *cft, s64 val);
258

259 260 261 262 263 264 265
	/*
	 * write_string() is passed a nul-terminated kernelspace
	 * buffer of maximum length determined by max_write_len.
	 * Returns 0 or -ve error code.
	 */
	int (*write_string)(struct cgroup *cgrp, struct cftype *cft,
			    const char *buffer);
266 267 268 269 270 271 272 273
	/*
	 * 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);

274
	int (*release)(struct inode *inode, struct file *file);
275 276
};

277 278 279 280 281 282 283 284
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;
};

285 286
/* Add a new file to the given cgroup directory. Should only be
 * called by subsystems from within a populate() method */
L
Li Zefan 已提交
287
int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
288 289 290 291
		       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 */
L
Li Zefan 已提交
292
int cgroup_add_files(struct cgroup *cgrp,
293 294 295 296
			struct cgroup_subsys *subsys,
			const struct cftype cft[],
			int count);

L
Li Zefan 已提交
297
int cgroup_is_removed(const struct cgroup *cgrp);
298

L
Li Zefan 已提交
299
int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
300

L
Li Zefan 已提交
301
int cgroup_task_count(const struct cgroup *cgrp);
302

303
/* Return true if the cgroup is a descendant of the current cgroup */
L
Li Zefan 已提交
304
int cgroup_is_descendant(const struct cgroup *cgrp);
305 306 307 308 309

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

struct cgroup_subsys {
	struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
L
Li Zefan 已提交
310 311 312
						  struct cgroup *cgrp);
	void (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
313
	int (*can_attach)(struct cgroup_subsys *ss,
L
Li Zefan 已提交
314 315 316
			  struct cgroup *cgrp, struct task_struct *tsk);
	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
			struct cgroup *old_cgrp, struct task_struct *tsk);
317 318 319
	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,
L
Li Zefan 已提交
320 321
			struct cgroup *cgrp);
	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
322
	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
323 324 325 326 327
	/*
	 * This routine is called with the task_lock of mm->owner held
	 */
	void (*mm_owner_changed)(struct cgroup_subsys *ss,
					struct cgroup *old,
328 329
					struct cgroup *new,
					struct task_struct *p);
330 331
	int subsys_id;
	int active;
332
	int disabled;
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
	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(
L
Li Zefan 已提交
350
	struct cgroup *cgrp, int subsys_id)
351
{
L
Li Zefan 已提交
352
	return cgrp->subsys[subsys_id];
353 354 355 356 357
}

static inline struct cgroup_subsys_state *task_subsys_state(
	struct task_struct *task, int subsys_id)
{
358
	return rcu_dereference(task->cgroups->subsys[subsys_id]);
359 360 361 362 363 364 365 366
}

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

367 368
int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *ss,
							char *nodename);
369

370 371 372 373 374 375 376 377 378 379 380 381 382 383
/* 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.
384 385 386 387
 *
 * 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.
388
 */
L
Li Zefan 已提交
389 390
void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
391
					struct cgroup_iter *it);
L
Li Zefan 已提交
392
void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
393
int cgroup_scan_tasks(struct cgroup_scanner *scan);
394
int cgroup_attach_task(struct cgroup *, struct task_struct *);
395

396 397 398 399 400
#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) {}
401 402
static inline void cgroup_fork(struct task_struct *p) {}
static inline void cgroup_fork_callbacks(struct task_struct *p) {}
403
static inline void cgroup_post_fork(struct task_struct *p) {}
404
static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
405 406 407

static inline void cgroup_lock(void) {}
static inline void cgroup_unlock(void) {}
B
Balbir Singh 已提交
408 409 410 411 412
static inline int cgroupstats_build(struct cgroupstats *stats,
					struct dentry *dentry)
{
	return -EINVAL;
}
413 414 415

#endif /* !CONFIG_CGROUPS */

416 417 418 419 420 421 422 423 424
#ifdef CONFIG_MM_OWNER
extern void
cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new);
#else /* !CONFIG_MM_OWNER */
static inline void
cgroup_mm_owner_callbacks(struct task_struct *old, struct task_struct *new)
{
}
#endif /* CONFIG_MM_OWNER */
425
#endif /* _LINUX_CGROUP_H */