linux/include/linux/cgroup.h
<<
>>
Prefs
   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/cgroupstats.h>
  16#include <linux/prio_heap.h>
  17#include <linux/rwsem.h>
  18
  19#ifdef CONFIG_CGROUPS
  20
  21struct cgroupfs_root;
  22struct cgroup_subsys;
  23struct inode;
  24struct cgroup;
  25
  26extern int cgroup_init_early(void);
  27extern int cgroup_init(void);
  28extern void cgroup_lock(void);
  29extern bool cgroup_lock_live_group(struct cgroup *cgrp);
  30extern void cgroup_unlock(void);
  31extern void cgroup_fork(struct task_struct *p);
  32extern void cgroup_fork_callbacks(struct task_struct *p);
  33extern void cgroup_post_fork(struct task_struct *p);
  34extern void cgroup_exit(struct task_struct *p, int run_callbacks);
  35extern int cgroupstats_build(struct cgroupstats *stats,
  36                                struct dentry *dentry);
  37
  38extern struct file_operations proc_cgroup_operations;
  39
  40/* Define the enumeration of all cgroup subsystems */
  41#define SUBSYS(_x) _x ## _subsys_id,
  42enum cgroup_subsys_id {
  43#include <linux/cgroup_subsys.h>
  44        CGROUP_SUBSYS_COUNT
  45};
  46#undef SUBSYS
  47
  48/* Per-subsystem/per-cgroup state maintained by the system. */
  49struct cgroup_subsys_state {
  50        /* The cgroup that this subsystem is attached to. Useful
  51         * for subsystems that want to know about the cgroup
  52         * hierarchy structure */
  53        struct cgroup *cgroup;
  54
  55        /* State maintained by the cgroup system to allow
  56         * subsystems to be "busy". Should be accessed via css_get()
  57         * and css_put() */
  58
  59        atomic_t refcnt;
  60
  61        unsigned long flags;
  62};
  63
  64/* bits in struct cgroup_subsys_state flags field */
  65enum {
  66        CSS_ROOT, /* This CSS is the root of the subsystem */
  67};
  68
  69/*
  70 * Call css_get() to hold a reference on the cgroup;
  71 *
  72 */
  73
  74static inline void css_get(struct cgroup_subsys_state *css)
  75{
  76        /* We don't need to reference count the root state */
  77        if (!test_bit(CSS_ROOT, &css->flags))
  78                atomic_inc(&css->refcnt);
  79}
  80/*
  81 * css_put() should be called to release a reference taken by
  82 * css_get()
  83 */
  84
  85extern void __css_put(struct cgroup_subsys_state *css);
  86static inline void css_put(struct cgroup_subsys_state *css)
  87{
  88        if (!test_bit(CSS_ROOT, &css->flags))
  89                __css_put(css);
  90}
  91
  92/* bits in struct cgroup flags field */
  93enum {
  94        /* Control Group is dead */
  95        CGRP_REMOVED,
  96        /* Control Group has previously had a child cgroup or a task,
  97         * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
  98        CGRP_RELEASABLE,
  99        /* Control Group requires release notifications to userspace */
 100        CGRP_NOTIFY_ON_RELEASE,
 101};
 102
 103struct cgroup {
 104        unsigned long flags;            /* "unsigned long" so bitops work */
 105
 106        /* count users of this cgroup. >0 means busy, but doesn't
 107         * necessarily indicate the number of tasks in the
 108         * cgroup */
 109        atomic_t count;
 110
 111        /*
 112         * We link our 'sibling' struct into our parent's 'children'.
 113         * Our children link their 'sibling' into our 'children'.
 114         */
 115        struct list_head sibling;       /* my parent's children */
 116        struct list_head children;      /* my children */
 117
 118        struct cgroup *parent;  /* my parent */
 119        struct dentry *dentry;          /* cgroup fs entry */
 120
 121        /* Private pointers for each registered subsystem */
 122        struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
 123
 124        struct cgroupfs_root *root;
 125        struct cgroup *top_cgroup;
 126
 127        /*
 128         * List of cg_cgroup_links pointing at css_sets with
 129         * tasks in this cgroup. Protected by css_set_lock
 130         */
 131        struct list_head css_sets;
 132
 133        /*
 134         * Linked list running through all cgroups that can
 135         * potentially be reaped by the release agent. Protected by
 136         * release_list_lock
 137         */
 138        struct list_head release_list;
 139
 140        /* pids_mutex protects the fields below */
 141        struct rw_semaphore pids_mutex;
 142        /* Array of process ids in the cgroup */
 143        pid_t *tasks_pids;
 144        /* How many files are using the current tasks_pids array */
 145        int pids_use_count;
 146        /* Length of the current tasks_pids array */
 147        int pids_length;
 148};
 149
 150/* A css_set is a structure holding pointers to a set of
 151 * cgroup_subsys_state objects. This saves space in the task struct
 152 * object and speeds up fork()/exit(), since a single inc/dec and a
 153 * list_add()/del() can bump the reference count on the entire
 154 * cgroup set for a task.
 155 */
 156
 157struct css_set {
 158
 159        /* Reference count */
 160        atomic_t refcount;
 161
 162        /*
 163         * List running through all cgroup groups in the same hash
 164         * slot. Protected by css_set_lock
 165         */
 166        struct hlist_node hlist;
 167
 168        /*
 169         * List running through all tasks using this cgroup
 170         * group. Protected by css_set_lock
 171         */
 172        struct list_head tasks;
 173
 174        /*
 175         * List of cg_cgroup_link objects on link chains from
 176         * cgroups referenced from this css_set. Protected by
 177         * css_set_lock
 178         */
 179        struct list_head cg_links;
 180
 181        /*
 182         * Set of subsystem states, one for each subsystem. This array
 183         * is immutable after creation apart from the init_css_set
 184         * during subsystem registration (at boot time).
 185         */
 186        struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
 187};
 188
 189/*
 190 * cgroup_map_cb is an abstract callback API for reporting map-valued
 191 * control files
 192 */
 193
 194struct cgroup_map_cb {
 195        int (*fill)(struct cgroup_map_cb *cb, const char *key, u64 value);
 196        void *state;
 197};
 198
 199/* struct cftype:
 200 *
 201 * The files in the cgroup filesystem mostly have a very simple read/write
 202 * handling, some common function will take care of it. Nevertheless some cases
 203 * (read tasks) are special and therefore I define this structure for every
 204 * kind of file.
 205 *
 206 *
 207 * When reading/writing to a file:
 208 *      - the cgroup to use is file->f_dentry->d_parent->d_fsdata
 209 *      - the 'cftype' of the file is file->f_dentry->d_fsdata
 210 */
 211
 212#define MAX_CFTYPE_NAME 64
 213struct cftype {
 214        /* By convention, the name should begin with the name of the
 215         * subsystem, followed by a period */
 216        char name[MAX_CFTYPE_NAME];
 217        int private;
 218
 219        /*
 220         * If non-zero, defines the maximum length of string that can
 221         * be passed to write_string; defaults to 64
 222         */
 223        size_t max_write_len;
 224
 225        int (*open)(struct inode *inode, struct file *file);
 226        ssize_t (*read)(struct cgroup *cgrp, struct cftype *cft,
 227                        struct file *file,
 228                        char __user *buf, size_t nbytes, loff_t *ppos);
 229        /*
 230         * read_u64() is a shortcut for the common case of returning a
 231         * single integer. Use it in place of read()
 232         */
 233        u64 (*read_u64)(struct cgroup *cgrp, struct cftype *cft);
 234        /*
 235         * read_s64() is a signed version of read_u64()
 236         */
 237        s64 (*read_s64)(struct cgroup *cgrp, struct cftype *cft);
 238        /*
 239         * read_map() is used for defining a map of key/value
 240         * pairs. It should call cb->fill(cb, key, value) for each
 241         * entry. The key/value pairs (and their ordering) should not
 242         * change between reboots.
 243         */
 244        int (*read_map)(struct cgroup *cont, struct cftype *cft,
 245                        struct cgroup_map_cb *cb);
 246        /*
 247         * read_seq_string() is used for outputting a simple sequence
 248         * using seqfile.
 249         */
 250        int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
 251                               struct seq_file *m);
 252
 253        ssize_t (*write)(struct cgroup *cgrp, struct cftype *cft,
 254                         struct file *file,
 255                         const char __user *buf, size_t nbytes, loff_t *ppos);
 256
 257        /*
 258         * write_u64() is a shortcut for the common case of accepting
 259         * a single integer (as parsed by simple_strtoull) from
 260         * userspace. Use in place of write(); return 0 or error.
 261         */
 262        int (*write_u64)(struct cgroup *cgrp, struct cftype *cft, u64 val);
 263        /*
 264         * write_s64() is a signed version of write_u64()
 265         */
 266        int (*write_s64)(struct cgroup *cgrp, struct cftype *cft, s64 val);
 267
 268        /*
 269         * write_string() is passed a nul-terminated kernelspace
 270         * buffer of maximum length determined by max_write_len.
 271         * Returns 0 or -ve error code.
 272         */
 273        int (*write_string)(struct cgroup *cgrp, struct cftype *cft,
 274                            const char *buffer);
 275        /*
 276         * trigger() callback can be used to get some kick from the
 277         * userspace, when the actual string written is not important
 278         * at all. The private field can be used to determine the
 279         * kick type for multiplexing.
 280         */
 281        int (*trigger)(struct cgroup *cgrp, unsigned int event);
 282
 283        int (*release)(struct inode *inode, struct file *file);
 284};
 285
 286struct cgroup_scanner {
 287        struct cgroup *cg;
 288        int (*test_task)(struct task_struct *p, struct cgroup_scanner *scan);
 289        void (*process_task)(struct task_struct *p,
 290                        struct cgroup_scanner *scan);
 291        struct ptr_heap *heap;
 292};
 293
 294/* Add a new file to the given cgroup directory. Should only be
 295 * called by subsystems from within a populate() method */
 296int cgroup_add_file(struct cgroup *cgrp, struct cgroup_subsys *subsys,
 297                       const struct cftype *cft);
 298
 299/* Add a set of new files to the given cgroup directory. Should
 300 * only be called by subsystems from within a populate() method */
 301int cgroup_add_files(struct cgroup *cgrp,
 302                        struct cgroup_subsys *subsys,
 303                        const struct cftype cft[],
 304                        int count);
 305
 306int cgroup_is_removed(const struct cgroup *cgrp);
 307
 308int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
 309
 310int cgroup_task_count(const struct cgroup *cgrp);
 311
 312/* Return true if the cgroup is a descendant of the current cgroup */
 313int cgroup_is_descendant(const struct cgroup *cgrp);
 314
 315/* Control Group subsystem type. See Documentation/cgroups.txt for details */
 316
 317struct cgroup_subsys {
 318        struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
 319                                                  struct cgroup *cgrp);
 320        void (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
 321        void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
 322        int (*can_attach)(struct cgroup_subsys *ss,
 323                          struct cgroup *cgrp, struct task_struct *tsk);
 324        void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
 325                        struct cgroup *old_cgrp, struct task_struct *tsk);
 326        void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);
 327        void (*exit)(struct cgroup_subsys *ss, struct task_struct *task);
 328        int (*populate)(struct cgroup_subsys *ss,
 329                        struct cgroup *cgrp);
 330        void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
 331        void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
 332        /*
 333         * This routine is called with the task_lock of mm->owner held
 334         */
 335        void (*mm_owner_changed)(struct cgroup_subsys *ss,
 336                                        struct cgroup *old,
 337                                        struct cgroup *new,
 338                                        struct task_struct *p);
 339        int subsys_id;
 340        int active;
 341        int disabled;
 342        int early_init;
 343#define MAX_CGROUP_TYPE_NAMELEN 32
 344        const char *name;
 345
 346        /* Protected by RCU */
 347        struct cgroupfs_root *root;
 348
 349        struct list_head sibling;
 350};
 351
 352#define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
 353#include <linux/cgroup_subsys.h>
 354#undef SUBSYS
 355
 356static inline struct cgroup_subsys_state *cgroup_subsys_state(
 357        struct cgroup *cgrp, int subsys_id)
 358{
 359        return cgrp->subsys[subsys_id];
 360}
 361
 362static inline struct cgroup_subsys_state *task_subsys_state(
 363        struct task_struct *task, int subsys_id)
 364{
 365        return rcu_dereference(task->cgroups->subsys[subsys_id]);
 366}
 367
 368static inline struct cgroup* task_cgroup(struct task_struct *task,
 369                                               int subsys_id)
 370{
 371        return task_subsys_state(task, subsys_id)->cgroup;
 372}
 373
 374int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *ss,
 375                                                        char *nodename);
 376
 377/* A cgroup_iter should be treated as an opaque object */
 378struct cgroup_iter {
 379        struct list_head *cg_link;
 380        struct list_head *task;
 381};
 382
 383/* To iterate across the tasks in a cgroup:
 384 *
 385 * 1) call cgroup_iter_start to intialize an iterator
 386 *
 387 * 2) call cgroup_iter_next() to retrieve member tasks until it
 388 *    returns NULL or until you want to end the iteration
 389 *
 390 * 3) call cgroup_iter_end() to destroy the iterator.
 391 *
 392 * Or, call cgroup_scan_tasks() to iterate through every task in a cpuset.
 393 *    - cgroup_scan_tasks() holds the css_set_lock when calling the test_task()
 394 *      callback, but not while calling the process_task() callback.
 395 */
 396void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it);
 397struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
 398                                        struct cgroup_iter *it);
 399void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it);
 400int cgroup_scan_tasks(struct cgroup_scanner *scan);
 401int cgroup_attach_task(struct cgroup *, struct task_struct *);
 402
 403void cgroup_mm_owner_callbacks(struct task_struct *old,
 404                               struct task_struct *new);
 405
 406#else /* !CONFIG_CGROUPS */
 407
 408static inline int cgroup_init_early(void) { return 0; }
 409static inline int cgroup_init(void) { return 0; }
 410static inline void cgroup_fork(struct task_struct *p) {}
 411static inline void cgroup_fork_callbacks(struct task_struct *p) {}
 412static inline void cgroup_post_fork(struct task_struct *p) {}
 413static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
 414
 415static inline void cgroup_lock(void) {}
 416static inline void cgroup_unlock(void) {}
 417static inline int cgroupstats_build(struct cgroupstats *stats,
 418                                        struct dentry *dentry)
 419{
 420        return -EINVAL;
 421}
 422
 423static inline void cgroup_mm_owner_callbacks(struct task_struct *old,
 424                                             struct task_struct *new) {}
 425
 426#endif /* !CONFIG_CGROUPS */
 427
 428#endif /* _LINUX_CGROUP_H */
 429
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.