cgroup: rename subsys_bits to subsys_mask

In a previous discussion, Tejun Heo suggested to rename references to
subsys_bits (added_bits, removed_bits, etc) by something more meaningful.

Cc: Li Zefan <lizefan@huawei.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Hugh Dickins <hughd@google.com>
Cc: Hillf Danton <dhillf@gmail.com>
Cc: Lennart Poettering <lpoetter@redhat.com>
Signed-off-by: Aristeu Rozanski <aris@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>

1 files changed, 42 insertions, 42 deletions

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 508b4a97ab19..ced292d720b9 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -111,13 +111,13 @@ struct cgroupfs_root {
          * The bitmask of subsystems intended to be attached to this
          * hierarchy
          */
-        unsigned long subsys_bits;
+        unsigned long subsys_mask;
 
         /* Unique id for this hierarchy. */
         int hierarchy_id;
 
         /* The bitmask of subsystems currently attached to this hierarchy */
-        unsigned long actual_subsys_bits;
+        unsigned long actual_subsys_mask;
 
         /* A list running through the attached subsystems */
         struct list_head subsys_list;
@@ -557,7 +557,7 @@ static struct css_set *find_existing_css_set(
          * won't change, so no need for locking.
          */
         for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
-                if (root->subsys_bits & (1UL << i)) {
+                if (root->subsys_mask & (1UL << i)) {
                         /* Subsystem is in this hierarchy. So we want
                          * the subsystem state from the new
                          * cgroup */
@@ -1002,7 +1002,7 @@ static void cgroup_d_remove_dir(struct dentry *dentry)
         struct dentry *parent;
         struct cgroupfs_root *root = dentry->d_sb->s_fs_info;
 
-        cgroup_clear_directory(dentry, true, root->subsys_bits);
+        cgroup_clear_directory(dentry, true, root->subsys_mask);
 
         parent = dentry->d_parent;
         spin_lock(&parent->d_lock);
@@ -1046,22 +1046,22 @@ void cgroup_release_and_wakeup_rmdir(struct cgroup_subsys_state *css)
  * returns an error, no reference counts are touched.
  */
 static int rebind_subsystems(struct cgroupfs_root *root,
-                              unsigned long final_bits)
+                              unsigned long final_subsys_mask)
 {
-        unsigned long added_bits, removed_bits;
+        unsigned long added_mask, removed_mask;
         struct cgroup *cgrp = &root->top_cgroup;
         int i;
 
         BUG_ON(!mutex_is_locked(&cgroup_mutex));
         BUG_ON(!mutex_is_locked(&cgroup_root_mutex));
 
-        removed_bits = root->actual_subsys_bits & ~final_bits;
-        added_bits = final_bits & ~root->actual_subsys_bits;
+        removed_mask = root->actual_subsys_mask & ~final_subsys_mask;
+        added_mask = final_subsys_mask & ~root->actual_subsys_mask;
         /* Check that any added subsystems are currently free */
         for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
                 unsigned long bit = 1UL << i;
                 struct cgroup_subsys *ss = subsys[i];
-                if (!(bit & added_bits))
+                if (!(bit & added_mask))
                         continue;
                 /*
                  * Nobody should tell us to do a subsys that doesn't exist:
@@ -1086,7 +1086,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
         for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
                 struct cgroup_subsys *ss = subsys[i];
                 unsigned long bit = 1UL << i;
-                if (bit & added_bits) {
+                if (bit & added_mask) {
                         /* We're binding this subsystem to this hierarchy */
                         BUG_ON(ss == NULL);
                         BUG_ON(cgrp->subsys[i]);
@@ -1099,7 +1099,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
                         if (ss->bind)
                                 ss->bind(cgrp);
                         /* refcount was already taken, and we're keeping it */
-                } else if (bit & removed_bits) {
+                } else if (bit & removed_mask) {
                         /* We're removing this subsystem */
                         BUG_ON(ss == NULL);
                         BUG_ON(cgrp->subsys[i] != dummytop->subsys[i]);
@@ -1112,7 +1112,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
                         list_move(&ss->sibling, &rootnode.subsys_list);
                         /* subsystem is now free - drop reference on module */
                         module_put(ss->module);
-                } else if (bit & final_bits) {
+                } else if (bit & final_subsys_mask) {
                         /* Subsystem state should already exist */
                         BUG_ON(ss == NULL);
                         BUG_ON(!cgrp->subsys[i]);
@@ -1129,7 +1129,7 @@ static int rebind_subsystems(struct cgroupfs_root *root,
                         BUG_ON(cgrp->subsys[i]);
                 }
         }
-        root->subsys_bits = root->actual_subsys_bits = final_bits;
+        root->subsys_mask = root->actual_subsys_mask = final_subsys_mask;
         synchronize_rcu();
 
         return 0;
@@ -1158,7 +1158,7 @@ static int cgroup_show_options(struct seq_file *seq, struct dentry *dentry)
 }
 
 struct cgroup_sb_opts {
-        unsigned long subsys_bits;
+        unsigned long subsys_mask;
         unsigned long flags;
         char *release_agent;
         bool clone_children;
@@ -1267,7 +1267,7 @@ static int parse_cgroupfs_options(char *data, struct cgroup_sb_opts *opts)
                         /* Mutually exclusive option 'all' + subsystem name */
                         if (all_ss)
                                 return -EINVAL;
-                        set_bit(i, &opts->subsys_bits);
+                        set_bit(i, &opts->subsys_mask);
                         one_ss = true;
 
                         break;
@@ -1288,7 +1288,7 @@ static int parse_cgroupfs_options(char *data, struct cgroup_sb_opts *opts)
                                 continue;
                         if (ss->disabled)
                                 continue;
-                        set_bit(i, &opts->subsys_bits);
+                        set_bit(i, &opts->subsys_mask);
                 }
         }
 
@@ -1300,19 +1300,19 @@ static int parse_cgroupfs_options(char *data, struct cgroup_sb_opts *opts)
          * the cpuset subsystem.
          */
         if (test_bit(ROOT_NOPREFIX, &opts->flags) &&
-            (opts->subsys_bits & mask))
+            (opts->subsys_mask & mask))
                 return -EINVAL;
 
 
         /* Can't specify "none" and some subsystems */
