blkcg: mass rename of blkcg API

During the recent blkcg cleanup, most of blkcg API has changed to such
extent that mass renaming wouldn't cause any noticeable pain.  Take
the chance and cleanup the naming.

* Rename blkio_cgroup to blkcg.

* Drop blkio / blkiocg prefixes and consistently use blkcg.

* Rename blkio_group to blkcg_gq, which is consistent with io_cq but
  keep the blkg prefix / variable name.

* Rename policy method type and field names to signify they're dealing
  with policy data.

* Rename blkio_policy_type to blkcg_policy.

This patch doesn't cause any functional change.

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 99 insertions, 103 deletions

diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
index 63337024e4d7..997570329517 100644
--- a/block/blk-cgroup.c
+++ b/block/blk-cgroup.c
@@ -26,39 +26,39 @@
 
 static DEFINE_MUTEX(blkcg_pol_mutex);
 
-struct blkio_cgroup blkio_root_cgroup = { .cfq_weight = 2 * CFQ_WEIGHT_DEFAULT };
-EXPORT_SYMBOL_GPL(blkio_root_cgroup);
+struct blkcg blkcg_root = { .cfq_weight = 2 * CFQ_WEIGHT_DEFAULT };
+EXPORT_SYMBOL_GPL(blkcg_root);
 
-static struct blkio_policy_type *blkio_policy[BLKCG_MAX_POLS];
+static struct blkcg_policy *blkcg_policy[BLKCG_MAX_POLS];
 
-struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
+struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup)
 {
         return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),
-                            struct blkio_cgroup, css);
+                            struct blkcg, css);
 }
-EXPORT_SYMBOL_GPL(cgroup_to_blkio_cgroup);
+EXPORT_SYMBOL_GPL(cgroup_to_blkcg);
 
-static struct blkio_cgroup *task_blkio_cgroup(struct task_struct *tsk)
+static struct blkcg *task_blkcg(struct task_struct *tsk)
 {
         return container_of(task_subsys_state(tsk, blkio_subsys_id),
-                            struct blkio_cgroup, css);
+                            struct blkcg, css);
 }
 
-struct blkio_cgroup *bio_blkio_cgroup(struct bio *bio)
+struct blkcg *bio_blkcg(struct bio *bio)
 {
         if (bio && bio->bi_css)
-                return container_of(bio->bi_css, struct blkio_cgroup, css);
-        return task_blkio_cgroup(current);
+                return container_of(bio->bi_css, struct blkcg, css);
+        return task_blkcg(current);
 }
-EXPORT_SYMBOL_GPL(bio_blkio_cgroup);
+EXPORT_SYMBOL_GPL(bio_blkcg);
 
 static bool blkcg_policy_enabled(struct request_queue *q,
-                                 const struct blkio_policy_type *pol)
+                                 const struct blkcg_policy *pol)
 {
         return pol && test_bit(pol->plid, q->blkcg_pols);
 }
 
-static size_t blkg_pd_size(const struct blkio_policy_type *pol)
+static size_t blkg_pd_size(const struct blkcg_policy *pol)
 {
         return sizeof(struct blkg_policy_data) + pol->pdata_size;
 }
@@ -69,7 +69,7 @@ static size_t blkg_pd_size(const struct blkio_policy_type *pol)
  *
  * Free @blkg which may be partially allocated.
  */
