cgroup.h 25.5 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>
15
#include <linux/rculist.h>
B
Balbir Singh 已提交
16
#include <linux/cgroupstats.h>
17
#include <linux/prio_heap.h>
18
#include <linux/rwsem.h>
K
KAMEZAWA Hiroyuki 已提交
19
#include <linux/idr.h>
20
#include <linux/workqueue.h>
21
#include <linux/fs.h>
22
#include <linux/percpu-refcount.h>
23
#include <linux/seq_file.h>
T
Tejun Heo 已提交
24
#include <linux/kernfs.h>
25 26 27 28 29 30

#ifdef CONFIG_CGROUPS

struct cgroupfs_root;
struct cgroup_subsys;
struct inode;
31
struct cgroup;
32 33 34

extern int cgroup_init_early(void);
extern int cgroup_init(void);
35
extern void cgroup_fork(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 int proc_cgroup_show(struct seq_file *, void *);
42

T
Tejun Heo 已提交
43
/* define the enumeration of all cgroup subsystems */
44
#define SUBSYS(_x) _x ## _cgrp_id,
45 46
enum cgroup_subsys_id {
#include <linux/cgroup_subsys.h>
47
	CGROUP_SUBSYS_COUNT,
48 49 50
};
#undef SUBSYS

51 52
/* Per-subsystem/per-cgroup state maintained by the system. */
struct cgroup_subsys_state {
53
	/* the cgroup that this css is attached to */
54 55
	struct cgroup *cgroup;

56 57 58
	/* the cgroup subsystem that this css is attached to */
	struct cgroup_subsys *ss;

59 60
	/* reference count - access via css_[try]get() and css_put() */
	struct percpu_ref refcnt;
61

62 63 64
	/* the parent css */
	struct cgroup_subsys_state *parent;

65
	unsigned long flags;
66

67 68
	/* percpu_ref killing and RCU release */
	struct rcu_head rcu_head;
69
	struct work_struct destroy_work;
70 71 72 73
};

/* bits in struct cgroup_subsys_state flags field */
enum {
74
	CSS_ROOT	= (1 << 0), /* this CSS is the root of the subsystem */
75
	CSS_ONLINE	= (1 << 1), /* between ->css_online() and ->css_offline() */
76 77
};

78 79 80 81 82
/**
 * css_get - obtain a reference on the specified css
 * @css: target css
 *
 * The caller must already have a reference.
83 84 85 86
 */
static inline void css_get(struct cgroup_subsys_state *css)
{
	/* We don't need to reference count the root state */
87
	if (!(css->flags & CSS_ROOT))
88
		percpu_ref_get(&css->refcnt);
89
}
P
Paul Menage 已提交
90

91 92 93 94 95 96 97 98 99 100
/**
 * css_tryget - try to obtain a reference on the specified css
 * @css: target css
 *
 * Obtain a reference on @css if it's alive.  The caller naturally needs to
 * ensure that @css is accessible but doesn't have to be holding a
 * reference on it - IOW, RCU protected access is good enough for this
 * function.  Returns %true if a reference count was successfully obtained;
 * %false otherwise.
 */
P
Paul Menage 已提交
101 102
static inline bool css_tryget(struct cgroup_subsys_state *css)
{
103
	if (css->flags & CSS_ROOT)
P
Paul Menage 已提交
104
		return true;
105
	return percpu_ref_tryget(&css->refcnt);
P
Paul Menage 已提交
106 107
}

108 109 110 111 112 113
/**
 * css_put - put a css reference
 * @css: target css
 *
 * Put a reference obtained via css_get() and css_tryget().
 */
114 115
static inline void css_put(struct cgroup_subsys_state *css)
{
116
	if (!(css->flags & CSS_ROOT))
117
		percpu_ref_put(&css->refcnt);
118 119
}

120 121 122
/* bits in struct cgroup flags field */
enum {
	/* Control Group is dead */
123
	CGRP_DEAD,
P
Paul Menage 已提交
124 125 126 127
	/*
	 * Control Group has previously had a child cgroup or a task,
	 * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
	 */
128 129 130
	CGRP_RELEASABLE,
	/* Control Group requires release notifications to userspace */
	CGRP_NOTIFY_ON_RELEASE,
131
	/*
132 133 134
	 * Clone the parent's configuration when creating a new child
	 * cpuset cgroup.  For historical reasons, this option can be
	 * specified at mount time and thus is implemented here.
135
	 */
136
	CGRP_CPUSET_CLONE_CHILDREN,
137 138
	/* see the comment above CGRP_ROOT_SANE_BEHAVIOR for details */
	CGRP_SANE_BEHAVIOR,
139 140
};

141 142 143
struct cgroup {
	unsigned long flags;		/* "unsigned long" so bitops work */

144 145 146 147 148
	/*
	 * idr allocated in-hierarchy ID.
	 *
	 * The ID of the root cgroup is always 0, and a new cgroup
	 * will be assigned with a smallest available ID.
149 150
	 *
	 * Allocating/Removing ID must be protected by cgroup_mutex.
151 152
	 */
	int id;
T
Tejun Heo 已提交
153

154 155 156
	/* the number of attached css's */
	int nr_css;

T
Tejun Heo 已提交
157 158
	atomic_t refcnt;

159 160 161 162 163 164 165
	/*
	 * 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 已提交
166
	struct cgroup *parent;		/* my parent */
T
Tejun Heo 已提交
167
	struct kernfs_node *kn;		/* cgroup kernfs entry */
168

169 170 171 172 173 174 175 176
	/*
	 * Monotonically increasing unique serial number which defines a
	 * uniform order among all cgroups.  It's guaranteed that all
	 * ->children lists are in the ascending order of ->serial_nr.
	 * It's used to allow interrupting and resuming iterations.
	 */
	u64 serial_nr;

177
	/* Private pointers for each registered subsystem */
178
	struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
179 180

	struct cgroupfs_root *root;
181 182

	/*
183 184
	 * List of cgrp_cset_links pointing at css_sets with tasks in this
	 * cgroup.  Protected by css_set_lock.
185
	 */
186
	struct list_head cset_links;
187 188 189 190 191 192 193

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

195 196 197 198 199 200
	/*
	 * 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;
201

T
Tejun Heo 已提交
202 203 204
	/* dummy css with NULL ->ss, points back to this cgroup */
	struct cgroup_subsys_state dummy_css;

205
	/* For css percpu_ref killing and RCU-protected deletion */
206
	struct rcu_head rcu_head;
207
	struct work_struct destroy_work;
208 209
};

210 211 212 213
#define MAX_CGROUP_ROOT_NAMELEN 64

/* cgroupfs_root->flags */
enum {
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
	/*
	 * Unfortunately, cgroup core and various controllers are riddled
	 * with idiosyncrasies and pointless options.  The following flag,
	 * when set, will force sane behavior - some options are forced on,
	 * others are disallowed, and some controllers will change their
	 * hierarchical or other behaviors.
	 *
	 * The set of behaviors affected by this flag are still being
	 * determined and developed and the mount option for this flag is
	 * prefixed with __DEVEL__.  The prefix will be dropped once we
	 * reach the point where all behaviors are compatible with the
	 * planned unified hierarchy, which will automatically turn on this
	 * flag.
	 *
	 * The followings are the behaviors currently affected this flag.
	 *
	 * - Mount options "noprefix" and "clone_children" are disallowed.
	 *   Also, cgroupfs file cgroup.clone_children is not created.
	 *
	 * - When mounting an existing superblock, mount options should
	 *   match.
	 *
	 * - Remount is disallowed.
	 *
238 239
	 * - rename(2) is disallowed.
	 *
240 241
	 * - "tasks" is removed.  Everything should be at process
	 *   granularity.  Use "cgroup.procs" instead.
242
	 *
243 244 245
	 * - "cgroup.procs" is not sorted.  pids will be unique unless they
	 *   got recycled inbetween reads.
	 *
246 247
	 * - "release_agent" and "notify_on_release" are removed.
	 *   Replacement notification mechanism will be implemented.
248
	 *
249 250
	 * - "xattr" mount option is deprecated.  kernfs always enables it.
	 *
251 252 253 254
	 * - cpuset: tasks will be kept in empty cpusets when hotplug happens
	 *   and take masks of ancestors with non-empty cpus/mems, instead of
	 *   being moved to an ancestor.
	 *
255 256
	 * - cpuset: a task can be moved into an empty cpuset, and again it
	 *   takes masks of ancestors.
257
	 *
258 259
	 * - memcg: use_hierarchy is on by default and the cgroup file for
	 *   the flag is not created.
260
	 *
261
	 * - blkcg: blk-throttle becomes properly hierarchical.
262 263 264
	 */
	CGRP_ROOT_SANE_BEHAVIOR	= (1 << 0),

265 266
	CGRP_ROOT_NOPREFIX	= (1 << 1), /* mounted subsystems have no named prefix */
	CGRP_ROOT_XATTR		= (1 << 2), /* supports extended attributes */
267 268 269 270 271

	/* mount options live below bit 16 */
	CGRP_ROOT_OPTION_MASK	= (1 << 16) - 1,

	CGRP_ROOT_SUBSYS_BOUND	= (1 << 16), /* subsystems finished binding */
272 273 274 275
};

/*
 * A cgroupfs_root represents the root of a cgroup hierarchy, and may be
T
Tejun Heo 已提交
276
 * associated with a kernfs_root to form an active hierarchy.  This is
277 278 279
 * internal to cgroup core.  Don't access directly from controllers.
 */
struct cgroupfs_root {
T
Tejun Heo 已提交
280
	struct kernfs_root *kf_root;
281

282
	/* The bitmask of subsystems attached to this hierarchy */
283 284
	unsigned long subsys_mask;

T
Tejun Heo 已提交
285 286
	atomic_t refcnt;

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
	/* Unique id for this hierarchy. */
	int hierarchy_id;

	/* The root cgroup for this hierarchy */
	struct cgroup top_cgroup;

	/* Tracks how many cgroups are currently defined in hierarchy.*/
	int number_of_cgroups;

	/* A list running through the active hierarchies */
	struct list_head root_list;

	/* Hierarchy-specific flags */
	unsigned long flags;

	/* IDs for cgroups in this hierarchy */
303
	struct idr cgroup_idr;
304 305 306 307 308 309 310 311

	/* The path to use for release notifications. */
	char release_agent_path[PATH_MAX];

	/* The name for this hierarchy - may be empty */
	char name[MAX_CGROUP_ROOT_NAMELEN];
};

P
Paul Menage 已提交
312 313
/*
 * A css_set is a structure holding pointers to a set of
314 315
 * 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 已提交
316 317
 * list_add()/del() can bump the reference count on the entire cgroup
 * set for a task.
318 319 320 321 322
 */

struct css_set {

	/* Reference count */
323
	atomic_t refcount;
324

325 326 327 328 329 330
	/*
	 * List running through all cgroup groups in the same hash
	 * slot. Protected by css_set_lock
	 */
	struct hlist_node hlist;

331 332 333 334 335 336 337
	/*
	 * List running through all tasks using this cgroup
	 * group. Protected by css_set_lock
	 */
	struct list_head tasks;

	/*
338 339
	 * List of cgrp_cset_links pointing at cgroups referenced from this
	 * css_set.  Protected by css_set_lock.
340
	 */
341
	struct list_head cgrp_links;
342 343

	/*
T
Tejun Heo 已提交
344 345 346
	 * 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).
347 348
	 */
	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
349 350 351

	/* For RCU-protected deletion */
	struct rcu_head rcu_head;
352 353
};

P
Paul Menage 已提交
354 355
/*
 * struct cftype: handler definitions for cgroup control files
356 357
 *
 * When reading/writing to a file:
L
Li Zefan 已提交
358
 *	- the cgroup to use is file->f_dentry->d_parent->d_fsdata
359 360 361
 *	- the 'cftype' of the file is file->f_dentry->d_fsdata
 */

362
/* cftype->flags */
363
enum {
L
Li Zefan 已提交
364 365
	CFTYPE_ONLY_ON_ROOT	= (1 << 0),	/* only create on root cgrp */
	CFTYPE_NOT_ON_ROOT	= (1 << 1),	/* don't create on root cgrp */
366
	CFTYPE_INSANE		= (1 << 2),	/* don't create if sane_behavior */
T
Tejun Heo 已提交
367
	CFTYPE_NO_PREFIX	= (1 << 3),	/* (DON'T USE FOR NEW FILES) no subsys prefix */
368
};
369 370 371

#define MAX_CFTYPE_NAME		64

372
struct cftype {
P
Paul Menage 已提交
373 374
	/*
	 * By convention, the name should begin with the name of the
375 376
	 * subsystem, followed by a period.  Zero length string indicates
	 * end of cftype array.
P
Paul Menage 已提交
377
	 */
378 379
	char name[MAX_CFTYPE_NAME];
	int private;
L
Li Zefan 已提交
380 381 382 383
	/*
	 * If not 0, file mode is set to this value, otherwise it will
	 * be figured out automatically
	 */
A
Al Viro 已提交
384
	umode_t mode;
385 386

	/*
387 388 389
	 * The maximum length of string, excluding trailing nul, that can
	 * be passed to write_string.  If < PAGE_SIZE-1, PAGE_SIZE-1 is
	 * assumed.
390 391 392
	 */
	size_t max_write_len;

393 394 395
	/* CFTYPE_* flags */
	unsigned int flags;

396
	/*
T
Tejun Heo 已提交
397 398
	 * Fields used for internal bookkeeping.  Initialized automatically
	 * during registration.
399
	 */
T
Tejun Heo 已提交
400 401
	struct cgroup_subsys *ss;	/* NULL for cgroup core files */
	struct list_head node;		/* anchored at ss->cfts */
T
Tejun Heo 已提交
402 403
	struct kernfs_ops *kf_ops;

404
	/*
405
	 * read_u64() is a shortcut for the common case of returning a
406 407
	 * single integer. Use it in place of read()
	 */
408
	u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
409 410 411
	/*
	 * read_s64() is a signed version of read_u64()
	 */
412
	s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
413 414 415

	/* generic seq_file read interface */
	int (*seq_show)(struct seq_file *sf, void *v);
416

417 418 419 420 421
	/* optional ops, implement all or none */
	void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
	void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
	void (*seq_stop)(struct seq_file *sf, void *v);

422
	/*
423
	 * write_u64() is a shortcut for the common case of accepting
424 425 426
	 * a single integer (as parsed by simple_strtoull) from
	 * userspace. Use in place of write(); return 0 or error.
	 */
427 428
	int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
			 u64 val);
429 430 431
	/*
	 * write_s64() is a signed version of write_u64()
	 */
432 433
	int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
			 s64 val);