-        if (opts->subsys_bits && opts->none)
+        if (opts->subsys_mask && opts->none)
                 return -EINVAL;
 
         /*
          * We either have to specify by name or by subsystems. (So all
          * empty hierarchies must have a name).
          */
-        if (!opts->subsys_bits && !opts->name)
+        if (!opts->subsys_mask && !opts->name)
                 return -EINVAL;
 
         /*
@@ -1324,7 +1324,7 @@ static int parse_cgroupfs_options(char *data, struct cgroup_sb_opts *opts)
         for (i = CGROUP_BUILTIN_SUBSYS_COUNT; i < CGROUP_SUBSYS_COUNT; i++) {
                 unsigned long bit = 1UL << i;
 
-                if (!(bit & opts->subsys_bits))
+                if (!(bit & opts->subsys_mask))
                         continue;
                 if (!try_module_get(subsys[i]->module)) {
                         module_pin_failed = true;
@@ -1341,7 +1341,7 @@ static int parse_cgroupfs_options(char *data, struct cgroup_sb_opts *opts)
                         /* drop refcounts only on the ones we took */
                         unsigned long bit = 1UL << i;
 
-                        if (!(bit & opts->subsys_bits))
+                        if (!(bit & opts->subsys_mask))
                                 continue;
                         module_put(subsys[i]->module);
                 }
@@ -1351,13 +1351,13 @@ static int parse_cgroupfs_options(char *data, struct cgroup_sb_opts *opts)
         return 0;
 }
 
