Skip to content

L
linux
Commit bd89aabc authored by Paul Menage's avatar Paul Menage Committed by Linus Torvalds
Browse files
Options

Control groups: Replace "cont" with "cgrp" and other misc renaming 

Replace "cont" with "cgrp" and other misc renaming

This patch finishes some of the names that got missed in the great
"task containers" -> "control groups" rename. Primarily it renames
the local variable "cont" to "cgrp" in a number of places, and renames
the CONT_* enum members to CGRP_*.

This patch is not intended to have any effect on the generated code;
the output of "objdump -d kernel/cgroup.o" is unchanged.
Signed-off-by: default avatarPaul Menage <menage@google.com>
Acked-by: default avatarPaul Jackson <pj@sgi.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 69cccb88
Hide whitespace changes
Inline Side-by-side
Showing with 247 additions and 247 deletions
kernel/cgroup.c
View file @ bd89aabc
...@@ -124,18 +124,18 @@ static int need_forkexit_callback; ...@@ -124,18 +124,18 @@ static int need_forkexit_callback;
/* bits in struct cgroup flags field */ /* bits in struct cgroup flags field */
enum { enum {
/* Control Group is dead */ /* Control Group is dead */
CONT_REMOVED, CGRP_REMOVED,
/* Control Group has previously had a child cgroup or a task, /* Control Group has previously had a child cgroup or a task,
* but no longer (only if CONT_NOTIFY_ON_RELEASE is set) */ * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
CONT_RELEASABLE, CGRP_RELEASABLE,
/* Control Group requires release notifications to userspace */ /* Control Group requires release notifications to userspace */
CONT_NOTIFY_ON_RELEASE, CGRP_NOTIFY_ON_RELEASE,
}; };
/* convenient tests for these bits */ /* convenient tests for these bits */
inline int cgroup_is_removed(const struct cgroup *cont) inline int cgroup_is_removed(const struct cgroup *cgrp)
{ {
return test_bit(CONT_REMOVED, &cont->flags); return test_bit(CGRP_REMOVED, &cgrp->flags);
} }
/* bits in struct cgroupfs_root flags field */ /* bits in struct cgroupfs_root flags field */
...@@ -143,17 +143,17 @@ enum { ...@@ -143,17 +143,17 @@ enum {
ROOT_NOPREFIX, /* mounted subsystems have no named prefix */ ROOT_NOPREFIX, /* mounted subsystems have no named prefix */
}; };
inline int cgroup_is_releasable(const struct cgroup *cont) inline int cgroup_is_releasable(const struct cgroup *cgrp)
{ {
const int bits = const int bits =
(1 << CONT_RELEASABLE) | (1 << CGRP_RELEASABLE) |
(1 << CONT_NOTIFY_ON_RELEASE); (1 << CGRP_NOTIFY_ON_RELEASE);
return (cont->flags & bits) == bits; return (cgrp->flags & bits) == bits;
} }
inline int notify_on_release(const struct cgroup *cont) inline int notify_on_release(const struct cgroup *cgrp)
{ {
return test_bit(CONT_NOTIFY_ON_RELEASE, &cont->flags); return test_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
} }
/* /*
...@@ -173,7 +173,7 @@ static LIST_HEAD(release_list); ...@@ -173,7 +173,7 @@ static LIST_HEAD(release_list);
static DEFINE_SPINLOCK(release_list_lock); static DEFINE_SPINLOCK(release_list_lock);
static void cgroup_release_agent(struct work_struct *work); static void cgroup_release_agent(struct work_struct *work);
static DECLARE_WORK(release_agent_work, cgroup_release_agent); static DECLARE_WORK(release_agent_work, cgroup_release_agent);
static void check_for_release(struct cgroup *cont); static void check_for_release(struct cgroup *cgrp);
/* Link structure for associating css_set objects with cgroups */ /* Link structure for associating css_set objects with cgroups */
struct cg_cgroup_link { struct cg_cgroup_link {
...@@ -181,7 +181,7 @@ struct cg_cgroup_link { ...@@ -181,7 +181,7 @@ struct cg_cgroup_link {
* List running through cg_cgroup_links associated with a * List running through cg_cgroup_links associated with a
* cgroup, anchored on cgroup->css_sets * cgroup, anchored on cgroup->css_sets
*/ */
struct list_head cont_link_list; struct list_head cgrp_link_list;
/* /*
* List running through cg_cgroup_links pointing at a * List running through cg_cgroup_links pointing at a
* single css_set object, anchored on css_set->cg_links * single css_set object, anchored on css_set->cg_links
...@@ -239,7 +239,7 @@ static void unlink_css_set(struct css_set *cg) ...@@ -239,7 +239,7 @@ static void unlink_css_set(struct css_set *cg)
link = list_entry(cg->cg_links.next, link = list_entry(cg->cg_links.next,
struct cg_cgroup_link, cg_link_list); struct cg_cgroup_link, cg_link_list);
list_del(&link->cg_link_list); list_del(&link->cg_link_list);
list_del(&link->cont_link_list); list_del(&link->cgrp_link_list);
kfree(link); kfree(link);
} }
write_unlock(&css_set_lock); write_unlock(&css_set_lock);
...@@ -254,12 +254,12 @@ static void __release_css_set(struct kref *k, int taskexit) ...@@ -254,12 +254,12 @@ static void __release_css_set(struct kref *k, int taskexit)
rcu_read_lock(); rcu_read_lock();
for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) { for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
struct cgroup *cont = cg->subsys[i]->cgroup; struct cgroup *cgrp = cg->subsys[i]->cgroup;
if (atomic_dec_and_test(&cont->count) && if (atomic_dec_and_test(&cgrp->count) &&
notify_on_release(cont)) { notify_on_release(cgrp)) {
if (taskexit) if (taskexit)
set_bit(CONT_RELEASABLE, &cont->flags); set_bit(CGRP_RELEASABLE, &cgrp->flags);
check_for_release(cont); check_for_release(cgrp);
} }
} }
rcu_read_unlock(); rcu_read_unlock();
...@@ -304,7 +304,7 @@ static inline void put_css_set_taskexit(struct css_set *cg) ...@@ -304,7 +304,7 @@ static inline void put_css_set_taskexit(struct css_set *cg)
* oldcg: the cgroup group that we're using before the cgroup * oldcg: the cgroup group that we're using before the cgroup
* transition * transition
* *
* cont: the cgroup that we're moving into * cgrp: the cgroup that we're moving into
* *
* template: location in which to build the desired set of subsystem * template: location in which to build the desired set of subsystem
* state objects for the new cgroup group * state objects for the new cgroup group
...@@ -312,11 +312,11 @@ static inline void put_css_set_taskexit(struct css_set *cg) ...@@ -312,11 +312,11 @@ static inline void put_css_set_taskexit(struct css_set *cg)
static struct css_set *find_existing_css_set( static struct css_set *find_existing_css_set(
struct css_set *oldcg, struct css_set *oldcg,
struct cgroup *cont, struct cgroup *cgrp,
struct cgroup_subsys_state *template[]) struct cgroup_subsys_state *template[])
{ {
int i; int i;
struct cgroupfs_root *root = cont->root; struct cgroupfs_root *root = cgrp->root;
struct list_head *l = &init_css_set.list; struct list_head *l = &init_css_set.list;
/* Built the set of subsystem state objects that we want to /* Built the set of subsystem state objects that we want to
...@@ -326,7 +326,7 @@ static struct css_set *find_existing_css_set( ...@@ -326,7 +326,7 @@ static struct css_set *find_existing_css_set(
/* Subsystem is in this hierarchy. So we want /* Subsystem is in this hierarchy. So we want
* the subsystem state from the new * the subsystem state from the new
* cgroup */ * cgroup */
template[i] = cont->subsys[i]; template[i] = cgrp->subsys[i];
} else { } else {
/* Subsystem is not in this hierarchy, so we /* Subsystem is not in this hierarchy, so we
* don't want to change the subsystem state */ * don't want to change the subsystem state */
...@@ -353,7 +353,7 @@ static struct css_set *find_existing_css_set( ...@@ -353,7 +353,7 @@ static struct css_set *find_existing_css_set(
/* /*
* allocate_cg_links() allocates "count" cg_cgroup_link structures * allocate_cg_links() allocates "count" cg_cgroup_link structures
* and chains them on tmp through their cont_link_list fields. Returns 0 on * and chains them on tmp through their cgrp_link_list fields. Returns 0 on
* success or a negative error * success or a negative error
*/ */
...@@ -368,13 +368,13 @@ static int allocate_cg_links(int count, struct list_head *tmp) ...@@ -368,13 +368,13 @@ static int allocate_cg_links(int count, struct list_head *tmp)
while (!list_empty(tmp)) { while (!list_empty(tmp)) {
link = list_entry(tmp->next, link = list_entry(tmp->next,
struct cg_cgroup_link, struct cg_cgroup_link,
cont_link_list); cgrp_link_list);
list_del(&link->cont_link_list); list_del(&link->cgrp_link_list);
kfree(link); kfree(link);
} }
return -ENOMEM; return -ENOMEM;
} }
list_add(&link->cont_link_list, tmp); list_add(&link->cgrp_link_list, tmp);
} }
return 0; return 0;
} }
...@@ -385,8 +385,8 @@ static void free_cg_links(struct list_head *tmp) ...@@ -385,8 +385,8 @@ static void free_cg_links(struct list_head *tmp)
struct cg_cgroup_link *link; struct cg_cgroup_link *link;
link = list_entry(tmp->next, link = list_entry(tmp->next,
struct cg_cgroup_link, struct cg_cgroup_link,
cont_link_list); cgrp_link_list);
list_del(&link->cont_link_list); list_del(&link->cgrp_link_list);
kfree(link); kfree(link);
} }
} }
...@@ -400,7 +400,7 @@ static void free_cg_links(struct list_head *tmp) ...@@ -400,7 +400,7 @@ static void free_cg_links(struct list_head *tmp)
*/ */
static struct css_set *find_css_set( static struct css_set *find_css_set(
struct css_set *oldcg, struct cgroup *cont) struct css_set *oldcg, struct cgroup *cgrp)
{ {
struct css_set *res; struct css_set *res;
struct cgroup_subsys_state *template[CGROUP_SUBSYS_COUNT]; struct cgroup_subsys_state *template[CGROUP_SUBSYS_COUNT];
...@@ -412,7 +412,7 @@ static struct css_set *find_css_set( ...@@ -412,7 +412,7 @@ static struct css_set *find_css_set(
/* First see if we already have a cgroup group that matches /* First see if we already have a cgroup group that matches
* the desired set */ * the desired set */
write_lock(&css_set_lock); write_lock(&css_set_lock);
res = find_existing_css_set(oldcg, cont, template); res = find_existing_css_set(oldcg, cgrp, template);
if (res) if (res)
get_css_set(res); get_css_set(res);
write_unlock(&css_set_lock); write_unlock(&css_set_lock);
...@@ -441,9 +441,9 @@ static struct css_set *find_css_set( ...@@ -441,9 +441,9 @@ static struct css_set *find_css_set(
write_lock(&css_set_lock); write_lock(&css_set_lock);
/* Add reference counts and links from the new css_set. */ /* Add reference counts and links from the new css_set. */
for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) { for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
struct cgroup *cont = res->subsys[i]->cgroup; struct cgroup *cgrp = res->subsys[i]->cgroup;
struct cgroup_subsys *ss = subsys[i]; struct cgroup_subsys *ss = subsys[i];
atomic_inc(&cont->count); atomic_inc(&cgrp->count);
/* /*
* We want to add a link once per cgroup, so we * We want to add a link once per cgroup, so we
* only do it for the first subsystem in each * only do it for the first subsystem in each
...@@ -453,9 +453,9 @@ static struct css_set *find_css_set( ...@@ -453,9 +453,9 @@ static struct css_set *find_css_set(
BUG_ON(list_empty(&tmp_cg_links)); BUG_ON(list_empty(&tmp_cg_links));
link = list_entry(tmp_cg_links.next, link = list_entry(tmp_cg_links.next,
struct cg_cgroup_link, struct cg_cgroup_link,
cont_link_list); cgrp_link_list);
list_del(&link->cont_link_list); list_del(&link->cgrp_link_list);
list_add(&link->cont_link_list, &cont->css_sets); list_add(&link->cgrp_link_list, &cgrp->css_sets);
link->cg = res; link->cg = res;
list_add(&link->cg_link_list, &res->cg_links); list_add(&link->cg_link_list, &res->cg_links);
} }
...@@ -463,9 +463,9 @@ static struct css_set *find_css_set( ...@@ -463,9 +463,9 @@ static struct css_set *find_css_set(
if (list_empty(&rootnode.subsys_list)) { if (list_empty(&rootnode.subsys_list)) {
link = list_entry(tmp_cg_links.next, link = list_entry(tmp_cg_links.next,
struct cg_cgroup_link, struct cg_cgroup_link,
cont_link_list); cgrp_link_list);
list_del(&link->cont_link_list); list_del(&link->cgrp_link_list);
list_add(&link->cont_link_list, &dummytop->css_sets); list_add(&link->cgrp_link_list, &dummytop->css_sets);
link->cg = res; link->cg = res;
list_add(&link->cg_link_list, &res->cg_links); list_add(&link->cg_link_list, &res->cg_links);
} }
...@@ -565,7 +565,7 @@ void cgroup_unlock(void) ...@@ -565,7 +565,7 @@ void cgroup_unlock(void)
static int cgroup_mkdir(struct inode *dir, struct dentry *dentry, int mode); static int cgroup_mkdir(struct inode *dir, struct dentry *dentry, int mode);
static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry); static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry);
static int cgroup_populate_dir(struct cgroup *cont); static int cgroup_populate_dir(struct cgroup *cgrp);
static struct inode_operations cgroup_dir_inode_operations; static struct inode_operations cgroup_dir_inode_operations;
static struct file_operations proc_cgroupstats_operations; static struct file_operations proc_cgroupstats_operations;
...@@ -592,8 +592,8 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode) ...@@ -592,8 +592,8 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode)
{ {
/* is dentry a directory ? if so, kfree() associated cgroup */ /* is dentry a directory ? if so, kfree() associated cgroup */
if (S_ISDIR(inode->i_mode)) { if (S_ISDIR(inode->i_mode)) {
struct cgroup *cont = dentry->d_fsdata; struct cgroup *cgrp = dentry->d_fsdata;
BUG_ON(!(cgroup_is_removed(cont))); BUG_ON(!(cgroup_is_removed(cgrp)));
/* It's possible for external users to be holding css /* It's possible for external users to be holding css
* reference counts on a cgroup; css_put() needs to * reference counts on a cgroup; css_put() needs to
* be able to access the cgroup after decrementing * be able to access the cgroup after decrementing
...@@ -601,7 +601,7 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode) ...@@ -601,7 +601,7 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode)
* queue the cgroup to be handled by the release * queue the cgroup to be handled by the release
* agent */ * agent */
synchronize_rcu(); synchronize_rcu();
kfree(cont); kfree(cgrp);
} }
iput(inode); iput(inode);
} }
...@@ -658,7 +658,7 @@ static int rebind_subsystems(struct cgroupfs_root *root, ...@@ -658,7 +658,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
unsigned long final_bits) unsigned long final_bits)
{ {
unsigned long added_bits, removed_bits; unsigned long added_bits, removed_bits;
struct cgroup *cont = &root->top_cgroup; struct cgroup *cgrp = &root->top_cgroup;
int i; int i;
removed_bits = root->actual_subsys_bits & ~final_bits; removed_bits = root->actual_subsys_bits & ~final_bits;
...@@ -679,7 +679,7 @@ static int rebind_subsystems(struct cgroupfs_root *root, ...@@ -679,7 +679,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
* any child cgroups exist. This is theoretically supportable * any child cgroups exist. This is theoretically supportable
* but involves complex error handling, so it's being left until * but involves complex error handling, so it's being left until
* later */ * later */
if (!list_empty(&cont->children)) if (!list_empty(&cgrp->children))
return -EBUSY; return -EBUSY;
/* Process each subsystem */ /* Process each subsystem */
...@@ -688,32 +688,32 @@ static int rebind_subsystems(struct cgroupfs_root *root, ...@@ -688,32 +688,32 @@ static int rebind_subsystems(struct cgroupfs_root *root,
unsigned long bit = 1UL << i; unsigned long bit = 1UL << i;
if (bit & added_bits) { if (bit & added_bits) {
/* We're binding this subsystem to this hierarchy */ /* We're binding this subsystem to this hierarchy */
BUG_ON(cont->subsys[i]); BUG_ON(cgrp->subsys[i]);
BUG_ON(!dummytop->subsys[i]); BUG_ON(!dummytop->subsys[i]);
BUG_ON(dummytop->subsys[i]->cgroup != dummytop); BUG_ON(dummytop->subsys[i]->cgroup != dummytop);
cont->subsys[i] = dummytop->subsys[i]; cgrp->subsys[i] = dummytop->subsys[i];
cont->subsys[i]->cgroup = cont; cgrp->subsys[i]->cgroup = cgrp;
list_add(&ss->sibling, &root->subsys_list); list_add(&ss->sibling, &root->subsys_list);
rcu_assign_pointer(ss->root, root); rcu_assign_pointer(ss->root, root);
if (ss->bind) if (ss->bind)
ss->bind(ss, cont); ss->bind(ss, cgrp);
} else if (bit & removed_bits) { } else if (bit & removed_bits) {
/* We're removing this subsystem */ /* We're removing this subsystem */
BUG_ON(cont->subsys[i] != dummytop->subsys[i]); BUG_ON(cgrp->subsys[i] != dummytop->subsys[i]);
BUG_ON(cont->subsys[i]->cgroup != cont); BUG_ON(cgrp->subsys[i]->cgroup != cgrp);
if (ss->bind) if (ss->bind)
ss->bind(ss, dummytop); ss->bind(ss, dummytop);
dummytop->subsys[i]->cgroup = dummytop; dummytop->subsys[i]->cgroup = dummytop;
cont->subsys[i] = NULL; cgrp->subsys[i] = NULL;
rcu_assign_pointer(subsys[i]->root, &rootnode); rcu_assign_pointer(subsys[i]->root, &rootnode);
list_del(&ss->sibling); list_del(&ss->sibling);
} else if (bit & final_bits) { } else if (bit & final_bits) {
/* Subsystem state should already exist */ /* Subsystem state should already exist */
BUG_ON(!cont->subsys[i]); BUG_ON(!cgrp->subsys[i]);
} else { } else {
/* Subsystem state shouldn't exist */ /* Subsystem state shouldn't exist */
BUG_ON(cont->subsys[i]); BUG_ON(cgrp->subsys[i]);
} }
} }
root->subsys_bits = root->actual_subsys_bits = final_bits; root->subsys_bits = root->actual_subsys_bits = final_bits;
...@@ -797,10 +797,10 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data) ...@@ -797,10 +797,10 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
{ {
int ret = 0; int ret = 0;
struct cgroupfs_root *root = sb->s_fs_info; struct cgroupfs_root *root = sb->s_fs_info;
struct cgroup *cont = &root->top_cgroup; struct cgroup *cgrp = &root->top_cgroup;
struct cgroup_sb_opts opts; struct cgroup_sb_opts opts;
mutex_lock(&cont->dentry->d_inode->i_mutex); mutex_lock(&cgrp->dentry->d_inode->i_mutex);
mutex_lock(&cgroup_mutex); mutex_lock(&cgroup_mutex);
/* See what subsystems are wanted */ /* See what subsystems are wanted */
...@@ -818,7 +818,7 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data) ...@@ -818,7 +818,7 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
/* (re)populate subsystem files */ /* (re)populate subsystem files */
if (!ret) if (!ret)
cgroup_populate_dir(cont); cgroup_populate_dir(cgrp);
if (opts.release_agent) if (opts.release_agent)
strcpy(root->release_agent_path, opts.release_agent); strcpy(root->release_agent_path, opts.release_agent);
...@@ -826,7 +826,7 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data) ...@@ -826,7 +826,7 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
if (opts.release_agent) if (opts.release_agent)
kfree(opts.release_agent); kfree(opts.release_agent);
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
mutex_unlock(&cont->dentry->d_inode->i_mutex); mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
return ret; return ret;
} }
...@@ -839,16 +839,16 @@ static struct super_operations cgroup_ops = { ...@@ -839,16 +839,16 @@ static struct super_operations cgroup_ops = {
static void init_cgroup_root(struct cgroupfs_root *root) static void init_cgroup_root(struct cgroupfs_root *root)
{ {
struct cgroup *cont = &root->top_cgroup; struct cgroup *cgrp = &root->top_cgroup;
INIT_LIST_HEAD(&root->subsys_list); INIT_LIST_HEAD(&root->subsys_list);
INIT_LIST_HEAD(&root->root_list); INIT_LIST_HEAD(&root->root_list);
root->number_of_cgroups = 1; root->number_of_cgroups = 1;
cont->root = root; cgrp->root = root;
cont->top_cgroup = cont; cgrp->top_cgroup = cgrp;
INIT_LIST_HEAD(&cont->sibling); INIT_LIST_HEAD(&cgrp->sibling);
INIT_LIST_HEAD(&cont->children); INIT_LIST_HEAD(&cgrp->children);
INIT_LIST_HEAD(&cont->css_sets); INIT_LIST_HEAD(&cgrp->css_sets);
INIT_LIST_HEAD(&cont->release_list); INIT_LIST_HEAD(&cgrp->release_list);
} }
static int cgroup_test_super(struct super_block *sb, void *data) static int cgroup_test_super(struct super_block *sb, void *data)
...@@ -955,7 +955,7 @@ static int cgroup_get_sb(struct file_system_type *fs_type, ...@@ -955,7 +955,7 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
root = NULL; root = NULL;
} else { } else {
/* New superblock */ /* New superblock */
struct cgroup *cont = &root->top_cgroup; struct cgroup *cgrp = &root->top_cgroup;
struct inode *inode; struct inode *inode;
BUG_ON(sb->s_root != NULL); BUG_ON(sb->s_root != NULL);
...@@ -1009,10 +1009,10 @@ static int cgroup_get_sb(struct file_system_type *fs_type, ...@@ -1009,10 +1009,10 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
BUG_ON(list_empty(&tmp_cg_links)); BUG_ON(list_empty(&tmp_cg_links));
link = list_entry(tmp_cg_links.next, link = list_entry(tmp_cg_links.next,
struct cg_cgroup_link, struct cg_cgroup_link,
cont_link_list); cgrp_link_list);
list_del(&link->cont_link_list); list_del(&link->cgrp_link_list);
link->cg = cg; link->cg = cg;
list_add(&link->cont_link_list, list_add(&link->cgrp_link_list,
&root->top_cgroup.css_sets); &root->top_cgroup.css_sets);
list_add(&link->cg_link_list, &cg->cg_links); list_add(&link->cg_link_list, &cg->cg_links);
l = l->next; l = l->next;
...@@ -1021,11 +1021,11 @@ static int cgroup_get_sb(struct file_system_type *fs_type, ...@@ -1021,11 +1021,11 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
free_cg_links(&tmp_cg_links); free_cg_links(&tmp_cg_links);
BUG_ON(!list_empty(&cont->sibling)); BUG_ON(!list_empty(&cgrp->sibling));
BUG_ON(!list_empty(&cont->children)); BUG_ON(!list_empty(&cgrp->children));
BUG_ON(root->number_of_cgroups != 1); BUG_ON(root->number_of_cgroups != 1);
cgroup_populate_dir(cont); cgroup_populate_dir(cgrp);
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
} }
...@@ -1041,14 +1041,14 @@ static int cgroup_get_sb(struct file_system_type *fs_type, ...@@ -1041,14 +1041,14 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
static void cgroup_kill_sb(struct super_block *sb) { static void cgroup_kill_sb(struct super_block *sb) {
struct cgroupfs_root *root = sb->s_fs_info; struct cgroupfs_root *root = sb->s_fs_info;
struct cgroup *cont = &root->top_cgroup; struct cgroup *cgrp = &root->top_cgroup;
int ret; int ret;
BUG_ON(!root); BUG_ON(!root);
BUG_ON(root->number_of_cgroups != 1); BUG_ON(root->number_of_cgroups != 1);
BUG_ON(!list_empty(&cont->children)); BUG_ON(!list_empty(&cgrp->children));
BUG_ON(!list_empty(&cont->sibling)); BUG_ON(!list_empty(&cgrp->sibling));
mutex_lock(&cgroup_mutex); mutex_lock(&cgroup_mutex);
...@@ -1062,12 +1062,12 @@ static void cgroup_kill_sb(struct super_block *sb) { ...@@ -1062,12 +1062,12 @@ static void cgroup_kill_sb(struct super_block *sb) {
* root cgroup * root cgroup
*/ */
write_lock(&css_set_lock); write_lock(&css_set_lock);
while (!list_empty(&cont->css_sets)) { while (!list_empty(&cgrp->css_sets)) {
struct cg_cgroup_link *link; struct cg_cgroup_link *link;
link = list_entry(cont->css_sets.next, link = list_entry(cgrp->css_sets.next,
struct cg_cgroup_link, cont_link_list); struct cg_cgroup_link, cgrp_link_list);
list_del(&link->cg_link_list); list_del(&link->cg_link_list);
list_del(&link->cont_link_list); list_del(&link->cgrp_link_list);
kfree(link); kfree(link);
} }
write_unlock(&css_set_lock); write_unlock(&css_set_lock);
...@@ -1088,7 +1088,7 @@ static struct file_system_type cgroup_fs_type = { ...@@ -1088,7 +1088,7 @@ static struct file_system_type cgroup_fs_type = {
.kill_sb = cgroup_kill_sb, .kill_sb = cgroup_kill_sb,
}; };
static inline struct cgroup *__d_cont(struct dentry *dentry) static inline struct cgroup *__d_cgrp(struct dentry *dentry)
{ {
return dentry->d_fsdata; return dentry->d_fsdata;
} }
...@@ -1102,11 +1102,11 @@ static inline struct cftype *__d_cft(struct dentry *dentry) ...@@ -1102,11 +1102,11 @@ static inline struct cftype *__d_cft(struct dentry *dentry)
* Called with cgroup_mutex held. Writes path of cgroup into buf. * Called with cgroup_mutex held. Writes path of cgroup into buf.
* Returns 0 on success, -errno on error. * Returns 0 on success, -errno on error.
*/ */
int cgroup_path(const struct cgroup *cont, char *buf, int buflen) int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen)
{ {
char *start; char *start;
if (cont == dummytop) { if (cgrp == dummytop) {
/* /*
* Inactive subsystems have no dentry for their root * Inactive subsystems have no dentry for their root
* cgroup * cgroup
...@@ -1119,14 +1119,14 @@ int cgroup_path(const struct cgroup *cont, char *buf, int buflen) ...@@ -1119,14 +1119,14 @@ int cgroup_path(const struct cgroup *cont, char *buf, int buflen)
*--start = '\0'; *--start = '\0';
for (;;) { for (;;) {
int len = cont->dentry->d_name.len; int len = cgrp->dentry->d_name.len;
if ((start -= len) < buf) if ((start -= len) < buf)
return -ENAMETOOLONG; return -ENAMETOOLONG;
memcpy(start, cont->dentry->d_name.name, len); memcpy(start, cgrp->dentry->d_name.name, len);
cont = cont->parent; cgrp = cgrp->parent;
if (!cont) if (!cgrp)
break; break;
if (!cont->parent) if (!cgrp->parent)
continue; continue;
if (--start < buf) if (--start < buf)
return -ENAMETOOLONG; return -ENAMETOOLONG;
...@@ -1141,16 +1141,16 @@ int cgroup_path(const struct cgroup *cont, char *buf, int buflen) ...@@ -1141,16 +1141,16 @@ int cgroup_path(const struct cgroup *cont, char *buf, int buflen)
* its subsystem id. * its subsystem id.
*/ */
static void get_first_subsys(const struct cgroup *cont, static void get_first_subsys(const struct cgroup *cgrp,
struct cgroup_subsys_state **css, int *subsys_id) struct cgroup_subsys_state **css, int *subsys_id)
{ {
const struct cgroupfs_root *root = cont->root; const struct cgroupfs_root *root = cgrp->root;
const struct cgroup_subsys *test_ss; const struct cgroup_subsys *test_ss;
BUG_ON(list_empty(&root->subsys_list)); BUG_ON(list_empty(&root->subsys_list));
test_ss = list_entry(root->subsys_list.next, test_ss = list_entry(root->subsys_list.next,
struct cgroup_subsys, sibling); struct cgroup_subsys, sibling);
if (css) { if (css) {
*css = cont->subsys[test_ss->subsys_id]; *css = cgrp->subsys[test_ss->subsys_id];
BUG_ON(!*css); BUG_ON(!*css);
} }
if (subsys_id) if (subsys_id)
...@@ -1158,31 +1158,31 @@ static void get_first_subsys(const struct cgroup *cont, ...@@ -1158,31 +1158,31 @@ static void get_first_subsys(const struct cgroup *cont,
} }
/* /*
* Attach task 'tsk' to cgroup 'cont' * Attach task 'tsk' to cgroup 'cgrp'
* *
* Call holding cgroup_mutex. May take task_lock of * Call holding cgroup_mutex. May take task_lock of
* the task 'pid' during call. * the task 'pid' during call.
*/ */
static int attach_task(struct cgroup *cont, struct task_struct *tsk) static int attach_task(struct cgroup *cgrp, struct task_struct *tsk)
{ {
int retval = 0; int retval = 0;
struct cgroup_subsys *ss; struct cgroup_subsys *ss;
struct cgroup *oldcont; struct cgroup *oldcgrp;
struct css_set *cg = tsk->cgroups; struct css_set *cg = tsk->cgroups;
struct css_set *newcg; struct css_set *newcg;
struct cgroupfs_root *root = cont->root; struct cgroupfs_root *root = cgrp->root;
int subsys_id; int subsys_id;
get_first_subsys(cont, NULL, &subsys_id); get_first_subsys(cgrp, NULL, &subsys_id);
/* Nothing to do if the task is already in that cgroup */ /* Nothing to do if the task is already in that cgroup */
oldcont = task_cgroup(tsk, subsys_id); oldcgrp = task_cgroup(tsk, subsys_id);
if (cont == oldcont) if (cgrp == oldcgrp)
return 0; return 0;
for_each_subsys(root, ss) { for_each_subsys(root, ss) {
if (ss->can_attach) { if (ss->can_attach) {
retval = ss->can_attach(ss, cont, tsk); retval = ss->can_attach(ss, cgrp, tsk);
if (retval) { if (retval) {
return retval; return retval;
} }
...@@ -1193,7 +1193,7 @@ static int attach_task(struct cgroup *cont, struct task_struct *tsk) ...@@ -1193,7 +1193,7 @@ static int attach_task(struct cgroup *cont, struct task_struct *tsk)
* Locate or allocate a new css_set for this task, * Locate or allocate a new css_set for this task,
* based on its final set of cgroups * based on its final set of cgroups
*/ */
newcg = find_css_set(cg, cont); newcg = find_css_set(cg, cgrp);
if (!newcg) { if (!newcg) {
return -ENOMEM; return -ENOMEM;
} }
...@@ -1217,20 +1217,20 @@ static int attach_task(struct cgroup *cont, struct task_struct *tsk) ...@@ -1217,20 +1217,20 @@ static int attach_task(struct cgroup *cont, struct task_struct *tsk)
for_each_subsys(root, ss) { for_each_subsys(root, ss) {
if (ss->attach) { if (ss->attach) {
ss->attach(ss, cont, oldcont, tsk); ss->attach(ss, cgrp, oldcgrp, tsk);
} }
} }
set_bit(CONT_RELEASABLE, &oldcont->flags); set_bit(CGRP_RELEASABLE, &oldcgrp->flags);
synchronize_rcu(); synchronize_rcu();
put_css_set(cg); put_css_set(cg);
return 0; return 0;
} }
/* /*
* Attach task with pid 'pid' to cgroup 'cont'. Call with * Attach task with pid 'pid' to cgroup 'cgrp'. Call with
* cgroup_mutex, may take task_lock of task * cgroup_mutex, may take task_lock of task
*/ */
static int attach_task_by_pid(struct cgroup *cont, char *pidbuf) static int attach_task_by_pid(struct cgroup *cgrp, char *pidbuf)
{ {
pid_t pid; pid_t pid;
struct task_struct *tsk; struct task_struct *tsk;
...@@ -1259,7 +1259,7 @@ static int attach_task_by_pid(struct cgroup *cont, char *pidbuf) ...@@ -1259,7 +1259,7 @@ static int attach_task_by_pid(struct cgroup *cont, char *pidbuf)
get_task_struct(tsk); get_task_struct(tsk);
} }
ret = attach_task(cont, tsk); ret = attach_task(cgrp, tsk);
put_task_struct(tsk); put_task_struct(tsk);
return ret; return ret;
} }
...@@ -1275,7 +1275,7 @@ enum cgroup_filetype { ...@@ -1275,7 +1275,7 @@ enum cgroup_filetype {
FILE_RELEASE_AGENT, FILE_RELEASE_AGENT,
}; };
static ssize_t cgroup_write_uint(struct cgroup *cont, struct cftype *cft, static ssize_t cgroup_write_uint(struct cgroup *cgrp, struct cftype *cft,
struct file *file, struct file *file,
const char __user *userbuf, const char __user *userbuf,
size_t nbytes, loff_t *unused_ppos) size_t nbytes, loff_t *unused_ppos)
...@@ -1302,13 +1302,13 @@ static ssize_t cgroup_write_uint(struct cgroup *cont, struct cftype *cft, ...@@ -1302,13 +1302,13 @@ static ssize_t cgroup_write_uint(struct cgroup *cont, struct cftype *cft,
return -EINVAL; return -EINVAL;
/* Pass to subsystem */ /* Pass to subsystem */
retval = cft->write_uint(cont, cft, val); retval = cft->write_uint(cgrp, cft, val);
if (!retval) if (!retval)
retval = nbytes; retval = nbytes;
return retval; return retval;
} }
static ssize_t cgroup_common_file_write(struct cgroup *cont, static ssize_t cgroup_common_file_write(struct cgroup *cgrp,
struct cftype *cft, struct cftype *cft,
struct file *file, struct file *file,
const char __user *userbuf, const char __user *userbuf,
...@@ -1334,25 +1334,25 @@ static ssize_t cgroup_common_file_write(struct cgroup *cont, ...@@ -1334,25 +1334,25 @@ static ssize_t cgroup_common_file_write(struct cgroup *cont,
mutex_lock(&cgroup_mutex); mutex_lock(&cgroup_mutex);
if (cgroup_is_removed(cont)) { if (cgroup_is_removed(cgrp)) {
retval = -ENODEV; retval = -ENODEV;
goto out2; goto out2;
} }
switch (type) { switch (type) {
case FILE_TASKLIST: case FILE_TASKLIST:
retval = attach_task_by_pid(cont, buffer); retval = attach_task_by_pid(cgrp, buffer);
break; break;
case FILE_NOTIFY_ON_RELEASE: case FILE_NOTIFY_ON_RELEASE:
clear_bit(CONT_RELEASABLE, &cont->flags); clear_bit(CGRP_RELEASABLE, &cgrp->flags);
if (simple_strtoul(buffer, NULL, 10) != 0) if (simple_strtoul(buffer, NULL, 10) != 0)
set_bit(CONT_NOTIFY_ON_RELEASE, &cont->flags); set_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
else else
clear_bit(CONT_NOTIFY_ON_RELEASE, &cont->flags); clear_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
break; break;
case FILE_RELEASE_AGENT: case FILE_RELEASE_AGENT:
{ {
struct cgroupfs_root *root = cont->root; struct cgroupfs_root *root = cgrp->root;
/* Strip trailing newline */ /* Strip trailing newline */
if (nbytes && (buffer[nbytes-1] == '\n')) { if (nbytes && (buffer[nbytes-1] == '\n')) {
buffer[nbytes-1] = 0; buffer[nbytes-1] = 0;
...@@ -1387,30 +1387,30 @@ static ssize_t cgroup_file_write(struct file *file, const char __user *buf, ...@@ -1387,30 +1387,30 @@ static ssize_t cgroup_file_write(struct file *file, const char __user *buf,
size_t nbytes, loff_t *ppos) size_t nbytes, loff_t *ppos)
{ {
struct cftype *cft = __d_cft(file->f_dentry); struct cftype *cft = __d_cft(file->f_dentry);
struct cgroup *cont = __d_cont(file->f_dentry->d_parent); struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
if (!cft) if (!cft)
return -ENODEV; return -ENODEV;
if (cft->write) if (cft->write)
return cft->write(cont, cft, file, buf, nbytes, ppos); return cft->write(cgrp, cft, file, buf, nbytes, ppos);
if (cft->write_uint) if (cft->write_uint)
return cgroup_write_uint(cont, cft, file, buf, nbytes, ppos); return cgroup_write_uint(cgrp, cft, file, buf, nbytes, ppos);
return -EINVAL; return -EINVAL;
} }
static ssize_t cgroup_read_uint(struct cgroup *cont, struct cftype *cft, static ssize_t cgroup_read_uint(struct cgroup *cgrp, struct cftype *cft,
struct file *file, struct file *file,
char __user *buf, size_t nbytes, char __user *buf, size_t nbytes,
loff_t *ppos) loff_t *ppos)
{ {
char tmp[64]; char tmp[64];
u64 val = cft->read_uint(cont, cft); u64 val = cft->read_uint(cgrp, cft);
int len = sprintf(tmp, "%llu\n", (unsigned long long) val); int len = sprintf(tmp, "%llu\n", (unsigned long long) val);
return simple_read_from_buffer(buf, nbytes, ppos, tmp, len); return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
} }
static ssize_t cgroup_common_file_read(struct cgroup *cont, static ssize_t cgroup_common_file_read(struct cgroup *cgrp,
struct cftype *cft, struct cftype *cft,
struct file *file, struct file *file,
char __user *buf, char __user *buf,
...@@ -1432,7 +1432,7 @@ static ssize_t cgroup_common_file_read(struct cgroup *cont, ...@@ -1432,7 +1432,7 @@ static ssize_t cgroup_common_file_read(struct cgroup *cont,
struct cgroupfs_root *root; struct cgroupfs_root *root;
size_t n; size_t n;
mutex_lock(&cgroup_mutex); mutex_lock(&cgroup_mutex);
root = cont->root; root = cgrp->root;
n = strnlen(root->release_agent_path, n = strnlen(root->release_agent_path,
sizeof(root->release_agent_path)); sizeof(root->release_agent_path));
n = min(n, (size_t) PAGE_SIZE); n = min(n, (size_t) PAGE_SIZE);
...@@ -1457,15 +1457,15 @@ static ssize_t cgroup_file_read(struct file *file, char __user *buf, ...@@ -1457,15 +1457,15 @@ static ssize_t cgroup_file_read(struct file *file, char __user *buf,
size_t nbytes, loff_t *ppos) size_t nbytes, loff_t *ppos)
{ {
struct cftype *cft = __d_cft(file->f_dentry); struct cftype *cft = __d_cft(file->f_dentry);
struct cgroup *cont = __d_cont(file->f_dentry->d_parent); struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
if (!cft) if (!cft)
return -ENODEV; return -ENODEV;
if (cft->read) if (cft->read)
return cft->read(cont, cft, file, buf, nbytes, ppos); return cft->read(cgrp, cft, file, buf, nbytes, ppos);
if (cft->read_uint) if (cft->read_uint)
return cgroup_read_uint(cont, cft, file, buf, nbytes, ppos); return cgroup_read_uint(cgrp, cft, file, buf, nbytes, ppos);
return -EINVAL; return -EINVAL;
} }
...@@ -1567,24 +1567,24 @@ static int cgroup_create_file(struct dentry *dentry, int mode, ...@@ -1567,24 +1567,24 @@ static int cgroup_create_file(struct dentry *dentry, int mode,
/* /*
* cgroup_create_dir - create a directory for an object. * cgroup_create_dir - create a directory for an object.
* cont: the cgroup we create the directory for. * cgrp: the cgroup we create the directory for.
* It must have a valid ->parent field * It must have a valid ->parent field
* And we are going to fill its ->dentry field. * And we are going to fill its ->dentry field.
* dentry: dentry of the new container * dentry: dentry of the new cgroup
* mode: mode to set on new directory. * mode: mode to set on new directory.
*/ */
static int cgroup_create_dir(struct cgroup *cont, struct dentry *dentry, static int cgroup_create_dir(struct cgroup *cgrp, struct dentry *dentry,
int mode) int mode)
{ {
struct dentry *parent; struct dentry *parent;
int error = 0; int error = 0;
parent = cont->parent->dentry; parent = cgrp->parent->dentry;
error = cgroup_create_file(dentry, S_IFDIR | mode, cont->root->sb); error = cgroup_create_file(dentry, S_IFDIR | mode, cgrp->root->sb);
if (!error) { if (!error) {
dentry->d_fsdata = cont; dentry->d_fsdata = cgrp;
inc_nlink(parent->d_inode); inc_nlink(parent->d_inode);
cont->dentry = dentry; cgrp->dentry = dentry;
dget(dentry); dget(dentry);
} }
dput(dentry); dput(dentry);
...@@ -1592,16 +1592,16 @@ static int cgroup_create_dir(struct cgroup *cont, struct dentry *dentry, ...@@ -1592,16 +1592,16 @@ static int cgroup_create_dir(struct cgroup *cont, struct dentry *dentry,
return error; return error;
} }
int cgroup_add_file(struct cgroup *cont, int cgroup_add_file(struct cgroup *cgrp,
struct cgroup_subsys *subsys, struct cgroup_subsys *subsys,
const struct cftype *cft) const struct cftype *cft)
{ {
struct dentry *dir = cont->dentry; struct dentry *dir = cgrp->dentry;
struct dentry *dentry; struct dentry *dentry;
int error; int error;
char name[MAX_CGROUP_TYPE_NAMELEN + MAX_CFTYPE_NAME + 2] = { 0 }; char name[MAX_CGROUP_TYPE_NAMELEN + MAX_CFTYPE_NAME + 2] = { 0 };
if (subsys && !test_bit(ROOT_NOPREFIX, &cont->root->flags)) { if (subsys && !test_bit(ROOT_NOPREFIX, &cgrp->root->flags)) {
strcpy(name, subsys->name); strcpy(name, subsys->name);
strcat(name, "."); strcat(name, ".");
} }
...@@ -1610,7 +1610,7 @@ int cgroup_add_file(struct cgroup *cont, ...@@ -1610,7 +1610,7 @@ int cgroup_add_file(struct cgroup *cont,
dentry = lookup_one_len(name, dir, strlen(name)); dentry = lookup_one_len(name, dir, strlen(name));
if (!IS_ERR(dentry)) { if (!IS_ERR(dentry)) {
error = cgroup_create_file(dentry, 0644 | S_IFREG, error = cgroup_create_file(dentry, 0644 | S_IFREG,
cont->root->sb); cgrp->root->sb);
if (!error) if (!error)
dentry->d_fsdata = (void *)cft; dentry->d_fsdata = (void *)cft;
dput(dentry); dput(dentry);
...@@ -1619,14 +1619,14 @@ int cgroup_add_file(struct cgroup *cont, ...@@ -1619,14 +1619,14 @@ int cgroup_add_file(struct cgroup *cont,
return error; return error;
} }
int cgroup_add_files(struct cgroup *cont, int cgroup_add_files(struct cgroup *cgrp,
struct cgroup_subsys *subsys, struct cgroup_subsys *subsys,
const struct cftype cft[], const struct cftype cft[],
int count) int count)
{ {
int i, err; int i, err;
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
err = cgroup_add_file(cont, subsys, &cft[i]); err = cgroup_add_file(cgrp, subsys, &cft[i]);
if (err) if (err)
return err; return err;
} }
...@@ -1635,16 +1635,16 @@ int cgroup_add_files(struct cgroup *cont, ...@@ -1635,16 +1635,16 @@ int cgroup_add_files(struct cgroup *cont,
/* Count the number of tasks in a cgroup. */ /* Count the number of tasks in a cgroup. */
int cgroup_task_count(const struct cgroup *cont) int cgroup_task_count(const struct cgroup *cgrp)
{ {
int count = 0; int count = 0;
struct list_head *l; struct list_head *l;
read_lock(&css_set_lock); read_lock(&css_set_lock);
l = cont->css_sets.next; l = cgrp->css_sets.next;
while (l != &cont->css_sets) { while (l != &cgrp->css_sets) {
struct cg_cgroup_link *link = struct cg_cgroup_link *link =
list_entry(l, struct cg_cgroup_link, cont_link_list); list_entry(l, struct cg_cgroup_link, cgrp_link_list);
count += atomic_read(&link->cg->ref.refcount); count += atomic_read(&link->cg->ref.refcount);
l = l->next; l = l->next;
} }
...@@ -1656,7 +1656,7 @@ int cgroup_task_count(const struct cgroup *cont) ...@@ -1656,7 +1656,7 @@ int cgroup_task_count(const struct cgroup *cont)
* Advance a list_head iterator. The iterator should be positioned at * Advance a list_head iterator. The iterator should be positioned at
* the start of a css_set * the start of a css_set
*/ */
static void cgroup_advance_iter(struct cgroup *cont, static void cgroup_advance_iter(struct cgroup *cgrp,
struct cgroup_iter *it) struct cgroup_iter *it)
{ {
struct list_head *l = it->cg_link; struct list_head *l = it->cg_link;
...@@ -1666,18 +1666,18 @@ static void cgroup_advance_iter(struct cgroup *cont, ...@@ -1666,18 +1666,18 @@ static void cgroup_advance_iter(struct cgroup *cont,
/* Advance to the next non-empty css_set */ /* Advance to the next non-empty css_set */
do { do {
l = l->next; l = l->next;
if (l == &cont->css_sets) { if (l == &cgrp->css_sets) {
it->cg_link = NULL; it->cg_link = NULL;
return; return;
} }
link = list_entry(l, struct cg_cgroup_link, cont_link_list); link = list_entry(l, struct cg_cgroup_link, cgrp_link_list);
cg = link->cg; cg = link->cg;
} while (list_empty(&cg->tasks)); } while (list_empty(&cg->tasks));
it->cg_link = l; it->cg_link = l;
it->task = cg->tasks.next; it->task = cg->tasks.next;
} }
void cgroup_iter_start(struct cgroup *cont, struct cgroup_iter *it) void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it)
{ {
/* /*
* The first time anyone tries to iterate across a cgroup, * The first time anyone tries to iterate across a cgroup,
...@@ -1697,11 +1697,11 @@ void cgroup_iter_start(struct cgroup *cont, struct cgroup_iter *it) ...@@ -1697,11 +1697,11 @@ void cgroup_iter_start(struct cgroup *cont, struct cgroup_iter *it)
write_unlock(&css_set_lock); write_unlock(&css_set_lock);
} }
read_lock(&css_set_lock); read_lock(&css_set_lock);
it->cg_link = &cont->css_sets; it->cg_link = &cgrp->css_sets;
cgroup_advance_iter(cont, it); cgroup_advance_iter(cgrp, it);
} }
struct task_struct *cgroup_iter_next(struct cgroup *cont, struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
struct cgroup_iter *it) struct cgroup_iter *it)
{ {
struct task_struct *res; struct task_struct *res;
...@@ -1716,14 +1716,14 @@ struct task_struct *cgroup_iter_next(struct cgroup *cont, ...@@ -1716,14 +1716,14 @@ struct task_struct *cgroup_iter_next(struct cgroup *cont,
if (l == &res->cgroups->tasks) { if (l == &res->cgroups->tasks) {
/* We reached the end of this task list - move on to /* We reached the end of this task list - move on to
* the next cg_cgroup_link */ * the next cg_cgroup_link */
cgroup_advance_iter(cont, it); cgroup_advance_iter(cgrp, it);
} else { } else {
it->task = l; it->task = l;
} }
return res; return res;
} }
void cgroup_iter_end(struct cgroup *cont, struct cgroup_iter *it) void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it)
{ {
read_unlock(&css_set_lock); read_unlock(&css_set_lock);
} }
...@@ -1749,23 +1749,23 @@ struct ctr_struct { ...@@ -1749,23 +1749,23 @@ struct ctr_struct {
/* /*
* Load into 'pidarray' up to 'npids' of the tasks using cgroup * Load into 'pidarray' up to 'npids' of the tasks using cgroup
* 'cont'. Return actual number of pids loaded. No need to * 'cgrp'. Return actual number of pids loaded. No need to
* task_lock(p) when reading out p->cgroup, since we're in an RCU * task_lock(p) when reading out p->cgroup, since we're in an RCU
* read section, so the css_set can't go away, and is * read section, so the css_set can't go away, and is
* immutable after creation. * immutable after creation.
*/ */
static int pid_array_load(pid_t *pidarray, int npids, struct cgroup *cont) static int pid_array_load(pid_t *pidarray, int npids, struct cgroup *cgrp)
{ {
int n = 0; int n = 0;
struct cgroup_iter it; struct cgroup_iter it;
struct task_struct *tsk; struct task_struct *tsk;
cgroup_iter_start(cont, &it); cgroup_iter_start(cgrp, &it);
while ((tsk = cgroup_iter_next(cont, &it))) { while ((tsk = cgroup_iter_next(cgrp, &it))) {
if (unlikely(n == npids)) if (unlikely(n == npids))
break; break;
pidarray[n++] = task_pid_nr(tsk); pidarray[n++] = task_pid_nr(tsk);
} }
cgroup_iter_end(cont, &it); cgroup_iter_end(cgrp, &it);
return n; return n;
} }
...@@ -1780,7 +1780,7 @@ static int pid_array_load(pid_t *pidarray, int npids, struct cgroup *cont) ...@@ -1780,7 +1780,7 @@ static int pid_array_load(pid_t *pidarray, int npids, struct cgroup *cont)
int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry) int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
{ {
int ret = -EINVAL; int ret = -EINVAL;
struct cgroup *cont; struct cgroup *cgrp;
struct cgroup_iter it; struct cgroup_iter it;
struct task_struct *tsk; struct task_struct *tsk;
/* /*
...@@ -1790,11 +1790,11 @@ int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry) ...@@ -1790,11 +1790,11 @@ int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
goto err; goto err;
ret = 0; ret = 0;
cont = dentry->d_fsdata; cgrp = dentry->d_fsdata;
rcu_read_lock(); rcu_read_lock();
cgroup_iter_start(cont, &it); cgroup_iter_start(cgrp, &it);
while ((tsk = cgroup_iter_next(cont, &it))) { while ((tsk = cgroup_iter_next(cgrp, &it))) {
switch (tsk->state) { switch (tsk->state) {
case TASK_RUNNING: case TASK_RUNNING:
stats->nr_running++; stats->nr_running++;
...@@ -1814,7 +1814,7 @@ int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry) ...@@ -1814,7 +1814,7 @@ int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
break; break;
} }
} }
cgroup_iter_end(cont, &it); cgroup_iter_end(cgrp, &it);
rcu_read_unlock(); rcu_read_unlock();
err: err:
...@@ -1849,7 +1849,7 @@ static int pid_array_to_buf(char *buf, int sz, pid_t *a, int npids) ...@@ -1849,7 +1849,7 @@ static int pid_array_to_buf(char *buf, int sz, pid_t *a, int npids)
*/ */
static int cgroup_tasks_open(struct inode *unused, struct file *file) static int cgroup_tasks_open(struct inode *unused, struct file *file)
{ {
struct cgroup *cont = __d_cont(file->f_dentry->d_parent); struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
struct ctr_struct *ctr; struct ctr_struct *ctr;
pid_t *pidarray; pid_t *pidarray;
int npids; int npids;
...@@ -1868,13 +1868,13 @@ static int cgroup_tasks_open(struct inode *unused, struct file *file) ...@@ -1868,13 +1868,13 @@ static int cgroup_tasks_open(struct inode *unused, struct file *file)
* caller from the case that the additional cgroup users didn't * caller from the case that the additional cgroup users didn't
* show up until sometime later on. * show up until sometime later on.
*/ */
npids = cgroup_task_count(cont); npids = cgroup_task_count(cgrp);
if (npids) { if (npids) {
pidarray = kmalloc(npids * sizeof(pid_t), GFP_KERNEL); pidarray = kmalloc(npids * sizeof(pid_t), GFP_KERNEL);
if (!pidarray) if (!pidarray)
goto err1; goto err1;
npids = pid_array_load(pidarray, npids, cont); npids = pid_array_load(pidarray, npids, cgrp);
sort(pidarray, npids, sizeof(pid_t), cmppid, NULL); sort(pidarray, npids, sizeof(pid_t), cmppid, NULL);
/* Call pid_array_to_buf() twice, first just to get bufsz */ /* Call pid_array_to_buf() twice, first just to get bufsz */
...@@ -1900,7 +1900,7 @@ static int cgroup_tasks_open(struct inode *unused, struct file *file) ...@@ -1900,7 +1900,7 @@ static int cgroup_tasks_open(struct inode *unused, struct file *file)
return -ENOMEM; return -ENOMEM;
} }
static ssize_t cgroup_tasks_read(struct cgroup *cont, static ssize_t cgroup_tasks_read(struct cgroup *cgrp,
struct cftype *cft, struct cftype *cft,
struct file *file, char __user *buf, struct file *file, char __user *buf,
size_t nbytes, loff_t *ppos) size_t nbytes, loff_t *ppos)
...@@ -1923,15 +1923,15 @@ static int cgroup_tasks_release(struct inode *unused_inode, ...@@ -1923,15 +1923,15 @@ static int cgroup_tasks_release(struct inode *unused_inode,
return 0; return 0;
} }
static u64 cgroup_read_notify_on_release(struct cgroup *cont, static u64 cgroup_read_notify_on_release(struct cgroup *cgrp,
struct cftype *cft) struct cftype *cft)
{ {
return notify_on_release(cont); return notify_on_release(cgrp);
} }
static u64 cgroup_read_releasable(struct cgroup *cont, struct cftype *cft) static u64 cgroup_read_releasable(struct cgroup *cgrp, struct cftype *cft)
{ {
return test_bit(CONT_RELEASABLE, &cont->flags); return test_bit(CGRP_RELEASABLE, &cgrp->flags);
} }
/* /*
...@@ -1968,25 +1968,25 @@ static struct cftype cft_release_agent = { ...@@ -1968,25 +1968,25 @@ static struct cftype cft_release_agent = {
.private = FILE_RELEASE_AGENT, .private = FILE_RELEASE_AGENT,
}; };
static int cgroup_populate_dir(struct cgroup *cont) static int cgroup_populate_dir(struct cgroup *cgrp)
{ {
int err; int err;
struct cgroup_subsys *ss; struct cgroup_subsys *ss;
/* First clear out any existing files */ /* First clear out any existing files */
cgroup_clear_directory(cont->dentry); cgroup_clear_directory(cgrp->dentry);
err = cgroup_add_files(cont, NULL, files, ARRAY_SIZE(files)); err = cgroup_add_files(cgrp, NULL, files, ARRAY_SIZE(files));
if (err < 0) if (err < 0)
return err; return err;
if (cont == cont->top_cgroup) { if (cgrp == cgrp->top_cgroup) {
if ((err = cgroup_add_file(cont, NULL, &cft_release_agent)) < 0) if ((err = cgroup_add_file(cgrp, NULL, &cft_release_agent)) < 0)
return err; return err;
} }
for_each_subsys(cont->root, ss) { for_each_subsys(cgrp->root, ss) {
if (ss->populate && (err = ss->populate(ss, cont)) < 0) if (ss->populate && (err = ss->populate(ss, cgrp)) < 0)
return err; return err;
} }
...@@ -1995,15 +1995,15 @@ static int cgroup_populate_dir(struct cgroup *cont) ...@@ -1995,15 +1995,15 @@ static int cgroup_populate_dir(struct cgroup *cont)
static void init_cgroup_css(struct cgroup_subsys_state *css, static void init_cgroup_css(struct cgroup_subsys_state *css,
struct cgroup_subsys *ss, struct cgroup_subsys *ss,
struct cgroup *cont) struct cgroup *cgrp)
{ {
css->cgroup = cont; css->cgroup = cgrp;
atomic_set(&css->refcnt, 0); atomic_set(&css->refcnt, 0);
css->flags = 0; css->flags = 0;
if (cont == dummytop) if (cgrp == dummytop)
set_bit(CSS_ROOT, &css->flags); set_bit(CSS_ROOT, &css->flags);
BUG_ON(cont->subsys[ss->subsys_id]); BUG_ON(cgrp->subsys[ss->subsys_id]);
cont->subsys[ss->subsys_id] = css; cgrp->subsys[ss->subsys_id] = css;
} }
/* /*
...@@ -2018,14 +2018,14 @@ static void init_cgroup_css(struct cgroup_subsys_state *css, ...@@ -2018,14 +2018,14 @@ static void init_cgroup_css(struct cgroup_subsys_state *css,
static long cgroup_create(struct cgroup *parent, struct dentry *dentry, static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
int mode) int mode)
{ {
struct cgroup *cont; struct cgroup *cgrp;
struct cgroupfs_root *root = parent->root; struct cgroupfs_root *root = parent->root;
int err = 0; int err = 0;
struct cgroup_subsys *ss; struct cgroup_subsys *ss;
struct super_block *sb = root->sb; struct super_block *sb = root->sb;
cont = kzalloc(sizeof(*cont), GFP_KERNEL); cgrp = kzalloc(sizeof(*cgrp), GFP_KERNEL);
if (!cont) if (!cgrp)
return -ENOMEM; return -ENOMEM;
/* Grab a reference on the superblock so the hierarchy doesn't /* Grab a reference on the superblock so the hierarchy doesn't
...@@ -2037,53 +2037,53 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry, ...@@ -2037,53 +2037,53 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
mutex_lock(&cgroup_mutex); mutex_lock(&cgroup_mutex);
cont->flags = 0; cgrp->flags = 0;
INIT_LIST_HEAD(&cont->sibling); INIT_LIST_HEAD(&cgrp->sibling);
INIT_LIST_HEAD(&cont->children); INIT_LIST_HEAD(&cgrp->children);
INIT_LIST_HEAD(&cont->css_sets); INIT_LIST_HEAD(&cgrp->css_sets);
INIT_LIST_HEAD(&cont->release_list); INIT_LIST_HEAD(&cgrp->release_list);
cont->parent = parent; cgrp->parent = parent;
cont->root = parent->root; cgrp->root = parent->root;
cont->top_cgroup = parent->top_cgroup; cgrp->top_cgroup = parent->top_cgroup;
for_each_subsys(root, ss) { for_each_subsys(root, ss) {
struct cgroup_subsys_state *css = ss->create(ss, cont); struct cgroup_subsys_state *css = ss->create(ss, cgrp);
if (IS_ERR(css)) { if (IS_ERR(css)) {
err = PTR_ERR(css); err = PTR_ERR(css);
goto err_destroy; goto err_destroy;
} }
init_cgroup_css(css, ss, cont); init_cgroup_css(css, ss, cgrp);
} }
list_add(&cont->sibling, &cont->parent->children); list_add(&cgrp->sibling, &cgrp->parent->children);
root->number_of_cgroups++; root->number_of_cgroups++;
err = cgroup_create_dir(cont, dentry, mode); err = cgroup_create_dir(cgrp, dentry, mode);
if (err < 0) if (err < 0)
goto err_remove; goto err_remove;
/* The cgroup directory was pre-locked for us */ /* The cgroup directory was pre-locked for us */
BUG_ON(!mutex_is_locked(&cont->dentry->d_inode->i_mutex)); BUG_ON(!mutex_is_locked(&cgrp->dentry->d_inode->i_mutex));
err = cgroup_populate_dir(cont); err = cgroup_populate_dir(cgrp);
/* If err < 0, we have a half-filled directory - oh well ;) */ /* If err < 0, we have a half-filled directory - oh well ;) */
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
mutex_unlock(&cont->dentry->d_inode->i_mutex); mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
return 0; return 0;
err_remove: err_remove:
list_del(&cont->sibling); list_del(&cgrp->sibling);
root->number_of_cgroups--; root->number_of_cgroups--;
err_destroy: err_destroy:
for_each_subsys(root, ss) { for_each_subsys(root, ss) {
if (cont->subsys[ss->subsys_id]) if (cgrp->subsys[ss->subsys_id])
ss->destroy(ss, cont); ss->destroy(ss, cgrp);
} }
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
...@@ -2091,7 +2091,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry, ...@@ -2091,7 +2091,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
/* Release the reference count that we took on the superblock */ /* Release the reference count that we took on the superblock */
deactivate_super(sb); deactivate_super(sb);
kfree(cont); kfree(cgrp);
return err; return err;
} }
...@@ -2103,7 +2103,7 @@ static int cgroup_mkdir(struct inode *dir, struct dentry *dentry, int mode) ...@@ -2103,7 +2103,7 @@ static int cgroup_mkdir(struct inode *dir, struct dentry *dentry, int mode)
return cgroup_create(c_parent, dentry, mode | S_IFDIR); return cgroup_create(c_parent, dentry, mode | S_IFDIR);
} }
static inline int cgroup_has_css_refs(struct cgroup *cont) static inline int cgroup_has_css_refs(struct cgroup *cgrp)
{ {
/* Check the reference count on each subsystem. Since we /* Check the reference count on each subsystem. Since we
* already established that there are no tasks in the * already established that there are no tasks in the
...@@ -2119,9 +2119,9 @@ static inline int cgroup_has_css_refs(struct cgroup *cont) ...@@ -2119,9 +2119,9 @@ static inline int cgroup_has_css_refs(struct cgroup *cont)
struct cgroup_subsys *ss = subsys[i]; struct cgroup_subsys *ss = subsys[i];
struct cgroup_subsys_state *css; struct cgroup_subsys_state *css;
/* Skip subsystems not in this hierarchy */ /* Skip subsystems not in this hierarchy */
if (ss->root != cont->root) if (ss->root != cgrp->root)
continue; continue;
css = cont->subsys[ss->subsys_id]; css = cgrp->subsys[ss->subsys_id];
/* When called from check_for_release() it's possible /* When called from check_for_release() it's possible
* that by this point the cgroup has been removed * that by this point the cgroup has been removed
* and the css deleted. But a false-positive doesn't * and the css deleted. But a false-positive doesn't
...@@ -2137,7 +2137,7 @@ static inline int cgroup_has_css_refs(struct cgroup *cont) ...@@ -2137,7 +2137,7 @@ static inline int cgroup_has_css_refs(struct cgroup *cont)
static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry) static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
{ {
struct cgroup *cont = dentry->d_fsdata; struct cgroup *cgrp = dentry->d_fsdata;
struct dentry *d; struct dentry *d;
struct cgroup *parent; struct cgroup *parent;
struct cgroup_subsys *ss; struct cgroup_subsys *ss;
...@@ -2147,46 +2147,46 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry) ...@@ -2147,46 +2147,46 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
/* the vfs holds both inode->i_mutex already */ /* the vfs holds both inode->i_mutex already */
mutex_lock(&cgroup_mutex); mutex_lock(&cgroup_mutex);
if (atomic_read(&cont->count) != 0) { if (atomic_read(&cgrp->count) != 0) {
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
return -EBUSY; return -EBUSY;
} }
if (!list_empty(&cont->children)) { if (!list_empty(&cgrp->children)) {
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
return -EBUSY; return -EBUSY;
} }
parent = cont->parent; parent = cgrp->parent;
root = cont->root; root = cgrp->root;
sb = root->sb; sb = root->sb;
if (cgroup_has_css_refs(cont)) { if (cgroup_has_css_refs(cgrp)) {
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
return -EBUSY; return -EBUSY;
} }
for_each_subsys(root, ss) { for_each_subsys(root, ss) {
if (cont->subsys[ss->subsys_id]) if (cgrp->subsys[ss->subsys_id])
ss->destroy(ss, cont); ss->destroy(ss, cgrp);
} }
spin_lock(&release_list_lock); spin_lock(&release_list_lock);
set_bit(CONT_REMOVED, &cont->flags); set_bit(CGRP_REMOVED, &cgrp->flags);
if (!list_empty(&cont->release_list)) if (!list_empty(&cgrp->release_list))
list_del(&cont->release_list); list_del(&cgrp->release_list);
spin_unlock(&release_list_lock); spin_unlock(&release_list_lock);
/* delete my sibling from parent->children */ /* delete my sibling from parent->children */
list_del(&cont->sibling); list_del(&cgrp->sibling);
spin_lock(&cont->dentry->d_lock); spin_lock(&cgrp->dentry->d_lock);
d = dget(cont->dentry); d = dget(cgrp->dentry);
cont->dentry = NULL; cgrp->dentry = NULL;
spin_unlock(&d->d_lock); spin_unlock(&d->d_lock);
cgroup_d_remove_dir(d); cgroup_d_remove_dir(d);
dput(d); dput(d);
root->number_of_cgroups--; root->number_of_cgroups--;
set_bit(CONT_RELEASABLE, &parent->flags); set_bit(CGRP_RELEASABLE, &parent->flags);
check_for_release(parent); check_for_release(parent);
mutex_unlock(&cgroup_mutex); mutex_unlock(&cgroup_mutex);
...@@ -2260,7 +2260,7 @@ int __init cgroup_init_early(void) ...@@ -2260,7 +2260,7 @@ int __init cgroup_init_early(void)
init_task.cgroups = &init_css_set; init_task.cgroups = &init_css_set;
init_css_set_link.cg = &init_css_set; init_css_set_link.cg = &init_css_set;
list_add(&init_css_set_link.cont_link_list, list_add(&init_css_set_link.cgrp_link_list,
&rootnode.top_cgroup.css_sets); &rootnode.top_cgroup.css_sets);
list_add(&init_css_set_link.cg_link_list, list_add(&init_css_set_link.cg_link_list,
&init_css_set.cg_links); &init_css_set.cg_links);
...@@ -2357,7 +2357,7 @@ static int proc_cgroup_show(struct seq_file *m, void *v) ...@@ -2357,7 +2357,7 @@ static int proc_cgroup_show(struct seq_file *m, void *v)
for_each_root(root) { for_each_root(root) {
struct cgroup_subsys *ss; struct cgroup_subsys *ss;
struct cgroup *cont; struct cgroup *cgrp;
int subsys_id; int subsys_id;
int count = 0; int count = 0;
...@@ -2368,8 +2368,8 @@ static int proc_cgroup_show(struct seq_file *m, void *v) ...@@ -2368,8 +2368,8 @@ static int proc_cgroup_show(struct seq_file *m, void *v)
seq_printf(m, "%s%s", count++ ? "," : "", ss->name); seq_printf(m, "%s%s", count++ ? "," : "", ss->name);
seq_putc(m, ':'); seq_putc(m, ':');
get_first_subsys(&root->top_cgroup, NULL, &subsys_id); get_first_subsys(&root->top_cgroup, NULL, &subsys_id);
cont = task_cgroup(tsk, subsys_id); cgrp = task_cgroup(tsk, subsys_id);
retval = cgroup_path(cont, buf, PAGE_SIZE); retval = cgroup_path(cgrp, buf, PAGE_SIZE);
if (retval < 0) if (retval < 0)
goto out_unlock; goto out_unlock;
seq_puts(m, buf); seq_puts(m, buf);
...@@ -2614,7 +2614,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys) ...@@ -2614,7 +2614,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys)
/* Create the cgroup directory, which also creates the cgroup */ /* Create the cgroup directory, which also creates the cgroup */
ret = vfs_mkdir(inode, dentry, S_IFDIR | 0755); ret = vfs_mkdir(inode, dentry, S_IFDIR | 0755);
child = __d_cont(dentry); child = __d_cgrp(dentry);
dput(dentry); dput(dentry);
if (ret) { if (ret) {
printk(KERN_INFO printk(KERN_INFO
...@@ -2671,7 +2671,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys) ...@@ -2671,7 +2671,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys)
} }
/* /*
* See if "cont" is a descendant of the current task's cgroup in * See if "cgrp" is a descendant of the current task's cgroup in
* the appropriate hierarchy * the appropriate hierarchy
* *
* If we are sending in dummytop, then presumably we are creating * If we are sending in dummytop, then presumably we are creating
...@@ -2679,37 +2679,37 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys) ...@@ -2679,37 +2679,37 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys)
* *
* Called only by the ns (nsproxy) cgroup. * Called only by the ns (nsproxy) cgroup.
*/ */
int cgroup_is_descendant(const struct cgroup *cont) int cgroup_is_descendant(const struct cgroup *cgrp)
{ {
int ret; int ret;
struct cgroup *target; struct cgroup *target;
int subsys_id; int subsys_id;
if (cont == dummytop) if (cgrp == dummytop)
return 1; return 1;
get_first_subsys(cont, NULL, &subsys_id); get_first_subsys(cgrp, NULL, &subsys_id);
target = task_cgroup(current, subsys_id); target = task_cgroup(current, subsys_id);
while (cont != target && cont!= cont->top_cgroup) while (cgrp != target && cgrp!= cgrp->top_cgroup)
cont = cont->parent; cgrp = cgrp->parent;
ret = (cont == target); ret = (cgrp == target);
return ret; return ret;
} }
static void check_for_release(struct cgroup *cont) static void check_for_release(struct cgroup *cgrp)
{ {
/* All of these checks rely on RCU to keep the cgroup /* All of these checks rely on RCU to keep the cgroup
* structure alive */ * structure alive */
if (cgroup_is_releasable(cont) && !atomic_read(&cont->count) if (cgroup_is_releasable(cgrp) && !atomic_read(&cgrp->count)
&& list_empty(&cont->children) && !cgroup_has_css_refs(cont)) { && list_empty(&cgrp->children) && !cgroup_has_css_refs(cgrp)) {
/* Control Group is currently removeable. If it's not /* Control Group is currently removeable. If it's not
* already queued for a userspace notification, queue * already queued for a userspace notification, queue
* it now */ * it now */
int need_schedule_work = 0; int need_schedule_work = 0;
spin_lock(&release_list_lock); spin_lock(&release_list_lock);
if (!cgroup_is_removed(cont) && if (!cgroup_is_removed(cgrp) &&
list_empty(&cont->release_list)) { list_empty(&cgrp->release_list)) {
list_add(&cont->release_list, &release_list); list_add(&cgrp->release_list, &release_list);
need_schedule_work = 1; need_schedule_work = 1;
} }
spin_unlock(&release_list_lock); spin_unlock(&release_list_lock);
...@@ -2720,11 +2720,11 @@ static void check_for_release(struct cgroup *cont) ...@@ -2720,11 +2720,11 @@ static void check_for_release(struct cgroup *cont)
void __css_put(struct cgroup_subsys_state *css) void __css_put(struct cgroup_subsys_state *css)
{ {
struct cgroup *cont = css->cgroup; struct cgroup *cgrp = css->cgroup;
rcu_read_lock(); rcu_read_lock();
if (atomic_dec_and_test(&css->refcnt) && notify_on_release(cont)) { if (atomic_dec_and_test(&css->refcnt) && notify_on_release(cgrp)) {
set_bit(CONT_RELEASABLE, &cont->flags); set_bit(CGRP_RELEASABLE, &cgrp->flags);
check_for_release(cont); check_for_release(cgrp);
} }
rcu_read_unlock(); rcu_read_unlock();
} }
...@@ -2763,10 +2763,10 @@ static void cgroup_release_agent(struct work_struct *work) ...@@ -2763,10 +2763,10 @@ static void cgroup_release_agent(struct work_struct *work)
char *argv[3], *envp[3]; char *argv[3], *envp[3];
int i; int i;
char *pathbuf; char *pathbuf;
struct cgroup *cont = list_entry(release_list.next, struct cgroup *cgrp = list_entry(release_list.next,
struct cgroup, struct cgroup,
release_list); release_list);
list_del_init(&cont->release_list); list_del_init(&cgrp->release_list);
spin_unlock(&release_list_lock); spin_unlock(&release_list_lock);
pathbuf = kmalloc(PAGE_SIZE, GFP_KERNEL); pathbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
if (!pathbuf) { if (!pathbuf) {
...@@ -2774,14 +2774,14 @@ static void cgroup_release_agent(struct work_struct *work) ...@@ -2774,14 +2774,14 @@ static void cgroup_release_agent(struct work_struct *work)
continue; continue;
} }
if (cgroup_path(cont, pathbuf, PAGE_SIZE) < 0) { if (cgroup_path(cgrp, pathbuf, PAGE_SIZE) < 0) {
kfree(pathbuf); kfree(pathbuf);
spin_lock(&release_list_lock); spin_lock(&release_list_lock);
continue; continue;
} }
i = 0; i = 0;
argv[i++] = cont->root->release_agent_path; argv[i++] = cgrp->root->release_agent_path;
argv[i++] = (char *)pathbuf; argv[i++] = (char *)pathbuf;
argv[i] = NULL; argv[i] = NULL;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7