cgroup.h 19.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>
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
extern int cgroup_load_subsys(struct cgroup_subsys *ss);
B
Ben Blum 已提交
41
extern void cgroup_unload_subsys(struct cgroup_subsys *ss);
42

43
extern const struct file_operations proc_cgroup_operations;
44

B
Ben Blum 已提交
45
/* Define the enumeration of all builtin cgroup subsystems */
46 47 48
#define SUBSYS(_x) _x ## _subsys_id,
enum cgroup_subsys_id {
#include <linux/cgroup_subsys.h>
B
Ben Blum 已提交
49
	CGROUP_BUILTIN_SUBSYS_COUNT
50 51
};
#undef SUBSYS
B
Ben Blum 已提交
52 53 54 55 56 57
/*
 * This define indicates the maximum number of subsystems that can be loaded
 * at once. We limit to this many since cgroupfs_root has subsys_bits to keep
 * track of all of them.
 */
#define CGROUP_SUBSYS_COUNT (BITS_PER_BYTE*sizeof(unsigned long))
58

59 60
/* Per-subsystem/per-cgroup state maintained by the system. */
struct cgroup_subsys_state {
P
Paul Menage 已提交
61 62
	/*
	 * The cgroup that this subsystem is attached to. Useful
63
	 * for subsystems that want to know about the cgroup
P
Paul Menage 已提交
64 65
	 * hierarchy structure
	 */
66 67
	struct cgroup *cgroup;

P
Paul Menage 已提交
68 69
	/*
	 * State maintained by the cgroup system to allow subsystems
P
Paul Menage 已提交
70
	 * to be "busy". Should be accessed via css_get(),
P
Paul Menage 已提交
71 72
	 * css_tryget() and and css_put().
	 */
73 74 75 76

	atomic_t refcnt;

	unsigned long flags;
K
KAMEZAWA Hiroyuki 已提交
77
	/* ID for this css, if possible */
A
Arnd Bergmann 已提交
78
	struct css_id __rcu *id;
79 80 81 82 83
};

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

87 88 89 90 91 92
/* Caller must verify that the css is not for root cgroup */
static inline void __css_get(struct cgroup_subsys_state *css, int count)
{
	atomic_add(count, &css->refcnt);
}

93
/*
P
Paul Menage 已提交
94 95 96 97
 * 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
98 99 100 101 102 103
 */

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))
104
		__css_get(css, 1);
105
}
P
Paul Menage 已提交
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124

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;
125
		cpu_relax();
P
Paul Menage 已提交
126 127 128 129
	}
	return true;
}

130 131
/*
 * css_put() should be called to release a reference taken by
P
Paul Menage 已提交
132
 * css_get() or css_tryget()
133 134
 */

135
extern void __css_put(struct cgroup_subsys_state *css, int count);
136 137 138
static inline void css_put(struct cgroup_subsys_state *css)
{
	if (!test_bit(CSS_ROOT, &css->flags))
139
		__css_put(css, 1);
140 141
}

142 143 144 145
/* bits in struct cgroup flags field */
enum {
	/* Control Group is dead */
	CGRP_REMOVED,
P
Paul Menage 已提交
146 147 148 149
	/*
	 * Control Group has previously had a child cgroup or a task,
	 * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
	 */
150 151 152
	CGRP_RELEASABLE,
	/* Control Group requires release notifications to userspace */
	CGRP_NOTIFY_ON_RELEASE,
153 154 155 156
	/*
	 * A thread in rmdir() is wating for this cgroup.
	 */
	CGRP_WAIT_ON_RMDIR,
157 158 159 160
	/*
	 * Clone cgroup values when creating a new child cgroup
	 */
	CGRP_CLONE_CHILDREN,
161 162
};

163 164 165 166 167 168 169 170 171 172 173 174
/* 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.
 */