-static void drop_parsed_module_refcounts(unsigned long subsys_bits)
+static void drop_parsed_module_refcounts(unsigned long subsys_mask)
 {
         int i;
         for (i = CGROUP_BUILTIN_SUBSYS_COUNT; i < CGROUP_SUBSYS_COUNT; i++) {
                 unsigned long bit = 1UL << i;
 
-                if (!(bit & subsys_bits))
+                if (!(bit & subsys_mask))
                         continue;
                 module_put(subsys[i]->module);
         }
@@ -1369,7 +1369,7 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
         struct cgroupfs_root *root = sb->s_fs_info;
         struct cgroup *cgrp = &root->top_cgroup;
         struct cgroup_sb_opts opts;
-        unsigned long added_bits, removed_bits;
+        unsigned long added_mask, removed_mask;
 
         mutex_lock(&cgrp->dentry->d_inode->i_mutex);
         mutex_lock(&cgroup_mutex);
@@ -1381,31 +1381,31 @@ static int cgroup_remount(struct super_block *sb, int *flags, char *data)
                 goto out_unlock;
 
         /* See feature-removal-schedule.txt */
-        if (opts.subsys_bits != root->actual_subsys_bits || opts.release_agent)
+        if (opts.subsys_mask != root->actual_subsys_mask || opts.release_agent)
                 pr_warning("cgroup: option changes via remount are deprecated (pid=%d comm=%s)\n",
                            task_tgid_nr(current), current->comm);
 
-        added_bits = opts.subsys_bits & ~root->subsys_bits;
-        removed_bits = root->subsys_bits & ~opts.subsys_bits;
+        added_mask = opts.subsys_mask & ~root->subsys_mask;
+        removed_mask = root->subsys_mask & ~opts.subsys_mask;
 
         /* Don't allow flags or name to change at remount */
         if (opts.flags != root->flags ||
             (opts.name && strcmp(opts.name, root->name))) {
                 ret = -EINVAL;
-                drop_parsed_module_refcounts(opts.subsys_bits);
+                drop_parsed_module_refcounts(opts.subsys_mask);
                 goto out_unlock;
         }
 
-        ret = rebind_subsystems(root, opts.subsys_bits);
+        ret = rebind_subsystems(root, opts.subsys_mask);
         if (ret) {
-                drop_parsed_module_refcounts(opts.subsys_bits);
+                drop_parsed_module_refcounts(opts.subsys_mask);
                 goto out_unlock;
         }
 
         /* clear out any existing files and repopulate subsystem files */
-        cgroup_clear_directory(cgrp->dentry, false, removed_bits);
+        cgroup_clear_directory(cgrp->dentry, false, removed_mask);
         /* re-populate subsystem files */
-        cgroup_populate_dir(cgrp, false, added_bits);
+        cgroup_populate_dir(cgrp, false, added_mask);
 
         if (opts.release_agent)
                 strcpy(root->release_agent_path, opts.release_agent);
@@ -1491,8 +1491,8 @@ static int cgroup_test_super(struct super_block *sb, void *data)
          * If we asked for subsystems (or explicitly for no
          * subsystems) then they must match
          */
-        if ((opts->subsys_bits || opts->none)
-            && (opts->subsys_bits != root->subsys_bits))
+        if ((opts->subsys_mask || opts->none)
+            && (opts->subsys_mask != root->subsys_mask))
                 return 0;
 
         return 1;
@@ -1502,7 +1502,7 @@ static struct cgroupfs_root *cgroup_root_from_opts(struct cgroup_sb_opts *opts)
 {
         struct cgroupfs_root *root;
 
-        if (!opts->subsys_bits && !opts->none)
+        if (!opts->subsys_mask && !opts->none)
                 return NULL;
 
         root = kzalloc(sizeof(*root), GFP_KERNEL);
@@ -1515,7 +1515,7 @@ static struct cgroupfs_root *cgroup_root_from_opts(struct cgroup_sb_opts *opts)
         }
         init_cgroup_root(root);
 
-        root->subsys_bits = opts->subsys_bits;
+        root->subsys_mask = opts->subsys_mask;
         root->flags = opts->flags;
         if (opts->release_agent)
                 strcpy(root->release_agent_path, opts->release_agent);
@@ -1547,7 +1547,7 @@ static int cgroup_set_super(struct super_block *sb, void *data)
         if (!opts->new_root)
                 return -EINVAL;
 
-        BUG_ON(!opts->subsys_bits && !opts->none);
+        BUG_ON(!opts->subsys_mask && !opts->none);
 
         ret = set_anon_super(sb, NULL);
         if (ret)
@@ -1665,7 +1665,7 @@ static struct dentry *cgroup_mount(struct file_system_type *fs_type,
                 if (ret)
                         goto unlock_drop;
 
-                ret = rebind_subsystems(root, root->subsys_bits);
+                ret = rebind_subsystems(root, root->subsys_mask);
                 if (ret == -EBUSY) {
                         free_cg_links(&tmp_cg_links);
                         goto unlock_drop;
@@ -1705,7 +1705,7 @@ static struct dentry *cgroup_mount(struct file_system_type *fs_type,
                 BUG_ON(root->number_of_cgroups != 1);
 
                 cred = override_creds(&init_cred);
-                cgroup_populate_dir(root_cgrp, true, root->subsys_bits);
+                cgroup_populate_dir(root_cgrp, true, root->subsys_mask);
                 revert_creds(cred);
                 mutex_unlock(&cgroup_root_mutex);
                 mutex_unlock(&cgroup_mutex);
@@ -1717,7 +1717,7 @@ static struct dentry *cgroup_mount(struct file_system_type *fs_type,
                  */
                 cgroup_drop_root(opts.new_root);
                 /* no subsys rebinding, so refcounts don't change */
-                drop_parsed_module_refcounts(opts.subsys_bits);
+                drop_parsed_module_refcounts(opts.subsys_mask);
         }
 
         kfree(opts.release_agent);
@@ -1731,7 +1731,7 @@ static struct dentry *cgroup_mount(struct file_system_type *fs_type,
  drop_new_super:
         deactivate_locked_super(sb);
  drop_modules:
-        drop_parsed_module_refcounts(opts.subsys_bits);
+        drop_parsed_module_refcounts(opts.subsys_mask);
  out_err:
         kfree(opts.release_agent);
         kfree(opts.name);
@@ -4109,7 +4109,7 @@ static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
 
         list_add_tail(&cgrp->allcg_node, &root->allcg_list);
 
-        err = cgroup_populate_dir(cgrp, true, root->subsys_bits);
+        err = cgroup_populate_dir(cgrp, true, root->subsys_mask);
         /* If err < 0, we have a half-filled directory - oh well ;) */
 
         mutex_unlock(&cgroup_mutex);