cgroup: clean up MAINTAINERS entries
[deliverable/linux.git] / include / linux / cgroup.h
CommitLineData
ddbcc7e8
PM
1#ifndef _LINUX_CGROUP_H
2#define _LINUX_CGROUP_H
3/*
4 * cgroup interface
5 *
6 * Copyright (C) 2003 BULL SA
7 * Copyright (C) 2004-2006 Silicon Graphics, Inc.
8 *
9 */
10
11#include <linux/sched.h>
ddbcc7e8
PM
12#include <linux/cpumask.h>
13#include <linux/nodemask.h>
14#include <linux/rcupdate.h>
eb6fd504 15#include <linux/rculist.h>
846c7bb0 16#include <linux/cgroupstats.h>
cc31edce 17#include <linux/rwsem.h>
38460b48 18#include <linux/idr.h>
48ddbe19 19#include <linux/workqueue.h>
25a7e684 20#include <linux/fs.h>
d3daf28d 21#include <linux/percpu-refcount.h>
7da11279 22#include <linux/seq_file.h>
2bd59d48 23#include <linux/kernfs.h>
f8f22e53 24#include <linux/wait.h>
ddbcc7e8
PM
25
26#ifdef CONFIG_CGROUPS
27
3dd06ffa 28struct cgroup_root;
ddbcc7e8
PM
29struct cgroup_subsys;
30struct inode;
84eea842 31struct cgroup;
ddbcc7e8
PM
32
33extern int cgroup_init_early(void);
34extern int cgroup_init(void);
b4f48b63 35extern void cgroup_fork(struct task_struct *p);
817929ec 36extern void cgroup_post_fork(struct task_struct *p);
1ec41830 37extern void cgroup_exit(struct task_struct *p);
846c7bb0
BS
38extern int cgroupstats_build(struct cgroupstats *stats,
39 struct dentry *dentry);
ddbcc7e8 40
8d8b97ba 41extern int proc_cgroup_show(struct seq_file *, void *);
a424316c 42
3ed80a62 43/* define the enumeration of all cgroup subsystems */
073219e9 44#define SUBSYS(_x) _x ## _cgrp_id,
817929ec
PM
45enum cgroup_subsys_id {
46#include <linux/cgroup_subsys.h>
a6f00298 47 CGROUP_SUBSYS_COUNT,
817929ec
PM
48};
49#undef SUBSYS
50
5c9d535b
TH
51/*
52 * Per-subsystem/per-cgroup state maintained by the system. This is the
53 * fundamental structural building block that controllers deal with.
54 *
55 * Fields marked with "PI:" are public and immutable and may be accessed
56 * directly without synchronization.
57 */
ddbcc7e8 58struct cgroup_subsys_state {
5c9d535b 59 /* PI: the cgroup that this css is attached to */
ddbcc7e8
PM
60 struct cgroup *cgroup;
61
5c9d535b 62 /* PI: the cgroup subsystem that this css is attached to */
72c97e54
TH
63 struct cgroup_subsys *ss;
64
d3daf28d
TH
65 /* reference count - access via css_[try]get() and css_put() */
66 struct percpu_ref refcnt;
ddbcc7e8 67
5c9d535b 68 /* PI: the parent css */
0ae78e0b
TH
69 struct cgroup_subsys_state *parent;
70
d5c419b6
TH
71 /* siblings list anchored at the parent's ->children */
72 struct list_head sibling;
73 struct list_head children;
74
15a4c835 75 /*
5c9d535b 76 * PI: Subsys-unique ID. 0 is unused and root is always 1. The
15a4c835
TH
77 * matching css can be looked up using css_from_id().
78 */
79 int id;
80
69dfa00c 81 unsigned int flags;
48ddbe19 82
0cb51d71
TH
83 /*
84 * Monotonically increasing unique serial number which defines a
85 * uniform order among all csses. It's guaranteed that all
86 * ->children lists are in the ascending order of ->serial_nr and
87 * used to allow interrupting and resuming iterations.
88 */
89 u64 serial_nr;
90
0c21ead1
TH
91 /* percpu_ref killing and RCU release */
92 struct rcu_head rcu_head;
35ef10da 93 struct work_struct destroy_work;
ddbcc7e8
PM
94};
95
96/* bits in struct cgroup_subsys_state flags field */
97enum {
3b514d24 98 CSS_NO_REF = (1 << 0), /* no reference counting for this css */
92fb9748 99 CSS_ONLINE = (1 << 1), /* between ->css_online() and ->css_offline() */
de3f0341 100 CSS_RELEASED = (1 << 2), /* refcnt reached zero, released */
ddbcc7e8
PM
101};
102
5de0107e
TH
103/**
104 * css_get - obtain a reference on the specified css
105 * @css: target css
106 *
107 * The caller must already have a reference.
ddbcc7e8 108 */
ddbcc7e8
PM
109static inline void css_get(struct cgroup_subsys_state *css)
110{
3b514d24
TH
111 if (!(css->flags & CSS_NO_REF))
112 percpu_ref_get(&css->refcnt);
ddbcc7e8 113}
e7c5ec91 114
6f4524d3
TH
115/**
116 * css_tryget - try to obtain a reference on the specified css
117 * @css: target css
118 *
119 * Obtain a reference on @css unless it already has reached zero and is
120 * being released. This function doesn't care whether @css is on or
121 * offline. The caller naturally needs to ensure that @css is accessible
122 * but doesn't have to be holding a reference on it - IOW, RCU protected
123 * access is good enough for this function. Returns %true if a reference
124 * count was successfully obtained; %false otherwise.
125 */
126static inline bool css_tryget(struct cgroup_subsys_state *css)
127{
128 if (!(css->flags & CSS_NO_REF))
129 return percpu_ref_tryget(&css->refcnt);
130 return true;
131}
132
5de0107e 133/**
ec903c0c 134 * css_tryget_online - try to obtain a reference on the specified css if online
5de0107e
TH
135 * @css: target css
136 *
ec903c0c
TH
137 * Obtain a reference on @css if it's online. The caller naturally needs
138 * to ensure that @css is accessible but doesn't have to be holding a
5de0107e
TH
139 * reference on it - IOW, RCU protected access is good enough for this
140 * function. Returns %true if a reference count was successfully obtained;
141 * %false otherwise.
142 */
ec903c0c 143static inline bool css_tryget_online(struct cgroup_subsys_state *css)
e7c5ec91 144{
3b514d24
TH
145 if (!(css->flags & CSS_NO_REF))
146 return percpu_ref_tryget_live(&css->refcnt);
147 return true;
e7c5ec91
PM
148}
149
5de0107e
TH
150/**
151 * css_put - put a css reference
152 * @css: target css
153 *
ec903c0c 154 * Put a reference obtained via css_get() and css_tryget_online().
5de0107e 155 */
ddbcc7e8
PM
156static inline void css_put(struct cgroup_subsys_state *css)
157{
3b514d24
TH
158 if (!(css->flags & CSS_NO_REF))
159 percpu_ref_put(&css->refcnt);
ddbcc7e8
PM
160}
161
3116f0e3
PM
162/* bits in struct cgroup flags field */
163enum {
d20a390a
PM
164 /*
165 * Control Group has previously had a child cgroup or a task,
166 * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
167 */
3116f0e3
PM
168 CGRP_RELEASABLE,
169 /* Control Group requires release notifications to userspace */
170 CGRP_NOTIFY_ON_RELEASE,
97978e6d 171 /*
2260e7fc
TH
172 * Clone the parent's configuration when creating a new child
173 * cpuset cgroup. For historical reasons, this option can be
174 * specified at mount time and thus is implemented here.
97978e6d 175 */
2260e7fc 176 CGRP_CPUSET_CLONE_CHILDREN,
3116f0e3
PM
177};
178
ddbcc7e8 179struct cgroup {
9d800df1
TH
180 /* self css with NULL ->ss, points back to this cgroup */
181 struct cgroup_subsys_state self;
182
ddbcc7e8
PM
183 unsigned long flags; /* "unsigned long" so bitops work */
184
b414dc09
LZ
185 /*
186 * idr allocated in-hierarchy ID.
187 *
7d699ddb
TH
188 * ID 0 is not used, the ID of the root cgroup is always 1, and a
189 * new cgroup will be assigned with a smallest available ID.
0ab02ca8
LZ
190 *
191 * Allocating/Removing ID must be protected by cgroup_mutex.
b414dc09
LZ
192 */
193 int id;
0a950f65 194
842b597e
TH
195 /*
196 * If this cgroup contains any tasks, it contributes one to
197 * populated_cnt. All children with non-zero popuplated_cnt of
198 * their own contribute one. The count is zero iff there's no task
199 * in this cgroup or its subtree.
200 */
201 int populated_cnt;
202
2bd59d48 203 struct kernfs_node *kn; /* cgroup kernfs entry */
842b597e 204 struct kernfs_node *populated_kn; /* kn for "cgroup.subtree_populated" */
ddbcc7e8 205
f392e51c 206 /* the bitmask of subsystems enabled on the child cgroups */
69dfa00c 207 unsigned int child_subsys_mask;
94419627 208
ddbcc7e8 209 /* Private pointers for each registered subsystem */
73e80ed8 210 struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
ddbcc7e8 211
3dd06ffa 212 struct cgroup_root *root;
817929ec
PM
213
214 /*
69d0206c
TH
215 * List of cgrp_cset_links pointing at css_sets with tasks in this
216 * cgroup. Protected by css_set_lock.
817929ec 217 */
69d0206c 218 struct list_head cset_links;
81a6a5cd 219
2d8f243a
TH
220 /*
221 * On the default hierarchy, a css_set for a cgroup with some
222 * susbsys disabled will point to css's which are associated with
223 * the closest ancestor which has the subsys enabled. The
224 * following lists all css_sets which point to this cgroup's css
225 * for the given subsystem.
226 */
227 struct list_head e_csets[CGROUP_SUBSYS_COUNT];
228
81a6a5cd
PM
229 /*
230 * Linked list running through all cgroups that can
231 * potentially be reaped by the release agent. Protected by
232 * release_list_lock
233 */
234 struct list_head release_list;
cc31edce 235
72a8cb30
BB
236 /*
237 * list of pidlists, up to two for each namespace (one for procs, one
238 * for tasks); created on demand.
239 */
240 struct list_head pidlists;
241 struct mutex pidlist_mutex;
a47295e6 242
f8f22e53
TH
243 /* used to wait for offlining of csses */
244 wait_queue_head_t offline_waitq;
817929ec
PM
245};
246
25a7e684
TH
247#define MAX_CGROUP_ROOT_NAMELEN 64
248
3dd06ffa 249/* cgroup_root->flags */
25a7e684 250enum {
873fe09e
TH
251 /*
252 * Unfortunately, cgroup core and various controllers are riddled
253 * with idiosyncrasies and pointless options. The following flag,
254 * when set, will force sane behavior - some options are forced on,
255 * others are disallowed, and some controllers will change their
256 * hierarchical or other behaviors.
257 *
258 * The set of behaviors affected by this flag are still being
259 * determined and developed and the mount option for this flag is
260 * prefixed with __DEVEL__. The prefix will be dropped once we
261 * reach the point where all behaviors are compatible with the
262 * planned unified hierarchy, which will automatically turn on this
263 * flag.
264 *
265 * The followings are the behaviors currently affected this flag.
266 *
d3ba07c3
TH
267 * - Mount options "noprefix", "xattr", "clone_children",
268 * "release_agent" and "name" are disallowed.
873fe09e
TH
269 *
270 * - When mounting an existing superblock, mount options should
271 * match.
272 *
273 * - Remount is disallowed.
274 *
0b0585c3
LT
275 * - rename(2) is disallowed.
276 *
f63674fd
TH
277 * - "tasks" is removed. Everything should be at process
278 * granularity. Use "cgroup.procs" instead.
f00baae7 279 *
afb2bc14
TH
280 * - "cgroup.procs" is not sorted. pids will be unique unless they
281 * got recycled inbetween reads.
282 *
f63674fd
TH
283 * - "release_agent" and "notify_on_release" are removed.
284 * Replacement notification mechanism will be implemented.
873fe09e 285 *
d3ba07c3 286 * - "cgroup.clone_children" is removed.
86bf4b68 287 *
842b597e
TH
288 * - "cgroup.subtree_populated" is available. Its value is 0 if
289 * the cgroup and its descendants contain no task; otherwise, 1.
290 * The file also generates kernfs notification which can be
291 * monitored through poll and [di]notify when the value of the
292 * file changes.
293 *
a2dd4247
TH
294 * - If mount is requested with sane_behavior but without any
295 * subsystem, the default unified hierarchy is mounted.
296 *
5c5cc623
LZ
297 * - cpuset: tasks will be kept in empty cpusets when hotplug happens
298 * and take masks of ancestors with non-empty cpus/mems, instead of
299 * being moved to an ancestor.
300 *
88fa523b
LZ
301 * - cpuset: a task can be moved into an empty cpuset, and again it
302 * takes masks of ancestors.
6db8e85c 303 *
f63674fd
TH
304 * - memcg: use_hierarchy is on by default and the cgroup file for
305 * the flag is not created.
f00baae7 306 *
9138125b 307 * - blkcg: blk-throttle becomes properly hierarchical.
873fe09e
TH
308 */
309 CGRP_ROOT_SANE_BEHAVIOR = (1 << 0),
310
25a7e684
TH
311 CGRP_ROOT_NOPREFIX = (1 << 1), /* mounted subsystems have no named prefix */
312 CGRP_ROOT_XATTR = (1 << 2), /* supports extended attributes */
0ce6cba3
TH
313
314 /* mount options live below bit 16 */
315 CGRP_ROOT_OPTION_MASK = (1 << 16) - 1,
25a7e684
TH
316};
317
318/*
3dd06ffa 319 * A cgroup_root represents the root of a cgroup hierarchy, and may be
2bd59d48 320 * associated with a kernfs_root to form an active hierarchy. This is
25a7e684
TH
321 * internal to cgroup core. Don't access directly from controllers.
322 */
3dd06ffa 323struct cgroup_root {
2bd59d48 324 struct kernfs_root *kf_root;
25a7e684 325
f392e51c 326 /* The bitmask of subsystems attached to this hierarchy */
69dfa00c 327 unsigned int subsys_mask;
f392e51c 328
25a7e684
TH
329 /* Unique id for this hierarchy. */
330 int hierarchy_id;
331
776f02fa 332 /* The root cgroup. Root is destroyed on its release. */
3dd06ffa 333 struct cgroup cgrp;
25a7e684 334
3c9c825b
TH
335 /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
336 atomic_t nr_cgrps;
25a7e684
TH
337
338 /* A list running through the active hierarchies */
339 struct list_head root_list;
340
25a7e684 341 /* Hierarchy-specific flags */
69dfa00c 342 unsigned int flags;
25a7e684
TH
343
344 /* IDs for cgroups in this hierarchy */
4e96ee8e 345 struct idr cgroup_idr;
25a7e684
TH
346
347 /* The path to use for release notifications. */
348 char release_agent_path[PATH_MAX];
349
350 /* The name for this hierarchy - may be empty */
351 char name[MAX_CGROUP_ROOT_NAMELEN];
352};
353
d20a390a
PM
354/*
355 * A css_set is a structure holding pointers to a set of
817929ec
PM
356 * cgroup_subsys_state objects. This saves space in the task struct
357 * object and speeds up fork()/exit(), since a single inc/dec and a
d20a390a
PM
358 * list_add()/del() can bump the reference count on the entire cgroup
359 * set for a task.
817929ec
PM
360 */
361
362struct css_set {
363
364 /* Reference count */
146aa1bd 365 atomic_t refcount;
817929ec 366
472b1053
LZ
367 /*
368 * List running through all cgroup groups in the same hash
369 * slot. Protected by css_set_lock
370 */
371 struct hlist_node hlist;
372
817929ec 373 /*
c7561128
TH
374 * Lists running through all tasks using this cgroup group.
375 * mg_tasks lists tasks which belong to this cset but are in the
376 * process of being migrated out or in. Protected by
377 * css_set_rwsem, but, during migration, once tasks are moved to
378 * mg_tasks, it can be read safely while holding cgroup_mutex.
817929ec
PM
379 */
380 struct list_head tasks;
c7561128 381 struct list_head mg_tasks;
817929ec
PM
382
383 /*
69d0206c
TH
384 * List of cgrp_cset_links pointing at cgroups referenced from this
385 * css_set. Protected by css_set_lock.
817929ec 386 */
69d0206c 387 struct list_head cgrp_links;
817929ec 388
6803c006
TH
389 /* the default cgroup associated with this css_set */
390 struct cgroup *dfl_cgrp;
391
817929ec 392 /*
3ed80a62
TH
393 * Set of subsystem states, one for each subsystem. This array is
394 * immutable after creation apart from the init_css_set during
395 * subsystem registration (at boot time).
817929ec
PM
396 */
397 struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
c378369d 398
b3dc094e
TH
399 /*
400 * List of csets participating in the on-going migration either as
401 * source or destination. Protected by cgroup_mutex.
402 */
1958d2d5 403 struct list_head mg_preload_node;
b3dc094e
TH
404 struct list_head mg_node;
405
406 /*
407 * If this cset is acting as the source of migration the following
408 * two fields are set. mg_src_cgrp is the source cgroup of the
409 * on-going migration and mg_dst_cset is the destination cset the
410 * target tasks on this cset should be migrated to. Protected by
411 * cgroup_mutex.
412 */
413 struct cgroup *mg_src_cgrp;
414 struct css_set *mg_dst_cset;
415
2d8f243a
TH
416 /*
417 * On the default hierarhcy, ->subsys[ssid] may point to a css
418 * attached to an ancestor instead of the cgroup this css_set is
419 * associated with. The following node is anchored at
420 * ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to
421 * iterate through all css's attached to a given cgroup.
422 */
423 struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
424
c378369d
BB
425 /* For RCU-protected deletion */
426 struct rcu_head rcu_head;
ddbcc7e8
PM
427};
428
d20a390a
PM
429/*
430 * struct cftype: handler definitions for cgroup control files
ddbcc7e8
PM
431 *
432 * When reading/writing to a file:
a043e3b2 433 * - the cgroup to use is file->f_dentry->d_parent->d_fsdata
ddbcc7e8
PM
434 * - the 'cftype' of the file is file->f_dentry->d_fsdata
435 */
436
8e3f6541 437/* cftype->flags */
02c402d9 438enum {
6f4b7e63
LZ
439 CFTYPE_ONLY_ON_ROOT = (1 << 0), /* only create on root cgrp */
440 CFTYPE_NOT_ON_ROOT = (1 << 1), /* don't create on root cgrp */
02c402d9 441 CFTYPE_INSANE = (1 << 2), /* don't create if sane_behavior */
9fa4db33 442 CFTYPE_NO_PREFIX = (1 << 3), /* (DON'T USE FOR NEW FILES) no subsys prefix */
8cbbf2c9 443 CFTYPE_ONLY_ON_DFL = (1 << 4), /* only on default hierarchy */
02c402d9 444};
8e3f6541
TH
445
446#define MAX_CFTYPE_NAME 64
447
ddbcc7e8 448struct cftype {
d20a390a
PM
449 /*
450 * By convention, the name should begin with the name of the
8e3f6541
TH
451 * subsystem, followed by a period. Zero length string indicates
452 * end of cftype array.
d20a390a 453 */
ddbcc7e8
PM
454 char name[MAX_CFTYPE_NAME];
455 int private;
099fca32
LZ
456 /*
457 * If not 0, file mode is set to this value, otherwise it will
458 * be figured out automatically
459 */
a5e7ed32 460 umode_t mode;
db3b1497
PM
461
462 /*
5f469907 463 * The maximum length of string, excluding trailing nul, that can
451af504 464 * be passed to write. If < PAGE_SIZE-1, PAGE_SIZE-1 is assumed.
db3b1497
PM
465 */
466 size_t max_write_len;
467
8e3f6541
TH
468 /* CFTYPE_* flags */
469 unsigned int flags;
470
2bb566cb 471 /*
0adb0704
TH
472 * Fields used for internal bookkeeping. Initialized automatically
473 * during registration.
2bb566cb 474 */
0adb0704
TH
475 struct cgroup_subsys *ss; /* NULL for cgroup core files */
476 struct list_head node; /* anchored at ss->cfts */
2bd59d48
TH
477 struct kernfs_ops *kf_ops;
478
ddbcc7e8 479 /*
f4c753b7 480 * read_u64() is a shortcut for the common case of returning a
ddbcc7e8
PM
481 * single integer. Use it in place of read()
482 */
182446d0 483 u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
e73d2c61
PM
484 /*
485 * read_s64() is a signed version of read_u64()
486 */
182446d0 487 s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
2da8ca82
TH
488
489 /* generic seq_file read interface */
490 int (*seq_show)(struct seq_file *sf, void *v);
91796569 491
6612f05b
TH
492 /* optional ops, implement all or none */
493 void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
494 void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
495 void (*seq_stop)(struct seq_file *sf, void *v);
496
355e0c48 497 /*
f4c753b7 498 * write_u64() is a shortcut for the common case of accepting
355e0c48
PM
499 * a single integer (as parsed by simple_strtoull) from
500 * userspace. Use in place of write(); return 0 or error.
501 */
182446d0
TH
502 int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
503 u64 val);
e73d2c61
PM
504 /*
505 * write_s64() is a signed version of write_u64()
506 */
182446d0
TH
507 int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
508 s64 val);
355e0c48 509
b4168640
TH
510 /*
511 * write() is the generic write callback which maps directly to
512 * kernfs write operation and overrides all other operations.
513 * Maximum write size is determined by ->max_write_len. Use
514 * of_css/cft() to access the associated css and cft.
515 */
516 ssize_t (*write)(struct kernfs_open_file *of,
517 char *buf, size_t nbytes, loff_t off);
518
2bd59d48
TH
519#ifdef CONFIG_DEBUG_LOCK_ALLOC
520 struct lock_class_key lockdep_key;
521#endif
ddbcc7e8
PM
522};
523
a2dd4247 524extern struct cgroup_root cgrp_dfl_root;
5024ae29 525extern struct css_set init_css_set;
a2dd4247
TH
526
527static inline bool cgroup_on_dfl(const struct cgroup *cgrp)
528{
529 return cgrp->root == &cgrp_dfl_root;
530}
531
873fe09e
TH
532/*
533 * See the comment above CGRP_ROOT_SANE_BEHAVIOR for details. This
534 * function can be called as long as @cgrp is accessible.
535 */
536static inline bool cgroup_sane_behavior(const struct cgroup *cgrp)
537{
538 return cgrp->root->flags & CGRP_ROOT_SANE_BEHAVIOR;
539}
540
07bc356e
TH
541/* no synchronization, the result can only be used as a hint */
542static inline bool cgroup_has_tasks(struct cgroup *cgrp)
543{
544 return !list_empty(&cgrp->cset_links);
545}
546
b1664924
TH
547/* returns ino associated with a cgroup, 0 indicates unmounted root */
548static inline ino_t cgroup_ino(struct cgroup *cgrp)
549{
2bd59d48
TH
550 if (cgrp->kn)
551 return cgrp->kn->ino;
b1664924
TH
552 else
553 return 0;
554}
555
b4168640
TH
556/* cft/css accessors for cftype->write() operation */
557static inline struct cftype *of_cft(struct kernfs_open_file *of)
7da11279 558{
2bd59d48 559 return of->kn->priv;
7da11279
TH
560}
561
b4168640
TH
562struct cgroup_subsys_state *of_css(struct kernfs_open_file *of);
563
564/* cft/css accessors for cftype->seq_*() operations */
565static inline struct cftype *seq_cft(struct seq_file *seq)
566{
567 return of_cft(seq->private);
568}
569
570static inline struct cgroup_subsys_state *seq_css(struct seq_file *seq)
571{
572 return of_css(seq->private);
573}
59f5296b 574
e61734c5
TH
575/*
576 * Name / path handling functions. All are thin wrappers around the kernfs
577 * counterparts and can be called under any context.
578 */
579
580static inline int cgroup_name(struct cgroup *cgrp, char *buf, size_t buflen)
581{
fdce6bf8 582 return kernfs_name(cgrp->kn, buf, buflen);
e61734c5
TH
583}
584
585static inline char * __must_check cgroup_path(struct cgroup *cgrp, char *buf,
586 size_t buflen)
587{
fdce6bf8 588 return kernfs_path(cgrp->kn, buf, buflen);
e61734c5
TH
589}
590
591static inline void pr_cont_cgroup_name(struct cgroup *cgrp)
592{
fdce6bf8 593 pr_cont_kernfs_name(cgrp->kn);
e61734c5
TH
594}
595
596static inline void pr_cont_cgroup_path(struct cgroup *cgrp)
597{
fdce6bf8 598 pr_cont_kernfs_path(cgrp->kn);
e61734c5
TH
599}
600
601char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
602
03b1cde6 603int cgroup_add_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
2bb566cb 604int cgroup_rm_cftypes(struct cftype *cfts);
8e3f6541 605
78574cf9 606bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
ddbcc7e8 607
2f7ee569
TH
608/*
609 * Control Group taskset, used to pass around set of tasks to cgroup_subsys
610 * methods.
611 */
612struct cgroup_taskset;
613struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
614struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
2f7ee569
TH
615
616/**
617 * cgroup_taskset_for_each - iterate cgroup_taskset
618 * @task: the loop cursor
2f7ee569
TH
619 * @tset: taskset to iterate
620 */
924f0d9a 621#define cgroup_taskset_for_each(task, tset) \
2f7ee569 622 for ((task) = cgroup_taskset_first((tset)); (task); \
924f0d9a 623 (task) = cgroup_taskset_next((tset)))
2f7ee569 624
21acb9ca
TLSC
625/*
626 * Control Group subsystem type.
627 * See Documentation/cgroups/cgroups.txt for details
628 */
ddbcc7e8
PM
629
630struct cgroup_subsys {
eb95419b
TH
631 struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
632 int (*css_online)(struct cgroup_subsys_state *css);
633 void (*css_offline)(struct cgroup_subsys_state *css);
634 void (*css_free)(struct cgroup_subsys_state *css);
635
636 int (*can_attach)(struct cgroup_subsys_state *css,
637 struct cgroup_taskset *tset);
638 void (*cancel_attach)(struct cgroup_subsys_state *css,
639 struct cgroup_taskset *tset);
640 void (*attach)(struct cgroup_subsys_state *css,
641 struct cgroup_taskset *tset);
761b3ef5 642 void (*fork)(struct task_struct *task);
eb95419b
TH
643 void (*exit)(struct cgroup_subsys_state *css,
644 struct cgroup_subsys_state *old_css,
761b3ef5 645 struct task_struct *task);
eb95419b 646 void (*bind)(struct cgroup_subsys_state *root_css);
e5991371 647
8bab8dde 648 int disabled;
ddbcc7e8 649 int early_init;
48ddbe19 650
8c7f6edb
TH
651 /*
652 * If %false, this subsystem is properly hierarchical -
653 * configuration, resource accounting and restriction on a parent
654 * cgroup cover those of its children. If %true, hierarchy support
655 * is broken in some ways - some subsystems ignore hierarchy
656 * completely while others are only implemented half-way.
657 *
658 * It's now disallowed to create nested cgroups if the subsystem is
659 * broken and cgroup core will emit a warning message on such
660 * cases. Eventually, all subsystems will be made properly
661 * hierarchical and this will go away.
662 */
663 bool broken_hierarchy;
664 bool warned_broken_hierarchy;
665
073219e9 666 /* the following two fields are initialized automtically during boot */
aec25020 667 int id;
ddbcc7e8
PM
668#define MAX_CGROUP_TYPE_NAMELEN 32
669 const char *name;
670
b85d2040 671 /* link to parent, protected by cgroup_lock() */
3dd06ffa 672 struct cgroup_root *root;
e6a1105b 673
15a4c835
TH
674 /* idr for css->id */
675 struct idr css_idr;
676
0adb0704
TH
677 /*
678 * List of cftypes. Each entry is the first entry of an array
679 * terminated by zero length name.
680 */
681 struct list_head cfts;
8e3f6541 682
de00ffa5 683 /* base cftypes, automatically registered with subsys itself */
8e3f6541 684 struct cftype *base_cftypes;
ddbcc7e8
PM
685};
686
073219e9 687#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
ddbcc7e8
PM
688#include <linux/cgroup_subsys.h>
689#undef SUBSYS
690
14611e51
TH
691/**
692 * task_css_set_check - obtain a task's css_set with extra access conditions
693 * @task: the task to obtain css_set for
694 * @__c: extra condition expression to be passed to rcu_dereference_check()
695 *
696 * A task's css_set is RCU protected, initialized and exited while holding
697 * task_lock(), and can only be modified while holding both cgroup_mutex
698 * and task_lock() while the task is alive. This macro verifies that the
699 * caller is inside proper critical section and returns @task's css_set.
700 *
701 * The caller can also specify additional allowed conditions via @__c, such
702 * as locks used during the cgroup_subsys::attach() methods.
dc61b1d6 703 */
2219449a
TH
704#ifdef CONFIG_PROVE_RCU
705extern struct mutex cgroup_mutex;
0e1d768f 706extern struct rw_semaphore css_set_rwsem;
14611e51
TH
707#define task_css_set_check(task, __c) \
708 rcu_dereference_check((task)->cgroups, \
0e1d768f
TH
709 lockdep_is_held(&cgroup_mutex) || \
710 lockdep_is_held(&css_set_rwsem) || \
711 ((task)->flags & PF_EXITING) || (__c))
2219449a 712#else
14611e51
TH
713#define task_css_set_check(task, __c) \
714 rcu_dereference((task)->cgroups)
2219449a 715#endif
dc61b1d6 716
14611e51 717/**
8af01f56 718 * task_css_check - obtain css for (task, subsys) w/ extra access conds
14611e51
TH
719 * @task: the target task
720 * @subsys_id: the target subsystem ID
721 * @__c: extra condition expression to be passed to rcu_dereference_check()
722 *
723 * Return the cgroup_subsys_state for the (@task, @subsys_id) pair. The
724 * synchronization rules are the same as task_css_set_check().
725 */
8af01f56 726#define task_css_check(task, subsys_id, __c) \
14611e51
TH
727 task_css_set_check((task), (__c))->subsys[(subsys_id)]
728
729/**
730 * task_css_set - obtain a task's css_set
731 * @task: the task to obtain css_set for
732 *
733 * See task_css_set_check().
734 */
735static inline struct css_set *task_css_set(struct task_struct *task)
736{
737 return task_css_set_check(task, false);
738}
739
740/**
8af01f56 741 * task_css - obtain css for (task, subsys)
14611e51
TH
742 * @task: the target task
743 * @subsys_id: the target subsystem ID
744 *
8af01f56 745 * See task_css_check().
14611e51 746 */
8af01f56
TH
747static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
748 int subsys_id)
ddbcc7e8 749{
8af01f56 750 return task_css_check(task, subsys_id, false);
ddbcc7e8
PM
751}
752
5024ae29
TH
753/**
754 * task_css_is_root - test whether a task belongs to the root css
755 * @task: the target task
756 * @subsys_id: the target subsystem ID
757 *
758 * Test whether @task belongs to the root css on the specified subsystem.
759 * May be invoked in any context.
760 */
761static inline bool task_css_is_root(struct task_struct *task, int subsys_id)
762{
763 return task_css_check(task, subsys_id, true) ==
764 init_css_set.subsys[subsys_id];
765}
766
8af01f56
TH
767static inline struct cgroup *task_cgroup(struct task_struct *task,
768 int subsys_id)
ddbcc7e8 769{
8af01f56 770 return task_css(task, subsys_id)->cgroup;
ddbcc7e8
PM
771}
772
492eb21b
TH
773struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
774 struct cgroup_subsys_state *parent);
53fa5261 775
1cb650b9
LZ
776struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
777
574bd9f7 778/**
492eb21b
TH
779 * css_for_each_child - iterate through children of a css
780 * @pos: the css * to use as the loop cursor
781 * @parent: css whose children to walk
574bd9f7 782 *
c2931b70 783 * Walk @parent's children. Must be called under rcu_read_lock().
574bd9f7 784 *
c2931b70
TH
785 * If a subsystem synchronizes ->css_online() and the start of iteration, a
786 * css which finished ->css_online() is guaranteed to be visible in the
787 * future iterations and will stay visible until the last reference is put.
788 * A css which hasn't finished ->css_online() or already finished
789 * ->css_offline() may show up during traversal. It's each subsystem's
790 * responsibility to synchronize against on/offlining.
75501a6d
TH
791 *
792 * It is allowed to temporarily drop RCU read lock during iteration. The
793 * caller is responsible for ensuring that @pos remains accessible until
794 * the start of the next iteration by, for example, bumping the css refcnt.
574bd9f7 795 */
492eb21b
TH
796#define css_for_each_child(pos, parent) \
797 for ((pos) = css_next_child(NULL, (parent)); (pos); \
798 (pos) = css_next_child((pos), (parent)))
574bd9f7 799
492eb21b
TH
800struct cgroup_subsys_state *
801css_next_descendant_pre(struct cgroup_subsys_state *pos,
802 struct cgroup_subsys_state *css);
803
804struct cgroup_subsys_state *
805css_rightmost_descendant(struct cgroup_subsys_state *pos);
574bd9f7
TH
806
807/**
492eb21b
TH
808 * css_for_each_descendant_pre - pre-order walk of a css's descendants
809 * @pos: the css * to use as the loop cursor
810 * @root: css whose descendants to walk
574bd9f7 811 *
bd8815a6 812 * Walk @root's descendants. @root is included in the iteration and the
c2931b70 813 * first node to be visited. Must be called under rcu_read_lock().
574bd9f7 814 *
c2931b70
TH
815 * If a subsystem synchronizes ->css_online() and the start of iteration, a
816 * css which finished ->css_online() is guaranteed to be visible in the
817 * future iterations and will stay visible until the last reference is put.
818 * A css which hasn't finished ->css_online() or already finished
819 * ->css_offline() may show up during traversal. It's each subsystem's
820 * responsibility to synchronize against on/offlining.
574bd9f7 821 *
c2931b70 822 * For example, the following guarantees that a descendant can't escape
574bd9f7
TH
823 * state updates of its ancestors.
824 *
492eb21b 825 * my_online(@css)
574bd9f7 826 * {
492eb21b
TH
827 * Lock @css's parent and @css;
828 * Inherit state from the parent;
574bd9f7
TH
829 * Unlock both.
830 * }
831 *
492eb21b 832 * my_update_state(@css)
574bd9f7 833 * {
492eb21b 834 * css_for_each_descendant_pre(@pos, @css) {
574bd9f7 835 * Lock @pos;
bd8815a6
TH
836 * if (@pos == @css)
837 * Update @css's state;
838 * else
839 * Verify @pos is alive and inherit state from its parent;
574bd9f7
TH
840 * Unlock @pos;
841 * }
842 * }
843 *
844 * As long as the inheriting step, including checking the parent state, is
845 * enclosed inside @pos locking, double-locking the parent isn't necessary
846 * while inheriting. The state update to the parent is guaranteed to be
847 * visible by walking order and, as long as inheriting operations to the
848 * same @pos are atomic to each other, multiple updates racing each other
849 * still result in the correct state. It's guaranateed that at least one
492eb21b 850 * inheritance happens for any css after the latest update to its parent.
574bd9f7
TH
851 *
852 * If checking parent's state requires locking the parent, each inheriting
853 * iteration should lock and unlock both @pos->parent and @pos.
854 *
855 * Alternatively, a subsystem may choose to use a single global lock to
92fb9748 856 * synchronize ->css_online() and ->css_offline() against tree-walking
574bd9f7 857 * operations.
75501a6d
TH
858 *
859 * It is allowed to temporarily drop RCU read lock during iteration. The
860 * caller is responsible for ensuring that @pos remains accessible until
861 * the start of the next iteration by, for example, bumping the css refcnt.
574bd9f7 862 */
492eb21b
TH
863#define css_for_each_descendant_pre(pos, css) \
864 for ((pos) = css_next_descendant_pre(NULL, (css)); (pos); \
865 (pos) = css_next_descendant_pre((pos), (css)))
574bd9f7 866
492eb21b
TH
867struct cgroup_subsys_state *
868css_next_descendant_post(struct cgroup_subsys_state *pos,
869 struct cgroup_subsys_state *css);
574bd9f7
TH
870
871/**
492eb21b
TH
872 * css_for_each_descendant_post - post-order walk of a css's descendants
873 * @pos: the css * to use as the loop cursor
874 * @css: css whose descendants to walk
574bd9f7 875 *
492eb21b 876 * Similar to css_for_each_descendant_pre() but performs post-order
bd8815a6 877 * traversal instead. @root is included in the iteration and the last
c2931b70
TH
878 * node to be visited.
879 *
880 * If a subsystem synchronizes ->css_online() and the start of iteration, a
881 * css which finished ->css_online() is guaranteed to be visible in the
882 * future iterations and will stay visible until the last reference is put.
883 * A css which hasn't finished ->css_online() or already finished
884 * ->css_offline() may show up during traversal. It's each subsystem's
885 * responsibility to synchronize against on/offlining.
886 *
887 * Note that the walk visibility guarantee example described in pre-order
888 * walk doesn't apply the same to post-order walks.
574bd9f7 889 */
492eb21b
TH
890#define css_for_each_descendant_post(pos, css) \
891 for ((pos) = css_next_descendant_post(NULL, (css)); (pos); \
892 (pos) = css_next_descendant_post((pos), (css)))
574bd9f7 893
f3d46500
TH
894bool css_has_online_children(struct cgroup_subsys_state *css);
895
72ec7029
TH
896/* A css_task_iter should be treated as an opaque object */
897struct css_task_iter {
3ebb2b6e
TH
898 struct cgroup_subsys *ss;
899
0f0a2b4f
TH
900 struct list_head *cset_pos;
901 struct list_head *cset_head;
902
903 struct list_head *task_pos;
904 struct list_head *tasks_head;
905 struct list_head *mg_tasks_head;
817929ec
PM
906};
907
72ec7029
TH
908void css_task_iter_start(struct cgroup_subsys_state *css,
909 struct css_task_iter *it);
910struct task_struct *css_task_iter_next(struct css_task_iter *it);
911void css_task_iter_end(struct css_task_iter *it);
e535837b 912
31583bb0 913int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
8cc99345 914int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
31583bb0 915
ec903c0c
TH
916struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
917 struct cgroup_subsys *ss);
38460b48 918
ddbcc7e8
PM
919#else /* !CONFIG_CGROUPS */
920
921static inline int cgroup_init_early(void) { return 0; }
922static inline int cgroup_init(void) { return 0; }
b4f48b63 923static inline void cgroup_fork(struct task_struct *p) {}
817929ec 924static inline void cgroup_post_fork(struct task_struct *p) {}
1ec41830 925static inline void cgroup_exit(struct task_struct *p) {}
ddbcc7e8 926
846c7bb0
BS
927static inline int cgroupstats_build(struct cgroupstats *stats,
928 struct dentry *dentry)
929{
930 return -EINVAL;
931}
ddbcc7e8 932
d7926ee3 933/* No cgroups - nothing to do */
31583bb0
MT
934static inline int cgroup_attach_task_all(struct task_struct *from,
935 struct task_struct *t)
936{
937 return 0;
938}
d7926ee3 939
ddbcc7e8
PM
940#endif /* !CONFIG_CGROUPS */
941
942#endif /* _LINUX_CGROUP_H */
This page took 0.541635 seconds and 5 git commands to generate.