Merge branch 'for-3.12' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup

Pull cgroup updates from Tejun Heo:
 "A lot of activities on the cgroup front.  Most changes aren't visible
  to userland at all at this point and are laying foundation for the
  planned unified hierarchy.

   - The biggest change is decoupling the lifetime management of css
     (cgroup_subsys_state) from that of cgroup's.  Because controllers
     (cpu, memory, block and so on) will need to be dynamically enabled
     and disabled, css which is the association point between a cgroup
     and a controller may come and go dynamically across the lifetime of
     a cgroup.  Till now, css's were created when the associated cgroup
     was created and stayed till the cgroup got destroyed.

     Assumptions around this tight coupling permeated through cgroup
     core and controllers.  These assumptions are gradually removed,
     which consists bulk of patches, and css destruction path is
     completely decoupled from cgroup destruction path.  Note that
     decoupling of creation path is relatively easy on top of these
     changes and the patchset is pending for the next window.

   - cgroup has its own event mechanism cgroup.event_control, which is
     only used by memcg.  It is overly complex trying to achieve high
     flexibility whose benefits seem dubious at best.  Going forward,
     new events will simply generate file modified event and the
     existing mechanism is being made specific to memcg.  This pull
     request contains prepatory patches for such change.

   - Various fixes and cleanups"

Fixed up conflict in kernel/cgroup.c as per Tejun.

* 'for-3.12' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup: (69 commits)
  cgroup: fix cgroup_css() invocation in css_from_id()
  cgroup: make cgroup_write_event_control() use css_from_dir() instead of __d_cgrp()
  cgroup: make cgroup_event hold onto cgroup_subsys_state instead of cgroup
  cgroup: implement CFTYPE_NO_PREFIX
  cgroup: make cgroup_css() take cgroup_subsys * instead and allow NULL subsys
  cgroup: rename cgroup_css_from_dir() to css_from_dir() and update its syntax
  cgroup: fix cgroup_write_event_control()
  cgroup: fix subsystem file accesses on the root cgroup
  cgroup: change cgroup_from_id() to css_from_id()
  cgroup: use css_get() in cgroup_create() to check CSS_ROOT
  cpuset: remove an unncessary forward declaration
  cgroup: RCU protect each cgroup_subsys_state release
  cgroup: move subsys file removal to kill_css()
  cgroup: factor out kill_css()
  cgroup: decouple cgroup_subsys_state destruction from cgroup destruction
  cgroup: replace cgroup->css_kill_cnt with ->nr_css
  cgroup: bounce cgroup_subsys_state ref kill confirmation to a work item
  cgroup: move cgroup->subsys[] assignment to online_css()
  cgroup: reorganize css init / exit paths
  cgroup: add __rcu modifier to cgroup->subsys[]
  ...

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);