]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
Control groups: Replace "cont" with "cgrp" and other misc renaming
authorPaul Menage <menage@google.com>
Fri, 19 Oct 2007 06:40:44 +0000 (23:40 -0700)
committerLinus Torvalds <torvalds@woody.linux-foundation.org>
Fri, 19 Oct 2007 18:53:43 +0000 (11:53 -0700)
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: Paul Menage <menage@google.com>
Acked-by: Paul Jackson <pj@sgi.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
kernel/cgroup.c

index c2f12a49dff24b7cd5af139fa153594a1f8a408e..5987dccdb2a0bad4de04333dfa0e45b0690d3405 100644 (file)
@@ -124,18 +124,18 @@ static int need_forkexit_callback;
 /* bits in struct cgroup flags field */
 enum {
        /* Control Group is dead */
-       CONT_REMOVED,
+       CGRP_REMOVED,
        /* Control Group has previously had a child cgroup or a task,
-        * but no longer (only if CONT_NOTIFY_ON_RELEASE is set) */
-       CONT_RELEASABLE,
+        * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set) */
+       CGRP_RELEASABLE,
        /* Control Group requires release notifications to userspace */
-       CONT_NOTIFY_ON_RELEASE,
+       CGRP_NOTIFY_ON_RELEASE,
 };
 
 /* 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 */
@@ -143,17 +143,17 @@ enum {
        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 =
-               (1 << CONT_RELEASABLE) |
-               (1 << CONT_NOTIFY_ON_RELEASE);
-       return (cont->flags & bits) == bits;
+               (1 << CGRP_RELEASABLE) |
+               (1 << CGRP_NOTIFY_ON_RELEASE);
+       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);
 static DEFINE_SPINLOCK(release_list_lock);
 static void cgroup_release_agent(struct work_struct *work);
 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 */
 struct cg_cgroup_link {
@@ -181,7 +181,7 @@ struct cg_cgroup_link {
         * List running through cg_cgroup_links associated with a
         * 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
         * single css_set object, anchored on css_set->cg_links
@@ -239,7 +239,7 @@ static void unlink_css_set(struct css_set *cg)
                link = list_entry(cg->cg_links.next,
                                  struct cg_cgroup_link, cg_link_list);
                list_del(&link->cg_link_list);
-               list_del(&link->cont_link_list);
+               list_del(&link->cgrp_link_list);
                kfree(link);
        }
        write_unlock(&css_set_lock);
@@ -254,12 +254,12 @@ static void __release_css_set(struct kref *k, int taskexit)
 
        rcu_read_lock();
        for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
-               struct cgroup *cont = cg->subsys[i]->cgroup;
-               if (atomic_dec_and_test(&cont->count) &&
-                   notify_on_release(cont)) {
+               struct cgroup *cgrp = cg->subsys[i]->cgroup;
+               if (atomic_dec_and_test(&cgrp->count) &&
+                   notify_on_release(cgrp)) {
                        if (taskexit)
-                               set_bit(CONT_RELEASABLE, &cont->flags);
-                       check_for_release(cont);
+                               set_bit(CGRP_RELEASABLE, &cgrp->flags);
+                       check_for_release(cgrp);
                }
        }
        rcu_read_unlock();
@@ -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
  * 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
  * state objects for the new cgroup group
@@ -312,11 +312,11 @@ static inline void put_css_set_taskexit(struct css_set *cg)
 
 static struct css_set *find_existing_css_set(
        struct css_set *oldcg,
-       struct cgroup *cont,
+       struct cgroup *cgrp,
        struct cgroup_subsys_state *template[])
 {
        int i;
-       struct cgroupfs_root *root = cont->root;
+       struct cgroupfs_root *root = cgrp->root;
        struct list_head *l = &init_css_set.list;
 
        /* Built the set of subsystem state objects that we want to
@@ -326,7 +326,7 @@ static struct css_set *find_existing_css_set(
                        /* Subsystem is in this hierarchy. So we want
                         * the subsystem state from the new
                         * cgroup */
-                       template[i] = cont->subsys[i];
+                       template[i] = cgrp->subsys[i];
                } else {
                        /* Subsystem is not in this hierarchy, so we
                         * don't want to change the subsystem state */
@@ -353,7 +353,7 @@ static struct css_set *find_existing_css_set(
 
 /*
  * 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
  */
 
@@ -368,13 +368,13 @@ static int allocate_cg_links(int count, struct list_head *tmp)
                        while (!list_empty(tmp)) {
                                link = list_entry(tmp->next,
                                                  struct cg_cgroup_link,
-                                                 cont_link_list);
-                               list_del(&link->cont_link_list);
+                                                 cgrp_link_list);
+                               list_del(&link->cgrp_link_list);
                                kfree(link);
                        }
                        return -ENOMEM;
                }
-               list_add(&link->cont_link_list, tmp);
+               list_add(&link->cgrp_link_list, tmp);
        }
        return 0;
 }
@@ -385,8 +385,8 @@ static void free_cg_links(struct list_head *tmp)
                struct cg_cgroup_link *link;
                link = list_entry(tmp->next,
                                  struct cg_cgroup_link,
-                                 cont_link_list);
-               list_del(&link->cont_link_list);
+                                 cgrp_link_list);
+               list_del(&link->cgrp_link_list);
                kfree(link);
        }
 }
