4 files changed, 105 insertions, 115 deletions

diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
index 290792a13e3c..e90c7c164c83 100644
--- a/block/blk-cgroup.c
+++ b/block/blk-cgroup.c
@@ -437,10 +437,10 @@ struct request_list *__blk_queue_next_rl(struct request_list *rl,
         return &blkg->rl;
 }
 
-static int blkcg_reset_stats(struct cgroup *cgroup, struct cftype *cftype,
-                             u64 val)
+static int blkcg_reset_stats(struct cgroup_subsys_state *css,
+                             struct cftype *cftype, u64 val)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
+        struct blkcg *blkcg = css_to_blkcg(css);
         struct blkcg_gq *blkg;
         int i;
 
@@ -614,15 +614,13 @@ u64 blkg_stat_recursive_sum(struct blkg_policy_data *pd, int off)
 {
         struct blkcg_policy *pol = blkcg_policy[pd->plid];
         struct blkcg_gq *pos_blkg;
-        struct cgroup *pos_cgrp;
-        u64 sum;
+        struct cgroup_subsys_state *pos_css;
+        u64 sum = 0;
 
         lockdep_assert_held(pd->blkg->q->queue_lock);
 
-        sum = blkg_stat_read((void *)pd + off);
-
         rcu_read_lock();
-        blkg_for_each_descendant_pre(pos_blkg, pos_cgrp, pd_to_blkg(pd)) {
+        blkg_for_each_descendant_pre(pos_blkg, pos_css, pd_to_blkg(pd)) {
                 struct blkg_policy_data *pos_pd = blkg_to_pd(pos_blkg, pol);
                 struct blkg_stat *stat = (void *)pos_pd + off;
 
@@ -649,16 +647,14 @@ struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkg_policy_data *pd,
 {
         struct blkcg_policy *pol = blkcg_policy[pd->plid];
         struct blkcg_gq *pos_blkg;
-        struct cgroup *pos_cgrp;
-        struct blkg_rwstat sum;
+        struct cgroup_subsys_state *pos_css;
+        struct blkg_rwstat sum = { };
         int i;
 
         lockdep_assert_held(pd->blkg->q->queue_lock);
 
-        sum = blkg_rwstat_read((void *)pd + off);
-
         rcu_read_lock();
-        blkg_for_each_descendant_pre(pos_blkg, pos_cgrp, pd_to_blkg(pd)) {
+        blkg_for_each_descendant_pre(pos_blkg, pos_css, pd_to_blkg(pd)) {
                 struct blkg_policy_data *pos_pd = blkg_to_pd(pos_blkg, pol);
                 struct blkg_rwstat *rwstat = (void *)pos_pd + off;
                 struct blkg_rwstat tmp;
@@ -765,18 +761,18 @@ struct cftype blkcg_files[] = {
 
 /**
  * blkcg_css_offline - cgroup css_offline callback
- * @cgroup: cgroup of interest
+ * @css: css of interest
  *
- * This function is called when @cgroup is about to go away and responsible
- * for shooting down all blkgs associated with @cgroup.  blkgs should be
+ * This function is called when @css is about to go away and responsible
+ * for shooting down all blkgs associated with @css.  blkgs should be
  * removed while holding both q and blkcg locks.  As blkcg lock is nested
  * inside q lock, this function performs reverse double lock dancing.
  *
  * This is the blkcg counterpart of ioc_release_fn().
  */
-static void blkcg_css_offline(struct cgroup *cgroup)
+static void blkcg_css_offline(struct cgroup_subsys_state *css)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         spin_lock_irq(&blkcg->lock);
 
@@ -798,21 +794,21 @@ static void blkcg_css_offline(struct cgroup *cgroup)
         spin_unlock_irq(&blkcg->lock);
 }
 
-static void blkcg_css_free(struct cgroup *cgroup)
+static void blkcg_css_free(struct cgroup_subsys_state *css)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgroup);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         if (blkcg != &blkcg_root)
                 kfree(blkcg);
 }
 
-static struct cgroup_subsys_state *blkcg_css_alloc(struct cgroup *cgroup)
+static struct cgroup_subsys_state *
+blkcg_css_alloc(struct cgroup_subsys_state *parent_css)
 {
         static atomic64_t id_seq = ATOMIC64_INIT(0);
         struct blkcg *blkcg;
-        struct cgroup *parent = cgroup->parent;
 
-        if (!parent) {
+        if (!parent_css) {
                 blkcg = &blkcg_root;
                 goto done;
         }
@@ -883,14 +879,15 @@ 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 blkcg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
+static int blkcg_can_attach(struct cgroup_subsys_state *css,
+                            struct cgroup_taskset *tset)
 {
         struct task_struct *task;
         struct io_context *ioc;
         int ret = 0;
 
         /* task_lock() is needed to avoid races with exit_io_context() */
-        cgroup_taskset_for_each(task, cgrp, tset) {
+        cgroup_taskset_for_each(task, css, tset) {
                 task_lock(task);
                 ioc = task->io_context;
                 if (ioc && atomic_read(&ioc->nr_tasks) > 1)
@@ -1127,7 +1124,7 @@ void blkcg_policy_unregister(struct blkcg_policy *pol)
 
         /* kill the intf files first */
         if (pol->cftypes)
-                cgroup_rm_cftypes(&blkio_subsys, pol->cftypes);
+                cgroup_rm_cftypes(pol->cftypes);
 
         /* unregister and update blkgs */
         blkcg_policy[pol->plid] = NULL;
diff --git a/block/blk-cgroup.h b/block/blk-cgroup.h
index 8056c03a3382..ae6969a7ffd4 100644
--- a/block/blk-cgroup.h
+++ b/block/blk-cgroup.h
@@ -179,22 +179,20 @@ int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
 void blkg_conf_finish(struct blkg_conf_ctx *ctx);
 
 
-static inline struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup)
+static inline struct blkcg *css_to_blkcg(struct cgroup_subsys_state *css)
 {
-        return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),
-                            struct blkcg, css);
+        return css ? container_of(css, struct blkcg, css) : NULL;
 }
 
 static inline struct blkcg *task_blkcg(struct task_struct *tsk)
 {
-        return container_of(task_subsys_state(tsk, blkio_subsys_id),
-                            struct blkcg, css);
+        return css_to_blkcg(task_css(tsk, blkio_subsys_id));
 }
 
 static inline struct blkcg *bio_blkcg(struct bio *bio)
 {
         if (bio && bio->bi_css)
-                return container_of(bio->bi_css, struct blkcg, css);
+                return css_to_blkcg(bio->bi_css);
         return task_blkcg(current);
 }
 
@@ -206,9 +204,7 @@ static inline struct blkcg *bio_blkcg(struct bio *bio)
  */
 static inline struct blkcg *blkcg_parent(struct blkcg *blkcg)
 {
-        struct cgroup *pcg = blkcg->css.cgroup->parent;
-
-        return pcg ? cgroup_to_blkcg(pcg) : NULL;
+        return css_to_blkcg(css_parent(&blkcg->css));
 }
 
 /**
@@ -288,32 +284,33 @@ struct blkcg_gq *__blkg_lookup(struct blkcg *blkcg, struct request_queue *q,
 /**
  * blkg_for_each_descendant_pre - pre-order walk of a blkg's descendants
  * @d_blkg: loop cursor pointing to the current descendant
- * @pos_cgrp: used for iteration
+ * @pos_css: used for iteration
  * @p_blkg: target blkg to walk descendants of
  *
  * Walk @c_blkg through the descendants of @p_blkg.  Must be used with RCU
  * read locked.  If called under either blkcg or queue lock, the iteration
  * is guaranteed to include all and only online blkgs.  The caller may
- * update @pos_cgrp by calling cgroup_rightmost_descendant() to skip
- * subtree.
+ * update @pos_css by calling css_rightmost_descendant() to skip subtree.
+ * @p_blkg is included in the iteration and the first node to be visited.
  */
-#define blkg_for_each_descendant_pre(d_blkg, pos_cgrp, p_blkg)          \
-        cgroup_for_each_descendant_pre((pos_cgrp), (p_blkg)->blkcg->css.cgroup) \
-                if (((d_blkg) = __blkg_lookup(cgroup_to_blkcg(pos_cgrp), \
+#define blkg_for_each_descendant_pre(d_blkg, pos_css, p_blkg)           \
+        css_for_each_descendant_pre((pos_css), &(p_blkg)->blkcg->css)   \
+                if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
                                               (p_blkg)->q, false)))
 
 /**
  * blkg_for_each_descendant_post - post-order walk of a blkg's descendants
  * @d_blkg: loop cursor pointing to the current descendant
- * @pos_cgrp: used for iteration
+ * @pos_css: used for iteration
  * @p_blkg: target blkg to walk descendants of
  *
  * Similar to blkg_for_each_descendant_pre() but performs post-order
- * traversal instead.  Synchronization rules are the same.
+ * traversal instead.  Synchronization rules are the same.  @p_blkg is
+ * included in the iteration and the last node to be visited.
  */
-#define blkg_for_each_descendant_post(d_blkg, pos_cgrp, p_blkg)         \
-        cgroup_for_each_descendant_post((pos_cgrp), (p_blkg)->blkcg->css.cgroup) \
-                if (((d_blkg) = __blkg_lookup(cgroup_to_blkcg(pos_cgrp), \
+#define blkg_for_each_descendant_post(d_blkg, pos_css, p_blkg)          \
+        css_for_each_descendant_post((pos_css), &(p_blkg)->blkcg->css)  \
+                if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
                                               (p_blkg)->q, false)))
 
 /**
@@ -576,7 +573,6 @@ static inline int blkcg_activate_policy(struct request_queue *q,
 static inline void blkcg_deactivate_policy(struct request_queue *q,
                                            const struct blkcg_policy *pol) { }
 
-static inline struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup) { return NULL; }
 static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }
 
 static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
diff --git a/block/blk-throttle.c b/block/blk-throttle.c
index 08a32dfd3844..8331aba9426f 100644
--- a/block/blk-throttle.c
+++ b/block/blk-throttle.c
@@ -1293,10 +1293,10 @@ static u64 tg_prfill_cpu_rwstat(struct seq_file *sf,
         return __blkg_prfill_rwstat(sf, pd, &rwstat);
 }
 
-static int tg_print_cpu_rwstat(struct cgroup *cgrp, struct cftype *cft,
-                               struct seq_file *sf)
+static int tg_print_cpu_rwstat(struct cgroup_subsys_state *css,
+                               struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, tg_prfill_cpu_rwstat, &blkcg_policy_throtl,
                           cft->private, true);
@@ -1325,31 +1325,31 @@ static u64 tg_prfill_conf_uint(struct seq_file *sf, struct blkg_policy_data *pd,
         return __blkg_prfill_u64(sf, pd, v);
 }
 
-static int tg_print_conf_u64(struct cgroup *cgrp, struct cftype *cft,
-                             struct seq_file *sf)
+static int tg_print_conf_u64(struct cgroup_subsys_state *css,
+                             struct cftype *cft, struct seq_file *sf)
 {
-        blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp), tg_prfill_conf_u64,
+        blkcg_print_blkgs(sf, css_to_blkcg(css), tg_prfill_conf_u64,
                           &blkcg_policy_throtl, cft->private, false);
         return 0;
 }
 
-static int tg_print_conf_uint(struct cgroup *cgrp, struct cftype *cft,
-                              struct seq_file *sf)
+static int tg_print_conf_uint(struct cgroup_subsys_state *css,
+                              struct cftype *cft, struct seq_file *sf)
 {
-        blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp), tg_prfill_conf_uint,
+        blkcg_print_blkgs(sf, css_to_blkcg(css), tg_prfill_conf_uint,
                           &blkcg_policy_throtl, cft->private, false);
         return 0;
 }
 
-static int tg_set_conf(struct cgroup *cgrp, struct cftype *cft, const char *buf,
-                       bool is_u64)
+static int tg_set_conf(struct cgroup_subsys_state *css, struct cftype *cft,
+                       const char *buf, bool is_u64)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
         struct blkg_conf_ctx ctx;
         struct throtl_grp *tg;
         struct throtl_service_queue *sq;
         struct blkcg_gq *blkg;
-        struct cgroup *pos_cgrp;
+        struct cgroup_subsys_state *pos_css;
         int ret;
 
         ret = blkg_conf_prep(blkcg, &blkcg_policy_throtl, buf, &ctx);
@@ -1379,8 +1379,7 @@ static int tg_set_conf(struct cgroup *cgrp, struct cftype *cft, const char *buf,
          * restrictions in the whole hierarchy and allows them to bypass
          * blk-throttle.
          */
-        tg_update_has_rules(tg);
-        blkg_for_each_descendant_pre(blkg, pos_cgrp, ctx.blkg)
+        blkg_for_each_descendant_pre(blkg, pos_css, ctx.blkg)
                 tg_update_has_rules(blkg_to_tg(blkg));
 
         /*
@@ -1403,16 +1402,16 @@ static int tg_set_conf(struct cgroup *cgrp, struct cftype *cft, const char *buf,
         return 0;
 }
 
-static int tg_set_conf_u64(struct cgroup *cgrp, struct cftype *cft,
+static int tg_set_conf_u64(struct cgroup_subsys_state *css, struct cftype *cft,
                            const char *buf)
 {
-        return tg_set_conf(cgrp, cft, buf, true);
+        return tg_set_conf(css, cft, buf, true);
 }
 
-static int tg_set_conf_uint(struct cgroup *cgrp, struct cftype *cft,
+static int tg_set_conf_uint(struct cgroup_subsys_state *css, struct cftype *cft,
                             const char *buf)
 {
-        return tg_set_conf(cgrp, cft, buf, false);
+        return tg_set_conf(css, cft, buf, false);
 }
 
 static struct cftype throtl_files[] = {
@@ -1623,7 +1622,7 @@ void blk_throtl_drain(struct request_queue *q)
 {
         struct throtl_data *td = q->td;
         struct blkcg_gq *blkg;
-        struct cgroup *pos_cgrp;
+        struct cgroup_subsys_state *pos_css;
         struct bio *bio;
         int rw;
 
@@ -1636,11 +1635,9 @@ void blk_throtl_drain(struct request_queue *q)
          * better to walk service_queue tree directly but blkg walk is
          * easier.
          */
-        blkg_for_each_descendant_post(blkg, pos_cgrp, td->queue->root_blkg)
+        blkg_for_each_descendant_post(blkg, pos_css, td->queue->root_blkg)
                 tg_drain_bios(&blkg_to_tg(blkg)->service_queue);
 
-        tg_drain_bios(&td_root_tg(td)->service_queue);
-
         /* finally, transfer bios from top-level tg's into the td */
         tg_drain_bios(&td->service_queue);
 
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index d5bbdcfd0dab..dabb9d02cf9a 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -1607,12 +1607,11 @@ static u64 cfqg_prfill_weight_device(struct seq_file *sf,
         return __blkg_prfill_u64(sf, pd, cfqg->dev_weight);
 }
 
-static int cfqg_print_weight_device(struct cgroup *cgrp, struct cftype *cft,
-                                    struct seq_file *sf)
+static int cfqg_print_weight_device(struct cgroup_subsys_state *css,
+                                    struct cftype *cft, struct seq_file *sf)
 {
-        blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp),
-                          cfqg_prfill_weight_device, &blkcg_policy_cfq, 0,
-                          false);
+        blkcg_print_blkgs(sf, css_to_blkcg(css), cfqg_prfill_weight_device,
+                          &blkcg_policy_cfq, 0, false);
         return 0;
 }
 
@@ -1626,35 +1625,34 @@ static u64 cfqg_prfill_leaf_weight_device(struct seq_file *sf,
         return __blkg_prfill_u64(sf, pd, cfqg->dev_leaf_weight);
 }
 
-static int cfqg_print_leaf_weight_device(struct cgroup *cgrp,
+static int cfqg_print_leaf_weight_device(struct cgroup_subsys_state *css,
                                          struct cftype *cft,
                                          struct seq_file *sf)
 {
-        blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp),
-                          cfqg_prfill_leaf_weight_device, &blkcg_policy_cfq, 0,
-                          false);
+        blkcg_print_blkgs(sf, css_to_blkcg(css), cfqg_prfill_leaf_weight_device,
+                          &blkcg_policy_cfq, 0, false);
         return 0;
 }
 
-static int cfq_print_weight(struct cgroup *cgrp, struct cftype *cft,
+static int cfq_print_weight(struct cgroup_subsys_state *css, struct cftype *cft,
                             struct seq_file *sf)
 {
-        seq_printf(sf, "%u\n", cgroup_to_blkcg(cgrp)->cfq_weight);
+        seq_printf(sf, "%u\n", css_to_blkcg(css)->cfq_weight);
         return 0;
 }
 
-static int cfq_print_leaf_weight(struct cgroup *cgrp, struct cftype *cft,
-                                 struct seq_file *sf)
+static int cfq_print_leaf_weight(struct cgroup_subsys_state *css,
+                                 struct cftype *cft, struct seq_file *sf)
 {
-        seq_printf(sf, "%u\n",
-                   cgroup_to_blkcg(cgrp)->cfq_leaf_weight);
+        seq_printf(sf, "%u\n", css_to_blkcg(css)->cfq_leaf_weight);
         return 0;
 }
 
-static int __cfqg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
-                                    const char *buf, bool is_leaf_weight)
+static int __cfqg_set_weight_device(struct cgroup_subsys_state *css,
+                                    struct cftype *cft, const char *buf,
+                                    bool is_leaf_weight)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
         struct blkg_conf_ctx ctx;
         struct cfq_group *cfqg;
         int ret;
@@ -1680,22 +1678,22 @@ static int __cfqg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
         return ret;
 }
 
-static int cfqg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
-                                  const char *buf)
+static int cfqg_set_weight_device(struct cgroup_subsys_state *css,
+                                  struct cftype *cft, const char *buf)
 {
-        return __cfqg_set_weight_device(cgrp, cft, buf, false);
+        return __cfqg_set_weight_device(css, cft, buf, false);
 }
 
-static int cfqg_set_leaf_weight_device(struct cgroup *cgrp, struct cftype *cft,
-                                       const char *buf)
+static int cfqg_set_leaf_weight_device(struct cgroup_subsys_state *css,
+                                       struct cftype *cft, const char *buf)
 {
-        return __cfqg_set_weight_device(cgrp, cft, buf, true);
+        return __cfqg_set_weight_device(css, cft, buf, true);
 }
 
-static int __cfq_set_weight(struct cgroup *cgrp, struct cftype *cft, u64 val,
-                            bool is_leaf_weight)
+static int __cfq_set_weight(struct cgroup_subsys_state *css, struct cftype *cft,
+                            u64 val, bool is_leaf_weight)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
         struct blkcg_gq *blkg;
 
         if (val < CFQ_WEIGHT_MIN || val > CFQ_WEIGHT_MAX)
@@ -1727,30 +1725,32 @@ static int __cfq_set_weight(struct cgroup *cgrp, struct cftype *cft, u64 val,
         return 0;
 }
 
-static int cfq_set_weight(struct cgroup *cgrp, struct cftype *cft, u64 val)
+static int cfq_set_weight(struct cgroup_subsys_state *css, struct cftype *cft,
+                          u64 val)
 {
-        return __cfq_set_weight(cgrp, cft, val, false);
+        return __cfq_set_weight(css, cft, val, false);
 }
 
-static int cfq_set_leaf_weight(struct cgroup *cgrp, struct cftype *cft, u64 val)
+static int cfq_set_leaf_weight(struct cgroup_subsys_state *css,
+                               struct cftype *cft, u64 val)
 {
-        return __cfq_set_weight(cgrp, cft, val, true);
+        return __cfq_set_weight(css, cft, val, true);
 }
 
-static int cfqg_print_stat(struct cgroup *cgrp, struct cftype *cft,
+static int cfqg_print_stat(struct cgroup_subsys_state *css, struct cftype *cft,
                            struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, blkg_prfill_stat, &blkcg_policy_cfq,
                           cft->private, false);
         return 0;
 }
 
-static int cfqg_print_rwstat(struct cgroup *cgrp, struct cftype *cft,
-                             struct seq_file *sf)
+static int cfqg_print_rwstat(struct cgroup_subsys_state *css,
+                             struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, blkg_prfill_rwstat, &blkcg_policy_cfq,
                           cft->private, true);
@@ -1773,20 +1773,20 @@ static u64 cfqg_prfill_rwstat_recursive(struct seq_file *sf,
         return __blkg_prfill_rwstat(sf, pd, &sum);
 }
 
-static int cfqg_print_stat_recursive(struct cgroup *cgrp, struct cftype *cft,
-                                     struct seq_file *sf)
+static int cfqg_print_stat_recursive(struct cgroup_subsys_state *css,
+                                     struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, cfqg_prfill_stat_recursive,
                           &blkcg_policy_cfq, cft->private, false);
         return 0;
 }
 
-static int cfqg_print_rwstat_recursive(struct cgroup *cgrp, struct cftype *cft,
-                                       struct seq_file *sf)
+static int cfqg_print_rwstat_recursive(struct cgroup_subsys_state *css,
+                                       struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, cfqg_prfill_rwstat_recursive,
                           &blkcg_policy_cfq, cft->private, true);
@@ -1810,10 +1810,10 @@ static u64 cfqg_prfill_avg_queue_size(struct seq_file *sf,
 }
 
 /* print avg_queue_size */
-static int cfqg_print_avg_queue_size(struct cgroup *cgrp, struct cftype *cft,
-                                     struct seq_file *sf)
+static int cfqg_print_avg_queue_size(struct cgroup_subsys_state *css,
+                                     struct cftype *cft, struct seq_file *sf)
 {
-        struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
+        struct blkcg *blkcg = css_to_blkcg(css);
 
         blkcg_print_blkgs(sf, blkcg, cfqg_prfill_avg_queue_size,
                           &blkcg_policy_cfq, 0, false);