-static void blkg_free(struct blkio_group *blkg)
+static void blkg_free(struct blkcg_gq *blkg)
 {
         int i;
 
@@ -77,14 +77,14 @@ static void blkg_free(struct blkio_group *blkg)
                 return;
 
         for (i = 0; i < BLKCG_MAX_POLS; i++) {
-                struct blkio_policy_type *pol = blkio_policy[i];
+                struct blkcg_policy *pol = blkcg_policy[i];
                 struct blkg_policy_data *pd = blkg->pd[i];
 
                 if (!pd)
                         continue;
 
-                if (pol && pol->ops.blkio_exit_group_fn)
-                        pol->ops.blkio_exit_group_fn(blkg);
+                if (pol && pol->ops.pd_exit_fn)
+                        pol->ops.pd_exit_fn(blkg);
 
                 kfree(pd);
         }
@@ -99,10 +99,9 @@ static void blkg_free(struct blkio_group *blkg)
  *
  * Allocate a new blkg assocating @blkcg and @q.
  */
-static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg,
-                                      struct request_queue *q)
+static struct blkcg_gq *blkg_alloc(struct blkcg *blkcg, struct request_queue *q)
 {
-        struct blkio_group *blkg;
+        struct blkcg_gq *blkg;
         int i;
 
         /* alloc and init base part */
@@ -116,7 +115,7 @@ static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg,
         blkg->refcnt = 1;
 
         for (i = 0; i < BLKCG_MAX_POLS; i++) {
-                struct blkio_policy_type *pol = blkio_policy[i];
+                struct blkcg_policy *pol = blkcg_policy[i];
                 struct blkg_policy_data *pd;
 
                 if (!blkcg_policy_enabled(q, pol))
@@ -135,19 +134,19 @@ static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg,
 
         /* invoke per-policy init */
         for (i = 0; i < BLKCG_MAX_POLS; i++) {
-                struct blkio_policy_type *pol = blkio_policy[i];
+                struct blkcg_policy *pol = blkcg_policy[i];
 
                 if (blkcg_policy_enabled(blkg->q, pol))
-                        pol->ops.blkio_init_group_fn(blkg);
+                        pol->ops.pd_init_fn(blkg);
         }
 
         return blkg;
 }
 
-static struct blkio_group *__blkg_lookup(struct blkio_cgroup *blkcg,
-                                         struct request_queue *q)
+static struct blkcg_gq *__blkg_lookup(struct blkcg *blkcg,
+                                      struct request_queue *q)
 {
-        struct blkio_group *blkg;
+        struct blkcg_gq *blkg;
         struct hlist_node *n;
 
         hlist_for_each_entry_rcu(blkg, n, &blkcg->blkg_list, blkcg_node)
@@ -165,8 +164,7 @@ static struct blkio_group *__blkg_lookup(struct blkio_cgroup *blkcg,
  * under RCU read lock and is guaranteed to return %NULL if @q is bypassing
  * - see blk_queue_bypass_start() for details.
  */
-struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg,
-                                struct request_queue *q)
+struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, struct request_queue *q)
 {
         WARN_ON_ONCE(!rcu_read_lock_held());
 
@@ -176,11 +174,11 @@ struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg,
 }
 EXPORT_SYMBOL_GPL(blkg_lookup);
 
-static struct blkio_group *__blkg_lookup_create(struct blkio_cgroup *blkcg,
-                                                struct request_queue *q)
+static struct blkcg_gq *__blkg_lookup_create(struct blkcg *blkcg,
+                                             struct request_queue *q)
         __releases(q->queue_lock) __acquires(q->queue_lock)
 {
-        struct blkio_group *blkg;
+        struct blkcg_gq *blkg;
 
         WARN_ON_ONCE(!rcu_read_lock_held());
         lockdep_assert_held(q->queue_lock);
@@ -213,8 +211,8 @@ out:
         return blkg;
 }
 
-struct blkio_group *blkg_lookup_create(struct blkio_cgroup *blkcg,
-                                       struct request_queue *q)
+struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
+                                    struct request_queue *q)
 {
         /*
          * This could be the first entry point of blkcg implementation and
@@ -226,10 +224,10 @@ struct blkio_group *blkg_lookup_create(struct blkio_cgroup *blkcg,
 }
 EXPORT_SYMBOL_GPL(blkg_lookup_create);
 
-static void blkg_destroy(struct blkio_group *blkg)
+static void blkg_destroy(struct blkcg_gq *blkg)
 {
         struct request_queue *q = blkg->q;
-        struct blkio_cgroup *blkcg = blkg->blkcg;
+        struct blkcg *blkcg = blkg->blkcg;
 
         lockdep_assert_held(q->queue_lock);
         lockdep_assert_held(&blkcg->lock);
@@ -255,12 +253,12 @@ static void blkg_destroy(struct blkio_group *blkg)
  */
 static void blkg_destroy_all(struct request_queue *q)
 {
-        struct blkio_group *blkg, *n;
+        struct blkcg_gq *blkg, *n;
 
         lockdep_assert_held(q->queue_lock);
 
         list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {
-                struct blkio_cgroup *blkcg = blkg->blkcg;
+                struct blkcg *blkcg = blkg->blkcg;
 
                 spin_lock(&blkcg->lock);
                 blkg_destroy(blkg);
@@ -270,10 +268,10 @@ static void blkg_destroy_all(struct request_queue *q)
 
 static void blkg_rcu_free(struct rcu_head *rcu_head)
 {
-        blkg_free(container_of(rcu_head, struct blkio_group, rcu_head));
+        blkg_free(container_of(rcu_head, struct blkcg_gq, rcu_head));
 }
 
-void __blkg_release(struct blkio_group *blkg)
+void __blkg_release(struct blkcg_gq *blkg)
 {
         /* release the extra blkcg reference this blkg has been holding */
         css_put(&blkg->blkcg->css);
@@ -291,11 +289,11 @@ void __blkg_release(struct blkio_group *blkg)
 }
 EXPORT_SYMBOL_GPL(__blkg_release);
 
-static int
-blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val)
+static int blkcg_reset_stats(struct cgroup *cgroup, struct cftype *cftype,
+                             u64 val)
 {
-        struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);
-        struct blkio_group *blkg;
+        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
+        struct blkcg_gq *blkg;
         struct hlist_node *n;
         int i;
 
@@ -309,11 +307,11 @@ blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val)
          */
         hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
                 for (i = 0; i < BLKCG_MAX_POLS; i++) {
-                        struct blkio_policy_type *pol = blkio_policy[i];
+                        struct blkcg_policy *pol = blkcg_policy[i];
 
                         if (blkcg_policy_enabled(blkg->q, pol) &&
-                            pol->ops.blkio_reset_group_stats_fn)
-                                pol->ops.blkio_reset_group_stats_fn(blkg);
+                            pol->ops.pd_reset_stats_fn)
+                                pol->ops.pd_reset_stats_fn(blkg);
                 }
         }
 