@@ -400,7 +400,7 @@ static void free_cg_links(struct list_head *tmp)
  */
 
 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 cgroup_subsys_state *template[CGROUP_SUBSYS_COUNT];
@@ -412,7 +412,7 @@ static struct css_set *find_css_set(
        /* First see if we already have a cgroup group that matches
         * the desired set */
        write_lock(&css_set_lock);
-       res = find_existing_css_set(oldcg, cont, template);
+       res = find_existing_css_set(oldcg, cgrp, template);
        if (res)
                get_css_set(res);
        write_unlock(&css_set_lock);
@@ -441,9 +441,9 @@ static struct css_set *find_css_set(
        write_lock(&css_set_lock);
        /* Add reference counts and links from the new css_set. */
        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];
-               atomic_inc(&cont->count);
+               atomic_inc(&cgrp->count);
                /*
                 * We want to add a link once per cgroup, so we
                 * only do it for the first subsystem in each
@@ -453,9 +453,9 @@ static struct css_set *find_css_set(
                        BUG_ON(list_empty(&tmp_cg_links));
                        link = list_entry(tmp_cg_links.next,
                                          struct cg_cgroup_link,
-                                         cont_link_list);
-                       list_del(&link->cont_link_list);
-                       list_add(&link->cont_link_list, &cont->css_sets);
+                                         cgrp_link_list);
+                       list_del(&link->cgrp_link_list);
+                       list_add(&link->cgrp_link_list, &cgrp->css_sets);
                        link->cg = res;
                        list_add(&link->cg_link_list, &res->cg_links);
                }
@@ -463,9 +463,9 @@ static struct css_set *find_css_set(
        if (list_empty(&rootnode.subsys_list)) {
                link = list_entry(tmp_cg_links.next,
                                  struct cg_cgroup_link,
-                                 cont_link_list);
-               list_del(&link->cont_link_list);
-               list_add(&link->cont_link_list, &dummytop->css_sets);
+                                 cgrp_link_list);
+               list_del(&link->cgrp_link_list);
+               list_add(&link->cgrp_link_list, &dummytop->css_sets);
                link->cg = res;
                list_add(&link->cg_link_list, &res->cg_links);
        }
@@ -565,7 +565,7 @@ void cgroup_unlock(void)
 
 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_populate_dir(struct cgroup *cont);
+static int cgroup_populate_dir(struct cgroup *cgrp);
 static struct inode_operations cgroup_dir_inode_operations;
 static struct file_operations proc_cgroupstats_operations;
 
@@ -592,8 +592,8 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode)
 {
        /* is dentry a directory ? if so, kfree() associated cgroup */
        if (S_ISDIR(inode->i_mode)) {
-               struct cgroup *cont = dentry->d_fsdata;
-               BUG_ON(!(cgroup_is_removed(cont)));
+               struct cgroup *cgrp = dentry->d_fsdata;
+               BUG_ON(!(cgroup_is_removed(cgrp)));
                /* It's possible for external users to be holding css
                 * reference counts on a cgroup; css_put() needs to
                 * be able to access the cgroup after decrementing
@@ -601,7 +601,7 @@ static void cgroup_diput(struct dentry *dentry, struct inode *inode)
                 * queue the cgroup to be handled by the release
                 * agent */
                synchronize_rcu();
-               kfree(cont);
+               kfree(cgrp);
        }
        iput(inode);
 }
@@ -658,7 +658,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
                              unsigned long final_bits)
 {
        unsigned long added_bits, removed_bits;
-       struct cgroup *cont = &root->top_cgroup;
+       struct cgroup *cgrp = &root->top_cgroup;
        int i;
 
        removed_bits = root->actual_subsys_bits & ~final_bits;
@@ -679,7 +679,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
         * any child cgroups exist. This is theoretically supportable
         * but involves complex error handling, so it's being left until
         * later */
-       if (!list_empty(&cont->children))
+       if (!list_empty(&cgrp->children))
                return -EBUSY;
 
        /* Process each subsystem */
@@ -688,32 +688,32 @@ static int rebind_subsystems(struct cgroupfs_root *root,
                unsigned long bit = 1UL << i;
                if (bit & added_bits) {
                        /* 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]->cgroup != dummytop);
-                       cont->subsys[i] = dummytop->subsys[i];
-                       cont->subsys[i]->cgroup = cont;
+                       cgrp->subsys[i] = dummytop->subsys[i];
+                       cgrp->subsys[i]->cgroup = cgrp;
                        list_add(&ss->sibling, &root->subsys_list);
                        rcu_assign_pointer(ss->root, root);
                        if (ss->bind)
-                               ss->bind(ss, cont);
+                               ss->bind(ss, cgrp);
 
                } else if (bit & removed_bits) {
                        /* We're removing this subsystem */
-                       BUG_ON(cont->subsys[i] != dummytop->subsys[i]);
-                       BUG_ON(cont->subsys[i]->cgroup != cont);
+                       BUG_ON(cgrp->subsys[i] != dummytop->subsys[i]);
+                       BUG_ON(cgrp->subsys[i]->cgroup != cgrp);
                        if (ss->bind)
                                ss->bind(ss, dummytop);
                        dummytop->subsys[i]->cgroup = dummytop;
-                       cont->subsys[i] = NULL;
+                       cgrp->subsys[i] = NULL;
                        rcu_assign_pointer(subsys[i]->root, &rootnode);
                        list_del(&ss->sibling);
                } else if (bit & final_bits) {
                        /* Subsystem state should already exist */
-                       BUG_ON(!cont->subsys[i]);
+                       BUG_ON(!cgrp->subsys[i]);
                } else {
                        /* Subsystem state shouldn't exist */
-                       BUG_ON(cont->subsys[i]);
+                       BUG_ON(cgrp->subsys[i]);
                }
        }
        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)
 {
        int ret = 0;
        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;
 
-       mutex_lock(&cont->dentry->d_inode->i_mutex);
+       mutex_lock(&cgrp->dentry->d_inode->i_mutex);
        mutex_lock(&cgroup_mutex);
 
        /* See what subsystems are wanted */
@@ -818,7 +818,7 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
 
        /* (re)populate subsystem files */
        if (!ret)
-               cgroup_populate_dir(cont);
+               cgroup_populate_dir(cgrp);
 
        if (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)
        if (opts.release_agent)
                kfree(opts.release_agent);
        mutex_unlock(&cgroup_mutex);
-       mutex_unlock(&cont->dentry->d_inode->i_mutex);
+       mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
        return ret;
 }
 
