cgroup.h 15.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 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
struct cgroup {
	unsigned long flags;		/* "unsigned long" so bitops work */

P
Paul Menage 已提交
147 148 149 150
	/*
	 * count users of this cgroup. >0 means busy, but doesn't
	 * necessarily indicate the number of tasks in the cgroup
	 */
151 152 153 154 155 156 157 158 159
	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 已提交
160
	struct cgroup *parent;		/* my parent */
161
	struct dentry *dentry;	  	/* cgroup fs entry, RCU protected */
162 163 164 165 166 167

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

	struct cgroupfs_root *root;
	struct cgroup *top_cgroup;
168 169 170 171 172 173

	/*
	 * List of cg_cgroup_links pointing at css_sets with
	 * tasks in this cgroup. Protected by css_set_lock
	 */
	struct list_head css_sets;
174 175 176 177 178 179 180

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

	/* pids_mutex protects the fields below */
	struct rw_semaphore pids_mutex;
	/* Array of process ids in the cgroup */
	pid_t *tasks_pids;
	/* How many files are using the current tasks_pids array */
	int pids_use_count;
	/* Length of the current tasks_pids array */
	int pids_length;
190 191 192

	/* For RCU-protected deletion */
	struct rcu_head rcu_head;
193 194
};

P
Paul Menage 已提交
195 196
/*
 * A css_set is a structure holding pointers to a set of
197 198
 * 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 已提交
199 200
 * list_add()/del() can bump the reference count on the entire cgroup
 * set for a task.
201 202 203 204 205
 */

struct css_set {

	/* Reference count */
206
	atomic_t refcount;
207

208 209 210 211 212 213
	/*
	 * List running through all cgroup groups in the same hash
	 * slot. Protected by css_set_lock
	 */
	struct hlist_node hlist;

214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
	/*
	 * 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];
233 234
};

235 236 237 238 239 240 241 242 243 244
/*
 * 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 已提交
245 246
/*
 * struct cftype: handler definitions for cgroup control files
247 248
 *
 * When reading/writing to a file:
L
Li Zefan 已提交
249
 *	- the cgroup to use is file->f_dentry->d_parent->d_fsdata
250 251 252 253 254
 *	- the 'cftype' of the file is file->f_dentry->d_fsdata
 */

#define MAX_CFTYPE_NAME 64
struct cftype {
P
Paul Menage 已提交
255 256 257 258
	/*
	 * By convention, the name should begin with the name of the
	 * subsystem, followed by a period
	 */
259 260
	char name[MAX_CFTYPE_NAME];
	int private;
261 262 263 264 265 266 267

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

268 269 270 271
	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);
272
	/*
273
	 * read_u64() is a shortcut for the common case of returning a
274 275
	 * single integer. Use it in place of read()
	 */
276
	u64 (*read_u64)(struct cgroup *cgrp, struct cftype *cft);
277 278 279
	/*
	 * read_s64() is a signed version of read_u64()
	 */
280
	s64 (*read_s64)(struct cgroup *cgrp, struct cftype *cft);
281 282 283 284 285 286
	/*
	 * 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.
	 */
287 288
	int (*read_map)(struct cgroup *cont, struct cftype *cft,
			struct cgroup_map_cb *cb);
289 290 291 292
	/*
	 * read_seq_string() is used for outputting a simple sequence
	 * using seqfile.
	 */
293 294
	int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
			       struct seq_file *m);
295

296 297 298
	ssize_t (*write)(struct cgroup *cgrp, struct cftype *cft,
			 struct file *file,
			 const char __user *buf, size_t nbytes, loff_t *ppos);
299 300

	/*
301
	 * write_u64() is a shortcut for the common case of accepting
302 303 304
	 * a single integer (as parsed by simple_strtoull) from
	 * userspace. Use in place of write(); return 0 or error.
	 */
305
	int (*write_u64)(struct cgroup *cgrp, struct cftype *cft, u64 val);
306 307 308
	/*
	 * write_s64() is a signed version of write_u64()
	 */
309
	int (*write_s64)(struct cgroup *cgrp, struct cftype *cft, s64 val);
310

