cgroup.h 16.8 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
#include <linux/rwsem.h>
K
KAMEZAWA Hiroyuki 已提交
18
#include <linux/idr.h>
19 20 21 22 23 24

#ifdef CONFIG_CGROUPS

struct cgroupfs_root;
struct cgroup_subsys;
struct inode;
25
struct cgroup;
K
KAMEZAWA Hiroyuki 已提交
26
struct css_id;
27 28 29 30

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

40 41
extern struct file_operations proc_cgroup_operations;

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

50 51
/* Per-subsystem/per-cgroup state maintained by the system. */
struct cgroup_subsys_state {
P
Paul Menage 已提交
52 53
	/*
	 * The cgroup that this subsystem is attached to. Useful
54
	 * for subsystems that want to know about the cgroup
P
Paul Menage 已提交
55 56
	 * hierarchy structure
	 */
57 58
	struct cgroup *cgroup;

P
Paul Menage 已提交
59 60
	/*
	 * State maintained by the cgroup system to allow subsystems
P
Paul Menage 已提交
61
	 * to be "busy". Should be accessed via css_get(),
P
Paul Menage 已提交
62 63
	 * css_tryget() and and css_put().
	 */
64 65 66 67

	atomic_t refcnt;

	unsigned long flags;
K
KAMEZAWA Hiroyuki 已提交
68 69
	/* ID for this css, if possible */
	struct css_id *id;
70 71 72 73 74
};

/* bits in struct cgroup_subsys_state flags field */
enum {
	CSS_ROOT, /* This CSS is the root of the subsystem */
P
Paul Menage 已提交
75
	CSS_REMOVED, /* This CSS is dead */
76 77 78
};

/*
P
Paul Menage 已提交
79 80 81 82
 * Call css_get() to hold a reference on the css; it can be used
 * for a reference obtained via:
 * - an existing ref-counted reference to the css
 * - task->cgroups for a locked task
83 84 85 86 87 88 89 90
 */

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);
}
P
Paul Menage 已提交
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

static inline bool css_is_removed(struct cgroup_subsys_state *css)
{
	return test_bit(CSS_REMOVED, &css->flags);
}

/*
 * Call css_tryget() to take a reference on a css if your existing
 * (known-valid) reference isn't already ref-counted. Returns false if
 * the css has been destroyed.
 */

static inline bool css_tryget(struct cgroup_subsys_state *css)
{
	if (test_bit(CSS_ROOT, &css->flags))
		return true;
	while (!atomic_inc_not_zero(&css->refcnt)) {
		if (test_bit(CSS_REMOVED, &css->flags))
			return false;
110
		cpu_relax();
P
Paul Menage 已提交
111 112 113 114
	}
	return true;
}

115 116
/*
 * css_put() should be called to release a reference taken by
P
Paul Menage 已提交
117
 * css_get() or css_tryget()
118 119
 */

120
extern void __css_put(struct cgroup_subsys_state *css);
121 122 123
static inline void css_put(struct cgroup_subsys_state *css)
{
	if (!test_bit(CSS_ROOT, &css->flags))
124
		__css_put(css);
125 126
}

127 128 129 130
/* bits in struct cgroup flags field */
enum {
	/* Control Group is dead */
	CGRP_REMOVED,
P
Paul Menage 已提交
131 132 133 134
	/*
	 * Control Group has previously had a child cgroup or a task,
	 * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
	 */
135 136 137
	CGRP_RELEASABLE,
	/* Control Group requires release notifications to userspace */
	CGRP_NOTIFY_ON_RELEASE,
138 139 140 141
	/*
	 * A thread in rmdir() is wating for this cgroup.
	 */
	CGRP_WAIT_ON_RMDIR,
142 143
};

144 145 146 147 148 149 150 151 152 153 154 155
/* which pidlist file are we talking about? */
enum cgroup_filetype {
	CGROUP_FILE_PROCS,
	CGROUP_FILE_TASKS,
};

/*
 * A pidlist is a list of pids that virtually represents the contents of one
 * of the cgroup files ("procs" or "tasks"). We keep a list of such pidlists,
 * a pair (one each for procs, tasks) for each pid namespace that's relevant
 * to the cgroup.
 */