434

435 436 437 438 439
	/*
	 * write_string() is passed a nul-terminated kernelspace
	 * buffer of maximum length determined by max_write_len.
	 * Returns 0 or -ve error code.
	 */
440
	int (*write_string)(struct cgroup_subsys_state *css, struct cftype *cft,
441
			    const char *buffer);
442 443 444 445 446 447
	/*
	 * 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.
	 */
448
	int (*trigger)(struct cgroup_subsys_state *css, unsigned int event);
T
Tejun Heo 已提交
449 450 451 452

#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lock_class_key	lockdep_key;
#endif
453 454
};

455 456 457 458 459 460 461 462 463
/*
 * See the comment above CGRP_ROOT_SANE_BEHAVIOR for details.  This
 * function can be called as long as @cgrp is accessible.
 */
static inline bool cgroup_sane_behavior(const struct cgroup *cgrp)
{
	return cgrp->root->flags & CGRP_ROOT_SANE_BEHAVIOR;
}

T
Tejun Heo 已提交
464 465 466
/* returns ino associated with a cgroup, 0 indicates unmounted root */
static inline ino_t cgroup_ino(struct cgroup *cgrp)
{
T
Tejun Heo 已提交
467 468
	if (cgrp->kn)
		return cgrp->kn->ino;
T
Tejun Heo 已提交
469 470 471 472
	else
		return 0;
}

