mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Tejun Heo](/assets/img/avatar_default.png)
The debug controller, as its name suggests, exposes cgroup core internals to userland to aid debugging. Unfortunately, except for the name, there's no provision to prevent its usage in production configurations and the controller is widely enabled and mounted leaking internal details to userland. Like most other debug information, the information exposed by debug isn't interesting even for debugging itself once the related parts are working reliably. This controller has no reason for existing. This patch implements cgrp_dfl_root_inhibit_ss_mask which can suppress specific subsystems on the default hierarchy and adds the debug subsystem to it so that it can be gradually deprecated as usages move towards the unified hierarchy. Signed-off-by: Tejun Heo <tj@kernel.org>
944 lines
29 KiB
C
944 lines
29 KiB
C
#ifndef _LINUX_CGROUP_H
|
|
#define _LINUX_CGROUP_H
|
|
/*
|
|
* cgroup interface
|
|
*
|
|
* Copyright (C) 2003 BULL SA
|
|
* Copyright (C) 2004-2006 Silicon Graphics, Inc.
|
|
*
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/cpumask.h>
|
|
#include <linux/nodemask.h>
|
|
#include <linux/rcupdate.h>
|
|
#include <linux/rculist.h>
|
|
#include <linux/cgroupstats.h>
|
|
#include <linux/rwsem.h>
|
|
#include <linux/idr.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/percpu-refcount.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/kernfs.h>
|
|
#include <linux/wait.h>
|
|
|
|
#ifdef CONFIG_CGROUPS
|
|
|
|
struct cgroup_root;
|
|
struct cgroup_subsys;
|
|
struct inode;
|
|
struct cgroup;
|
|
|
|
extern int cgroup_init_early(void);
|
|
extern int cgroup_init(void);
|
|
extern void cgroup_fork(struct task_struct *p);
|
|
extern void cgroup_post_fork(struct task_struct *p);
|
|
extern void cgroup_exit(struct task_struct *p);
|
|
extern int cgroupstats_build(struct cgroupstats *stats,
|
|
struct dentry *dentry);
|
|
|
|
extern int proc_cgroup_show(struct seq_file *, void *);
|
|
|
|
/* define the enumeration of all cgroup subsystems */
|
|
#define SUBSYS(_x) _x ## _cgrp_id,
|
|
enum cgroup_subsys_id {
|
|
#include <linux/cgroup_subsys.h>
|
|
CGROUP_SUBSYS_COUNT,
|
|
};
|
|
#undef SUBSYS
|
|
|
|
/*
|
|
* Per-subsystem/per-cgroup state maintained by the system. This is the
|
|
* fundamental structural building block that controllers deal with.
|
|
*
|
|
* Fields marked with "PI:" are public and immutable and may be accessed
|
|
* directly without synchronization.
|
|
*/
|
|
struct cgroup_subsys_state {
|
|
/* PI: the cgroup that this css is attached to */
|
|
struct cgroup *cgroup;
|
|
|
|
/* PI: the cgroup subsystem that this css is attached to */
|
|
struct cgroup_subsys *ss;
|
|
|
|
/* reference count - access via css_[try]get() and css_put() */
|
|
struct percpu_ref refcnt;
|
|
|
|
/* PI: the parent css */
|
|
struct cgroup_subsys_state *parent;
|
|
|
|
/* siblings list anchored at the parent's ->children */
|
|
struct list_head sibling;
|
|
struct list_head children;
|
|
|
|
/*
|
|
* PI: Subsys-unique ID. 0 is unused and root is always 1. The
|
|
* matching css can be looked up using css_from_id().
|
|
*/
|
|
int id;
|
|
|
|
unsigned int flags;
|
|
|
|
/*
|
|
* Monotonically increasing unique serial number which defines a
|
|
* uniform order among all csses. It's guaranteed that all
|
|
* ->children lists are in the ascending order of ->serial_nr and
|
|
* used to allow interrupting and resuming iterations.
|
|
*/
|
|
u64 serial_nr;
|
|
|
|
/* percpu_ref killing and RCU release */
|
|
struct rcu_head rcu_head;
|
|
struct work_struct destroy_work;
|
|
};
|
|
|
|
/* bits in struct cgroup_subsys_state flags field */
|
|
enum {
|
|
CSS_NO_REF = (1 << 0), /* no reference counting for this css */
|
|
CSS_ONLINE = (1 << 1), /* between ->css_online() and ->css_offline() */
|
|
CSS_RELEASED = (1 << 2), /* refcnt reached zero, released */
|
|
};
|
|
|
|
/**
|
|
* css_get - obtain a reference on the specified css
|
|
* @css: target css
|
|
*
|
|
* The caller must already have a reference.
|
|
*/
|
|
static inline void css_get(struct cgroup_subsys_state *css)
|
|
{
|
|
if (!(css->flags & CSS_NO_REF))
|
|
percpu_ref_get(&css->refcnt);
|
|
}
|
|
|
|
/**
|
|
* css_tryget - try to obtain a reference on the specified css
|
|
* @css: target css
|
|
*
|
|
* Obtain a reference on @css unless it already has reached zero and is
|
|
* being released. This function doesn't care whether @css is on or
|
|
* offline. The caller naturally needs to ensure that @css is accessible
|
|
* but doesn't have to be holding a reference on it - IOW, RCU protected
|
|
* access is good enough for this function. Returns %true if a reference
|
|
* count was successfully obtained; %false otherwise.
|
|
*/
|
|
static inline bool css_tryget(struct cgroup_subsys_state *css)
|
|
{
|
|
if (!(css->flags & CSS_NO_REF))
|
|
return percpu_ref_tryget(&css->refcnt);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* css_tryget_online - try to obtain a reference on the specified css if online
|
|
* @css: target css
|
|
*
|
|
* Obtain a reference on @css if it's online. The caller naturally needs
|
|
* to ensure that @css is accessible but doesn't have to be holding a
|
|
* reference on it - IOW, RCU protected access is good enough for this
|
|
* function. Returns %true if a reference count was successfully obtained;
|
|
* %false otherwise.
|
|
*/
|
|
static inline bool css_tryget_online(struct cgroup_subsys_state *css)
|
|
{
|
|
if (!(css->flags & CSS_NO_REF))
|
|
return percpu_ref_tryget_live(&css->refcnt);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* css_put - put a css reference
|
|
* @css: target css
|
|
*
|
|
* Put a reference obtained via css_get() and css_tryget_online().
|
|
*/
|
|
static inline void css_put(struct cgroup_subsys_state *css)
|
|
{
|
|
if (!(css->flags & CSS_NO_REF))
|
|
percpu_ref_put(&css->refcnt);
|
|
}
|
|
|
|
/* bits in struct cgroup flags field */
|
|
enum {
|
|
/*
|
|
* Control Group has previously had a child cgroup or a task,
|
|
* but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
|
|
*/
|
|
CGRP_RELEASABLE,
|
|
/* Control Group requires release notifications to userspace */
|
|
CGRP_NOTIFY_ON_RELEASE,
|
|
/*
|
|
* Clone the parent's configuration when creating a new child
|
|
* cpuset cgroup. For historical reasons, this option can be
|
|
* specified at mount time and thus is implemented here.
|
|
*/
|
|
CGRP_CPUSET_CLONE_CHILDREN,
|
|
};
|
|
|
|
struct cgroup {
|
|
/* self css with NULL ->ss, points back to this cgroup */
|
|
struct cgroup_subsys_state self;
|
|
|
|
unsigned long flags; /* "unsigned long" so bitops work */
|
|
|
|
/*
|
|
* idr allocated in-hierarchy ID.
|
|
*
|
|
* ID 0 is not used, the ID of the root cgroup is always 1, and a
|
|
* new cgroup will be assigned with a smallest available ID.
|
|
*
|
|
* Allocating/Removing ID must be protected by cgroup_mutex.
|
|
*/
|
|
int id;
|
|
|
|
/*
|
|
* If this cgroup contains any tasks, it contributes one to
|
|
* populated_cnt. All children with non-zero popuplated_cnt of
|
|
* their own contribute one. The count is zero iff there's no task
|
|
* in this cgroup or its subtree.
|
|
*/
|
|
int populated_cnt;
|
|
|
|
struct kernfs_node *kn; /* cgroup kernfs entry */
|
|
struct kernfs_node *populated_kn; /* kn for "cgroup.subtree_populated" */
|
|
|
|
/* the bitmask of subsystems enabled on the child cgroups */
|
|
unsigned int child_subsys_mask;
|
|
|
|
/* Private pointers for each registered subsystem */
|
|
struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
|
|
|
|
struct cgroup_root *root;
|
|
|
|
/*
|
|
* List of cgrp_cset_links pointing at css_sets with tasks in this
|
|
* cgroup. Protected by css_set_lock.
|
|
*/
|
|
struct list_head cset_links;
|
|
|
|
/*
|
|
* On the default hierarchy, a css_set for a cgroup with some
|
|
* susbsys disabled will point to css's which are associated with
|
|
* the closest ancestor which has the subsys enabled. The
|
|
* following lists all css_sets which point to this cgroup's css
|
|
* for the given subsystem.
|
|
*/
|
|
struct list_head e_csets[CGROUP_SUBSYS_COUNT];
|
|
|
|
/*
|
|
* Linked list running through all cgroups that can
|
|
* potentially be reaped by the release agent. Protected by
|
|
* release_list_lock
|
|
*/
|
|
struct list_head release_list;
|
|
|
|
/*
|
|
* list of pidlists, up to two for each namespace (one for procs, one
|
|
* for tasks); created on demand.
|
|
*/
|
|
struct list_head pidlists;
|
|
struct mutex pidlist_mutex;
|
|
|
|
/* used to wait for offlining of csses */
|
|
wait_queue_head_t offline_waitq;
|
|
};
|
|
|
|
#define MAX_CGROUP_ROOT_NAMELEN 64
|
|
|
|
/* cgroup_root->flags */
|
|
enum {
|
|
/*
|
|
* Unfortunately, cgroup core and various controllers are riddled
|
|
* with idiosyncrasies and pointless options. The following flag,
|
|
* when set, will force sane behavior - some options are forced on,
|
|
* others are disallowed, and some controllers will change their
|
|
* hierarchical or other behaviors.
|
|
*
|
|
* The set of behaviors affected by this flag are still being
|
|
* determined and developed and the mount option for this flag is
|
|
* prefixed with __DEVEL__. The prefix will be dropped once we
|
|
* reach the point where all behaviors are compatible with the
|
|
* planned unified hierarchy, which will automatically turn on this
|
|
* flag.
|
|
*
|
|
* The followings are the behaviors currently affected this flag.
|
|
*
|
|
* - Mount options "noprefix", "xattr", "clone_children",
|
|
* "release_agent" and "name" are disallowed.
|
|
*
|
|
* - When mounting an existing superblock, mount options should
|
|
* match.
|
|
*
|
|
* - Remount is disallowed.
|
|
*
|
|
* - rename(2) is disallowed.
|
|
*
|
|
* - "tasks" is removed. Everything should be at process
|
|
* granularity. Use "cgroup.procs" instead.
|
|
*
|
|
* - "cgroup.procs" is not sorted. pids will be unique unless they
|
|
* got recycled inbetween reads.
|
|
*
|
|
* - "release_agent" and "notify_on_release" are removed.
|
|
* Replacement notification mechanism will be implemented.
|
|
*
|
|
* - "cgroup.clone_children" is removed.
|
|
*
|
|
* - "cgroup.subtree_populated" is available. Its value is 0 if
|
|
* the cgroup and its descendants contain no task; otherwise, 1.
|
|
* The file also generates kernfs notification which can be
|
|
* monitored through poll and [di]notify when the value of the
|
|
* file changes.
|
|
*
|
|
* - If mount is requested with sane_behavior but without any
|
|
* subsystem, the default unified hierarchy is mounted.
|
|
*
|
|
* - cpuset: tasks will be kept in empty cpusets when hotplug happens
|
|
* and take masks of ancestors with non-empty cpus/mems, instead of
|
|
* being moved to an ancestor.
|
|
*
|
|
* - cpuset: a task can be moved into an empty cpuset, and again it
|
|
* takes masks of ancestors.
|
|
*
|
|
* - memcg: use_hierarchy is on by default and the cgroup file for
|
|
* the flag is not created.
|
|
*
|
|
* - blkcg: blk-throttle becomes properly hierarchical.
|
|
*
|
|
* - debug: disallowed on the default hierarchy.
|
|
*/
|
|
CGRP_ROOT_SANE_BEHAVIOR = (1 << 0),
|
|
|
|
CGRP_ROOT_NOPREFIX = (1 << 1), /* mounted subsystems have no named prefix */
|
|
CGRP_ROOT_XATTR = (1 << 2), /* supports extended attributes */
|
|
|
|
/* mount options live below bit 16 */
|
|
CGRP_ROOT_OPTION_MASK = (1 << 16) - 1,
|
|
};
|
|
|
|
/*
|
|
* A cgroup_root represents the root of a cgroup hierarchy, and may be
|
|
* associated with a kernfs_root to form an active hierarchy. This is
|
|
* internal to cgroup core. Don't access directly from controllers.
|
|
*/
|
|
struct cgroup_root {
|
|
struct kernfs_root *kf_root;
|
|
|
|
/* The bitmask of subsystems attached to this hierarchy */
|
|
unsigned int subsys_mask;
|
|
|
|
/* Unique id for this hierarchy. */
|
|
int hierarchy_id;
|
|
|
|
/* The root cgroup. Root is destroyed on its release. */
|
|
struct cgroup cgrp;
|
|
|
|
/* Number of cgroups in the hierarchy, used only for /proc/cgroups */
|
|
atomic_t nr_cgrps;
|
|
|
|
/* A list running through the active hierarchies */
|
|
struct list_head root_list;
|
|
|
|
/* Hierarchy-specific flags */
|
|
unsigned int flags;
|
|
|
|
/* IDs for cgroups in this hierarchy */
|
|
struct idr cgroup_idr;
|
|
|
|
/* The path to use for release notifications. */
|
|
char release_agent_path[PATH_MAX];
|
|
|
|
/* The name for this hierarchy - may be empty */
|
|
char name[MAX_CGROUP_ROOT_NAMELEN];
|
|
};
|
|
|
|
/*
|
|
* A css_set is a structure holding pointers to a set of
|
|
* cgroup_subsys_state objects. This saves space in the task struct
|
|
* object and speeds up fork()/exit(), since a single inc/dec and a
|
|
* list_add()/del() can bump the reference count on the entire cgroup
|
|
* set for a task.
|
|
*/
|
|
|
|
struct css_set {
|
|
|
|
/* Reference count */
|
|
atomic_t refcount;
|
|
|
|
/*
|
|
* List running through all cgroup groups in the same hash
|
|
* slot. Protected by css_set_lock
|
|
*/
|
|
struct hlist_node hlist;
|
|
|
|
/*
|
|
* Lists running through all tasks using this cgroup group.
|
|
* mg_tasks lists tasks which belong to this cset but are in the
|
|
* process of being migrated out or in. Protected by
|
|
* css_set_rwsem, but, during migration, once tasks are moved to
|
|
* mg_tasks, it can be read safely while holding cgroup_mutex.
|
|
*/
|
|
struct list_head tasks;
|
|
struct list_head mg_tasks;
|
|
|
|
/*
|
|
* List of cgrp_cset_links pointing at cgroups referenced from this
|
|
* css_set. Protected by css_set_lock.
|
|
*/
|
|
struct list_head cgrp_links;
|
|
|
|
/* the default cgroup associated with this css_set */
|
|
struct cgroup *dfl_cgrp;
|
|
|
|
/*
|
|
* Set of subsystem states, one for each subsystem. This array is
|
|
* immutable after creation apart from the init_css_set during
|
|
* subsystem registration (at boot time).
|
|
*/
|
|
struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
|
|
|
|
/*
|
|
* List of csets participating in the on-going migration either as
|
|
* source or destination. Protected by cgroup_mutex.
|
|
*/
|
|
struct list_head mg_preload_node;
|
|
struct list_head mg_node;
|
|
|
|
/*
|
|
* If this cset is acting as the source of migration the following
|
|
* two fields are set. mg_src_cgrp is the source cgroup of the
|
|
* on-going migration and mg_dst_cset is the destination cset the
|
|
* target tasks on this cset should be migrated to. Protected by
|
|
* cgroup_mutex.
|
|
*/
|
|
struct cgroup *mg_src_cgrp;
|
|
struct css_set *mg_dst_cset;
|
|
|
|
/*
|
|
* On the default hierarhcy, ->subsys[ssid] may point to a css
|
|
* attached to an ancestor instead of the cgroup this css_set is
|
|
* associated with. The following node is anchored at
|
|
* ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to
|
|
* iterate through all css's attached to a given cgroup.
|
|
*/
|
|
struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
|
|
|
|
/* For RCU-protected deletion */
|
|
struct rcu_head rcu_head;
|
|
};
|
|
|
|
/*
|
|
* struct cftype: handler definitions for cgroup control files
|
|
*
|
|
* When reading/writing to a file:
|
|
* - the cgroup to use is file->f_dentry->d_parent->d_fsdata
|
|
* - the 'cftype' of the file is file->f_dentry->d_fsdata
|
|
*/
|
|
|
|
/* cftype->flags */
|
|
enum {
|
|
CFTYPE_ONLY_ON_ROOT = (1 << 0), /* only create on root cgrp */
|
|
CFTYPE_NOT_ON_ROOT = (1 << 1), /* don't create on root cgrp */
|
|
CFTYPE_INSANE = (1 << 2), /* don't create if sane_behavior */
|
|
CFTYPE_NO_PREFIX = (1 << 3), /* (DON'T USE FOR NEW FILES) no subsys prefix */
|
|
CFTYPE_ONLY_ON_DFL = (1 << 4), /* only on default hierarchy */
|
|
};
|
|
|
|
#define MAX_CFTYPE_NAME 64
|
|
|
|
struct cftype {
|
|
/*
|
|
* By convention, the name should begin with the name of the
|
|
* subsystem, followed by a period. Zero length string indicates
|
|
* end of cftype array.
|
|
*/
|
|
char name[MAX_CFTYPE_NAME];
|
|
int private;
|
|
/*
|
|
* If not 0, file mode is set to this value, otherwise it will
|
|
* be figured out automatically
|
|
*/
|
|
umode_t mode;
|
|
|
|
/*
|
|
* The maximum length of string, excluding trailing nul, that can
|
|
* be passed to write. If < PAGE_SIZE-1, PAGE_SIZE-1 is assumed.
|
|
*/
|
|
size_t max_write_len;
|
|
|
|
/* CFTYPE_* flags */
|
|
unsigned int flags;
|
|
|
|
/*
|
|
* Fields used for internal bookkeeping. Initialized automatically
|
|
* during registration.
|
|
*/
|
|
struct cgroup_subsys *ss; /* NULL for cgroup core files */
|
|
struct list_head node; /* anchored at ss->cfts */
|
|
struct kernfs_ops *kf_ops;
|
|
|
|
/*
|
|
* read_u64() is a shortcut for the common case of returning a
|
|
* single integer. Use it in place of read()
|
|
*/
|
|
u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
|
|
/*
|
|
* read_s64() is a signed version of read_u64()
|
|
*/
|
|
s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
|
|
|
|
/* generic seq_file read interface */
|
|
int (*seq_show)(struct seq_file *sf, void *v);
|
|
|
|
/* optional ops, implement all or none */
|
|
void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
|
|
void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
|
|
void (*seq_stop)(struct seq_file *sf, void *v);
|
|
|
|
/*
|
|
* write_u64() is a shortcut for the common case of accepting
|
|
* a single integer (as parsed by simple_strtoull) from
|
|
* userspace. Use in place of write(); return 0 or error.
|
|
*/
|
|
int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
|
|
u64 val);
|
|
/*
|
|
* write_s64() is a signed version of write_u64()
|
|
*/
|
|
int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
|
|
s64 val);
|
|
|
|
/*
|
|
* write() is the generic write callback which maps directly to
|
|
* kernfs write operation and overrides all other operations.
|
|
* Maximum write size is determined by ->max_write_len. Use
|
|
* of_css/cft() to access the associated css and cft.
|
|
*/
|
|
ssize_t (*write)(struct kernfs_open_file *of,
|
|
char *buf, size_t nbytes, loff_t off);
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
struct lock_class_key lockdep_key;
|
|
#endif
|
|
};
|
|
|
|
extern struct cgroup_root cgrp_dfl_root;
|
|
extern struct css_set init_css_set;
|
|
|
|
static inline bool cgroup_on_dfl(const struct cgroup *cgrp)
|
|
{
|
|
return cgrp->root == &cgrp_dfl_root;
|
|
}
|
|
|
|
/*
|
|
* See the comment above CGRP_ROOT_SANE_BEHAVIOR for details. This
|
|
* function can be called as long as @cgrp is accessible.
|
|
*/
|
|
static inline bool cgroup_sane_behavior(const struct cgroup *cgrp)
|
|
{
|
|
return cgrp->root->flags & CGRP_ROOT_SANE_BEHAVIOR;
|
|
}
|
|
|
|
/* no synchronization, the result can only be used as a hint */
|
|
static inline bool cgroup_has_tasks(struct cgroup *cgrp)
|
|
{
|
|
return !list_empty(&cgrp->cset_links);
|
|
}
|
|
|
|
/* returns ino associated with a cgroup, 0 indicates unmounted root */
|
|
static inline ino_t cgroup_ino(struct cgroup *cgrp)
|
|
{
|
|
if (cgrp->kn)
|
|
return cgrp->kn->ino;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/* cft/css accessors for cftype->write() operation */
|
|
static inline struct cftype *of_cft(struct kernfs_open_file *of)
|
|
{
|
|
return of->kn->priv;
|
|
}
|
|
|
|
struct cgroup_subsys_state *of_css(struct kernfs_open_file *of);
|
|
|
|
/* cft/css accessors for cftype->seq_*() operations */
|
|
static inline struct cftype *seq_cft(struct seq_file *seq)
|
|
{
|
|
return of_cft(seq->private);
|
|
}
|
|
|
|
static inline struct cgroup_subsys_state *seq_css(struct seq_file *seq)
|
|
{
|
|
return of_css(seq->private);
|
|
}
|
|
|
|
/*
|
|
* Name / path handling functions. All are thin wrappers around the kernfs
|
|
* counterparts and can be called under any context.
|
|
*/
|
|
|
|
static inline int cgroup_name(struct cgroup *cgrp, char *buf, size_t buflen)
|
|
{
|
|
return kernfs_name(cgrp->kn, buf, buflen);
|
|
}
|
|
|
|
static inline char * __must_check cgroup_path(struct cgroup *cgrp, char *buf,
|
|
size_t buflen)
|
|
{
|
|
return kernfs_path(cgrp->kn, buf, buflen);
|
|
}
|
|
|
|
static inline void pr_cont_cgroup_name(struct cgroup *cgrp)
|
|
{
|
|
pr_cont_kernfs_name(cgrp->kn);
|
|
}
|
|
|
|
static inline void pr_cont_cgroup_path(struct cgroup *cgrp)
|
|
{
|
|
pr_cont_kernfs_path(cgrp->kn);
|
|
}
|
|
|
|
char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
|
|
|
|
int cgroup_add_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
|
|
int cgroup_rm_cftypes(struct cftype *cfts);
|
|
|
|
bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
|
|
|
|
/*
|
|
* Control Group taskset, used to pass around set of tasks to cgroup_subsys
|
|
* methods.
|
|
*/
|
|
struct cgroup_taskset;
|
|
struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
|
|
struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
|
|
|
|
/**
|
|
* cgroup_taskset_for_each - iterate cgroup_taskset
|
|
* @task: the loop cursor
|
|
* @tset: taskset to iterate
|
|
*/
|
|
#define cgroup_taskset_for_each(task, tset) \
|
|
for ((task) = cgroup_taskset_first((tset)); (task); \
|
|
(task) = cgroup_taskset_next((tset)))
|
|
|
|
/*
|
|
* Control Group subsystem type.
|
|
* See Documentation/cgroups/cgroups.txt for details
|
|
*/
|
|
|
|
struct cgroup_subsys {
|
|
struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
|
|
int (*css_online)(struct cgroup_subsys_state *css);
|
|
void (*css_offline)(struct cgroup_subsys_state *css);
|
|
void (*css_free)(struct cgroup_subsys_state *css);
|
|
|
|
int (*can_attach)(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset);
|
|
void (*cancel_attach)(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset);
|
|
void (*attach)(struct cgroup_subsys_state *css,
|
|
struct cgroup_taskset *tset);
|
|
void (*fork)(struct task_struct *task);
|
|
void (*exit)(struct cgroup_subsys_state *css,
|
|
struct cgroup_subsys_state *old_css,
|
|
struct task_struct *task);
|
|
void (*bind)(struct cgroup_subsys_state *root_css);
|
|
|
|
int disabled;
|
|
int early_init;
|
|
|
|
/*
|
|
* If %false, this subsystem is properly hierarchical -
|
|
* configuration, resource accounting and restriction on a parent
|
|
* cgroup cover those of its children. If %true, hierarchy support
|
|
* is broken in some ways - some subsystems ignore hierarchy
|
|
* completely while others are only implemented half-way.
|
|
*
|
|
* It's now disallowed to create nested cgroups if the subsystem is
|
|
* broken and cgroup core will emit a warning message on such
|
|
* cases. Eventually, all subsystems will be made properly
|
|
* hierarchical and this will go away.
|
|
*/
|
|
bool broken_hierarchy;
|
|
bool warned_broken_hierarchy;
|
|
|
|
/* the following two fields are initialized automtically during boot */
|
|
int id;
|
|
#define MAX_CGROUP_TYPE_NAMELEN 32
|
|
const char *name;
|
|
|
|
/* link to parent, protected by cgroup_lock() */
|
|
struct cgroup_root *root;
|
|
|
|
/* idr for css->id */
|
|
struct idr css_idr;
|
|
|
|
/*
|
|
* List of cftypes. Each entry is the first entry of an array
|
|
* terminated by zero length name.
|
|
*/
|
|
struct list_head cfts;
|
|
|
|
/* base cftypes, automatically registered with subsys itself */
|
|
struct cftype *base_cftypes;
|
|
};
|
|
|
|
#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
|
|
#include <linux/cgroup_subsys.h>
|
|
#undef SUBSYS
|
|
|
|
/**
|
|
* task_css_set_check - obtain a task's css_set with extra access conditions
|
|
* @task: the task to obtain css_set for
|
|
* @__c: extra condition expression to be passed to rcu_dereference_check()
|
|
*
|
|
* A task's css_set is RCU protected, initialized and exited while holding
|
|
* task_lock(), and can only be modified while holding both cgroup_mutex
|
|
* and task_lock() while the task is alive. This macro verifies that the
|
|
* caller is inside proper critical section and returns @task's css_set.
|
|
*
|
|
* The caller can also specify additional allowed conditions via @__c, such
|
|
* as locks used during the cgroup_subsys::attach() methods.
|
|
*/
|
|
#ifdef CONFIG_PROVE_RCU
|
|
extern struct mutex cgroup_mutex;
|
|
extern struct rw_semaphore css_set_rwsem;
|
|
#define task_css_set_check(task, __c) \
|
|
rcu_dereference_check((task)->cgroups, \
|
|
lockdep_is_held(&cgroup_mutex) || \
|
|
lockdep_is_held(&css_set_rwsem) || \
|
|
((task)->flags & PF_EXITING) || (__c))
|
|
#else
|
|
#define task_css_set_check(task, __c) \
|
|
rcu_dereference((task)->cgroups)
|
|
#endif
|
|
|
|
/**
|
|
* task_css_check - obtain css for (task, subsys) w/ extra access conds
|
|
* @task: the target task
|
|
* @subsys_id: the target subsystem ID
|
|
* @__c: extra condition expression to be passed to rcu_dereference_check()
|
|
*
|
|
* Return the cgroup_subsys_state for the (@task, @subsys_id) pair. The
|
|
* synchronization rules are the same as task_css_set_check().
|
|
*/
|
|
#define task_css_check(task, subsys_id, __c) \
|
|
task_css_set_check((task), (__c))->subsys[(subsys_id)]
|
|
|
|
/**
|
|
* task_css_set - obtain a task's css_set
|
|
* @task: the task to obtain css_set for
|
|
*
|
|
* See task_css_set_check().
|
|
*/
|
|
static inline struct css_set *task_css_set(struct task_struct *task)
|
|
{
|
|
return task_css_set_check(task, false);
|
|
}
|
|
|
|
/**
|
|
* task_css - obtain css for (task, subsys)
|
|
* @task: the target task
|
|
* @subsys_id: the target subsystem ID
|
|
*
|
|
* See task_css_check().
|
|
*/
|
|
static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
|
|
int subsys_id)
|
|
{
|
|
return task_css_check(task, subsys_id, false);
|
|
}
|
|
|
|
/**
|
|
* task_css_is_root - test whether a task belongs to the root css
|
|
* @task: the target task
|
|
* @subsys_id: the target subsystem ID
|
|
*
|
|
* Test whether @task belongs to the root css on the specified subsystem.
|
|
* May be invoked in any context.
|
|
*/
|
|
static inline bool task_css_is_root(struct task_struct *task, int subsys_id)
|
|
{
|
|
return task_css_check(task, subsys_id, true) ==
|
|
init_css_set.subsys[subsys_id];
|
|
}
|
|
|
|
static inline struct cgroup *task_cgroup(struct task_struct *task,
|
|
int subsys_id)
|
|
{
|
|
return task_css(task, subsys_id)->cgroup;
|
|
}
|
|
|
|
struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
|
|
struct cgroup_subsys_state *parent);
|
|
|
|
struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
|
|
|
|
/**
|
|
* css_for_each_child - iterate through children of a css
|
|
* @pos: the css * to use as the loop cursor
|
|
* @parent: css whose children to walk
|
|
*
|
|
* Walk @parent's children. Must be called under rcu_read_lock().
|
|
*
|
|
* If a subsystem synchronizes ->css_online() and the start of iteration, a
|
|
* css which finished ->css_online() is guaranteed to be visible in the
|
|
* future iterations and will stay visible until the last reference is put.
|
|
* A css which hasn't finished ->css_online() or already finished
|
|
* ->css_offline() may show up during traversal. It's each subsystem's
|
|
* responsibility to synchronize against on/offlining.
|
|
*
|
|
* It is allowed to temporarily drop RCU read lock during iteration. The
|
|
* caller is responsible for ensuring that @pos remains accessible until
|
|
* the start of the next iteration by, for example, bumping the css refcnt.
|
|
*/
|
|
#define css_for_each_child(pos, parent) \
|
|
for ((pos) = css_next_child(NULL, (parent)); (pos); \
|
|
(pos) = css_next_child((pos), (parent)))
|
|
|
|
struct cgroup_subsys_state *
|
|
css_next_descendant_pre(struct cgroup_subsys_state *pos,
|
|
struct cgroup_subsys_state *css);
|
|
|
|
struct cgroup_subsys_state *
|
|
css_rightmost_descendant(struct cgroup_subsys_state *pos);
|
|
|
|
/**
|
|
* css_for_each_descendant_pre - pre-order walk of a css's descendants
|
|
* @pos: the css * to use as the loop cursor
|
|
* @root: css whose descendants to walk
|
|
*
|
|
* Walk @root's descendants. @root is included in the iteration and the
|
|
* first node to be visited. Must be called under rcu_read_lock().
|
|
*
|
|
* If a subsystem synchronizes ->css_online() and the start of iteration, a
|
|
* css which finished ->css_online() is guaranteed to be visible in the
|
|
* future iterations and will stay visible until the last reference is put.
|
|
* A css which hasn't finished ->css_online() or already finished
|
|
* ->css_offline() may show up during traversal. It's each subsystem's
|
|
* responsibility to synchronize against on/offlining.
|
|
*
|
|
* For example, the following guarantees that a descendant can't escape
|
|
* state updates of its ancestors.
|
|
*
|
|
* my_online(@css)
|
|
* {
|
|
* Lock @css's parent and @css;
|
|
* Inherit state from the parent;
|
|
* Unlock both.
|
|
* }
|
|
*
|
|
* my_update_state(@css)
|
|
* {
|
|
* css_for_each_descendant_pre(@pos, @css) {
|
|
* Lock @pos;
|
|
* if (@pos == @css)
|
|
* Update @css's state;
|
|
* else
|
|
* Verify @pos is alive and inherit state from its parent;
|
|
* Unlock @pos;
|
|
* }
|
|
* }
|
|
*
|
|
* As long as the inheriting step, including checking the parent state, is
|
|
* enclosed inside @pos locking, double-locking the parent isn't necessary
|
|
* while inheriting. The state update to the parent is guaranteed to be
|
|
* visible by walking order and, as long as inheriting operations to the
|
|
* same @pos are atomic to each other, multiple updates racing each other
|
|
* still result in the correct state. It's guaranateed that at least one
|
|
* inheritance happens for any css after the latest update to its parent.
|
|
*
|
|
* If checking parent's state requires locking the parent, each inheriting
|
|
* iteration should lock and unlock both @pos->parent and @pos.
|
|
*
|
|
* Alternatively, a subsystem may choose to use a single global lock to
|
|
* synchronize ->css_online() and ->css_offline() against tree-walking
|
|
* operations.
|
|
*
|
|
* It is allowed to temporarily drop RCU read lock during iteration. The
|
|
* caller is responsible for ensuring that @pos remains accessible until
|
|
* the start of the next iteration by, for example, bumping the css refcnt.
|
|
*/
|
|
#define css_for_each_descendant_pre(pos, css) \
|
|
for ((pos) = css_next_descendant_pre(NULL, (css)); (pos); \
|
|
(pos) = css_next_descendant_pre((pos), (css)))
|
|
|
|
struct cgroup_subsys_state *
|
|
css_next_descendant_post(struct cgroup_subsys_state *pos,
|
|
struct cgroup_subsys_state *css);
|
|
|
|
/**
|
|
* css_for_each_descendant_post - post-order walk of a css's descendants
|
|
* @pos: the css * to use as the loop cursor
|
|
* @css: css whose descendants to walk
|
|
*
|
|
* Similar to css_for_each_descendant_pre() but performs post-order
|
|
* traversal instead. @root is included in the iteration and the last
|
|
* node to be visited.
|
|
*
|
|
* If a subsystem synchronizes ->css_online() and the start of iteration, a
|
|
* css which finished ->css_online() is guaranteed to be visible in the
|
|
* future iterations and will stay visible until the last reference is put.
|
|
* A css which hasn't finished ->css_online() or already finished
|
|
* ->css_offline() may show up during traversal. It's each subsystem's
|
|
* responsibility to synchronize against on/offlining.
|
|
*
|
|
* Note that the walk visibility guarantee example described in pre-order
|
|
* walk doesn't apply the same to post-order walks.
|
|
*/
|
|
#define css_for_each_descendant_post(pos, css) \
|
|
for ((pos) = css_next_descendant_post(NULL, (css)); (pos); \
|
|
(pos) = css_next_descendant_post((pos), (css)))
|
|
|
|
bool css_has_online_children(struct cgroup_subsys_state *css);
|
|
|
|
/* A css_task_iter should be treated as an opaque object */
|
|
struct css_task_iter {
|
|
struct cgroup_subsys *ss;
|
|
|
|
struct list_head *cset_pos;
|
|
struct list_head *cset_head;
|
|
|
|
struct list_head *task_pos;
|
|
struct list_head *tasks_head;
|
|
struct list_head *mg_tasks_head;
|
|
};
|
|
|
|
void css_task_iter_start(struct cgroup_subsys_state *css,
|
|
struct css_task_iter *it);
|
|
struct task_struct *css_task_iter_next(struct css_task_iter *it);
|
|
void css_task_iter_end(struct css_task_iter *it);
|
|
|
|
int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
|
|
int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
|
|
|
|
struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
|
|
struct cgroup_subsys *ss);
|
|
|
|
#else /* !CONFIG_CGROUPS */
|
|
|
|
static inline int cgroup_init_early(void) { return 0; }
|
|
static inline int cgroup_init(void) { return 0; }
|
|
static inline void cgroup_fork(struct task_struct *p) {}
|
|
static inline void cgroup_post_fork(struct task_struct *p) {}
|
|
static inline void cgroup_exit(struct task_struct *p) {}
|
|
|
|
static inline int cgroupstats_build(struct cgroupstats *stats,
|
|
struct dentry *dentry)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* No cgroups - nothing to do */
|
|
static inline int cgroup_attach_task_all(struct task_struct *from,
|
|
struct task_struct *t)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif /* !CONFIG_CGROUPS */
|
|
|
|
#endif /* _LINUX_CGROUP_H */
|