1 files changed, 247 insertions, 247 deletions

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index c2f12a49dff2..5987dccdb2a0 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -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;