473 474
static inline struct cftype *seq_cft(struct seq_file *seq)
{
T
Tejun Heo 已提交
475 476 477
	struct kernfs_open_file *of = seq->private;

	return of->kn->priv;
478 479
}

480 481
struct cgroup_subsys_state *seq_css(struct seq_file *seq);

T
Tejun Heo 已提交
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 507 508 509 510 511 512 513 514 515 516 517
/*
 * Name / path handling functions.  All are thin wrappers around the kernfs
 * counterparts and can be called under any context.
 */

static inline int cgroup_name(struct cgroup *cgrp, char *buf, size_t buflen)
{
	return kernfs_name(cgrp->kn, buf, buflen);
}

static inline char * __must_check cgroup_path(struct cgroup *cgrp, char *buf,
					      size_t buflen)
{
	return kernfs_path(cgrp->kn, buf, buflen);
}

static inline void pr_cont_cgroup_name(struct cgroup *cgrp)
{
	/* dummy_top doesn't have a kn associated */
	if (cgrp->kn)
		pr_cont_kernfs_name(cgrp->kn);
	else
		pr_cont("/");
}

static inline void pr_cont_cgroup_path(struct cgroup *cgrp)
{
	/* dummy_top doesn't have a kn associated */
	if (cgrp->kn)
		pr_cont_kernfs_path(cgrp->kn);
	else
		pr_cont("/");
}