311 312 313 314 315 316 317
	/*
	 * 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);
318 319 320 321 322 323 324 325
	/*
	 * 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);

326
	int (*release)(struct inode *inode, struct file *file);
327 328
};

329 330 331 332 333 334 335 336
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;
};

P
Paul Menage 已提交
337 338 339 340
/*
 * Add a new file to the given cgroup directory. Should only be
 * called by subsystems from within a populate() method
 */
L
Li Zefan 已提交
341
int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
342 343
		       const struct cftype *cft);

P
Paul Menage 已提交
344 345 346 347
/*
 * 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 已提交
348
int cgroup_add_files(struct cgroup *cgrp,
349 350 351 352
			struct cgroup_subsys *subsys,
			const struct cftype cft[],
			int count);

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

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

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

359 360
/* Return true if cgrp is a descendant of the task's cgroup */
int cgroup_is_descendant(const struct cgroup *cgrp, struct task_struct *task);
361 362 363 364 365

/* 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 已提交
366
						  struct cgroup *cgrp);
367
	int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
L
Li Zefan 已提交
368
	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
369
	int (*can_attach)(struct cgroup_subsys *ss,
L
Li Zefan 已提交
370 371 372
			  struct cgroup *cgrp, struct task_struct *tsk);
	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
			struct cgroup *old_cgrp, struct task_struct *tsk);
373 374 375
	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 已提交
376 377
			struct cgroup *cgrp);
	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
378
	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
379

380 381
	int subsys_id;
	int active;
382
	int disabled;
383
	int early_init;
K
KAMEZAWA Hiroyuki 已提交
384 385 386 387 388
	/*
	 * True if this subsys uses ID. ID is not available before cgroup_init()
	 * (not available in early_init time.)
	 */
	bool use_id;
389 390 391
#define MAX_CGROUP_TYPE_NAMELEN 32
	const char *name;

392 393 394 395 396 397 398 399 400 401 402
	/*
	 * 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;
403
	struct lock_class_key subsys_key;
404

405 406 407 408 409
	/*
	 * Link to parent, and list entry in parent's children.
	 * Protected by this->hierarchy_mutex and cgroup_lock()
	 */
	struct cgroupfs_root *root;
410
	struct list_head sibling;
K
KAMEZAWA Hiroyuki 已提交
411 412 413
	/* used when use_id == true */
	struct idr idr;
	spinlock_t id_lock;
414 415 416 417 418 419 420
};

#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 已提交
421
	struct cgroup *cgrp, int subsys_id)
422
{
L
Li Zefan 已提交
423
	return cgrp->subsys[subsys_id];
424 425 426 427 428
}

static inline struct cgroup_subsys_state *task_subsys_state(
	struct task_struct *task, int subsys_id)
{
429
	return rcu_dereference(task->cgroups->subsys[subsys_id]);
430 431 432 433 434 435 436 437
}

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

438 439
int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *ss,
							char *nodename);
440

441 442 443 444 445 446
/* 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 已提交
447 448
/*
 * To iterate across the tasks in a cgroup:
449 450 451 452 453 454 455
 *
 * 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.
456
 *
P
Paul Menage 已提交
457 458 459 460
 * 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.
461
 */
L
Li Zefan 已提交
462 463
void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
464
					struct cgroup_iter *it);
L
Li Zefan 已提交
465
void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
466
int cgroup_scan_tasks(struct cgroup_scanner *scan);
467
int cgroup_attach_task(struct cgroup *, struct task_struct *);
468

K
KAMEZAWA Hiroyuki 已提交
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
/*
 * 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,
		     struct cgroup_subsys_state *root);

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

507 508 509 510
#else /* !CONFIG_CGROUPS */

static inline int cgroup_init_early(void) { return 0; }
static inline int cgroup_init(void) { return 0; }
511 512
static inline void cgroup_fork(struct task_struct *p) {}
static inline void cgroup_fork_callbacks(struct task_struct *p) {}
513
static inline void cgroup_post_fork(struct task_struct *p) {}
514
static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
515 516 517

static inline void cgroup_lock(void) {}
static inline void cgroup_unlock(void) {}
B
Balbir Singh 已提交
518 519 520 521 522
static inline int cgroupstats_build(struct cgroupstats *stats,
					struct dentry *dentry)
{
	return -EINVAL;
}
523 524 525 526

#endif /* !CONFIG_CGROUPS */

#endif /* _LINUX_CGROUP_H */