175
struct cgroup_pidlist {
176 177 178 179 180
	/*
	 * 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;
181 182 183 184 185 186
	/* 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;
187 188 189 190 191 192
	/* 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;
193 194
};

195 196 197
struct cgroup {
	unsigned long flags;		/* "unsigned long" so bitops work */

P
Paul Menage 已提交
198 199 200 201
	/*
	 * count users of this cgroup. >0 means busy, but doesn't
	 * necessarily indicate the number of tasks in the cgroup
	 */
202 203 204 205 206 207 208 209 210
	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 已提交
211
	struct cgroup *parent;		/* my parent */
A
Arnd Bergmann 已提交
212
	struct dentry __rcu *dentry;	/* cgroup fs entry, RCU protected */
213 214 215 216 217 218

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

	struct cgroupfs_root *root;
	struct cgroup *top_cgroup;
219 220 221 222 223 224

	/*
	 * List of cg_cgroup_links pointing at css_sets with
	 * tasks in this cgroup. Protected by css_set_lock
	 */
	struct list_head css_sets;
225 226 227 228 229 230 231

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

233 234 235 236 237 238
	/*
	 * 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;
239 240 241

	/* For RCU-protected deletion */
	struct rcu_head rcu_head;
242

L
Lucas De Marchi 已提交
243
	/* List of events which userspace want to receive */
244 245
	struct list_head event_list;
	spinlock_t event_list_lock;
246 247
};

P
Paul Menage 已提交
248 249
/*
 * A css_set is a structure holding pointers to a set of
250 251
 * 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 已提交
252 253
 * list_add()/del() can bump the reference count on the entire cgroup
 * set for a task.
254 255 256 257 258
 */

struct css_set {

	/* Reference count */
259
	atomic_t refcount;
260

261 262 263 264 265 266
	/*
	 * List running through all cgroup groups in the same hash
	 * slot. Protected by css_set_lock
	 */
	struct hlist_node hlist;

267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
	/*
	 * 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
B
Ben Blum 已提交
283 284
	 * during subsystem registration (at boot time) and modular subsystem
	 * loading/unloading.
285 286
	 */
	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
287 288 289

	/* For RCU-protected deletion */
	struct rcu_head rcu_head;
290 291
};

292 293 294 295 296 297 298 299 300 301
/*
 * 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 已提交
302 303
/*
 * struct cftype: handler definitions for cgroup control files
304 305
 *
 * When reading/writing to a file:
L
Li Zefan 已提交
306
 *	- the cgroup to use is file->f_dentry->d_parent->d_fsdata
307 308 309 310 311
 *	- the 'cftype' of the file is file->f_dentry->d_fsdata
 */

#define MAX_CFTYPE_NAME 64
struct cftype {
P
Paul Menage 已提交
312 313 314 315
	/*
	 * By convention, the name should begin with the name of the
	 * subsystem, followed by a period
	 */
316 317
	char name[MAX_CFTYPE_NAME];
	int private;
L
Li Zefan 已提交
318 319 320 321 322
	/*
	 * If not 0, file mode is set to this value, otherwise it will
	 * be figured out automatically
	 */
	mode_t mode;
323 324 325 326 327 328 329

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

330 331 332 333
	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);
334
	/*
335
	 * read_u64() is a shortcut for the common case of returning a
336 337
	 * single integer. Use it in place of read()
	 */
338
	u64 (*read_u64)(struct cgroup *cgrp, struct cftype *cft);
339 340 341
	/*
	 * read_s64() is a signed version of read_u64()
	 */
342
	s64 (*read_s64)(struct cgroup *cgrp, struct cftype *cft);
343 344 345 346 347 348
	/*
	 * 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.
	 */
349 350
	int (*read_map)(struct cgroup *cont, struct cftype *cft,
			struct cgroup_map_cb *cb);
351 352 353 354
	/*
	 * read_seq_string() is used for outputting a simple sequence
	 * using seqfile.
	 */
355 356
	int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
			       struct seq_file *m);
357