char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);

A
Aristeu Rozanski 已提交
518
int cgroup_add_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
519
int cgroup_rm_cftypes(struct cftype *cfts);
520

521
bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
522

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

525 526 527 528 529 530 531
/*
 * Control Group taskset, used to pass around set of tasks to cgroup_subsys
 * methods.
 */
struct cgroup_taskset;
struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
532 533
struct cgroup_subsys_state *cgroup_taskset_cur_css(struct cgroup_taskset *tset,
						   int subsys_id);
534 535 536 537 538
int cgroup_taskset_size(struct cgroup_taskset *tset);

/**
 * cgroup_taskset_for_each - iterate cgroup_taskset
 * @task: the loop cursor
539
 * @skip_css: skip if task's css matches this, %NULL to iterate through all
540 541
 * @tset: taskset to iterate
 */
542
#define cgroup_taskset_for_each(task, skip_css, tset)			\
543 544
	for ((task) = cgroup_taskset_first((tset)); (task);		\
	     (task) = cgroup_taskset_next((tset)))			\
545 546
		if (!(skip_css) ||					\
		    cgroup_taskset_cur_css((tset),			\
547
			(skip_css)->ss->id) != (skip_css))
548

549 550 551 552
/*
 * Control Group subsystem type.
 * See Documentation/cgroups/cgroups.txt for details
 */
