cgroup.h 17.1 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 int cgroup_lock_is_held(void);
32
extern bool cgroup_lock_live_group(struct cgroup *cgrp);
33
extern void cgroup_unlock(void);
34 35
extern void cgroup_fork(struct task_struct *p);
extern void cgroup_fork_callbacks(struct task_struct *p);
36
extern void cgroup_post_fork(struct task_struct *p);
37
extern void cgroup_exit(struct task_struct *p, int run_callbacks);
B
Balbir Singh 已提交
38 39
extern int cgroupstats_build(struct cgroupstats *stats,
				struct dentry *dentry);
40

41
extern const struct file_operations proc_cgroup_operations;
42

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

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

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

	atomic_t refcnt;

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

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

/*
P
Paul Menage 已提交
80 81 82 83
 * 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
84 85 86 87 88 89 90 91
 */

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 已提交
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110

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;
111
		cpu_relax();
P
Paul Menage 已提交
112 113 114 115
	}
	return true;
}

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

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

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

145 146 147 148 149 150 151 152 153 154 155 156
/* 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.
 */
157
struct cgroup_pidlist {
158 159 160 161 162
	/*
	 * 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;
163 164 165 166 167 168
	/* 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;
169 170 171 172 173 174
	/* 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;
175 176
};

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

P
Paul Menage 已提交
180 181 182 183
	/*
	 * count users of this cgroup. >0 means busy, but doesn't
	 * necessarily indicate the number of tasks in the cgroup
	 */
184 185 186 187 188 189 190 191 192
	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 已提交
193
	struct cgroup *parent;		/* my parent */
194
	struct dentry *dentry;	  	/* cgroup fs entry, RCU protected */
195 196 197 198 199 200

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

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

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

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

215 216 217 218 219 220
	/*
	 * 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;
221 222 223

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

P
Paul Menage 已提交
226 227
/*
 * A css_set is a structure holding pointers to a set of
228 229
 * 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 已提交
230 231
 * list_add()/del() can bump the reference count on the entire cgroup
 * set for a task.
232 233 234 235 236
 */

struct css_set {

	/* Reference count */
237
	atomic_t refcount;
238

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

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

	/* For RCU-protected deletion */
	struct rcu_head rcu_head;
267 268
};

269 270 271 272 273 274 275 276 277 278
/*
 * 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 已提交
279 280
/*
 * struct cftype: handler definitions for cgroup control files
281 282
 *
 * When reading/writing to a file:
L
Li Zefan 已提交
283
 *	- the cgroup to use is file->f_dentry->d_parent->d_fsdata
284 285 286 287 288
 *	- the 'cftype' of the file is file->f_dentry->d_fsdata
 */

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

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

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

335 336 337
	ssize_t (*write)(struct cgroup *cgrp, struct cftype *cft,
			 struct file *file,
			 const char __user *buf, size_t nbytes, loff_t *ppos);
338 339

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

350 351 352 353 354 355 356
	/*
	 * 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);
357 358 359 360 361 362 363 364
	/*
	 * 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);

365
	int (*release)(struct inode *inode, struct file *file);
366 367
};

368 369 370 371 372 373
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;
374
	void *data;
375 376
};

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

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

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

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

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

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

402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
/*
 * 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);

419 420 421 422
/*
 * Control Group subsystem type.
 * See Documentation/cgroups/cgroups.txt for details
 */
423 424 425

struct cgroup_subsys {
	struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
L
Li Zefan 已提交
426
						  struct cgroup *cgrp);
427
	int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
L
Li Zefan 已提交
428
	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
429 430
	int (*can_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
			  struct task_struct *tsk, bool threadgroup);
431 432
	void (*cancel_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
			  struct task_struct *tsk, bool threadgroup);
L
Li Zefan 已提交
433
	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
434 435
			struct cgroup *old_cgrp, struct task_struct *tsk,
			bool threadgroup);
436 437 438
	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 已提交
439 440
			struct cgroup *cgrp);
	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
441
	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
442

443 444
	int subsys_id;
	int active;
445
	int disabled;
446
	int early_init;
K
KAMEZAWA Hiroyuki 已提交
447 448 449 450 451
	/*
	 * True if this subsys uses ID. ID is not available before cgroup_init()
	 * (not available in early_init time.)
	 */
	bool use_id;
452 453 454
#define MAX_CGROUP_TYPE_NAMELEN 32
	const char *name;

455 456 457 458 459 460 461 462 463 464 465
	/*
	 * 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;
466
	struct lock_class_key subsys_key;
467

468 469 470 471 472
	/*
	 * Link to parent, and list entry in parent's children.
	 * Protected by this->hierarchy_mutex and cgroup_lock()
	 */
	struct cgroupfs_root *root;
473
	struct list_head sibling;
K
KAMEZAWA Hiroyuki 已提交
474 475 476
	/* used when use_id == true */
	struct idr idr;
	spinlock_t id_lock;
477 478 479 480 481 482 483
};

#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 已提交
484
	struct cgroup *cgrp, int subsys_id)
485
{
L
Li Zefan 已提交
486
	return cgrp->subsys[subsys_id];
487 488 489 490 491
}

static inline struct cgroup_subsys_state *task_subsys_state(
	struct task_struct *task, int subsys_id)
{
492 493 494
	return rcu_dereference_check(task->cgroups->subsys[subsys_id],
				     rcu_read_lock_held() ||
				     cgroup_lock_is_held());
495 496 497 498 499 500 501 502
}

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

503 504
int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *ss,
							char *nodename);
505

506 507 508 509 510 511
/* 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 已提交
512 513
/*
 * To iterate across the tasks in a cgroup:
514 515 516 517 518 519 520
 *
 * 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.
521
 *
P
Paul Menage 已提交
522 523 524 525
 * 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.
526
 */
L
Li Zefan 已提交
527 528
void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
529
					struct cgroup_iter *it);
L
Li Zefan 已提交
530
void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
531
int cgroup_scan_tasks(struct cgroup_scanner *scan);
532
int cgroup_attach_task(struct cgroup *, struct task_struct *);
533

K
KAMEZAWA Hiroyuki 已提交
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
/*
 * 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,
566
		     const struct cgroup_subsys_state *root);
K
KAMEZAWA Hiroyuki 已提交
567 568 569 570 571

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

572 573 574 575
#else /* !CONFIG_CGROUPS */

static inline int cgroup_init_early(void) { return 0; }
static inline int cgroup_init(void) { return 0; }
576 577
static inline void cgroup_fork(struct task_struct *p) {}
static inline void cgroup_fork_callbacks(struct task_struct *p) {}
578
static inline void cgroup_post_fork(struct task_struct *p) {}
579
static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
580 581 582

static inline void cgroup_lock(void) {}
static inline void cgroup_unlock(void) {}
B
Balbir Singh 已提交
583 584 585 586 587
static inline int cgroupstats_build(struct cgroupstats *stats,
					struct dentry *dentry)
{
	return -EINVAL;
}
588 589 590 591

#endif /* !CONFIG_CGROUPS */

#endif /* _LINUX_CGROUP_H */