@@ -839,16 +839,16 @@ static struct super_operations cgroup_ops = {
 
 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->root_list);
        root->number_of_cgroups = 1;
-       cont->root = root;
-       cont->top_cgroup = cont;
-       INIT_LIST_HEAD(&cont->sibling);
-       INIT_LIST_HEAD(&cont->children);
-       INIT_LIST_HEAD(&cont->css_sets);
-       INIT_LIST_HEAD(&cont->release_list);
+       cgrp->root = root;
+       cgrp->top_cgroup = cgrp;
+       INIT_LIST_HEAD(&cgrp->sibling);
+       INIT_LIST_HEAD(&cgrp->children);
+       INIT_LIST_HEAD(&cgrp->css_sets);
+       INIT_LIST_HEAD(&cgrp->release_list);
 }
 
 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,
                root = NULL;
        } else {
                /* New superblock */
-               struct cgroup *cont = &root->top_cgroup;
+               struct cgroup *cgrp = &root->top_cgroup;
                struct inode *inode;
 
                BUG_ON(sb->s_root != NULL);
@@ -1009,10 +1009,10 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
                        BUG_ON(list_empty(&tmp_cg_links));
                        link = list_entry(tmp_cg_links.next,
                                          struct cg_cgroup_link,
-                                         cont_link_list);
-                       list_del(&link->cont_link_list);
+                                         cgrp_link_list);
+                       list_del(&link->cgrp_link_list);
                        link->cg = cg;
-                       list_add(&link->cont_link_list,
+                       list_add(&link->cgrp_link_list,
                                 &root->top_cgroup.css_sets);
                        list_add(&link->cg_link_list, &cg->cg_links);
                        l = l->next;
@@ -1021,11 +1021,11 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
 
                free_cg_links(&tmp_cg_links);
 
-               BUG_ON(!list_empty(&cont->sibling));
-               BUG_ON(!list_empty(&cont->children));
+               BUG_ON(!list_empty(&cgrp->sibling));
+               BUG_ON(!list_empty(&cgrp->children));
                BUG_ON(root->number_of_cgroups != 1);
 
-               cgroup_populate_dir(cont);
+               cgroup_populate_dir(cgrp);
                mutex_unlock(&inode->i_mutex);
                mutex_unlock(&cgroup_mutex);
        }