553 554

struct cgroup_subsys {
555 556 557 558 559 560 561 562 563 564 565
	struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
	int (*css_online)(struct cgroup_subsys_state *css);
	void (*css_offline)(struct cgroup_subsys_state *css);
	void (*css_free)(struct cgroup_subsys_state *css);

	int (*can_attach)(struct cgroup_subsys_state *css,
			  struct cgroup_taskset *tset);
	void (*cancel_attach)(struct cgroup_subsys_state *css,
			      struct cgroup_taskset *tset);
	void (*attach)(struct cgroup_subsys_state *css,
		       struct cgroup_taskset *tset);
566
	void (*fork)(struct task_struct *task);
567 568
	void (*exit)(struct cgroup_subsys_state *css,
		     struct cgroup_subsys_state *old_css,
569
		     struct task_struct *task);
570
	void (*bind)(struct cgroup_subsys_state *root_css);
571

572
	int disabled;
573
	int early_init;
574

575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
	/*
	 * If %false, this subsystem is properly hierarchical -
	 * configuration, resource accounting and restriction on a parent
	 * cgroup cover those of its children.  If %true, hierarchy support
	 * is broken in some ways - some subsystems ignore hierarchy
	 * completely while others are only implemented half-way.
	 *
	 * It's now disallowed to create nested cgroups if the subsystem is
	 * broken and cgroup core will emit a warning message on such
	 * cases.  Eventually, all subsystems will be made properly
	 * hierarchical and this will go away.
	 */
	bool broken_hierarchy;
	bool warned_broken_hierarchy;

590
	/* the following two fields are initialized automtically during boot */
591
	int id;
592 593 594
#define MAX_CGROUP_TYPE_NAMELEN 32
	const char *name;

T
Tejun Heo 已提交
595
	/* link to parent, protected by cgroup_lock() */
596
	struct cgroupfs_root *root;
597

T
Tejun Heo 已提交
598 599 600 601 602
	/*
	 * List of cftypes.  Each entry is the first entry of an array
	 * terminated by zero length name.
	 */
	struct list_head cfts;
603

604
	/* base cftypes, automatically registered with subsys itself */
605
	struct cftype *base_cftypes;
606 607
};