358 359 360
	ssize_t (*write)(struct cgroup *cgrp, struct cftype *cft,
			 struct file *file,
			 const char __user *buf, size_t nbytes, loff_t *ppos);
361 362

	/*
363
	 * write_u64() is a shortcut for the common case of accepting
364 365 366
	 * a single integer (as parsed by simple_strtoull) from
	 * userspace. Use in place of write(); return 0 or error.
	 */
367
	int (*write_u64)(struct cgroup *cgrp, struct cftype *cft, u64 val);
368 369 370
	/*
	 * write_s64() is a signed version of write_u64()
	 */
371
	int (*write_s64)(struct cgroup *cgrp, struct cftype *cft, s64 val);
372

373 374 375 376 377 378 379
	/*
	 * 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);
380 381 382 383 384 385 386 387
	/*
	 * 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);

388
	int (*release)(struct inode *inode, struct file *file);
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403

	/*
	 * register_event() callback will be used to add new userspace
	 * waiter for changes related to the cftype. Implement it if
	 * you want to provide this functionality. Use eventfd_signal()
	 * on eventfd to send notification to userspace.
	 */
	int (*register_event)(struct cgroup *cgrp, struct cftype *cft,
			struct eventfd_ctx *eventfd, const char *args);
	/*
	 * unregister_event() callback will be called when userspace
	 * closes the eventfd or on cgroup removing.
	 * This callback must be implemented, if you want provide
	 * notification functionality.
	 */
404
	void (*unregister_event)(struct cgroup *cgrp, struct cftype *cft,
405
			struct eventfd_ctx *eventfd);
406 407
};

408 409 410 411 412 413
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;
414
	void *data;
415 416
};

P
Paul Menage 已提交
417 418 419 420
/*
 * Add a new file to the given cgroup directory. Should only be
 * called by subsystems from within a populate() method
 */
L
Li Zefan 已提交
421
int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
422 423
		       const struct cftype *cft);

P
Paul Menage 已提交
424 425 426 427
/*
 * 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 已提交
428
int cgroup_add_files(struct cgroup *cgrp,
429 430 431 432
			struct cgroup_subsys *subsys,
			const struct cftype cft[],
			int count);

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

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

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

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

442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
/*
 * 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);

459 460 461 462
/*
 * Control Group subsystem type.
 * See Documentation/cgroups/cgroups.txt for details
 */
463 464 465

struct cgroup_subsys {
	struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
L
Li Zefan 已提交
466
						  struct cgroup *cgrp);
467
	int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
L
Li Zefan 已提交
468
	void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
469
	int (*can_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
470 471
			  struct task_struct *tsk);
	int (*can_attach_task)(struct cgroup *cgrp, struct task_struct *tsk);
472
	void (*cancel_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
473 474 475
			      struct task_struct *tsk);
	void (*pre_attach)(struct cgroup *cgrp);
	void (*attach_task)(struct cgroup *cgrp, struct task_struct *tsk);
L
Li Zefan 已提交
476
	void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
477
		       struct cgroup *old_cgrp, struct task_struct *tsk);
478
	void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);
479 480
	void (*exit)(struct cgroup_subsys *ss, struct cgroup *cgrp,
			struct cgroup *old_cgrp, struct task_struct *task);
481
	int (*populate)(struct cgroup_subsys *ss,
L
Li Zefan 已提交
482 483
			struct cgroup *cgrp);
	void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
484
	void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
485

486 487
	int subsys_id;
	int active;
488
	int disabled;
489
	int early_init;
K
KAMEZAWA Hiroyuki 已提交
490 491 492 493 494
	/*
	 * True if this subsys uses ID. ID is not available before cgroup_init()
	 * (not available in early_init time.)
	 */
	bool use_id;
495 496 497
#define MAX_CGROUP_TYPE_NAMELEN 32
	const char *name;

498 499 500 501 502 503 504 505 506 507 508
	/*
	 * 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;
509
	struct lock_class_key subsys_key;
510

511 512 513 514 515
	/*
	 * Link to parent, and list entry in parent's children.
	 * Protected by this->hierarchy_mutex and cgroup_lock()
	 */
	struct cgroupfs_root *root;