@@ -1041,14 +1041,14 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
 
 static void cgroup_kill_sb(struct super_block *sb) {
        struct cgroupfs_root *root = sb->s_fs_info;
-       struct cgroup *cont = &root->top_cgroup;
+       struct cgroup *cgrp = &root->top_cgroup;
        int ret;
 
        BUG_ON(!root);
 
        BUG_ON(root->number_of_cgroups != 1);
-       BUG_ON(!list_empty(&cont->children));
-       BUG_ON(!list_empty(&cont->sibling));
+       BUG_ON(!list_empty(&cgrp->children));
+       BUG_ON(!list_empty(&cgrp->sibling));
 
        mutex_lock(&cgroup_mutex);
 
@@ -1062,12 +1062,12 @@ static void cgroup_kill_sb(struct super_block *sb) {
         * root cgroup
         */
        write_lock(&css_set_lock);
-       while (!list_empty(&cont->css_sets)) {
+       while (!list_empty(&cgrp->css_sets)) {
                struct cg_cgroup_link *link;
-               link = list_entry(cont->css_sets.next,
-                                 struct cg_cgroup_link, cont_link_list);
+               link = list_entry(cgrp->css_sets.next,
+                                 struct cg_cgroup_link, cgrp_link_list);
                list_del(&link->cg_link_list);
-               list_del(&link->cont_link_list);
+               list_del(&link->cgrp_link_list);
                kfree(link);
        }
        write_unlock(&css_set_lock);
@@ -1088,7 +1088,7 @@ static struct file_system_type cgroup_fs_type = {
        .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;
 }
@@ -1102,11 +1102,11 @@ static inline struct cftype *__d_cft(struct dentry *dentry)
  * Called with cgroup_mutex held.  Writes path of cgroup into buf.
  * 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;
 
-       if (cont == dummytop) {
+       if (cgrp == dummytop) {
                /*
                 * Inactive subsystems have no dentry for their root
                 * cgroup
@@ -1119,14 +1119,14 @@ int cgroup_path(const struct cgroup *cont, char *buf, int buflen)
 
        *--start = '\0';
        for (;;) {
-               int len = cont->dentry->d_name.len;
+               int len = cgrp->dentry->d_name.len;
                if ((start -= len) < buf)
                        return -ENAMETOOLONG;
-               memcpy(start, cont->dentry->d_name.name, len);
-               cont = cont->parent;
-               if (!cont)
+               memcpy(start, cgrp->dentry->d_name.name, len);
+               cgrp = cgrp->parent;
+               if (!cgrp)
                        break;
-               if (!cont->parent)
+               if (!cgrp->parent)
                        continue;
                if (--start < buf)
                        return -ENAMETOOLONG;
@@ -1141,16 +1141,16 @@ int cgroup_path(const struct cgroup *cont, char *buf, int buflen)
  * 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)
 {
-       const struct cgroupfs_root *root = cont->root;
+       const struct cgroupfs_root *root = cgrp->root;
        const struct cgroup_subsys *test_ss;
        BUG_ON(list_empty(&root->subsys_list));
        test_ss = list_entry(root->subsys_list.next,
                             struct cgroup_subsys, sibling);
        if (css) {
-               *css = cont->subsys[test_ss->subsys_id];
+               *css = cgrp->subsys[test_ss->subsys_id];
                BUG_ON(!*css);
        }
        if (subsys_id)
@@ -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
  * 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;
        struct cgroup_subsys *ss;
-       struct cgroup *oldcont;
+       struct cgroup *oldcgrp;
        struct css_set *cg = tsk->cgroups;
        struct css_set *newcg;
-       struct cgroupfs_root *root = cont->root;
+       struct cgroupfs_root *root = cgrp->root;
        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 */
-       oldcont = task_cgroup(tsk, subsys_id);
-       if (cont == oldcont)
+       oldcgrp = task_cgroup(tsk, subsys_id);
+       if (cgrp == oldcgrp)
                return 0;
 
        for_each_subsys(root, ss) {
                if (ss->can_attach) {
-                       retval = ss->can_attach(ss, cont, tsk);
+                       retval = ss->can_attach(ss, cgrp, tsk);
                        if (retval) {
                                return retval;
                        }
@@ -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,
         * based on its final set of cgroups
         */
-       newcg = find_css_set(cg, cont);
+       newcg = find_css_set(cg, cgrp);
        if (!newcg) {
                return -ENOMEM;
        }
@@ -1217,20 +1217,20 @@ static int attach_task(struct cgroup *cont, struct task_struct *tsk)
 
        for_each_subsys(root, ss) {
                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();
        put_css_set(cg);
        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
  */
-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;
        struct task_struct *tsk;
@@ -1259,7 +1259,7 @@ static int attach_task_by_pid(struct cgroup *cont, char *pidbuf)
                get_task_struct(tsk);
        }
 
-       ret = attach_task(cont, tsk);
+       ret = attach_task(cgrp, tsk);
        put_task_struct(tsk);
        return ret;
 }
@@ -1275,7 +1275,7 @@ enum cgroup_filetype {
        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,
                                 const char __user *userbuf,
                                 size_t nbytes, loff_t *unused_ppos)
@@ -1302,13 +1302,13 @@ static ssize_t cgroup_write_uint(struct cgroup *cont, struct cftype *cft,
                return -EINVAL;
 
        /* Pass to subsystem */
-       retval = cft->write_uint(cont, cft, val);
+       retval = cft->write_uint(cgrp, cft, val);
        if (!retval)
                retval = nbytes;
        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 file *file,
                                           const char __user *userbuf,
@@ -1334,25 +1334,25 @@ static ssize_t cgroup_common_file_write(struct cgroup *cont,
 
        mutex_lock(&cgroup_mutex);
 
-       if (cgroup_is_removed(cont)) {
+       if (cgroup_is_removed(cgrp)) {
                retval = -ENODEV;
                goto out2;
        }
 
        switch (type) {
        case FILE_TASKLIST:
-               retval = attach_task_by_pid(cont, buffer);
+               retval = attach_task_by_pid(cgrp, buffer);
                break;
        case FILE_NOTIFY_ON_RELEASE:
-               clear_bit(CONT_RELEASABLE, &cont->flags);
+               clear_bit(CGRP_RELEASABLE, &cgrp->flags);
                if (simple_strtoul(buffer, NULL, 10) != 0)
-                       set_bit(CONT_NOTIFY_ON_RELEASE, &cont->flags);
+                       set_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
                else
-                       clear_bit(CONT_NOTIFY_ON_RELEASE, &cont->flags);
+                       clear_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
                break;
        case FILE_RELEASE_AGENT:
        {
-               struct cgroupfs_root *root = cont->root;
+               struct cgroupfs_root *root = cgrp->root;
                /* Strip trailing newline */
                if (nbytes && (buffer[nbytes-1] == '\n')) {
                        buffer[nbytes-1] = 0;
@@ -1387,30 +1387,30 @@ static ssize_t cgroup_file_write(struct file *file, const char __user *buf,
                                                size_t nbytes, loff_t *ppos)
 {
        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)
                return -ENODEV;
        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)
-               return cgroup_write_uint(cont, cft, file, buf, nbytes, ppos);
+               return cgroup_write_uint(cgrp, cft, file, buf, nbytes, ppos);
        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,
                                   char __user *buf, size_t nbytes,
                                   loff_t *ppos)
 {
        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);
 
        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 file *file,
                                          char __user *buf,
@@ -1432,7 +1432,7 @@ static ssize_t cgroup_common_file_read(struct cgroup *cont,
                struct cgroupfs_root *root;
                size_t n;
                mutex_lock(&cgroup_mutex);
-               root = cont->root;
+               root = cgrp->root;
                n = strnlen(root->release_agent_path,
                            sizeof(root->release_agent_path));
                n = min(n, (size_t) PAGE_SIZE);
@@ -1457,15 +1457,15 @@ static ssize_t cgroup_file_read(struct file *file, char __user *buf,
                                   size_t nbytes, loff_t *ppos)
 {
        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)
                return -ENODEV;
 
        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)
-               return cgroup_read_uint(cont, cft, file, buf, nbytes, ppos);
+               return cgroup_read_uint(cgrp, cft, file, buf, nbytes, ppos);
        return -EINVAL;
 }
 
@@ -1567,24 +1567,24 @@ static int cgroup_create_file(struct dentry *dentry, int mode,
 
 /*
  *     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
  *             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.
  */
-static int cgroup_create_dir(struct cgroup *cont, struct dentry *dentry,
+static int cgroup_create_dir(struct cgroup *cgrp, struct dentry *dentry,
                                int mode)
 {
        struct dentry *parent;
        int error = 0;
 
-       parent = cont->parent->dentry;
-       error = cgroup_create_file(dentry, S_IFDIR | mode, cont->root->sb);
+       parent = cgrp->parent->dentry;
+       error = cgroup_create_file(dentry, S_IFDIR | mode, cgrp->root->sb);
        if (!error) {
-               dentry->d_fsdata = cont;
+               dentry->d_fsdata = cgrp;
                inc_nlink(parent->d_inode);
-               cont->dentry = dentry;
+               cgrp->dentry = dentry;
                dget(dentry);
        }
        dput(dentry);
@@ -1592,16 +1592,16 @@ static int cgroup_create_dir(struct cgroup *cont, struct dentry *dentry,
        return error;
 }
 
-int cgroup_add_file(struct cgroup *cont,
+int cgroup_add_file(struct cgroup *cgrp,
                       struct cgroup_subsys *subsys,
                       const struct cftype *cft)
 {
-       struct dentry *dir = cont->dentry;
+       struct dentry *dir = cgrp->dentry;
        struct dentry *dentry;
        int error;
 
        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);
                strcat(name, ".");
        }
@@ -1610,7 +1610,7 @@ int cgroup_add_file(struct cgroup *cont,
        dentry = lookup_one_len(name, dir, strlen(name));
        if (!IS_ERR(dentry)) {
                error = cgroup_create_file(dentry, 0644 | S_IFREG,
-                                               cont->root->sb);
+                                               cgrp->root->sb);
                if (!error)
                        dentry->d_fsdata = (void *)cft;
                dput(dentry);
@@ -1619,14 +1619,14 @@ int cgroup_add_file(struct cgroup *cont,
        return error;
 }
 
-int cgroup_add_files(struct cgroup *cont,
+int cgroup_add_files(struct cgroup *cgrp,
                        struct cgroup_subsys *subsys,
                        const struct cftype cft[],
                        int count)
 {
        int i, err;
        for (i = 0; i < count; i++) {
-               err = cgroup_add_file(cont, subsys, &cft[i]);
+               err = cgroup_add_file(cgrp, subsys, &cft[i]);
                if (err)
                        return err;
        }
@@ -1635,16 +1635,16 @@ int cgroup_add_files(struct cgroup *cont,
 
 /* 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;
        struct list_head *l;
 
        read_lock(&css_set_lock);
-       l = cont->css_sets.next;
-       while (l != &cont->css_sets) {
+       l = cgrp->css_sets.next;
+       while (l != &cgrp->css_sets) {
                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);
                l = l->next;
        }
@@ -1656,7 +1656,7 @@ int cgroup_task_count(const struct cgroup *cont)
  * Advance a list_head iterator.  The iterator should be positioned at
  * 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 list_head *l = it->cg_link;
@@ -1666,18 +1666,18 @@ static void cgroup_advance_iter(struct cgroup *cont,
        /* Advance to the next non-empty css_set */
        do {
                l = l->next;
-               if (l == &cont->css_sets) {
+               if (l == &cgrp->css_sets) {
                        it->cg_link = NULL;
                        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;
        } while (list_empty(&cg->tasks));
        it->cg_link = l;
        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,
@@ -1697,11 +1697,11 @@ void cgroup_iter_start(struct cgroup *cont, struct cgroup_iter *it)
                write_unlock(&css_set_lock);
        }
        read_lock(&css_set_lock);
-       it->cg_link = &cont->css_sets;
-       cgroup_advance_iter(cont, it);
+       it->cg_link = &cgrp->css_sets;
+       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 task_struct *res;
@@ -1716,14 +1716,14 @@ struct task_struct *cgroup_iter_next(struct cgroup *cont,
        if (l == &res->cgroups->tasks) {
                /* We reached the end of this task list - move on to
                 * the next cg_cgroup_link */
-               cgroup_advance_iter(cont, it);
+               cgroup_advance_iter(cgrp, it);
        } else {
                it->task = l;
        }
        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);
 }
@@ -1749,23 +1749,23 @@ struct ctr_struct {
 
 /*
  * 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
  * read section, so the css_set can't go away, and is
  * 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;
        struct cgroup_iter it;
        struct task_struct *tsk;
-       cgroup_iter_start(cont, &it);
-       while ((tsk = cgroup_iter_next(cont, &it))) {
+       cgroup_iter_start(cgrp, &it);
+       while ((tsk = cgroup_iter_next(cgrp, &it))) {
                if (unlikely(n == npids))
                        break;
                pidarray[n++] = task_pid_nr(tsk);
        }
-       cgroup_iter_end(cont, &it);
+       cgroup_iter_end(cgrp, &it);
        return n;
 }
 
@@ -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 ret = -EINVAL;
-       struct cgroup *cont;
+       struct cgroup *cgrp;
        struct cgroup_iter it;
        struct task_struct *tsk;
        /*
@@ -1790,11 +1790,11 @@ int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
                 goto err;
 
        ret = 0;
-       cont = dentry->d_fsdata;
+       cgrp = dentry->d_fsdata;
        rcu_read_lock();
 
-       cgroup_iter_start(cont, &it);
-       while ((tsk = cgroup_iter_next(cont, &it))) {
+       cgroup_iter_start(cgrp, &it);
+       while ((tsk = cgroup_iter_next(cgrp, &it))) {
                switch (tsk->state) {
                case TASK_RUNNING:
                        stats->nr_running++;
@@ -1814,7 +1814,7 @@ int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
                        break;
                }
        }
-       cgroup_iter_end(cont, &it);
+       cgroup_iter_end(cgrp, &it);
 
        rcu_read_unlock();
 err:
@@ -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)
 {
-       struct cgroup *cont = __d_cont(file->f_dentry->d_parent);
+       struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
        struct ctr_struct *ctr;
        pid_t *pidarray;
        int npids;
@@ -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
         * show up until sometime later on.
         */
-       npids = cgroup_task_count(cont);
+       npids = cgroup_task_count(cgrp);
        if (npids) {
                pidarray = kmalloc(npids * sizeof(pid_t), GFP_KERNEL);
                if (!pidarray)
                        goto err1;
 
-               npids = pid_array_load(pidarray, npids, cont);
+               npids = pid_array_load(pidarray, npids, cgrp);
                sort(pidarray, npids, sizeof(pid_t), cmppid, NULL);
 
                /* Call pid_array_to_buf() twice, first just to get bufsz */
@@ -1900,7 +1900,7 @@ err0:
        return -ENOMEM;
 }
 
-static ssize_t cgroup_tasks_read(struct cgroup *cont,
+static ssize_t cgroup_tasks_read(struct cgroup *cgrp,
                                    struct cftype *cft,
                                    struct file *file, char __user *buf,
                                    size_t nbytes, loff_t *ppos)
@@ -1923,15 +1923,15 @@ static int cgroup_tasks_release(struct inode *unused_inode,
        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)
 {
-       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 = {
        .private = FILE_RELEASE_AGENT,
 };
 
-static int cgroup_populate_dir(struct cgroup *cont)
+static int cgroup_populate_dir(struct cgroup *cgrp)
 {
        int err;
        struct cgroup_subsys *ss;
 
        /* 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)
                return err;
 
-       if (cont == cont->top_cgroup) {
-               if ((err = cgroup_add_file(cont, NULL, &cft_release_agent)) < 0)
+       if (cgrp == cgrp->top_cgroup) {
+               if ((err = cgroup_add_file(cgrp, NULL, &cft_release_agent)) < 0)
                        return err;
        }
 
-       for_each_subsys(cont->root, ss) {
-               if (ss->populate && (err = ss->populate(ss, cont)) < 0)
+       for_each_subsys(cgrp->root, ss) {
+               if (ss->populate && (err = ss->populate(ss, cgrp)) < 0)
                        return err;
        }
 
@@ -1995,15 +1995,15 @@ static int cgroup_populate_dir(struct cgroup *cont)
 
 static void init_cgroup_css(struct cgroup_subsys_state *css,
                               struct cgroup_subsys *ss,
-                              struct cgroup *cont)
+                              struct cgroup *cgrp)
 {
-       css->cgroup = cont;
+       css->cgroup = cgrp;
        atomic_set(&css->refcnt, 0);
        css->flags = 0;
-       if (cont == dummytop)
+       if (cgrp == dummytop)
                set_bit(CSS_ROOT, &css->flags);
-       BUG_ON(cont->subsys[ss->subsys_id]);
-       cont->subsys[ss->subsys_id] = css;
+       BUG_ON(cgrp->subsys[ss->subsys_id]);
+       cgrp->subsys[ss->subsys_id] = 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,
                             int mode)
 {
-       struct cgroup *cont;
+       struct cgroup *cgrp;
        struct cgroupfs_root *root = parent->root;
        int err = 0;
        struct cgroup_subsys *ss;
        struct super_block *sb = root->sb;
 
-       cont = kzalloc(sizeof(*cont), GFP_KERNEL);
-       if (!cont)
+       cgrp = kzalloc(sizeof(*cgrp), GFP_KERNEL);
+       if (!cgrp)
                return -ENOMEM;
 
        /* 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,
 
        mutex_lock(&cgroup_mutex);
 
-       cont->flags = 0;
-       INIT_LIST_HEAD(&cont->sibling);
-       INIT_LIST_HEAD(&cont->children);
-       INIT_LIST_HEAD(&cont->css_sets);
-       INIT_LIST_HEAD(&cont->release_list);
+       cgrp->flags = 0;
+       INIT_LIST_HEAD(&cgrp->sibling);
+       INIT_LIST_HEAD(&cgrp->children);
+       INIT_LIST_HEAD(&cgrp->css_sets);
+       INIT_LIST_HEAD(&cgrp->release_list);
 
-       cont->parent = parent;
-       cont->root = parent->root;
-       cont->top_cgroup = parent->top_cgroup;
+       cgrp->parent = parent;
+       cgrp->root = parent->root;
+       cgrp->top_cgroup = parent->top_cgroup;
 
        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)) {
                        err = PTR_ERR(css);
                        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++;
 
-       err = cgroup_create_dir(cont, dentry, mode);
+       err = cgroup_create_dir(cgrp, dentry, mode);
        if (err < 0)
                goto err_remove;
 
        /* 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 ;) */
 
        mutex_unlock(&cgroup_mutex);
-       mutex_unlock(&cont->dentry->d_inode->i_mutex);
+       mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
 
        return 0;
 
  err_remove:
 
-       list_del(&cont->sibling);
+       list_del(&cgrp->sibling);
        root->number_of_cgroups--;
 
  err_destroy:
 
        for_each_subsys(root, ss) {
-               if (cont->subsys[ss->subsys_id])
-                       ss->destroy(ss, cont);
+               if (cgrp->subsys[ss->subsys_id])
+                       ss->destroy(ss, cgrp);
        }
 
        mutex_unlock(&cgroup_mutex);
@@ -2091,7 +2091,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
        /* Release the reference count that we took on the superblock */
        deactivate_super(sb);
 
-       kfree(cont);
+       kfree(cgrp);
        return err;
 }
 
@@ -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);
 }
 
-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
         * already established that there are no tasks in the
@@ -2119,9 +2119,9 @@ static inline int cgroup_has_css_refs(struct cgroup *cont)
                struct cgroup_subsys *ss = subsys[i];
                struct cgroup_subsys_state *css;
                /* Skip subsystems not in this hierarchy */
-               if (ss->root != cont->root)
+               if (ss->root != cgrp->root)
                        continue;
-               css = cont->subsys[ss->subsys_id];
+               css = cgrp->subsys[ss->subsys_id];
                /* When called from check_for_release() it's possible
                 * that by this point the cgroup has been removed
                 * and the css deleted. But a false-positive doesn't
@@ -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)
 {
-       struct cgroup *cont = dentry->d_fsdata;
+       struct cgroup *cgrp = dentry->d_fsdata;
        struct dentry *d;
        struct cgroup *parent;
        struct cgroup_subsys *ss;
@@ -2147,46 +2147,46 @@ static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
        /* the vfs holds both inode->i_mutex already */
 
        mutex_lock(&cgroup_mutex);
-       if (atomic_read(&cont->count) != 0) {
+       if (atomic_read(&cgrp->count) != 0) {
                mutex_unlock(&cgroup_mutex);
                return -EBUSY;
        }
-       if (!list_empty(&cont->children)) {
+       if (!list_empty(&cgrp->children)) {
                mutex_unlock(&cgroup_mutex);
                return -EBUSY;
        }
 
-       parent = cont->parent;
-       root = cont->root;
+       parent = cgrp->parent;
+       root = cgrp->root;
        sb = root->sb;
 
-       if (cgroup_has_css_refs(cont)) {
+       if (cgroup_has_css_refs(cgrp)) {
                mutex_unlock(&cgroup_mutex);
                return -EBUSY;
        }
 
        for_each_subsys(root, ss) {
-               if (cont->subsys[ss->subsys_id])
-                       ss->destroy(ss, cont);
+               if (cgrp->subsys[ss->subsys_id])
+                       ss->destroy(ss, cgrp);
        }
 
        spin_lock(&release_list_lock);
-       set_bit(CONT_REMOVED, &cont->flags);
-       if (!list_empty(&cont->release_list))
-               list_del(&cont->release_list);
+       set_bit(CGRP_REMOVED, &cgrp->flags);
+       if (!list_empty(&cgrp->release_list))
+               list_del(&cgrp->release_list);
        spin_unlock(&release_list_lock);
        /* delete my sibling from parent->children */
-       list_del(&cont->sibling);
-       spin_lock(&cont->dentry->d_lock);
-       d = dget(cont->dentry);
-       cont->dentry = NULL;
+       list_del(&cgrp->sibling);
+       spin_lock(&cgrp->dentry->d_lock);
+       d = dget(cgrp->dentry);
+       cgrp->dentry = NULL;
        spin_unlock(&d->d_lock);
 
        cgroup_d_remove_dir(d);
        dput(d);
        root->number_of_cgroups--;
 
-       set_bit(CONT_RELEASABLE, &parent->flags);
+       set_bit(CGRP_RELEASABLE, &parent->flags);
        check_for_release(parent);
 
        mutex_unlock(&cgroup_mutex);
@@ -2260,7 +2260,7 @@ int __init cgroup_init_early(void)
        init_task.cgroups = &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);
        list_add(&init_css_set_link.cg_link_list,
                 &init_css_set.cg_links);
@@ -2357,7 +2357,7 @@ static int proc_cgroup_show(struct seq_file *m, void *v)
 
        for_each_root(root) {
                struct cgroup_subsys *ss;
-               struct cgroup *cont;
+               struct cgroup *cgrp;
                int subsys_id;
                int count = 0;
 
@@ -2368,8 +2368,8 @@ static int proc_cgroup_show(struct seq_file *m, void *v)
                        seq_printf(m, "%s%s", count++ ? "," : "", ss->name);
                seq_putc(m, ':');
                get_first_subsys(&root->top_cgroup, NULL, &subsys_id);
-               cont = task_cgroup(tsk, subsys_id);
-               retval = cgroup_path(cont, buf, PAGE_SIZE);
+               cgrp = task_cgroup(tsk, subsys_id);
+               retval = cgroup_path(cgrp, buf, PAGE_SIZE);
                if (retval < 0)
                        goto out_unlock;
                seq_puts(m, buf);
@@ -2614,7 +2614,7 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys)
 
        /* Create the cgroup directory, which also creates the cgroup */
        ret = vfs_mkdir(inode, dentry, S_IFDIR | 0755);
-       child = __d_cont(dentry);
+       child = __d_cgrp(dentry);
        dput(dentry);
        if (ret) {
                printk(KERN_INFO
@@ -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
  *
  * 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)
  *
  * 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;
        struct cgroup *target;
        int subsys_id;
 
-       if (cont == dummytop)
+       if (cgrp == dummytop)
                return 1;
 
-       get_first_subsys(cont, NULL, &subsys_id);
+       get_first_subsys(cgrp, NULL, &subsys_id);
        target = task_cgroup(current, subsys_id);
-       while (cont != target && cont!= cont->top_cgroup)
-               cont = cont->parent;
-       ret = (cont == target);
+       while (cgrp != target && cgrp!= cgrp->top_cgroup)
+               cgrp = cgrp->parent;
+       ret = (cgrp == target);
        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
         * structure alive */
-       if (cgroup_is_releasable(cont) && !atomic_read(&cont->count)
-           && list_empty(&cont->children) && !cgroup_has_css_refs(cont)) {
+       if (cgroup_is_releasable(cgrp) && !atomic_read(&cgrp->count)
+           && list_empty(&cgrp->children) && !cgroup_has_css_refs(cgrp)) {
                /* Control Group is currently removeable. If it's not
                 * already queued for a userspace notification, queue
                 * it now */
                int need_schedule_work = 0;
                spin_lock(&release_list_lock);
-               if (!cgroup_is_removed(cont) &&
-                   list_empty(&cont->release_list)) {
-                       list_add(&cont->release_list, &release_list);
+               if (!cgroup_is_removed(cgrp) &&
+                   list_empty(&cgrp->release_list)) {
+                       list_add(&cgrp->release_list, &release_list);
                        need_schedule_work = 1;
                }
                spin_unlock(&release_list_lock);
@@ -2720,11 +2720,11 @@ static void check_for_release(struct cgroup *cont)
 
 void __css_put(struct cgroup_subsys_state *css)
 {
-       struct cgroup *cont = css->cgroup;
+       struct cgroup *cgrp = css->cgroup;
        rcu_read_lock();
-       if (atomic_dec_and_test(&css->refcnt) && notify_on_release(cont)) {
-               set_bit(CONT_RELEASABLE, &cont->flags);
-               check_for_release(cont);
+       if (atomic_dec_and_test(&css->refcnt) && notify_on_release(cgrp)) {
+               set_bit(CGRP_RELEASABLE, &cgrp->flags);
+               check_for_release(cgrp);
        }
        rcu_read_unlock();
 }
@@ -2763,10 +2763,10 @@ static void cgroup_release_agent(struct work_struct *work)
                char *argv[3], *envp[3];
                int i;
                char *pathbuf;
-               struct cgroup *cont = list_entry(release_list.next,
+               struct cgroup *cgrp = list_entry(release_list.next,
                                                    struct cgroup,
                                                    release_list);
-               list_del_init(&cont->release_list);
+               list_del_init(&cgrp->release_list);
                spin_unlock(&release_list_lock);
                pathbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
                if (!pathbuf) {
@@ -2774,14 +2774,14 @@ static void cgroup_release_agent(struct work_struct *work)
                        continue;
                }
 
-               if (cgroup_path(cont, pathbuf, PAGE_SIZE) < 0) {
+               if (cgroup_path(cgrp, pathbuf, PAGE_SIZE) < 0) {
                        kfree(pathbuf);
                        spin_lock(&release_list_lock);
                        continue;
                }
 
                i = 0;
-               argv[i++] = cont->root->release_agent_path;
+               argv[i++] = cgrp->root->release_agent_path;
                argv[i++] = (char *)pathbuf;
                argv[i] = NULL;