608
#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
609 610 611
#include <linux/cgroup_subsys.h>
#undef SUBSYS

T
Tejun Heo 已提交
612 613 614 615 616 617 618 619 620 621
/**
 * css_parent - find the parent css
 * @css: the target cgroup_subsys_state
 *
 * Return the parent css of @css.  This function is guaranteed to return
 * non-NULL parent as long as @css isn't the root.
 */
static inline
struct cgroup_subsys_state *css_parent(struct cgroup_subsys_state *css)
{
622
	return css->parent;
T
Tejun Heo 已提交
623 624
}

625 626 627 628 629 630 631 632 633 634 635 636
/**
 * task_css_set_check - obtain a task's css_set with extra access conditions
 * @task: the task to obtain css_set for
 * @__c: extra condition expression to be passed to rcu_dereference_check()
 *
 * A task's css_set is RCU protected, initialized and exited while holding
 * task_lock(), and can only be modified while holding both cgroup_mutex
 * and task_lock() while the task is alive.  This macro verifies that the
 * caller is inside proper critical section and returns @task's css_set.
 *
 * The caller can also specify additional allowed conditions via @__c, such
 * as locks used during the cgroup_subsys::attach() methods.
637
 */
T
Tejun Heo 已提交
638 639
#ifdef CONFIG_PROVE_RCU
extern struct mutex cgroup_mutex;
640 641 642 643
#define task_css_set_check(task, __c)					\
	rcu_dereference_check((task)->cgroups,				\
		lockdep_is_held(&(task)->alloc_lock) ||			\
		lockdep_is_held(&cgroup_mutex) || (__c))
T
Tejun Heo 已提交
644
#else
645 646
#define task_css_set_check(task, __c)					\
	rcu_dereference((task)->cgroups)
T
Tejun Heo 已提交
647
#endif
648

649
/**
650
 * task_css_check - obtain css for (task, subsys) w/ extra access conds
651 652 653 654 655 656 657
 * @task: the target task
 * @subsys_id: the target subsystem ID
 * @__c: extra condition expression to be passed to rcu_dereference_check()
 *
 * Return the cgroup_subsys_state for the (@task, @subsys_id) pair.  The
 * synchronization rules are the same as task_css_set_check().
 */