@@ -322,7 +320,7 @@ blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val)
         return 0;
 }
 
-static const char *blkg_dev_name(struct blkio_group *blkg)
+static const char *blkg_dev_name(struct blkcg_gq *blkg)
 {
         /* some drivers (floppy) instantiate a queue w/o disk registered */
         if (blkg->q->backing_dev_info.dev)
@@ -347,12 +345,12 @@ static const char *blkg_dev_name(struct blkio_group *blkg)
  * This is to be used to construct print functions for
  * cftype->read_seq_string method.
  */
-void blkcg_print_blkgs(struct seq_file *sf, struct blkio_cgroup *blkcg,
+void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
                        u64 (*prfill)(struct seq_file *, void *, int),
-                       const struct blkio_policy_type *pol, int data,
+                       const struct blkcg_policy *pol, int data,
                        bool show_total)
 {
-        struct blkio_group *blkg;
+        struct blkcg_gq *blkg;
         struct hlist_node *n;
         u64 total = 0;
 
@@ -462,13 +460,12 @@ EXPORT_SYMBOL_GPL(blkg_prfill_rwstat);
  * value.  This function returns with RCU read lock and queue lock held and
  * must be paired with blkg_conf_finish().
  */
-int blkg_conf_prep(struct blkio_cgroup *blkcg,
-                   const struct blkio_policy_type *pol, const char *input,
-                   struct blkg_conf_ctx *ctx)
+int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
+                   const char *input, struct blkg_conf_ctx *ctx)
         __acquires(rcu) __acquires(disk->queue->queue_lock)
 {
         struct gendisk *disk;
-        struct blkio_group *blkg;
+        struct blkcg_gq *blkg;
         unsigned int major, minor;
         unsigned long long v;
         int part, ret;
@@ -529,16 +526,16 @@ void blkg_conf_finish(struct blkg_conf_ctx *ctx)
 }
 EXPORT_SYMBOL_GPL(blkg_conf_finish);
 
-struct cftype blkio_files[] = {
+struct cftype blkcg_files[] = {
         {
                 .name = "reset_stats",
-                .write_u64 = blkiocg_reset_stats,
+                .write_u64 = blkcg_reset_stats,
         },
         { }     /* terminate */
 };
 
 /**
- * blkiocg_pre_destroy - cgroup pre_destroy callback
+ * blkcg_pre_destroy - cgroup pre_destroy callback
  * @cgroup: cgroup of interest
  *
  * This function is called when @cgroup is about to go away and responsible
@@ -548,15 +545,15 @@ struct cftype blkio_files[] = {
  *
  * This is the blkcg counterpart of ioc_release_fn().
  */
-static int blkiocg_pre_destroy(struct cgroup *cgroup)
+static int blkcg_pre_destroy(struct cgroup *cgroup)
 {
-        struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);
+        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
 
         spin_lock_irq(&blkcg->lock);
 
         while (!hlist_empty(&blkcg->blkg_list)) {
-                struct blkio_group *blkg = hlist_entry(blkcg->blkg_list.first,
-                                                struct blkio_group, blkcg_node);
+                struct blkcg_gq *blkg = hlist_entry(blkcg->blkg_list.first,
+                                                struct blkcg_gq, blkcg_node);
                 struct request_queue *q = blkg->q;
 
                 if (spin_trylock(q->queue_lock)) {
@@ -573,22 +570,22 @@ static int blkiocg_pre_destroy(struct cgroup *cgroup)
         return 0;
 }
 
-static void blkiocg_destroy(struct cgroup *cgroup)
+static void blkcg_destroy(struct cgroup *cgroup)
 {
-        struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);
+        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
 
-        if (blkcg != &blkio_root_cgroup)
+        if (blkcg != &blkcg_root)
                 kfree(blkcg);
 }
 
-static struct cgroup_subsys_state *blkiocg_create(struct cgroup *cgroup)
+static struct cgroup_subsys_state *blkcg_create(struct cgroup *cgroup)
 {
         static atomic64_t id_seq = ATOMIC64_INIT(0);
-        struct blkio_cgroup *blkcg;
+        struct blkcg *blkcg;
         struct cgroup *parent = cgroup->parent;
 
         if (!parent) {
-                blkcg = &blkio_root_cgroup;
+                blkcg = &blkcg_root;
                 goto done;
         }
 
@@ -656,7 +653,7 @@ void blkcg_exit_queue(struct request_queue *q)
  * of the main cic data structures.  For now we allow a task to change
  * its cgroup only if it's the only owner of its ioc.
  */
-static int blkiocg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
+static int blkcg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
 {
         struct task_struct *task;
         struct io_context *ioc;
@@ -677,12 +674,12 @@ static int blkiocg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
 
 struct cgroup_subsys blkio_subsys = {
         .name = "blkio",
-        .create = blkiocg_create,
-        .can_attach = blkiocg_can_attach,
-        .pre_destroy = blkiocg_pre_destroy,
-        .destroy = blkiocg_destroy,
+        .create = blkcg_create,
+        .can_attach = blkcg_can_attach,
+        .pre_destroy = blkcg_pre_destroy,
+        .destroy = blkcg_destroy,
         .subsys_id = blkio_subsys_id,
-        .base_cftypes = blkio_files,
+        .base_cftypes = blkcg_files,
         .module = THIS_MODULE,
 };
 EXPORT_SYMBOL_GPL(blkio_subsys);
@@ -704,10 +701,10 @@ EXPORT_SYMBOL_GPL(blkio_subsys);
  * [un]registerations.  Returns 0 on success, -errno on failure.
  */
 int blkcg_activate_policy(struct request_queue *q,
-                          const struct blkio_policy_type *pol)
+                          const struct blkcg_policy *pol)
 {
         LIST_HEAD(pds);
-        struct blkio_group *blkg;
+        struct blkcg_gq *blkg;
         struct blkg_policy_data *pd, *n;
         int cnt = 0, ret;
 
@@ -720,7 +717,7 @@ int blkcg_activate_policy(struct request_queue *q,
         spin_lock_irq(q->queue_lock);
 
         rcu_read_lock();
-        blkg = __blkg_lookup_create(&blkio_root_cgroup, q);
+        blkg = __blkg_lookup_create(&blkcg_root, q);
         rcu_read_unlock();
 
         if (IS_ERR(blkg)) {
@@ -764,7 +761,7 @@ int blkcg_activate_policy(struct request_queue *q,
 
                 blkg->pd[pol->plid] = pd;
                 pd->blkg = blkg;
-                pol->ops.blkio_init_group_fn(blkg);
+                pol->ops.pd_init_fn(blkg);
 
                 spin_unlock(&blkg->blkcg->lock);
         }
@@ -790,9 +787,9 @@ EXPORT_SYMBOL_GPL(blkcg_activate_policy);
  * blkcg_activate_policy().
  */
 void blkcg_deactivate_policy(struct request_queue *q,
-                             const struct blkio_policy_type *pol)
+                             const struct blkcg_policy *pol)
 {
-        struct blkio_group *blkg;
+        struct blkcg_gq *blkg;
 
         if (!blkcg_policy_enabled(q, pol))
                 return;
@@ -810,8 +807,8 @@ void blkcg_deactivate_policy(struct request_queue *q,
                 /* grab blkcg lock too while removing @pd from @blkg */
                 spin_lock(&blkg->blkcg->lock);
 
-                if (pol->ops.blkio_exit_group_fn)
-                        pol->ops.blkio_exit_group_fn(blkg);
+                if (pol->ops.pd_exit_fn)
+                        pol->ops.pd_exit_fn(blkg);
 
                 kfree(blkg->pd[pol->plid]);
                 blkg->pd[pol->plid] = NULL;
@@ -825,14 +822,13 @@ void blkcg_deactivate_policy(struct request_queue *q,
 EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);
 
 /**
- * blkio_policy_register - register a blkcg policy
- * @blkiop: blkcg policy to register
+ * blkcg_policy_register - register a blkcg policy
+ * @pol: blkcg policy to register
  *
- * Register @blkiop with blkcg core.  Might sleep and @blkiop may be
- * modified on successful registration.  Returns 0 on success and -errno on
- * failure.
+ * Register @pol with blkcg core.  Might sleep and @pol may be modified on
+ * successful registration.  Returns 0 on success and -errno on failure.
  */
-int blkio_policy_register(struct blkio_policy_type *blkiop)
+int blkcg_policy_register(struct blkcg_policy *pol)
 {
         int i, ret;
 
@@ -841,45 +837,45 @@ int blkio_policy_register(struct blkio_policy_type *blkiop)
         /* find an empty slot */
         ret = -ENOSPC;
         for (i = 0; i < BLKCG_MAX_POLS; i++)
-                if (!blkio_policy[i])
+                if (!blkcg_policy[i])
                         break;
         if (i >= BLKCG_MAX_POLS)
                 goto out_unlock;
 
         /* register and update blkgs */
-        blkiop->plid = i;
-        blkio_policy[i] = blkiop;
+        pol->plid = i;
+        blkcg_policy[i] = pol;
 
         /* everything is in place, add intf files for the new policy */
-        if (blkiop->cftypes)
-                WARN_ON(cgroup_add_cftypes(&blkio_subsys, blkiop->cftypes));
+        if (pol->cftypes)
+                WARN_ON(cgroup_add_cftypes(&blkio_subsys, pol->cftypes));
         ret = 0;
 out_unlock:
         mutex_unlock(&blkcg_pol_mutex);
         return ret;
 }
-EXPORT_SYMBOL_GPL(blkio_policy_register);
+EXPORT_SYMBOL_GPL(blkcg_policy_register);
 
 /**
- * blkiop_policy_unregister - unregister a blkcg policy
- * @blkiop: blkcg policy to unregister
+ * blkcg_policy_unregister - unregister a blkcg policy
+ * @pol: blkcg policy to unregister
  *
- * Undo blkio_policy_register(@blkiop).  Might sleep.
+ * Undo blkcg_policy_register(@pol).  Might sleep.
  */
-void blkio_policy_unregister(struct blkio_policy_type *blkiop)
+void blkcg_policy_unregister(struct blkcg_policy *pol)
 {
         mutex_lock(&blkcg_pol_mutex);
 
-        if (WARN_ON(blkio_policy[blkiop->plid] != blkiop))
+        if (WARN_ON(blkcg_policy[pol->plid] != pol))
                 goto out_unlock;
 
         /* kill the intf files first */
-        if (blkiop->cftypes)
-                cgroup_rm_cftypes(&blkio_subsys, blkiop->cftypes);
+        if (pol->cftypes)
+                cgroup_rm_cftypes(&blkio_subsys, pol->cftypes);
 
         /* unregister and update blkgs */
-        blkio_policy[blkiop->plid] = NULL;
+        blkcg_policy[pol->plid] = NULL;
 out_unlock:
         mutex_unlock(&blkcg_pol_mutex);
 }
-EXPORT_SYMBOL_GPL(blkio_policy_unregister);
+EXPORT_SYMBOL_GPL(blkcg_policy_unregister);