dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

cgroup: rename ->create/post_create/pre_destroy/destroy() to ->css_alloc/online/offline/free() 

Rename cgroup_subsys css lifetime related callbacks to better describe
what their roles are.  Also, update documentation.

Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Li Zefan <lizefan@huawei.com>
This commit is contained in:
Tejun Heo 2012-11-19 08:13:38 -08:00
parent b1929db42f
commit 92fb97487a
13 changed files with 130 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
Documentation/cgroups/cgroups.txt
View File

@ -553,16 +553,16 @@ call to cgroup_unload_subsys(). It should also set its_subsys.module =
THIS_MODULE in its .c file. THIS_MODULE in its .c file.
Each subsystem may export the following methods. The only mandatory Each subsystem may export the following methods. The only mandatory
methods are create/destroy. Any others that are null are presumed to methods are css_alloc/free. Any others that are null are presumed to
be successful no-ops. be successful no-ops.
struct cgroup_subsys_state *create(struct cgroup *cgrp) struct cgroup_subsys_state *css_alloc(struct cgroup *cgrp)
(cgroup_mutex held by caller) (cgroup_mutex held by caller)
Called to create a subsystem state object for a cgroup. The Called to allocate a subsystem state object for a cgroup. The
subsystem should allocate its subsystem state object for the passed subsystem should allocate its subsystem state object for the passed
cgroup, returning a pointer to the new object on success or a cgroup, returning a pointer to the new object on success or a
negative error code. On success, the subsystem pointer should point to ERR_PTR() value. On success, the subsystem pointer should point to
a structure of type cgroup_subsys_state (typically embedded in a a structure of type cgroup_subsys_state (typically embedded in a
larger subsystem-specific object), which will be initialized by the larger subsystem-specific object), which will be initialized by the
cgroup system. Note that this will be called at initialization to cgroup system. Note that this will be called at initialization to
@ -571,24 +571,33 @@ identified by the passed cgroup object having a NULL parent (since
it's the root of the hierarchy) and may be an appropriate place for it's the root of the hierarchy) and may be an appropriate place for
initialization code. initialization code.
void destroy(struct cgroup *cgrp) int css_online(struct cgroup *cgrp)
(cgroup_mutex held by caller) (cgroup_mutex held by caller)
The cgroup system is about to destroy the passed cgroup; the subsystem Called after @cgrp successfully completed all allocations and made
should do any necessary cleanup and free its subsystem state visible to cgroup_for_each_child/descendant_*() iterators. The
object. By the time this method is called, the cgroup has already been subsystem may choose to fail creation by returning -errno. This
unlinked from the file system and from the child list of its parent; callback can be used to implement reliable state sharing and
cgroup->parent is still valid. (Note - can also be called for a propagation along the hierarchy. See the comment on
newly-created cgroup if an error occurs after this subsystem's cgroup_for_each_descendant_pre() for details.
create() method has been called for the new cgroup).
int pre_destroy(struct cgroup *cgrp); void css_offline(struct cgroup *cgrp);
Called before checking the reference count on each subsystem. This may This is the counterpart of css_online() and called iff css_online()
be useful for subsystems which have some extra references even if has succeeded on @cgrp. This signifies the beginning of the end of
there are not tasks in the cgroup. If pre_destroy() returns error code, @cgrp. @cgrp is being removed and the subsystem should start dropping
rmdir() will fail with it. From this behavior, pre_destroy() can be all references it's holding on @cgrp. When all references are dropped,
called multiple times against a cgroup. cgroup removal will proceed to the next step - css_free(). After this
callback, @cgrp should be considered dead to the subsystem.
void css_free(struct cgroup *cgrp)
(cgroup_mutex held by caller)
The cgroup system is about to free @cgrp; the subsystem should free
its subsystem state object. By the time this method is called, @cgrp
is completely unused; @cgrp->parent is still valid. (Note - can also
be called for a newly-created cgroup if an error occurs after this
subsystem's create() method has been called for the new cgroup).
int can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset) int can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
(cgroup_mutex held by caller) (cgroup_mutex held by caller)

14
block/blk-cgroup.c
View File