156
struct cgroup_pidlist {
157 158 159 160 161
	/*
	 * used to find which pidlist is wanted. doesn't change as long as
	 * this particular list stays in the list.
	 */
	struct { enum cgroup_filetype type; struct pid_namespace *ns; } key;
162 163 164 165 166 167
	/* array of xids */
	pid_t *list;
	/* how many elements the above list has */
	int length;
	/* how many files are using the current array */
	int use_count;
168 169 170 171 172 173
	/* each of these stored in a list by its cgroup */
	struct list_head links;
	/* pointer to the cgroup we belong to, for list removal purposes */
	struct cgroup *owner;
	/* protects the other fields */
	struct rw_semaphore mutex;
174 175
};

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

P
Paul Menage 已提交
179 180 181 182
	/*
	 * count users of this cgroup. >0 means busy, but doesn't
	 * necessarily indicate the number of tasks in the cgroup
	 */
183 184 185 186 187 188 189 190 191
	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 */

P
Paul Menage 已提交
192
	struct cgroup *parent;		/* my parent */
193
	struct dentry *dentry;	  	/* cgroup fs entry, RCU protected */
194 195 196 197 198 199

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

	struct cgroupfs_root *root;
	struct cgroup *top_cgroup;
200 201 202 203 204 205

	/*
	 * List of cg_cgroup_links pointing at css_sets with
	 * tasks in this cgroup. Protected by css_set_lock
	 */
	struct list_head css_sets;
206 207 208 209 210 211 212

	/*
	 * 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;
213

214 215 216 217 218 219
	/*
	 * list of pidlists, up to two for each namespace (one for procs, one
	 * for tasks); created on demand.
	 */
	struct list_head pidlists;
	struct mutex pidlist_mutex;
220 221 222

	/* For RCU-protected deletion */
	struct rcu_head rcu_head;
223 224
};

P
Paul Menage 已提交
225 226
/*
 * A css_set is a structure holding pointers to a set of
227 228
 * cgroup_subsys_state objects. This saves space in the task struct
 * object and speeds up fork()/exit(), since a single inc/dec and a
P
Paul Menage 已提交
229 230
 * list_add()/del() can bump the reference count on the entire cgroup
 * set for a task.
231 232 233 234 235
 */

struct css_set {

	/* Reference count */
236
	atomic_t refcount;
237

238 239 240 241 242 243
	/*
	 * List running through all cgroup groups in the same hash
	 * slot. Protected by css_set_lock
	 */
	struct hlist_node hlist;

244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
	/*
	 * 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];
263 264
};

265 266 267 268 269 270 271 272 273 274
/*
 * 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;
};

P
Paul Menage 已提交
275 276
/*
 * struct cftype: handler definitions for cgroup control files
277 278
 *
 * When reading/writing to a file:
L
Li Zefan 已提交
279
 *	- the cgroup to use is file->f_dentry->d_parent->d_fsdata
280 281 282 283 284
 *	- the 'cftype' of the file is file->f_dentry->d_fsdata
 */

#define MAX_CFTYPE_NAME 64
struct cftype {
P
Paul Menage 已提交
285 286 287 288
	/*
	 * By convention, the name should begin with the name of the
	 * subsystem, followed by a period
	 */
289 290
	char name[MAX_CFTYPE_NAME];
	int private;
L
Li Zefan 已提交
291 292 293 294 295
	/*
	 * If not 0, file mode is set to this value, otherwise it will
	 * be figured out automatically
	 */
	mode_t mode;
296 297 298 299 300 301 302

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

303 304 305 306
	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);
307
	/*
308
	 * read_u64() is a shortcut for the common case of returning a
309 310
	 * single integer. Use it in place of read()
	 */
311
	u64 (*read_u64)(struct cgroup *cgrp, struct cftype *cft);
312 313 314
	/*
	 * read_s64() is a signed version of read_u64()
	 */
315
	s64 (*read_s64)(struct cgroup *cgrp, struct cftype *cft);
316 317 318 319 320 321
	/*
	 * 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.
	 */
322 323
	int (*read_map)(struct cgroup *cont, struct cftype *cft,
			struct cgroup_map_cb *cb);
324 325 326 327
	/*
	 * read_seq_string() is used for outputting a simple sequence
	 * using seqfile.
	 */
328 329
	int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
			       struct seq_file *m);