658
#define task_css_check(task, subsys_id, __c)				\
659 660 661 662 663 664 665 666 667 668 669 670 671 672
	task_css_set_check((task), (__c))->subsys[(subsys_id)]

/**
 * task_css_set - obtain a task's css_set
 * @task: the task to obtain css_set for
 *
 * See task_css_set_check().
 */
static inline struct css_set *task_css_set(struct task_struct *task)
{
	return task_css_set_check(task, false);
}

/**
673
 * task_css - obtain css for (task, subsys)
674 675 676
 * @task: the target task
 * @subsys_id: the target subsystem ID
 *
677
 * See task_css_check().
678
 */
679 680
static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
						   int subsys_id)
681
{
682
	return task_css_check(task, subsys_id, false);
683 684
}

685 686
static inline struct cgroup *task_cgroup(struct task_struct *task,
					 int subsys_id)
687
{
688
	return task_css(task, subsys_id)->cgroup;
689 690
}

691 692
struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
					   struct cgroup_subsys_state *parent);
693

694 695
struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);

696
/**
697 698 699
 * css_for_each_child - iterate through children of a css
 * @pos: the css * to use as the loop cursor
 * @parent: css whose children to walk
700
 *
701 702
 * Walk @parent's children.  Must be called under rcu_read_lock().  A child
 * css which hasn't finished ->css_online() or already has finished
703
 * ->css_offline() may show up during traversal and it's each subsystem's
704 705
 * responsibility to verify that each @pos is alive.
 *
706
 * If a subsystem synchronizes against the parent in its ->css_online() and
707
 * before starting iterating, a css which finished ->css_online() is
708
 * guaranteed to be visible in the future iterations.
709 710 711 712
 *
 * It is allowed to temporarily drop RCU read lock during iteration.  The
 * caller is responsible for ensuring that @pos remains accessible until
 * the start of the next iteration by, for example, bumping the css refcnt.
713
 */
714 715 716
#define css_for_each_child(pos, parent)					\
	for ((pos) = css_next_child(NULL, (parent)); (pos);		\
	     (pos) = css_next_child((pos), (parent)))
717

718 719 720 721 722 723
struct cgroup_subsys_state *
css_next_descendant_pre(struct cgroup_subsys_state *pos,
			struct cgroup_subsys_state *css);

struct cgroup_subsys_state *
css_rightmost_descendant(struct cgroup_subsys_state *pos);
724 725

/**
726 727 728
 * css_for_each_descendant_pre - pre-order walk of a css's descendants
 * @pos: the css * to use as the loop cursor
 * @root: css whose descendants to walk
729
 *
730 731
 * Walk @root's descendants.  @root is included in the iteration and the
 * first node to be visited.  Must be called under rcu_read_lock().  A
732
 * descendant css which hasn't finished ->css_online() or already has
733
 * finished ->css_offline() may show up during traversal and it's each
734 735
 * subsystem's responsibility to verify that each @pos is alive.
 *
736 737
 * If a subsystem synchronizes against the parent in its ->css_online() and
 * before starting iterating, and synchronizes against @pos on each
738
 * iteration, any descendant css which finished ->css_online() is
739 740 741 742 743
 * guaranteed to be visible in the future iterations.
 *
 * In other words, the following guarantees that a descendant can't escape
 * state updates of its ancestors.
 *
744
 * my_online(@css)
745
 * {
746 747
 *	Lock @css's parent and @css;
 *	Inherit state from the parent;
748 749 750
 *	Unlock both.
 * }
 *
751
 * my_update_state(@css)
752
 * {
753
 *	css_for_each_descendant_pre(@pos, @css) {
754
 *		Lock @pos;
755 756 757 758
 *		if (@pos == @css)
 *			Update @css's state;
 *		else
 *			Verify @pos is alive and inherit state from its parent;
759 760 761 762 763 764 765 766 767 768
 *		Unlock @pos;
 *	}
 * }
 *
 * As long as the inheriting step, including checking the parent state, is
 * enclosed inside @pos locking, double-locking the parent isn't necessary
 * while inheriting.  The state update to the parent is guaranteed to be
 * visible by walking order and, as long as inheriting operations to the
 * same @pos are atomic to each other, multiple updates racing each other
 * still result in the correct state.  It's guaranateed that at least one
769
 * inheritance happens for any css after the latest update to its parent.
770 771 772 773 774
 *
 * If checking parent's state requires locking the parent, each inheriting
 * iteration should lock and unlock both @pos->parent and @pos.
 *
 * Alternatively, a subsystem may choose to use a single global lock to
775
 * synchronize ->css_online() and ->css_offline() against tree-walking
776
 * operations.
777 778 779 780
 *
 * It is allowed to temporarily drop RCU read lock during iteration.  The
 * caller is responsible for ensuring that @pos remains accessible until
 * the start of the next iteration by, for example, bumping the css refcnt.
781
 */