@ -600,7 +600,7 @@ struct cftype blkcg_files[] = {
}; };
/** /**
* blkcg_pre_destroy - cgroup pre_destroy callback * blkcg_css_offline - cgroup css_offline callback
* @cgroup: cgroup of interest * @cgroup: cgroup of interest
* *
* This function is called when @cgroup is about to go away and responsible * This function is called when @cgroup is about to go away and responsible
@ -610,7 +610,7 @@ struct cftype blkcg_files[] = {
* *
* This is the blkcg counterpart of ioc_release_fn(). * This is the blkcg counterpart of ioc_release_fn().
*/ */
static void blkcg_pre_destroy(struct cgroup *cgroup) static void blkcg_css_offline(struct cgroup *cgroup)
{ {
struct blkcg *blkcg = cgroup_to_blkcg(cgroup); struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
@ -634,7 +634,7 @@ static void blkcg_pre_destroy(struct cgroup *cgroup)
spin_unlock_irq(&blkcg->lock); spin_unlock_irq(&blkcg->lock);
} }
static void blkcg_destroy(struct cgroup *cgroup) static void blkcg_css_free(struct cgroup *cgroup)
{ {
struct blkcg *blkcg = cgroup_to_blkcg(cgroup); struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
@ -642,7 +642,7 @@ static void blkcg_destroy(struct cgroup *cgroup)
kfree(blkcg); kfree(blkcg);
} }
static struct cgroup_subsys_state *blkcg_create(struct cgroup *cgroup) static struct cgroup_subsys_state *blkcg_css_alloc(struct cgroup *cgroup)
{ {
static atomic64_t id_seq = ATOMIC64_INIT(0); static atomic64_t id_seq = ATOMIC64_INIT(0);
struct blkcg *blkcg; struct blkcg *blkcg;
@ -739,10 +739,10 @@ static int blkcg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
struct cgroup_subsys blkio_subsys = { struct cgroup_subsys blkio_subsys = {
.name = "blkio", .name = "blkio",
.create = blkcg_create, .css_alloc = blkcg_css_alloc,
.css_offline = blkcg_css_offline,
.css_free = blkcg_css_free,
.can_attach = blkcg_can_attach, .can_attach = blkcg_can_attach,
.pre_destroy = blkcg_pre_destroy,
.destroy = blkcg_destroy,
.subsys_id = blkio_subsys_id, .subsys_id = blkio_subsys_id,
.base_cftypes = blkcg_files, .base_cftypes = blkcg_files,
.module = THIS_MODULE, .module = THIS_MODULE,

35
include/linux/cgroup.h
View File

@ -82,7 +82,7 @@ struct cgroup_subsys_state {
/* bits in struct cgroup_subsys_state flags field */ /* bits in struct cgroup_subsys_state flags field */
enum { enum {
CSS_ROOT = (1 << 0), /* this CSS is the root of the subsystem */ CSS_ROOT = (1 << 0), /* this CSS is the root of the subsystem */
CSS_ONLINE = (1 << 1), /* between ->post_create() and ->pre_destroy() */ CSS_ONLINE = (1 << 1), /* between ->css_online() and ->css_offline() */
}; };
/* Caller must verify that the css is not for root cgroup */ /* Caller must verify that the css is not for root cgroup */
@ -439,10 +439,11 @@ int cgroup_taskset_size(struct cgroup_taskset *tset);
*/ */
struct cgroup_subsys { struct cgroup_subsys {
struct cgroup_subsys_state *(*create)(struct cgroup *cgrp); struct cgroup_subsys_state *(*css_alloc)(struct cgroup *cgrp);
int (*post_create)(struct cgroup *cgrp); int (*css_online)(struct cgroup *cgrp);
void (*pre_destroy)(struct cgroup *cgrp); void (*css_offline)(struct cgroup *cgrp);
void (*destroy)(struct cgroup *cgrp); void (*css_free)(struct cgroup *cgrp);
int (*can_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset); int (*can_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
void (*cancel_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset); void (*cancel_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
void (*attach)(struct cgroup *cgrp, struct cgroup_taskset *tset); void (*attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
@ -541,13 +542,13 @@ static inline struct cgroup* task_cgroup(struct task_struct *task,
* @cgroup: cgroup whose children to walk * @cgroup: cgroup whose children to walk
* *
* Walk @cgroup's children. Must be called under rcu_read_lock(). A child * Walk @cgroup's children. Must be called under rcu_read_lock(). A child
* cgroup which hasn't finished ->post_create() or already has finished * cgroup which hasn't finished ->css_online() or already has finished
* ->pre_destroy() may show up during traversal and it's each subsystem's * ->css_offline() may show up during traversal and it's each subsystem's
* responsibility to verify that each @pos is alive. * responsibility to verify that each @pos is alive.
* *
* If a subsystem synchronizes against the parent in its ->post_create() * If a subsystem synchronizes against the parent in its ->css_online() and
* and before starting iterating, a cgroup which finished ->post_create() * before starting iterating, a cgroup which finished ->css_online() is
* is guaranteed to be visible in the future iterations. * guaranteed to be visible in the future iterations.
*/ */
#define cgroup_for_each_child(pos, cgroup) \ #define cgroup_for_each_child(pos, cgroup) \
list_for_each_entry_rcu(pos, &(cgroup)->children, sibling) list_for_each_entry_rcu(pos, &(cgroup)->children, sibling)
@ -561,19 +562,19 @@ struct cgroup *cgroup_next_descendant_pre(struct cgroup *pos,
* @cgroup: cgroup whose descendants to walk * @cgroup: cgroup whose descendants to walk
* *
* Walk @cgroup's descendants. Must be called under rcu_read_lock(). A * Walk @cgroup's descendants. Must be called under rcu_read_lock(). A
* descendant cgroup which hasn't finished ->post_create() or already has * descendant cgroup which hasn't finished ->css_online() or already has
* finished ->pre_destroy() may show up during traversal and it's each * finished ->css_offline() may show up during traversal and it's each
* subsystem's responsibility to verify that each @pos is alive. * subsystem's responsibility to verify that each @pos is alive.
* *
* If a subsystem synchronizes against the parent in its ->post_create() * If a subsystem synchronizes against the parent in its ->css_online() and
* and before starting iterating, and synchronizes against @pos on each * before starting iterating, and synchronizes against @pos on each
* iteration, any descendant cgroup which finished ->post_create() is * iteration, any descendant cgroup which finished ->css_offline() is
* guaranteed to be visible in the future iterations. * guaranteed to be visible in the future iterations.
* *
* In other words, the following guarantees that a descendant can't escape * In other words, the following guarantees that a descendant can't escape
* state updates of its ancestors. * state updates of its ancestors.
* *
* my_post_create(@cgrp) * my_online(@cgrp)
* { * {
* Lock @cgrp->parent and @cgrp; * Lock @cgrp->parent and @cgrp;
* Inherit state from @cgrp->parent; * Inherit state from @cgrp->parent;
@ -606,7 +607,7 @@ struct cgroup *cgroup_next_descendant_pre(struct cgroup *pos,
* iteration should lock and unlock both @pos->parent and @pos. * iteration should lock and unlock both @pos->parent and @pos.
* *
* Alternatively, a subsystem may choose to use a single global lock to * Alternatively, a subsystem may choose to use a single global lock to
* synchronize ->post_create() and ->pre_destroy() against tree-walking * synchronize ->css_online() and ->css_offline() against tree-walking
* operations. * operations.
*/ */
#define cgroup_for_each_descendant_pre(pos, cgroup) \ #define cgroup_for_each_descendant_pre(pos, cgroup) \

51
kernel/cgroup.c
View File

@ -876,7 +876,7 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode)
* Release the subsystem state objects. * Release the subsystem state objects.
*/ */
for_each_subsys(cgrp->root, ss) for_each_subsys(cgrp->root, ss)
ss->destroy(cgrp); ss->css_free(cgrp);
cgrp->root->number_of_cgroups--; cgrp->root->number_of_cgroups--;
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
@ -4048,8 +4048,8 @@ static int online_css(struct cgroup_subsys *ss, struct cgroup *cgrp)
lockdep_assert_held(&cgroup_mutex); lockdep_assert_held(&cgroup_mutex);
if (ss->post_create) if (ss->css_online)
ret = ss->post_create(cgrp); ret = ss->css_online(cgrp);
if (!ret) if (!ret)
cgrp->subsys[ss->subsys_id]->flags |= CSS_ONLINE; cgrp->subsys[ss->subsys_id]->flags |= CSS_ONLINE;
return ret; return ret;
@ -4067,14 +4067,14 @@ static void offline_css(struct cgroup_subsys *ss, struct cgroup *cgrp)
return; return;
/* /*
* pre_destroy() should be called with cgroup_mutex unlocked. See * css_offline() should be called with cgroup_mutex unlocked. See
* 3fa59dfbc3 ("cgroup: fix potential deadlock in pre_destroy") for * 3fa59dfbc3 ("cgroup: fix potential deadlock in pre_destroy") for
* details. This temporary unlocking should go away once * details. This temporary unlocking should go away once
* cgroup_mutex is unexported from controllers. * cgroup_mutex is unexported from controllers.
*/ */
if (ss->pre_destroy) { if (ss->css_offline) {
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
ss->pre_destroy(cgrp); ss->css_offline(cgrp);
mutex_lock(&cgroup_mutex); mutex_lock(&cgroup_mutex);
} }
@ -4136,7 +4136,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
for_each_subsys(root, ss) { for_each_subsys(root, ss) {
struct cgroup_subsys_state *css; struct cgroup_subsys_state *css;
css = ss->create(cgrp); css = ss->css_alloc(cgrp);
if (IS_ERR(css)) { if (IS_ERR(css)) {
err = PTR_ERR(css); err = PTR_ERR(css);
goto err_free_all; goto err_free_all;
@ -4147,7 +4147,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
if (err) if (err)
goto err_free_all; goto err_free_all;
} }
/* At error, ->destroy() callback has to free assigned ID. */ /* At error, ->css_free() callback has to free assigned ID. */
if (clone_children(parent) && ss->post_clone) if (clone_children(parent) && ss->post_clone)
ss->post_clone(cgrp); ss->post_clone(cgrp);
@ -4201,7 +4201,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
err_free_all: err_free_all:
for_each_subsys(root, ss) { for_each_subsys(root, ss) {
if (cgrp->subsys[ss->subsys_id]) if (cgrp->subsys[ss->subsys_id])
ss->destroy(cgrp); ss->css_free(cgrp);
} }
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
/* Release the reference count that we took on the superblock */ /* Release the reference count that we took on the superblock */
@ -4381,7 +4381,7 @@ static void __init cgroup_init_subsys(struct cgroup_subsys *ss)
/* Create the top cgroup state for this subsystem */ /* Create the top cgroup state for this subsystem */
list_add(&ss->sibling, &rootnode.subsys_list); list_add(&ss->sibling, &rootnode.subsys_list);
ss->root = &rootnode; ss->root = &rootnode;
css = ss->create(dummytop); css = ss->css_alloc(dummytop);
/* We don't handle early failures gracefully */ /* We don't handle early failures gracefully */
BUG_ON(IS_ERR(css)); BUG_ON(IS_ERR(css));
init_cgroup_css(css, ss, dummytop); init_cgroup_css(css, ss, dummytop);
@ -4425,7 +4425,7 @@ int __init_or_module cgroup_load_subsys(struct cgroup_subsys *ss)
/* check name and function validity */ /* check name and function validity */
if (ss->name == NULL || strlen(ss->name) > MAX_CGROUP_TYPE_NAMELEN || if (ss->name == NULL || strlen(ss->name) > MAX_CGROUP_TYPE_NAMELEN ||
ss->create == NULL || ss->destroy == NULL) ss->css_alloc == NULL || ss->css_free == NULL)
return -EINVAL; return -EINVAL;
/* /*
@ -4454,10 +4454,11 @@ int __init_or_module cgroup_load_subsys(struct cgroup_subsys *ss)
subsys[ss->subsys_id] = ss; subsys[ss->subsys_id] = ss;
/* /*
* no ss->create seems to need anything important in the ss struct, so * no ss->css_alloc seems to need anything important in the ss
* this can happen first (i.e. before the rootnode attachment). * struct, so this can happen first (i.e. before the rootnode
* attachment).
*/ */
css = ss->create(dummytop); css = ss->css_alloc(dummytop);
if (IS_ERR(css)) { if (IS_ERR(css)) {
/* failure case - need to deassign the subsys[] slot. */ /* failure case - need to deassign the subsys[] slot. */
subsys[ss->subsys_id] = NULL; subsys[ss->subsys_id] = NULL;
@ -4577,12 +4578,12 @@ void cgroup_unload_subsys(struct cgroup_subsys *ss)
write_unlock(&css_set_lock); write_unlock(&css_set_lock);
/* /*
* remove subsystem's css from the dummytop and free it - need to free * remove subsystem's css from the dummytop and free it - need to
* before marking as null because ss->destroy needs the cgrp->subsys * free before marking as null because ss->css_free needs the
* pointer to find their state. note that this also takes care of * cgrp->subsys pointer to find their state. note that this also
* freeing the css_id. * takes care of freeing the css_id.
*/ */
ss->destroy(dummytop); ss->css_free(dummytop);
dummytop->subsys[ss->subsys_id] = NULL; dummytop->subsys[ss->subsys_id] = NULL;
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
@ -4626,8 +4627,8 @@ int __init cgroup_init_early(void)
BUG_ON(!ss->name); BUG_ON(!ss->name);
BUG_ON(strlen(ss->name) > MAX_CGROUP_TYPE_NAMELEN); BUG_ON(strlen(ss->name) > MAX_CGROUP_TYPE_NAMELEN);
BUG_ON(!ss->create); BUG_ON(!ss->css_alloc);
BUG_ON(!ss->destroy); BUG_ON(!ss->css_free);
if (ss->subsys_id != i) { if (ss->subsys_id != i) {
printk(KERN_ERR "cgroup: Subsys %s id == %d\n", printk(KERN_ERR "cgroup: Subsys %s id == %d\n",
ss->name, ss->subsys_id); ss->name, ss->subsys_id);
@ -5439,7 +5440,7 @@ struct cgroup_subsys_state *cgroup_css_from_dir(struct file *f, int id)
} }
#ifdef CONFIG_CGROUP_DEBUG #ifdef CONFIG_CGROUP_DEBUG
static struct cgroup_subsys_state *debug_create(struct cgroup *cont) static struct cgroup_subsys_state *debug_css_alloc(struct cgroup *cont)
{ {
struct cgroup_subsys_state *css = kzalloc(sizeof(*css), GFP_KERNEL); struct cgroup_subsys_state *css = kzalloc(sizeof(*css), GFP_KERNEL);
@ -5449,7 +5450,7 @@ static struct cgroup_subsys_state *debug_create(struct cgroup *cont)
return css; return css;
} }
static void debug_destroy(struct cgroup *cont) static void debug_css_free(struct cgroup *cont)
{ {
kfree(cont->subsys[debug_subsys_id]); kfree(cont->subsys[debug_subsys_id]);
} }
@ -5578,8 +5579,8 @@ static struct cftype debug_files[] = {
struct cgroup_subsys debug_subsys = { struct cgroup_subsys debug_subsys = {
.name = "debug", .name = "debug",
.create = debug_create, .css_alloc = debug_css_alloc,
.destroy = debug_destroy, .css_free = debug_css_free,
.subsys_id = debug_subsys_id, .subsys_id = debug_subsys_id,
.base_cftypes = debug_files, .base_cftypes = debug_files,
}; };

20
kernel/cgroup_freezer.c
View File

@ -92,7 +92,7 @@ static const char *freezer_state_strs(unsigned int state)
struct cgroup_subsys freezer_subsys; struct cgroup_subsys freezer_subsys;
static struct cgroup_subsys_state *freezer_create(struct cgroup *cgroup) static struct cgroup_subsys_state *freezer_css_alloc(struct cgroup *cgroup)
{ {
struct freezer *freezer; struct freezer *freezer;
@ -105,14 +105,14 @@ static struct cgroup_subsys_state *freezer_create(struct cgroup *cgroup)
} }
/** /**
* freezer_post_create - commit creation of a freezer cgroup * freezer_css_online - commit creation of a freezer cgroup
* @cgroup: cgroup being created * @cgroup: cgroup being created
* *
* We're committing to creation of @cgroup. Mark it online and inherit * We're committing to creation of @cgroup. Mark it online and inherit
* parent's freezing state while holding both parent's and our * parent's freezing state while holding both parent's and our
* freezer->lock. * freezer->lock.
*/ */
static int freezer_post_create(struct cgroup *cgroup) static int freezer_css_online(struct cgroup *cgroup)
{ {
struct freezer *freezer = cgroup_freezer(cgroup); struct freezer *freezer = cgroup_freezer(cgroup);
struct freezer *parent = parent_freezer(freezer); struct freezer *parent = parent_freezer(freezer);
@ -141,13 +141,13 @@ static int freezer_post_create(struct cgroup *cgroup)
} }
/** /**
* freezer_pre_destroy - initiate destruction of @cgroup * freezer_css_offline - initiate destruction of @cgroup
* @cgroup: cgroup being destroyed * @cgroup: cgroup being destroyed
* *
* @cgroup is going away. Mark it dead and decrement system_freezing_count * @cgroup is going away. Mark it dead and decrement system_freezing_count
* if it was holding one. * if it was holding one.
*/ */
static void freezer_pre_destroy(struct cgroup *cgroup) static void freezer_css_offline(struct cgroup *cgroup)
{ {
struct freezer *freezer = cgroup_freezer(cgroup); struct freezer *freezer = cgroup_freezer(cgroup);
@ -161,7 +161,7 @@ static void freezer_pre_destroy(struct cgroup *cgroup)
spin_unlock_irq(&freezer->lock); spin_unlock_irq(&freezer->lock);
} }
static void freezer_destroy(struct cgroup *cgroup) static void freezer_css_free(struct cgroup *cgroup)
{ {
kfree(cgroup_freezer(cgroup)); kfree(cgroup_freezer(cgroup));
} }
@ -477,10 +477,10 @@ static struct cftype files[] = {
struct cgroup_subsys freezer_subsys = { struct cgroup_subsys freezer_subsys = {
.name = "freezer", .name = "freezer",
.create = freezer_create, .css_alloc = freezer_css_alloc,
.post_create = freezer_post_create, .css_online = freezer_css_online,
.pre_destroy = freezer_pre_destroy, .css_offline = freezer_css_offline,
.destroy = freezer_destroy, .css_free = freezer_css_free,
.subsys_id = freezer_subsys_id, .subsys_id = freezer_subsys_id,
.attach = freezer_attach, .attach = freezer_attach,
.fork = freezer_fork, .fork = freezer_fork,

10
kernel/cpuset.c
View File

@ -1821,11 +1821,11 @@ static void cpuset_post_clone(struct cgroup *cgroup)
} }
/* /*
* cpuset_create - create a cpuset * cpuset_css_alloc - allocate a cpuset css
* cont: control group that the new cpuset will be part of * cont: control group that the new cpuset will be part of
*/ */
static struct cgroup_subsys_state *cpuset_create(struct cgroup *cont) static struct cgroup_subsys_state *cpuset_css_alloc(struct cgroup *cont)
{ {
struct cpuset *cs; struct cpuset *cs;
struct cpuset *parent; struct cpuset *parent;
@ -1864,7 +1864,7 @@ static struct cgroup_subsys_state *cpuset_create(struct cgroup *cont)
* will call async_rebuild_sched_domains(). * will call async_rebuild_sched_domains().
*/ */
static void cpuset_destroy(struct cgroup *cont) static void cpuset_css_free(struct cgroup *cont)
{ {
struct cpuset *cs = cgroup_cs(cont); struct cpuset *cs = cgroup_cs(cont);
@ -1878,8 +1878,8 @@ static void cpuset_destroy(struct cgroup *cont)
struct cgroup_subsys cpuset_subsys = { struct cgroup_subsys cpuset_subsys = {
.name = "cpuset", .name = "cpuset",
.create = cpuset_create, .css_alloc = cpuset_css_alloc,
.destroy = cpuset_destroy, .css_free = cpuset_css_free,
.can_attach = cpuset_can_attach, .can_attach = cpuset_can_attach,
.attach = cpuset_attach, .attach = cpuset_attach,
.post_clone = cpuset_post_clone, .post_clone = cpuset_post_clone,

8
kernel/events/core.c
View File

@ -7434,7 +7434,7 @@ unlock:
device_initcall(perf_event_sysfs_init); device_initcall(perf_event_sysfs_init);
#ifdef CONFIG_CGROUP_PERF #ifdef CONFIG_CGROUP_PERF
static struct cgroup_subsys_state *perf_cgroup_create(struct cgroup *cont) static struct cgroup_subsys_state *perf_cgroup_css_alloc(struct cgroup *cont)
{ {
struct perf_cgroup *jc; struct perf_cgroup *jc;
@ -7451,7 +7451,7 @@ static struct cgroup_subsys_state *perf_cgroup_create(struct cgroup *cont)
return &jc->css; return &jc->css;
} }
static void perf_cgroup_destroy(struct cgroup *cont) static void perf_cgroup_css_free(struct cgroup *cont)
{ {
struct perf_cgroup *jc; struct perf_cgroup *jc;
jc = container_of(cgroup_subsys_state(cont, perf_subsys_id), jc = container_of(cgroup_subsys_state(cont, perf_subsys_id),
@ -7492,8 +7492,8 @@ static void perf_cgroup_exit(struct cgroup *cgrp, struct cgroup *old_cgrp,
struct cgroup_subsys perf_subsys = { struct cgroup_subsys perf_subsys = {
.name = "perf_event", .name = "perf_event",
.subsys_id = perf_subsys_id, .subsys_id = perf_subsys_id,
.create = perf_cgroup_create, .css_alloc = perf_cgroup_css_alloc,
.destroy = perf_cgroup_destroy, .css_free = perf_cgroup_css_free,
.exit = perf_cgroup_exit, .exit = perf_cgroup_exit,
.attach = perf_cgroup_attach, .attach = perf_cgroup_attach,

16
kernel/sched/core.c
View File

@ -7468,7 +7468,7 @@ static inline struct task_group *cgroup_tg(struct cgroup *cgrp)
struct task_group, css); struct task_group, css);
} }
static struct cgroup_subsys_state *cpu_cgroup_create(struct cgroup *cgrp) static struct cgroup_subsys_state *cpu_cgroup_css_alloc(struct cgroup *cgrp)
{ {
struct task_group *tg, *parent; struct task_group *tg, *parent;
@ -7485,7 +7485,7 @@ static struct cgroup_subsys_state *cpu_cgroup_create(struct cgroup *cgrp)
return &tg->css; return &tg->css;
} }
static void cpu_cgroup_destroy(struct cgroup *cgrp) static void cpu_cgroup_css_free(struct cgroup *cgrp)
{ {
struct task_group *tg = cgroup_tg(cgrp); struct task_group *tg = cgroup_tg(cgrp);
@ -7845,8 +7845,8 @@ static struct cftype cpu_files[] = {
struct cgroup_subsys cpu_cgroup_subsys = { struct cgroup_subsys cpu_cgroup_subsys = {
.name = "cpu", .name = "cpu",
.create = cpu_cgroup_create, .css_alloc = cpu_cgroup_css_alloc,
.destroy = cpu_cgroup_destroy, .css_free = cpu_cgroup_css_free,
.can_attach = cpu_cgroup_can_attach, .can_attach = cpu_cgroup_can_attach,
.attach = cpu_cgroup_attach, .attach = cpu_cgroup_attach,
.exit = cpu_cgroup_exit, .exit = cpu_cgroup_exit,
@ -7869,7 +7869,7 @@ struct cgroup_subsys cpu_cgroup_subsys = {
struct cpuacct root_cpuacct; struct cpuacct root_cpuacct;
/* create a new cpu accounting group */ /* create a new cpu accounting group */
static struct cgroup_subsys_state *cpuacct_create(struct cgroup *cgrp) static struct cgroup_subsys_state *cpuacct_css_alloc(struct cgroup *cgrp)
{ {
struct cpuacct *ca; struct cpuacct *ca;
@ -7899,7 +7899,7 @@ out:
} }
/* destroy an existing cpu accounting group */ /* destroy an existing cpu accounting group */
static void cpuacct_destroy(struct cgroup *cgrp) static void cpuacct_css_free(struct cgroup *cgrp)
{ {
struct cpuacct *ca = cgroup_ca(cgrp); struct cpuacct *ca = cgroup_ca(cgrp);
@ -8070,8 +8070,8 @@ void cpuacct_charge(struct task_struct *tsk, u64 cputime)
struct cgroup_subsys cpuacct_subsys = { struct cgroup_subsys cpuacct_subsys = {
.name = "cpuacct", .name = "cpuacct",
.create = cpuacct_create, .css_alloc = cpuacct_css_alloc,
.destroy = cpuacct_destroy, .css_free = cpuacct_css_free,
.subsys_id = cpuacct_subsys_id, .subsys_id = cpuacct_subsys_id,
.base_cftypes = files, .base_cftypes = files,
}; };

12
mm/hugetlb_cgroup.c
View File

@ -77,7 +77,7 @@ static inline bool hugetlb_cgroup_have_usage(struct cgroup *cg)
return false; return false;
} }
static struct cgroup_subsys_state *hugetlb_cgroup_create(struct cgroup *cgroup) static struct cgroup_subsys_state *hugetlb_cgroup_css_alloc(struct cgroup *cgroup)
{ {
int idx; int idx;
struct cgroup *parent_cgroup; struct cgroup *parent_cgroup;
@ -101,7 +101,7 @@ static struct cgroup_subsys_state *hugetlb_cgroup_create(struct cgroup *cgroup)
return &h_cgroup->css; return &h_cgroup->css;
} }
static void hugetlb_cgroup_destroy(struct cgroup *cgroup) static void hugetlb_cgroup_css_free(struct cgroup *cgroup)
{ {
struct hugetlb_cgroup *h_cgroup; struct hugetlb_cgroup *h_cgroup;
@ -155,7 +155,7 @@ out:
* Force the hugetlb cgroup to empty the hugetlb resources by moving them to * Force the hugetlb cgroup to empty the hugetlb resources by moving them to
* the parent cgroup. * the parent cgroup.
*/ */
static void hugetlb_cgroup_pre_destroy(struct cgroup *cgroup) static void hugetlb_cgroup_css_offline(struct cgroup *cgroup)
{ {
struct hstate *h; struct hstate *h;
struct page *page; struct page *page;
@ -404,8 +404,8 @@ void hugetlb_cgroup_migrate(struct page *oldhpage, struct page *newhpage)
struct cgroup_subsys hugetlb_subsys = { struct cgroup_subsys hugetlb_subsys = {
.name = "hugetlb", .name = "hugetlb",
.create = hugetlb_cgroup_create, .css_alloc = hugetlb_cgroup_css_alloc,
.pre_destroy = hugetlb_cgroup_pre_destroy, .css_offline = hugetlb_cgroup_css_offline,
.destroy = hugetlb_cgroup_destroy, .css_free = hugetlb_cgroup_css_free,
.subsys_id = hugetlb_subsys_id, .subsys_id = hugetlb_subsys_id,
}; };

12
mm/memcontrol.c
View File

@ -4922,7 +4922,7 @@ err_cleanup:
} }
static struct cgroup_subsys_state * __ref static struct cgroup_subsys_state * __ref
mem_cgroup_create(struct cgroup *cont) mem_cgroup_css_alloc(struct cgroup *cont)
{ {
struct mem_cgroup *memcg, *parent; struct mem_cgroup *memcg, *parent;
long error = -ENOMEM; long error = -ENOMEM;
@ -5003,14 +5003,14 @@ free_out:
return ERR_PTR(error); return ERR_PTR(error);
} }
static void mem_cgroup_pre_destroy(struct cgroup *cont) static void mem_cgroup_css_offline(struct cgroup *cont)
{ {
struct mem_cgroup *memcg = mem_cgroup_from_cont(cont); struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
mem_cgroup_reparent_charges(memcg); mem_cgroup_reparent_charges(memcg);
} }
static void mem_cgroup_destroy(struct cgroup *cont) static void mem_cgroup_css_free(struct cgroup *cont)
{ {
struct mem_cgroup *memcg = mem_cgroup_from_cont(cont); struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
@ -5600,9 +5600,9 @@ static void mem_cgroup_move_task(struct cgroup *cont,
struct cgroup_subsys mem_cgroup_subsys = { struct cgroup_subsys mem_cgroup_subsys = {
.name = "memory", .name = "memory",
.subsys_id = mem_cgroup_subsys_id, .subsys_id = mem_cgroup_subsys_id,
.create = mem_cgroup_create, .css_alloc = mem_cgroup_css_alloc,
.pre_destroy = mem_cgroup_pre_destroy, .css_offline = mem_cgroup_css_offline,
.destroy = mem_cgroup_destroy, .css_free = mem_cgroup_css_free,
.can_attach = mem_cgroup_can_attach, .can_attach = mem_cgroup_can_attach,
.cancel_attach = mem_cgroup_cancel_attach, .cancel_attach = mem_cgroup_cancel_attach,
.attach = mem_cgroup_move_task, .attach = mem_cgroup_move_task,

8
net/core/netprio_cgroup.c
View File

@ -108,7 +108,7 @@ static int write_update_netdev_table(struct net_device *dev)
return ret; return ret;
} }
static struct cgroup_subsys_state *cgrp_create(struct cgroup *cgrp) static struct cgroup_subsys_state *cgrp_css_alloc(struct cgroup *cgrp)
{ {
struct cgroup_netprio_state *cs; struct cgroup_netprio_state *cs;
int ret = -EINVAL; int ret = -EINVAL;
@ -132,7 +132,7 @@ out:
return ERR_PTR(ret); return ERR_PTR(ret);
} }
static void cgrp_destroy(struct cgroup *cgrp) static void cgrp_css_free(struct cgroup *cgrp)
{ {
struct cgroup_netprio_state *cs; struct cgroup_netprio_state *cs;
struct net_device *dev; struct net_device *dev;
@ -276,8 +276,8 @@ static struct cftype ss_files[] = {
struct cgroup_subsys net_prio_subsys = { struct cgroup_subsys net_prio_subsys = {
.name = "net_prio", .name = "net_prio",
.create = cgrp_create, .css_alloc = cgrp_css_alloc,
.destroy = cgrp_destroy, .css_free = cgrp_css_free,
.attach = net_prio_attach, .attach = net_prio_attach,
.subsys_id = net_prio_subsys_id, .subsys_id = net_prio_subsys_id,
.base_cftypes = ss_files, .base_cftypes = ss_files,

8
net/sched/cls_cgroup.c
View File

@ -34,7 +34,7 @@ static inline struct cgroup_cls_state *task_cls_state(struct task_struct *p)
struct cgroup_cls_state, css); struct cgroup_cls_state, css);
} }
static struct cgroup_subsys_state *cgrp_create(struct cgroup *cgrp) static struct cgroup_subsys_state *cgrp_css_alloc(struct cgroup *cgrp)
{ {
struct cgroup_cls_state *cs; struct cgroup_cls_state *cs;
@ -48,7 +48,7 @@ static struct cgroup_subsys_state *cgrp_create(struct cgroup *cgrp)
return &cs->css; return &cs->css;
} }
static void cgrp_destroy(struct cgroup *cgrp) static void cgrp_css_free(struct cgroup *cgrp)
{ {
kfree(cgrp_cls_state(cgrp)); kfree(cgrp_cls_state(cgrp));
} }
@ -75,8 +75,8 @@ static struct cftype ss_files[] = {
struct cgroup_subsys net_cls_subsys = { struct cgroup_subsys net_cls_subsys = {
.name = "net_cls", .name = "net_cls",
.create = cgrp_create, .css_alloc = cgrp_css_alloc,
.destroy = cgrp_destroy, .css_free = cgrp_css_free,
.subsys_id = net_cls_subsys_id, .subsys_id = net_cls_subsys_id,
.base_cftypes = ss_files, .base_cftypes = ss_files,
.module = THIS_MODULE, .module = THIS_MODULE,

8
security/device_cgroup.c
View File

@ -180,7 +180,7 @@ static void dev_exception_clean(struct dev_cgroup *dev_cgroup)
/* /*
* called from kernel/cgroup.c with cgroup_lock() held. * called from kernel/cgroup.c with cgroup_lock() held.
*/ */
static struct cgroup_subsys_state *devcgroup_create(struct cgroup *cgroup) static struct cgroup_subsys_state *devcgroup_css_alloc(struct cgroup *cgroup)
{ {
struct dev_cgroup *dev_cgroup, *parent_dev_cgroup; struct dev_cgroup *dev_cgroup, *parent_dev_cgroup;
struct cgroup *parent_cgroup; struct cgroup *parent_cgroup;
@ -210,7 +210,7 @@ static struct cgroup_subsys_state *devcgroup_create(struct cgroup *cgroup)
return &dev_cgroup->css; return &dev_cgroup->css;
} }
static void devcgroup_destroy(struct cgroup *cgroup) static void devcgroup_css_free(struct cgroup *cgroup)
{ {
struct dev_cgroup *dev_cgroup; struct dev_cgroup *dev_cgroup;
@ -564,8 +564,8 @@ static struct cftype dev_cgroup_files[] = {
struct cgroup_subsys devices_subsys = { struct cgroup_subsys devices_subsys = {
.name = "devices", .name = "devices",
.can_attach = devcgroup_can_attach, .can_attach = devcgroup_can_attach,
.create = devcgroup_create, .css_alloc = devcgroup_css_alloc,
.destroy = devcgroup_destroy, .css_free = devcgroup_css_free,
.subsys_id = devices_subsys_id, .subsys_id = devices_subsys_id,
.base_cftypes = dev_cgroup_files, .base_cftypes = dev_cgroup_files,