330

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

	/*
336
	 * write_u64() is a shortcut for the common case of accepting
337 338 339
	 * a single integer (as parsed by simple_strtoull) from
	 * userspace. Use in place of write(); return 0 or error.
	 */
340
	int (*write_u64)(struct cgroup *cgrp, struct cftype *cft, u64 val);
341 342 343
	/*
	 * write_s64() is a signed version of write_u64()
	 */
344
	int (*write_s64)(struct cgroup *cgrp, struct cftype *cft, s64 val);
345

346 347 348 349 350 351 352
	/*
	 * 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);
353 354 355 356 357 358 359 360
	/*
	 * 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);

361
	int (*release)(struct inode *inode, struct file *file);
362 363
};

364 365 366 367 368 369
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;
370
	void *data;
371 372
};

P
Paul Menage 已提交
373 374 375 376
/*
 * Add a new file to the given cgroup directory. Should only be
 * called by subsystems from within a populate() method
 */
L
Li Zefan 已提交
377
int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
378 379
		       const struct cftype *cft);

P
Paul Menage 已提交
380 381 382 383
/*
 * 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 已提交
384
int cgroup_add_files(struct cgroup *cgrp,
385 386 387 388
			struct cgroup_subsys *subsys,
			const struct cftype cft[],
			int count);

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

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

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

395 396
/* Return true if cgrp is a descendant of the task's cgroup */
int cgroup_is_descendant(const struct cgroup *cgrp, struct task_struct *task);
397

398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
/*
 * When the subsys has to access css and may add permanent refcnt to css,
 * it should take care of racy conditions with rmdir(). Following set of
 * functions, is for stop/restart rmdir if necessary.
 * Because these will call css_get/put, "css" should be alive css.
 *
 *  cgroup_exclude_rmdir();
 *  ...do some jobs which may access arbitrary empty cgroup
 *  cgroup_release_and_wakeup_rmdir();
 *
 *  When someone removes a cgroup while cgroup_exclude_rmdir() holds it,
 *  it sleeps and cgroup_release_and_wakeup_rmdir() will wake him up.
 */

void cgroup_exclude_rmdir(struct cgroup_subsys_state *css);
void cgroup_release_and_wakeup_rmdir(struct cgroup_subsys_state *css);

415 416 417 418
/*
 * Control Group subsystem type.
 * See Documentation/cgroups/cgroups.txt for details
 */
419 420 421

struct cgroup_subsys {
	struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
L
Li Zefan 已提交
422
						  struct cgroup *cgrp);
423
	int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
L
Li Zefan 已提交
424
	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
425
	int (*can_attach)(struct cgroup_subsys *ss,
L
Li Zefan 已提交
426 427 428
			  struct cgroup *cgrp, struct task_struct *tsk);
	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
			struct cgroup *old_cgrp, struct task_struct *tsk);
429 430 431
	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 已提交
432 433
			struct cgroup *cgrp);
	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
434
	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
435

436 437
	int subsys_id;
	int active;
438
	int disabled;
439
	int early_init;
K
KAMEZAWA Hiroyuki 已提交
440 441 442 443 444
	/*
	 * True if this subsys uses ID. ID is not available before cgroup_init()
	 * (not available in early_init time.)
	 */
	bool use_id;
445 446 447
#define MAX_CGROUP_TYPE_NAMELEN 32
	const char *name;

448 449 450 451 452 453 454 455 456 457 458
	/*
	 * Protects sibling/children links of cgroups in this
	 * hierarchy, plus protects which hierarchy (or none) the
	 * subsystem is a part of (i.e. root/sibling).  To avoid
	 * potential deadlocks, the following operations should not be
	 * undertaken while holding any hierarchy_mutex:
	 *
	 * - allocating memory
	 * - initiating hotplug events
	 */
	struct mutex hierarchy_mutex;
459
	struct lock_class_key subsys_key;
460

461 462 463 464 465
	/*
	 * Link to parent, and list entry in parent's children.
	 * Protected by this->hierarchy_mutex and cgroup_lock()
	 */
	struct cgroupfs_root *root;
