Branch data Line data Source code
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>
12 : : #include <linux/cpumask.h>
13 : : #include <linux/nodemask.h>
14 : : #include <linux/rcupdate.h>
15 : : #include <linux/rculist.h>
16 : : #include <linux/cgroupstats.h>
17 : : #include <linux/prio_heap.h>
18 : : #include <linux/rwsem.h>
19 : : #include <linux/idr.h>
20 : : #include <linux/workqueue.h>
21 : : #include <linux/xattr.h>
22 : : #include <linux/fs.h>
23 : : #include <linux/percpu-refcount.h>
24 : :
25 : : #ifdef CONFIG_CGROUPS
26 : :
27 : : struct cgroupfs_root;
28 : : struct cgroup_subsys;
29 : : struct inode;
30 : : struct cgroup;
31 : : struct css_id;
32 : : struct eventfd_ctx;
33 : :
34 : : extern int cgroup_init_early(void);
35 : : extern int cgroup_init(void);
36 : : extern void cgroup_fork(struct task_struct *p);
37 : : extern void cgroup_post_fork(struct task_struct *p);
38 : : extern void cgroup_exit(struct task_struct *p, int run_callbacks);
39 : : extern int cgroupstats_build(struct cgroupstats *stats,
40 : : struct dentry *dentry);
41 : : extern int cgroup_load_subsys(struct cgroup_subsys *ss);
42 : : extern void cgroup_unload_subsys(struct cgroup_subsys *ss);
43 : :
44 : : extern int proc_cgroup_show(struct seq_file *, void *);
45 : :
46 : : /*
47 : : * Define the enumeration of all cgroup subsystems.
48 : : *
49 : : * We define ids for builtin subsystems and then modular ones.
50 : : */
51 : : #define SUBSYS(_x) _x ## _subsys_id,
52 : : enum cgroup_subsys_id {
53 : : #define IS_SUBSYS_ENABLED(option) IS_BUILTIN(option)
54 : : #include <linux/cgroup_subsys.h>
55 : : #undef IS_SUBSYS_ENABLED
56 : : CGROUP_BUILTIN_SUBSYS_COUNT,
57 : :
58 : : __CGROUP_SUBSYS_TEMP_PLACEHOLDER = CGROUP_BUILTIN_SUBSYS_COUNT - 1,
59 : :
60 : : #define IS_SUBSYS_ENABLED(option) IS_MODULE(option)
61 : : #include <linux/cgroup_subsys.h>
62 : : #undef IS_SUBSYS_ENABLED
63 : : CGROUP_SUBSYS_COUNT,
64 : : };
65 : : #undef SUBSYS
66 : :
67 : : /* Per-subsystem/per-cgroup state maintained by the system. */
68 : : struct cgroup_subsys_state {
69 : : /* the cgroup that this css is attached to */
70 : : struct cgroup *cgroup;
71 : :
72 : : /* the cgroup subsystem that this css is attached to */
73 : : struct cgroup_subsys *ss;
74 : :
75 : : /* reference count - access via css_[try]get() and css_put() */
76 : : struct percpu_ref refcnt;
77 : :
78 : : /* the parent css */
79 : : struct cgroup_subsys_state *parent;
80 : :
81 : : unsigned long flags;
82 : : /* ID for this css, if possible */
83 : : struct css_id __rcu *id;
84 : :
85 : : /* percpu_ref killing and RCU release */
86 : : struct rcu_head rcu_head;
87 : : struct work_struct destroy_work;
88 : : };
89 : :
90 : : /* bits in struct cgroup_subsys_state flags field */
91 : : enum {
92 : : CSS_ROOT = (1 << 0), /* this CSS is the root of the subsystem */
93 : : CSS_ONLINE = (1 << 1), /* between ->css_online() and ->css_offline() */
94 : : };
95 : :
96 : : /**
97 : : * css_get - obtain a reference on the specified css
98 : : * @css: target css
99 : : *
100 : : * The caller must already have a reference.
101 : : */
102 : : static inline void css_get(struct cgroup_subsys_state *css)
103 : : {
104 : : /* We don't need to reference count the root state */
105 [ # # ][ # # ]: 0 : if (!(css->flags & CSS_ROOT))
106 : : percpu_ref_get(&css->refcnt);
107 : : }
108 : :
109 : : /**
110 : : * css_tryget - try to obtain a reference on the specified css
111 : : * @css: target css
112 : : *
113 : : * Obtain a reference on @css if it's alive. The caller naturally needs to
114 : : * ensure that @css is accessible but doesn't have to be holding a
115 : : * reference on it - IOW, RCU protected access is good enough for this
116 : : * function. Returns %true if a reference count was successfully obtained;
117 : : * %false otherwise.
118 : : */
119 : : static inline bool css_tryget(struct cgroup_subsys_state *css)
120 : : {
121 [ # # ][ # # ]: 0 : if (css->flags & CSS_ROOT)
122 : : return true;
123 : : return percpu_ref_tryget(&css->refcnt);
124 : : }
125 : :
126 : : /**
127 : : * css_put - put a css reference
128 : : * @css: target css
129 : : *
130 : : * Put a reference obtained via css_get() and css_tryget().
131 : : */
132 : : static inline void css_put(struct cgroup_subsys_state *css)
133 : : {
134 [ # # ][ # # ]: 0 : if (!(css->flags & CSS_ROOT))
[ # # # # ]
[ # # ][ # # ]
135 : 0 : percpu_ref_put(&css->refcnt);
136 : : }
137 : :
138 : : /* bits in struct cgroup flags field */
139 : : enum {
140 : : /* Control Group is dead */
141 : : CGRP_DEAD,
142 : : /*
143 : : * Control Group has previously had a child cgroup or a task,
144 : : * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
145 : : */
146 : : CGRP_RELEASABLE,
147 : : /* Control Group requires release notifications to userspace */
148 : : CGRP_NOTIFY_ON_RELEASE,
149 : : /*
150 : : * Clone the parent's configuration when creating a new child
151 : : * cpuset cgroup. For historical reasons, this option can be
152 : : * specified at mount time and thus is implemented here.
153 : : */
154 : : CGRP_CPUSET_CLONE_CHILDREN,
155 : : /* see the comment above CGRP_ROOT_SANE_BEHAVIOR for details */
156 : : CGRP_SANE_BEHAVIOR,
157 : : };
158 : :
159 : : struct cgroup_name {
160 : : struct rcu_head rcu_head;
161 : : char name[];
162 : : };
163 : :
164 : : struct cgroup {
165 : : unsigned long flags; /* "unsigned long" so bitops work */
166 : :
167 : : /*
168 : : * idr allocated in-hierarchy ID.
169 : : *
170 : : * The ID of the root cgroup is always 0, and a new cgroup
171 : : * will be assigned with a smallest available ID.
172 : : */
173 : : int id;
174 : :
175 : : /* the number of attached css's */
176 : : int nr_css;
177 : :
178 : : /*
179 : : * We link our 'sibling' struct into our parent's 'children'.
180 : : * Our children link their 'sibling' into our 'children'.
181 : : */
182 : : struct list_head sibling; /* my parent's children */
183 : : struct list_head children; /* my children */
184 : : struct list_head files; /* my files */
185 : :
186 : : struct cgroup *parent; /* my parent */
187 : : struct dentry *dentry; /* cgroup fs entry, RCU protected */
188 : :
189 : : /*
190 : : * Monotonically increasing unique serial number which defines a
191 : : * uniform order among all cgroups. It's guaranteed that all
192 : : * ->children lists are in the ascending order of ->serial_nr.
193 : : * It's used to allow interrupting and resuming iterations.
194 : : */
195 : : u64 serial_nr;
196 : :
197 : : /*
198 : : * This is a copy of dentry->d_name, and it's needed because
199 : : * we can't use dentry->d_name in cgroup_path().
200 : : *
201 : : * You must acquire rcu_read_lock() to access cgrp->name, and
202 : : * the only place that can change it is rename(), which is
203 : : * protected by parent dir's i_mutex.
204 : : *
205 : : * Normally you should use cgroup_name() wrapper rather than
206 : : * access it directly.
207 : : */
208 : : struct cgroup_name __rcu *name;
209 : :
210 : : /* Private pointers for each registered subsystem */
211 : : struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
212 : :
213 : : struct cgroupfs_root *root;
214 : :
215 : : /*
216 : : * List of cgrp_cset_links pointing at css_sets with tasks in this
217 : : * cgroup. Protected by css_set_lock.
218 : : */
219 : : struct list_head cset_links;
220 : :
221 : : /*
222 : : * Linked list running through all cgroups that can
223 : : * potentially be reaped by the release agent. Protected by
224 : : * release_list_lock
225 : : */
226 : : struct list_head release_list;
227 : :
228 : : /*
229 : : * list of pidlists, up to two for each namespace (one for procs, one
230 : : * for tasks); created on demand.
231 : : */
232 : : struct list_head pidlists;
233 : : struct mutex pidlist_mutex;
234 : :
235 : : /* dummy css with NULL ->ss, points back to this cgroup */
236 : : struct cgroup_subsys_state dummy_css;
237 : :
238 : : /* For css percpu_ref killing and RCU-protected deletion */
239 : : struct rcu_head rcu_head;
240 : : struct work_struct destroy_work;
241 : :
242 : : /* List of events which userspace want to receive */
243 : : struct list_head event_list;
244 : : spinlock_t event_list_lock;
245 : :
246 : : /* directory xattrs */
247 : : struct simple_xattrs xattrs;
248 : : };
249 : :
250 : : #define MAX_CGROUP_ROOT_NAMELEN 64
251 : :
252 : : /* cgroupfs_root->flags */
253 : : enum {
254 : : /*
255 : : * Unfortunately, cgroup core and various controllers are riddled
256 : : * with idiosyncrasies and pointless options. The following flag,
257 : : * when set, will force sane behavior - some options are forced on,
258 : : * others are disallowed, and some controllers will change their
259 : : * hierarchical or other behaviors.
260 : : *
261 : : * The set of behaviors affected by this flag are still being
262 : : * determined and developed and the mount option for this flag is
263 : : * prefixed with __DEVEL__. The prefix will be dropped once we
264 : : * reach the point where all behaviors are compatible with the
265 : : * planned unified hierarchy, which will automatically turn on this
266 : : * flag.
267 : : *
268 : : * The followings are the behaviors currently affected this flag.
269 : : *
270 : : * - Mount options "noprefix" and "clone_children" are disallowed.
271 : : * Also, cgroupfs file cgroup.clone_children is not created.
272 : : *
273 : : * - When mounting an existing superblock, mount options should
274 : : * match.
275 : : *
276 : : * - Remount is disallowed.
277 : : *
278 : : * - rename(2) is disallowed.
279 : : *
280 : : * - "tasks" is removed. Everything should be at process
281 : : * granularity. Use "cgroup.procs" instead.
282 : : *
283 : : * - "release_agent" and "notify_on_release" are removed.
284 : : * Replacement notification mechanism will be implemented.
285 : : *
286 : : * - cpuset: tasks will be kept in empty cpusets when hotplug happens
287 : : * and take masks of ancestors with non-empty cpus/mems, instead of
288 : : * being moved to an ancestor.
289 : : *
290 : : * - cpuset: a task can be moved into an empty cpuset, and again it
291 : : * takes masks of ancestors.
292 : : *
293 : : * - memcg: use_hierarchy is on by default and the cgroup file for
294 : : * the flag is not created.
295 : : *
296 : : * - blkcg: blk-throttle becomes properly hierarchical.
297 : : */
298 : : CGRP_ROOT_SANE_BEHAVIOR = (1 << 0),
299 : :
300 : : CGRP_ROOT_NOPREFIX = (1 << 1), /* mounted subsystems have no named prefix */
301 : : CGRP_ROOT_XATTR = (1 << 2), /* supports extended attributes */
302 : :
303 : : /* mount options live below bit 16 */
304 : : CGRP_ROOT_OPTION_MASK = (1 << 16) - 1,
305 : :
306 : : CGRP_ROOT_SUBSYS_BOUND = (1 << 16), /* subsystems finished binding */
307 : : };
308 : :
309 : : /*
310 : : * A cgroupfs_root represents the root of a cgroup hierarchy, and may be
311 : : * associated with a superblock to form an active hierarchy. This is
312 : : * internal to cgroup core. Don't access directly from controllers.
313 : : */
314 : : struct cgroupfs_root {
315 : : struct super_block *sb;
316 : :
317 : : /* The bitmask of subsystems attached to this hierarchy */
318 : : unsigned long subsys_mask;
319 : :
320 : : /* Unique id for this hierarchy. */
321 : : int hierarchy_id;
322 : :
323 : : /* A list running through the attached subsystems */
324 : : struct list_head subsys_list;
325 : :
326 : : /* The root cgroup for this hierarchy */
327 : : struct cgroup top_cgroup;
328 : :
329 : : /* Tracks how many cgroups are currently defined in hierarchy.*/
330 : : int number_of_cgroups;
331 : :
332 : : /* A list running through the active hierarchies */
333 : : struct list_head root_list;
334 : :
335 : : /* Hierarchy-specific flags */
336 : : unsigned long flags;
337 : :
338 : : /* IDs for cgroups in this hierarchy */
339 : : struct idr cgroup_idr;
340 : :
341 : : /* The path to use for release notifications. */
342 : : char release_agent_path[PATH_MAX];
343 : :
344 : : /* The name for this hierarchy - may be empty */
345 : : char name[MAX_CGROUP_ROOT_NAMELEN];
346 : : };
347 : :
348 : : /*
349 : : * A css_set is a structure holding pointers to a set of
350 : : * cgroup_subsys_state objects. This saves space in the task struct
351 : : * object and speeds up fork()/exit(), since a single inc/dec and a
352 : : * list_add()/del() can bump the reference count on the entire cgroup
353 : : * set for a task.
354 : : */
355 : :
356 : : struct css_set {
357 : :
358 : : /* Reference count */
359 : : atomic_t refcount;
360 : :
361 : : /*
362 : : * List running through all cgroup groups in the same hash
363 : : * slot. Protected by css_set_lock
364 : : */
365 : : struct hlist_node hlist;
366 : :
367 : : /*
368 : : * List running through all tasks using this cgroup
369 : : * group. Protected by css_set_lock
370 : : */
371 : : struct list_head tasks;
372 : :
373 : : /*
374 : : * List of cgrp_cset_links pointing at cgroups referenced from this
375 : : * css_set. Protected by css_set_lock.
376 : : */
377 : : struct list_head cgrp_links;
378 : :
379 : : /*
380 : : * Set of subsystem states, one for each subsystem. This array
381 : : * is immutable after creation apart from the init_css_set
382 : : * during subsystem registration (at boot time) and modular subsystem
383 : : * loading/unloading.
384 : : */
385 : : struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
386 : :
387 : : /* For RCU-protected deletion */
388 : : struct rcu_head rcu_head;
389 : : };
390 : :
391 : : /*
392 : : * cgroup_map_cb is an abstract callback API for reporting map-valued
393 : : * control files
394 : : */
395 : :
396 : : struct cgroup_map_cb {
397 : : int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
398 : : void *state;
399 : : };
400 : :
401 : : /*
402 : : * struct cftype: handler definitions for cgroup control files
403 : : *
404 : : * When reading/writing to a file:
405 : : * - the cgroup to use is file->f_dentry->d_parent->d_fsdata
406 : : * - the 'cftype' of the file is file->f_dentry->d_fsdata
407 : : */
408 : :
409 : : /* cftype->flags */
410 : : enum {
411 : : CFTYPE_ONLY_ON_ROOT = (1 << 0), /* only create on root cgrp */
412 : : CFTYPE_NOT_ON_ROOT = (1 << 1), /* don't create on root cgrp */
413 : : CFTYPE_INSANE = (1 << 2), /* don't create if sane_behavior */
414 : : CFTYPE_NO_PREFIX = (1 << 3), /* (DON'T USE FOR NEW FILES) no subsys prefix */
415 : : };
416 : :
417 : : #define MAX_CFTYPE_NAME 64
418 : :
419 : : struct cftype {
420 : : /*
421 : : * By convention, the name should begin with the name of the
422 : : * subsystem, followed by a period. Zero length string indicates
423 : : * end of cftype array.
424 : : */
425 : : char name[MAX_CFTYPE_NAME];
426 : : int private;
427 : : /*
428 : : * If not 0, file mode is set to this value, otherwise it will
429 : : * be figured out automatically
430 : : */
431 : : umode_t mode;
432 : :
433 : : /*
434 : : * If non-zero, defines the maximum length of string that can
435 : : * be passed to write_string; defaults to 64
436 : : */
437 : : size_t max_write_len;
438 : :
439 : : /* CFTYPE_* flags */
440 : : unsigned int flags;
441 : :
442 : : /*
443 : : * The subsys this file belongs to. Initialized automatically
444 : : * during registration. NULL for cgroup core files.
445 : : */
446 : : struct cgroup_subsys *ss;
447 : :
448 : : int (*open)(struct inode *inode, struct file *file);
449 : : ssize_t (*read)(struct cgroup_subsys_state *css, struct cftype *cft,
450 : : struct file *file,
451 : : char __user *buf, size_t nbytes, loff_t *ppos);
452 : : /*
453 : : * read_u64() is a shortcut for the common case of returning a
454 : : * single integer. Use it in place of read()
455 : : */
456 : : u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
457 : : /*
458 : : * read_s64() is a signed version of read_u64()
459 : : */
460 : : s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
461 : : /*
462 : : * read_map() is used for defining a map of key/value
463 : : * pairs. It should call cb->fill(cb, key, value) for each
464 : : * entry. The key/value pairs (and their ordering) should not
465 : : * change between reboots.
466 : : */
467 : : int (*read_map)(struct cgroup_subsys_state *css, struct cftype *cft,
468 : : struct cgroup_map_cb *cb);
469 : : /*
470 : : * read_seq_string() is used for outputting a simple sequence
471 : : * using seqfile.
472 : : */
473 : : int (*read_seq_string)(struct cgroup_subsys_state *css,
474 : : struct cftype *cft, struct seq_file *m);
475 : :
476 : : ssize_t (*write)(struct cgroup_subsys_state *css, struct cftype *cft,
477 : : struct file *file,
478 : : const char __user *buf, size_t nbytes, loff_t *ppos);
479 : :
480 : : /*
481 : : * write_u64() is a shortcut for the common case of accepting
482 : : * a single integer (as parsed by simple_strtoull) from
483 : : * userspace. Use in place of write(); return 0 or error.
484 : : */
485 : : int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
486 : : u64 val);
487 : : /*
488 : : * write_s64() is a signed version of write_u64()
489 : : */
490 : : int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
491 : : s64 val);
492 : :
493 : : /*
494 : : * write_string() is passed a nul-terminated kernelspace
495 : : * buffer of maximum length determined by max_write_len.
496 : : * Returns 0 or -ve error code.
497 : : */
498 : : int (*write_string)(struct cgroup_subsys_state *css, struct cftype *cft,
499 : : const char *buffer);
500 : : /*
501 : : * trigger() callback can be used to get some kick from the
502 : : * userspace, when the actual string written is not important
503 : : * at all. The private field can be used to determine the
504 : : * kick type for multiplexing.
505 : : */
506 : : int (*trigger)(struct cgroup_subsys_state *css, unsigned int event);
507 : :
508 : : int (*release)(struct inode *inode, struct file *file);
509 : :
510 : : /*
511 : : * register_event() callback will be used to add new userspace
512 : : * waiter for changes related to the cftype. Implement it if
513 : : * you want to provide this functionality. Use eventfd_signal()
514 : : * on eventfd to send notification to userspace.
515 : : */
516 : : int (*register_event)(struct cgroup_subsys_state *css,
517 : : struct cftype *cft, struct eventfd_ctx *eventfd,
518 : : const char *args);
519 : : /*
520 : : * unregister_event() callback will be called when userspace
521 : : * closes the eventfd or on cgroup removing.
522 : : * This callback must be implemented, if you want provide
523 : : * notification functionality.
524 : : */
525 : : void (*unregister_event)(struct cgroup_subsys_state *css,
526 : : struct cftype *cft,
527 : : struct eventfd_ctx *eventfd);
528 : : };
529 : :
530 : : /*
531 : : * cftype_sets describe cftypes belonging to a subsystem and are chained at
532 : : * cgroup_subsys->cftsets. Each cftset points to an array of cftypes
533 : : * terminated by zero length name.
534 : : */
535 : : struct cftype_set {
536 : : struct list_head node; /* chained at subsys->cftsets */
537 : : struct cftype *cfts;
538 : : };
539 : :
540 : : /*
541 : : * See the comment above CGRP_ROOT_SANE_BEHAVIOR for details. This
542 : : * function can be called as long as @cgrp is accessible.
543 : : */
544 : : static inline bool cgroup_sane_behavior(const struct cgroup *cgrp)
545 : : {
546 : 28 : return cgrp->root->flags & CGRP_ROOT_SANE_BEHAVIOR;
547 : : }
548 : :
549 : : /* Caller should hold rcu_read_lock() */
550 : : static inline const char *cgroup_name(const struct cgroup *cgrp)
551 : : {
552 : : return rcu_dereference(cgrp->name)->name;
553 : : }
554 : :
555 : : int cgroup_add_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
556 : : int cgroup_rm_cftypes(struct cftype *cfts);
557 : :
558 : : bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
559 : :
560 : : int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
561 : : int task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
562 : :
563 : : int cgroup_task_count(const struct cgroup *cgrp);
564 : :
565 : : /*
566 : : * Control Group taskset, used to pass around set of tasks to cgroup_subsys
567 : : * methods.
568 : : */
569 : : struct cgroup_taskset;
570 : : struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
571 : : struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
572 : : struct cgroup_subsys_state *cgroup_taskset_cur_css(struct cgroup_taskset *tset,
573 : : int subsys_id);
574 : : int cgroup_taskset_size(struct cgroup_taskset *tset);
575 : :
576 : : /**
577 : : * cgroup_taskset_for_each - iterate cgroup_taskset
578 : : * @task: the loop cursor
579 : : * @skip_css: skip if task's css matches this, %NULL to iterate through all
580 : : * @tset: taskset to iterate
581 : : */
582 : : #define cgroup_taskset_for_each(task, skip_css, tset) \
583 : : for ((task) = cgroup_taskset_first((tset)); (task); \
584 : : (task) = cgroup_taskset_next((tset))) \
585 : : if (!(skip_css) || \
586 : : cgroup_taskset_cur_css((tset), \
587 : : (skip_css)->ss->subsys_id) != (skip_css))
588 : :
589 : : /*
590 : : * Control Group subsystem type.
591 : : * See Documentation/cgroups/cgroups.txt for details
592 : : */
593 : :
594 : : struct cgroup_subsys {
595 : : struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
596 : : int (*css_online)(struct cgroup_subsys_state *css);
597 : : void (*css_offline)(struct cgroup_subsys_state *css);
598 : : void (*css_free)(struct cgroup_subsys_state *css);
599 : :
600 : : int (*can_attach)(struct cgroup_subsys_state *css,
601 : : struct cgroup_taskset *tset);
602 : : void (*cancel_attach)(struct cgroup_subsys_state *css,
603 : : struct cgroup_taskset *tset);
604 : : void (*attach)(struct cgroup_subsys_state *css,
605 : : struct cgroup_taskset *tset);
606 : : void (*fork)(struct task_struct *task);
607 : : void (*exit)(struct cgroup_subsys_state *css,
608 : : struct cgroup_subsys_state *old_css,
609 : : struct task_struct *task);
610 : : void (*bind)(struct cgroup_subsys_state *root_css);
611 : :
612 : : int subsys_id;
613 : : int disabled;
614 : : int early_init;
615 : :
616 : : /*
617 : : * If %false, this subsystem is properly hierarchical -
618 : : * configuration, resource accounting and restriction on a parent
619 : : * cgroup cover those of its children. If %true, hierarchy support
620 : : * is broken in some ways - some subsystems ignore hierarchy
621 : : * completely while others are only implemented half-way.
622 : : *
623 : : * It's now disallowed to create nested cgroups if the subsystem is
624 : : * broken and cgroup core will emit a warning message on such
625 : : * cases. Eventually, all subsystems will be made properly
626 : : * hierarchical and this will go away.
627 : : */
628 : : bool broken_hierarchy;
629 : : bool warned_broken_hierarchy;
630 : :
631 : : #define MAX_CGROUP_TYPE_NAMELEN 32
632 : : const char *name;
633 : :
634 : : /*
635 : : * Link to parent, and list entry in parent's children.
636 : : * Protected by cgroup_lock()
637 : : */
638 : : struct cgroupfs_root *root;
639 : : struct list_head sibling;
640 : :
641 : : /* list of cftype_sets */
642 : : struct list_head cftsets;
643 : :
644 : : /* base cftypes, automatically [de]registered with subsys itself */
645 : : struct cftype *base_cftypes;
646 : : struct cftype_set base_cftset;
647 : :
648 : : /* should be defined only by modular subsystems */
649 : : struct module *module;
650 : : };
651 : :
652 : : #define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
653 : : #define IS_SUBSYS_ENABLED(option) IS_BUILTIN(option)
654 : : #include <linux/cgroup_subsys.h>
655 : : #undef IS_SUBSYS_ENABLED
656 : : #undef SUBSYS
657 : :
658 : : /**
659 : : * css_parent - find the parent css
660 : : * @css: the target cgroup_subsys_state
661 : : *
662 : : * Return the parent css of @css. This function is guaranteed to return
663 : : * non-NULL parent as long as @css isn't the root.
664 : : */
665 : : static inline
666 : : struct cgroup_subsys_state *css_parent(struct cgroup_subsys_state *css)
667 : : {
668 : : return css->parent;
669 : : }
670 : :
671 : : /**
672 : : * task_css_set_check - obtain a task's css_set with extra access conditions
673 : : * @task: the task to obtain css_set for
674 : : * @__c: extra condition expression to be passed to rcu_dereference_check()
675 : : *
676 : : * A task's css_set is RCU protected, initialized and exited while holding
677 : : * task_lock(), and can only be modified while holding both cgroup_mutex
678 : : * and task_lock() while the task is alive. This macro verifies that the
679 : : * caller is inside proper critical section and returns @task's css_set.
680 : : *
681 : : * The caller can also specify additional allowed conditions via @__c, such
682 : : * as locks used during the cgroup_subsys::attach() methods.
683 : : */
684 : : #ifdef CONFIG_PROVE_RCU
685 : : extern struct mutex cgroup_mutex;
686 : : #define task_css_set_check(task, __c) \
687 : : rcu_dereference_check((task)->cgroups, \
688 : : lockdep_is_held(&(task)->alloc_lock) || \
689 : : lockdep_is_held(&cgroup_mutex) || (__c))
690 : : #else
691 : : #define task_css_set_check(task, __c) \
692 : : rcu_dereference((task)->cgroups)
693 : : #endif
694 : :
695 : : /**
696 : : * task_css_check - obtain css for (task, subsys) w/ extra access conds
697 : : * @task: the target task
698 : : * @subsys_id: the target subsystem ID
699 : : * @__c: extra condition expression to be passed to rcu_dereference_check()
700 : : *
701 : : * Return the cgroup_subsys_state for the (@task, @subsys_id) pair. The
702 : : * synchronization rules are the same as task_css_set_check().
703 : : */
704 : : #define task_css_check(task, subsys_id, __c) \
705 : : task_css_set_check((task), (__c))->subsys[(subsys_id)]
706 : :
707 : : /**
708 : : * task_css_set - obtain a task's css_set
709 : : * @task: the task to obtain css_set for
710 : : *
711 : : * See task_css_set_check().
712 : : */
713 : : static inline struct css_set *task_css_set(struct task_struct *task)
714 : : {
715 : 2324505 : return task_css_set_check(task, false);
716 : : }
717 : :
718 : : /**
719 : : * task_css - obtain css for (task, subsys)
720 : : * @task: the target task
721 : : * @subsys_id: the target subsystem ID
722 : : *
723 : : * See task_css_check().
724 : : */
725 : : static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
726 : : int subsys_id)
727 : : {
728 : : return task_css_check(task, subsys_id, false);
729 : : }
730 : :
731 : : static inline struct cgroup *task_cgroup(struct task_struct *task,
732 : : int subsys_id)
733 : : {
734 : : return task_css(task, subsys_id)->cgroup;
735 : : }
736 : :
737 : : struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
738 : : struct cgroup_subsys_state *parent);
739 : :
740 : : struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
741 : :
742 : : /**
743 : : * css_for_each_child - iterate through children of a css
744 : : * @pos: the css * to use as the loop cursor
745 : : * @parent: css whose children to walk
746 : : *
747 : : * Walk @parent's children. Must be called under rcu_read_lock(). A child
748 : : * css which hasn't finished ->css_online() or already has finished
749 : : * ->css_offline() may show up during traversal and it's each subsystem's
750 : : * responsibility to verify that each @pos is alive.
751 : : *
752 : : * If a subsystem synchronizes against the parent in its ->css_online() and
753 : : * before starting iterating, a css which finished ->css_online() is
754 : : * guaranteed to be visible in the future iterations.
755 : : *
756 : : * It is allowed to temporarily drop RCU read lock during iteration. The
757 : : * caller is responsible for ensuring that @pos remains accessible until
758 : : * the start of the next iteration by, for example, bumping the css refcnt.
759 : : */
760 : : #define css_for_each_child(pos, parent) \
761 : : for ((pos) = css_next_child(NULL, (parent)); (pos); \
762 : : (pos) = css_next_child((pos), (parent)))
763 : :
764 : : struct cgroup_subsys_state *
765 : : css_next_descendant_pre(struct cgroup_subsys_state *pos,
766 : : struct cgroup_subsys_state *css);
767 : :
768 : : struct cgroup_subsys_state *
769 : : css_rightmost_descendant(struct cgroup_subsys_state *pos);
770 : :
771 : : /**
772 : : * css_for_each_descendant_pre - pre-order walk of a css's descendants
773 : : * @pos: the css * to use as the loop cursor
774 : : * @root: css whose descendants to walk
775 : : *
776 : : * Walk @root's descendants. @root is included in the iteration and the
777 : : * first node to be visited. Must be called under rcu_read_lock(). A
778 : : * descendant css which hasn't finished ->css_online() or already has
779 : : * finished ->css_offline() may show up during traversal and it's each
780 : : * subsystem's responsibility to verify that each @pos is alive.
781 : : *
782 : : * If a subsystem synchronizes against the parent in its ->css_online() and
783 : : * before starting iterating, and synchronizes against @pos on each
784 : : * iteration, any descendant css which finished ->css_online() is
785 : : * guaranteed to be visible in the future iterations.
786 : : *
787 : : * In other words, the following guarantees that a descendant can't escape
788 : : * state updates of its ancestors.
789 : : *
790 : : * my_online(@css)
791 : : * {
792 : : * Lock @css's parent and @css;
793 : : * Inherit state from the parent;
794 : : * Unlock both.
795 : : * }
796 : : *
797 : : * my_update_state(@css)
798 : : * {
799 : : * css_for_each_descendant_pre(@pos, @css) {
800 : : * Lock @pos;
801 : : * if (@pos == @css)
802 : : * Update @css's state;
803 : : * else
804 : : * Verify @pos is alive and inherit state from its parent;
805 : : * Unlock @pos;
806 : : * }
807 : : * }
808 : : *
809 : : * As long as the inheriting step, including checking the parent state, is
810 : : * enclosed inside @pos locking, double-locking the parent isn't necessary
811 : : * while inheriting. The state update to the parent is guaranteed to be
812 : : * visible by walking order and, as long as inheriting operations to the
813 : : * same @pos are atomic to each other, multiple updates racing each other
814 : : * still result in the correct state. It's guaranateed that at least one
815 : : * inheritance happens for any css after the latest update to its parent.
816 : : *
817 : : * If checking parent's state requires locking the parent, each inheriting
818 : : * iteration should lock and unlock both @pos->parent and @pos.
819 : : *
820 : : * Alternatively, a subsystem may choose to use a single global lock to
821 : : * synchronize ->css_online() and ->css_offline() against tree-walking
822 : : * operations.
823 : : *
824 : : * It is allowed to temporarily drop RCU read lock during iteration. The
825 : : * caller is responsible for ensuring that @pos remains accessible until
826 : : * the start of the next iteration by, for example, bumping the css refcnt.
827 : : */
828 : : #define css_for_each_descendant_pre(pos, css) \
829 : : for ((pos) = css_next_descendant_pre(NULL, (css)); (pos); \
830 : : (pos) = css_next_descendant_pre((pos), (css)))
831 : :
832 : : struct cgroup_subsys_state *
833 : : css_next_descendant_post(struct cgroup_subsys_state *pos,
834 : : struct cgroup_subsys_state *css);
835 : :
836 : : /**
837 : : * css_for_each_descendant_post - post-order walk of a css's descendants
838 : : * @pos: the css * to use as the loop cursor
839 : : * @css: css whose descendants to walk
840 : : *
841 : : * Similar to css_for_each_descendant_pre() but performs post-order
842 : : * traversal instead. @root is included in the iteration and the last
843 : : * node to be visited. Note that the walk visibility guarantee described
844 : : * in pre-order walk doesn't apply the same to post-order walks.
845 : : */
846 : : #define css_for_each_descendant_post(pos, css) \
847 : : for ((pos) = css_next_descendant_post(NULL, (css)); (pos); \
848 : : (pos) = css_next_descendant_post((pos), (css)))
849 : :
850 : : /* A css_task_iter should be treated as an opaque object */
851 : : struct css_task_iter {
852 : : struct cgroup_subsys_state *origin_css;
853 : : struct list_head *cset_link;
854 : : struct list_head *task;
855 : : };
856 : :
857 : : void css_task_iter_start(struct cgroup_subsys_state *css,
858 : : struct css_task_iter *it);
859 : : struct task_struct *css_task_iter_next(struct css_task_iter *it);
860 : : void css_task_iter_end(struct css_task_iter *it);
861 : :
862 : : int css_scan_tasks(struct cgroup_subsys_state *css,
863 : : bool (*test)(struct task_struct *, void *),
864 : : void (*process)(struct task_struct *, void *),
865 : : void *data, struct ptr_heap *heap);
866 : :
867 : : int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
868 : : int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
869 : :
870 : : struct cgroup_subsys_state *css_from_dir(struct dentry *dentry,
871 : : struct cgroup_subsys *ss);
872 : :
873 : : #else /* !CONFIG_CGROUPS */
874 : :
875 : : static inline int cgroup_init_early(void) { return 0; }
876 : : static inline int cgroup_init(void) { return 0; }
877 : : static inline void cgroup_fork(struct task_struct *p) {}
878 : : static inline void cgroup_post_fork(struct task_struct *p) {}
879 : : static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
880 : :
881 : : static inline int cgroupstats_build(struct cgroupstats *stats,
882 : : struct dentry *dentry)
883 : : {
884 : : return -EINVAL;
885 : : }
886 : :
887 : : /* No cgroups - nothing to do */
888 : : static inline int cgroup_attach_task_all(struct task_struct *from,
889 : : struct task_struct *t)
890 : : {
891 : : return 0;
892 : : }
893 : :
894 : : #endif /* !CONFIG_CGROUPS */
895 : :
896 : : #endif /* _LINUX_CGROUP_H */
|