782 783 784
#define css_for_each_descendant_pre(pos, css)				\
	for ((pos) = css_next_descendant_pre(NULL, (css)); (pos);	\
	     (pos) = css_next_descendant_pre((pos), (css)))
785

786 787 788
struct cgroup_subsys_state *
css_next_descendant_post(struct cgroup_subsys_state *pos,
			 struct cgroup_subsys_state *css);
789 790

/**
791 792 793
 * css_for_each_descendant_post - post-order walk of a css's descendants
 * @pos: the css * to use as the loop cursor
 * @css: css whose descendants to walk
794
 *
795
 * Similar to css_for_each_descendant_pre() but performs post-order
796 797 798
 * traversal instead.  @root is included in the iteration and the last
 * node to be visited.  Note that the walk visibility guarantee described
 * in pre-order walk doesn't apply the same to post-order walks.
799
 */
800 801 802
#define css_for_each_descendant_post(pos, css)				\
	for ((pos) = css_next_descendant_post(NULL, (css)); (pos);	\
	     (pos) = css_next_descendant_post((pos), (css)))
803

804 805 806
/* A css_task_iter should be treated as an opaque object */
struct css_task_iter {
	struct cgroup_subsys_state	*origin_css;
807 808
	struct list_head		*cset_link;
	struct list_head		*task;
809 810
};

811 812 813 814
void css_task_iter_start(struct cgroup_subsys_state *css,
			 struct css_task_iter *it);
struct task_struct *css_task_iter_next(struct css_task_iter *it);
void css_task_iter_end(struct css_task_iter *it);
T
Tejun Heo 已提交
815

816 817 818 819
int css_scan_tasks(struct cgroup_subsys_state *css,
		   bool (*test)(struct task_struct *, void *),
		   void (*process)(struct task_struct *, void *),
		   void *data, struct ptr_heap *heap);
T
Tejun Heo 已提交
820

M
Michael S. Tsirkin 已提交
821
int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
822
int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
M
Michael S. Tsirkin 已提交
823

824 825
struct cgroup_subsys_state *css_tryget_from_dir(struct dentry *dentry,
						struct cgroup_subsys *ss);
K
KAMEZAWA Hiroyuki 已提交
826

827 828 829 830
#else /* !CONFIG_CGROUPS */

static inline int cgroup_init_early(void) { return 0; }
static inline int cgroup_init(void) { return 0; }
831
static inline void cgroup_fork(struct task_struct *p) {}
832
static inline void cgroup_post_fork(struct task_struct *p) {}
833
static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
834

B
Balbir Singh 已提交
835 836 837 838 839
static inline int cgroupstats_build(struct cgroupstats *stats,
					struct dentry *dentry)
{
	return -EINVAL;
}
840

841
/* No cgroups - nothing to do */
M
Michael S. Tsirkin 已提交
842 843 844 845 846
static inline int cgroup_attach_task_all(struct task_struct *from,
					 struct task_struct *t)
{
	return 0;
}
847

848 849 850
#endif /* !CONFIG_CGROUPS */

#endif /* _LINUX_CGROUP_H */