include/linux/cgroup.h

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