516
	struct list_head sibling;
K
KAMEZAWA Hiroyuki 已提交
517 518 519
	/* used when use_id == true */
	struct idr idr;
	spinlock_t id_lock;
520 521 522

	/* should be defined only by modular subsystems */
	struct module *module;
523 524 525 526 527 528 529
};

#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 已提交
530
	struct cgroup *cgrp, int subsys_id)
531
{
L
Li Zefan 已提交
532
	return cgrp->subsys[subsys_id];
533 534
}

535 536 537 538 539 540 541 542 543 544 545 546
/*
 * function to get the cgroup_subsys_state which allows for extra
 * rcu_dereference_check() conditions, such as locks used during the
 * cgroup_subsys::attach() methods.
 */
#define task_subsys_state_check(task, subsys_id, __c)			\
	rcu_dereference_check(task->cgroups->subsys[subsys_id],		\
			      lockdep_is_held(&task->alloc_lock) ||	\
			      cgroup_lock_is_held() || (__c))

static inline struct cgroup_subsys_state *
task_subsys_state(struct task_struct *task, int subsys_id)
547
{
548
	return task_subsys_state_check(task, subsys_id, false);
549 550 551 552 553 554 555 556
}

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

557 558 559 560 561 562
/* 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 已提交
563 564
/*
 * To iterate across the tasks in a cgroup:
565
 *
566
 * 1) call cgroup_iter_start to initialize an iterator
567 568 569 570 571
 *
 * 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.
572
 *
P
Paul Menage 已提交
573 574 575 576
 * 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.
577
 */
L
Li Zefan 已提交
578 579
void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
580
					struct cgroup_iter *it);
L
Li Zefan 已提交
581
void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
582
int cgroup_scan_tasks(struct cgroup_scanner *scan);
583
int cgroup_attach_task(struct cgroup *, struct task_struct *);
M
Michael S. Tsirkin 已提交
584 585 586 587 588 589
int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);

static inline int cgroup_attach_task_current_cg(struct task_struct *tsk)
{
	return cgroup_attach_task_all(current, tsk);
}
590

K
KAMEZAWA Hiroyuki 已提交
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
/*
 * 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,
623
		     const struct cgroup_subsys_state *root);
K
KAMEZAWA Hiroyuki 已提交
624 625 626 627

/* Get id and depth of css */
unsigned short css_id(struct cgroup_subsys_state *css);
unsigned short css_depth(struct cgroup_subsys_state *css);
S
Stephane Eranian 已提交
628
struct cgroup_subsys_state *cgroup_css_from_dir(struct file *f, int id);
K
KAMEZAWA Hiroyuki 已提交
629

630 631 632 633
#else /* !CONFIG_CGROUPS */

static inline int cgroup_init_early(void) { return 0; }
static inline int cgroup_init(void) { return 0; }
634 635
static inline void cgroup_fork(struct task_struct *p) {}
static inline void cgroup_fork_callbacks(struct task_struct *p) {}
636
static inline void cgroup_post_fork(struct task_struct *p) {}
637
static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
638 639 640

static inline void cgroup_lock(void) {}
static inline void cgroup_unlock(void) {}
B
Balbir Singh 已提交
641 642 643 644 645
static inline int cgroupstats_build(struct cgroupstats *stats,
					struct dentry *dentry)
{
	return -EINVAL;
}
646

647
/* No cgroups - nothing to do */
M
Michael S. Tsirkin 已提交
648 649 650 651 652
static inline int cgroup_attach_task_all(struct task_struct *from,
					 struct task_struct *t)
{
	return 0;
}
653 654 655 656 657
static inline int cgroup_attach_task_current_cg(struct task_struct *t)
{
	return 0;
}

658 659 660
#endif /* !CONFIG_CGROUPS */

#endif /* _LINUX_CGROUP_H */