466
	struct list_head sibling;
K
KAMEZAWA Hiroyuki 已提交
467 468 469
	/* used when use_id == true */
	struct idr idr;
	spinlock_t id_lock;
470 471 472 473 474 475 476
};

#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 已提交
477
	struct cgroup *cgrp, int subsys_id)
478
{
L
Li Zefan 已提交
479
	return cgrp->subsys[subsys_id];
480 481 482 483 484
}

static inline struct cgroup_subsys_state *task_subsys_state(
	struct task_struct *task, int subsys_id)
{
485
	return rcu_dereference(task->cgroups->subsys[subsys_id]);
486 487 488 489 490 491 492 493
}

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

494 495
int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *ss,
							char *nodename);
496

497 498 499 500 501 502
/* A cgroup_iter should be treated as an opaque object */
struct cgroup_iter {
	struct list_head *cg_link;
	struct list_head *task;
};

P
Paul Menage 已提交
503 504
/*
 * To iterate across the tasks in a cgroup:
505 506 507 508 509 510 511
 *
 * 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.
512
 *
P
Paul Menage 已提交
513 514 515 516
 * Or, call cgroup_scan_tasks() to iterate through every task in a
 * cgroup - cgroup_scan_tasks() holds the css_set_lock when calling
 * the test_task() callback, but not while calling the process_task()
 * callback.
517
 */
L
Li Zefan 已提交
518 519
void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
520
					struct cgroup_iter *it);
L
Li Zefan 已提交
521
void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
522
int cgroup_scan_tasks(struct cgroup_scanner *scan);
523
int cgroup_attach_task(struct cgroup *, struct task_struct *);
524

K
KAMEZAWA Hiroyuki 已提交
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
/*
 * CSS ID is ID for cgroup_subsys_state structs under subsys. This only works
 * if cgroup_subsys.use_id == true. It can be used for looking up and scanning.
 * CSS ID is assigned at cgroup allocation (create) automatically
 * and removed when subsys calls free_css_id() function. This is because
 * the lifetime of cgroup_subsys_state is subsys's matter.
 *
 * Looking up and scanning function should be called under rcu_read_lock().
 * Taking cgroup_mutex()/hierarchy_mutex() is not necessary for following calls.
 * But the css returned by this routine can be "not populated yet" or "being
 * destroyed". The caller should check css and cgroup's status.
 */

/*
 * Typically Called at ->destroy(), or somewhere the subsys frees
 * cgroup_subsys_state.
 */
void free_css_id(struct cgroup_subsys *ss, struct cgroup_subsys_state *css);

/* Find a cgroup_subsys_state which has given ID */

struct cgroup_subsys_state *css_lookup(struct cgroup_subsys *ss, int id);

/*
 * Get a cgroup whose id is greater than or equal to id under tree of root.
 * Returning a cgroup_subsys_state or NULL.
 */
struct cgroup_subsys_state *css_get_next(struct cgroup_subsys *ss, int id,
		struct cgroup_subsys_state *root, int *foundid);

/* Returns true if root is ancestor of cg */
bool css_is_ancestor(struct cgroup_subsys_state *cg,
557
		     const struct cgroup_subsys_state *root);
K
KAMEZAWA Hiroyuki 已提交
558 559 560 561 562

/* Get id and depth of css */
unsigned short css_id(struct cgroup_subsys_state *css);
unsigned short css_depth(struct cgroup_subsys_state *css);

563 564 565 566
#else /* !CONFIG_CGROUPS */

static inline int cgroup_init_early(void) { return 0; }
static inline int cgroup_init(void) { return 0; }
567 568
static inline void cgroup_fork(struct task_struct *p) {}
static inline void cgroup_fork_callbacks(struct task_struct *p) {}
569
static inline void cgroup_post_fork(struct task_struct *p) {}
570
static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
571 572 573

static inline void cgroup_lock(void) {}
static inline void cgroup_unlock(void) {}
B
Balbir Singh 已提交
574 575 576 577 578
static inline int cgroupstats_build(struct cgroupstats *stats,
					struct dentry *dentry)
{
	return -EINVAL;
}
579 580 581 582

#endif /* !CONFIG_CGROUPS */

#endif /* _LINUX_CGROUP_H */