5 files changed, 70 insertions, 71 deletions

diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
index 159aef59589f..5e50ca1f5b47 100644
--- a/block/blk-cgroup.c
+++ b/block/blk-cgroup.c
@@ -129,7 +129,7 @@ blkio_update_group_weight(struct blkio_group *blkg, unsigned int weight)
                 if (blkiop->plid != blkg->plid)
                         continue;
                 if (blkiop->ops.blkio_update_group_weight_fn)
-                        blkiop->ops.blkio_update_group_weight_fn(blkg->key,
+                        blkiop->ops.blkio_update_group_weight_fn(blkg->q,
                                                         blkg, weight);
         }
 }
@@ -147,12 +147,12 @@ static inline void blkio_update_group_bps(struct blkio_group *blkg, u64 bps,
 
                 if (fileid == BLKIO_THROTL_read_bps_device
                     && blkiop->ops.blkio_update_group_read_bps_fn)
-                        blkiop->ops.blkio_update_group_read_bps_fn(blkg->key,
+                        blkiop->ops.blkio_update_group_read_bps_fn(blkg->q,
                                                                 blkg, bps);
 
                 if (fileid == BLKIO_THROTL_write_bps_device
                     && blkiop->ops.blkio_update_group_write_bps_fn)
-                        blkiop->ops.blkio_update_group_write_bps_fn(blkg->key,
+                        blkiop->ops.blkio_update_group_write_bps_fn(blkg->q,
                                                                 blkg, bps);
         }
 }
@@ -170,12 +170,12 @@ static inline void blkio_update_group_iops(struct blkio_group *blkg,
 
                 if (fileid == BLKIO_THROTL_read_iops_device
                     && blkiop->ops.blkio_update_group_read_iops_fn)
-                        blkiop->ops.blkio_update_group_read_iops_fn(blkg->key,
+                        blkiop->ops.blkio_update_group_read_iops_fn(blkg->q,
                                                                 blkg, iops);
 
                 if (fileid == BLKIO_THROTL_write_iops_device
                     && blkiop->ops.blkio_update_group_write_iops_fn)
-                        blkiop->ops.blkio_update_group_write_iops_fn(blkg->key,
+                        blkiop->ops.blkio_update_group_write_iops_fn(blkg->q,
                                                                 blkg,iops);
         }
 }
@@ -478,14 +478,14 @@ int blkio_alloc_blkg_stats(struct blkio_group *blkg)
 EXPORT_SYMBOL_GPL(blkio_alloc_blkg_stats);
 
 void blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
-                struct blkio_group *blkg, void *key, dev_t dev,
+                struct blkio_group *blkg, struct request_queue *q, dev_t dev,
                 enum blkio_policy_id plid)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&blkcg->lock, flags);
         spin_lock_init(&blkg->stats_lock);
-        rcu_assign_pointer(blkg->key, key);
+        rcu_assign_pointer(blkg->q, q);
         blkg->blkcg_id = css_id(&blkcg->css);
         hlist_add_head_rcu(&blkg->blkcg_node, &blkcg->blkg_list);
         blkg->plid = plid;
@@ -531,18 +531,16 @@ int blkiocg_del_blkio_group(struct blkio_group *blkg)
 EXPORT_SYMBOL_GPL(blkiocg_del_blkio_group);
 
 /* called under rcu_read_lock(). */
-struct blkio_group *blkiocg_lookup_group(struct blkio_cgroup *blkcg, void *key)
+struct blkio_group *blkiocg_lookup_group(struct blkio_cgroup *blkcg,
+                                         struct request_queue *q,
+                                         enum blkio_policy_id plid)
 {
         struct blkio_group *blkg;
         struct hlist_node *n;
-        void *__key;
 
-        hlist_for_each_entry_rcu(blkg, n, &blkcg->blkg_list, blkcg_node) {
-                __key = blkg->key;
-                if (__key == key)
+        hlist_for_each_entry_rcu(blkg, n, &blkcg->blkg_list, blkcg_node)
+                if (blkg->q == q && blkg->plid == plid)
                         return blkg;
-        }
-
         return NULL;
 }
 EXPORT_SYMBOL_GPL(blkiocg_lookup_group);
@@ -1582,7 +1580,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
         struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);
         unsigned long flags;
         struct blkio_group *blkg;
-        void *key;
+        struct request_queue *q;
         struct blkio_policy_type *blkiop;
         struct blkio_policy_node *pn, *pntmp;
 
@@ -1597,7 +1595,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 
                 blkg = hlist_entry(blkcg->blkg_list.first, struct blkio_group,
                                         blkcg_node);
-                key = rcu_dereference(blkg->key);
+                q = rcu_dereference(blkg->q);
                 __blkiocg_del_blkio_group(blkg);
 
                 spin_unlock_irqrestore(&blkcg->lock, flags);
@@ -1611,7 +1609,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
                 list_for_each_entry(blkiop, &blkio_list, list) {
                         if (blkiop->plid != blkg->plid)
                                 continue;
-                        blkiop->ops.blkio_unlink_group_fn(key, blkg);
+                        blkiop->ops.blkio_unlink_group_fn(q, blkg);
                 }
                 spin_unlock(&blkio_list_lock);
         } while (1);
diff --git a/block/blk-cgroup.h b/block/blk-cgroup.h
index e5cfcbd4d2f4..41c960b99c57 100644
--- a/block/blk-cgroup.h
+++ b/block/blk-cgroup.h
@@ -153,8 +153,8 @@ struct blkio_group_stats_cpu {
 };
 
 struct blkio_group {
-        /* An rcu protected unique identifier for the group */
-        void *key;
+        /* Pointer to the associated request_queue, RCU protected */
+        struct request_queue __rcu *q;
         struct hlist_node blkcg_node;
         unsigned short blkcg_id;
         /* Store cgroup path */
@@ -202,17 +202,18 @@ extern unsigned int blkcg_get_read_iops(struct blkio_cgroup *blkcg,
 extern unsigned int blkcg_get_write_iops(struct blkio_cgroup *blkcg,
                                      dev_t dev);
 
-typedef void (blkio_unlink_group_fn) (void *key, struct blkio_group *blkg);
+typedef void (blkio_unlink_group_fn)(struct request_queue *q,
+                        struct blkio_group *blkg);
 typedef bool (blkio_clear_queue_fn)(struct request_queue *q);
-typedef void (blkio_update_group_weight_fn) (void *key,
+typedef void (blkio_update_group_weight_fn)(struct request_queue *q,
                         struct blkio_group *blkg, unsigned int weight);
-typedef void (blkio_update_group_read_bps_fn) (void * key,
+typedef void (blkio_update_group_read_bps_fn)(struct request_queue *q,
                         struct blkio_group *blkg, u64 read_bps);
-typedef void (blkio_update_group_write_bps_fn) (void *key,
+typedef void (blkio_update_group_write_bps_fn)(struct request_queue *q,
                         struct blkio_group *blkg, u64 write_bps);
-typedef void (blkio_update_group_read_iops_fn) (void *key,
+typedef void (blkio_update_group_read_iops_fn)(struct request_queue *q,
                         struct blkio_group *blkg, unsigned int read_iops);
-typedef void (blkio_update_group_write_iops_fn) (void *key,
+typedef void (blkio_update_group_write_iops_fn)(struct request_queue *q,
                         struct blkio_group *blkg, unsigned int write_iops);
 
 struct blkio_policy_ops {
@@ -305,12 +306,13 @@ extern struct blkio_cgroup blkio_root_cgroup;
 extern struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup);
 extern struct blkio_cgroup *task_blkio_cgroup(struct task_struct *tsk);
 extern void blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
-        struct blkio_group *blkg, void *key, dev_t dev,
+        struct blkio_group *blkg, struct request_queue *q, dev_t dev,
         enum blkio_policy_id plid);
 extern int blkio_alloc_blkg_stats(struct blkio_group *blkg);
 extern int blkiocg_del_blkio_group(struct blkio_group *blkg);
 extern struct blkio_group *blkiocg_lookup_group(struct blkio_cgroup *blkcg,
-                                                void *key);
+                                                struct request_queue *q,
+                                                enum blkio_policy_id plid);
 void blkiocg_update_timeslice_used(struct blkio_group *blkg,
                                         unsigned long time,
                                         unsigned long unaccounted_time);
diff --git a/block/blk-throttle.c b/block/blk-throttle.c
index c252df9169db..6613de78e364 100644
--- a/block/blk-throttle.c
+++ b/block/blk-throttle.c
@@ -252,7 +252,7 @@ static void throtl_init_add_tg_lists(struct throtl_data *td,
         __throtl_tg_fill_dev_details(td, tg);
 
         /* Add group onto cgroup list */
-        blkiocg_add_blkio_group(blkcg, &tg->blkg, (void *)td,
+        blkiocg_add_blkio_group(blkcg, &tg->blkg, td->queue,
                                 tg->blkg.dev, BLKIO_POLICY_THROTL);
 
         tg->bps[READ] = blkcg_get_read_bps(blkcg, tg->blkg.dev);
@@ -288,7 +288,6 @@ static struct
 throtl_grp *throtl_find_tg(struct throtl_data *td, struct blkio_cgroup *blkcg)
 {
         struct throtl_grp *tg = NULL;
-        void *key = td;
 
         /*
          * This is the common case when there are no blkio cgroups.
@@ -297,7 +296,8 @@ throtl_grp *throtl_find_tg(struct throtl_data *td, struct blkio_cgroup *blkcg)
         if (blkcg == &blkio_root_cgroup)
                 tg = td->root_tg;
         else
-                tg = tg_of_blkg(blkiocg_lookup_group(blkcg, key));
+                tg = tg_of_blkg(blkiocg_lookup_group(blkcg, td->queue,
+                                                     BLKIO_POLICY_THROTL));
 
         __throtl_tg_fill_dev_details(td, tg);
         return tg;
@@ -1012,22 +1012,22 @@ static bool throtl_release_tgs(struct throtl_data *td, bool release_root)
  * no new IO will come in this group. So get rid of this group as soon as
  * any pending IO in the group is finished.
  *
- * This function is called under rcu_read_lock(). key is the rcu protected
- * pointer. That means "key" is a valid throtl_data pointer as long as we are
- * rcu read lock.
+ * This function is called under rcu_read_lock(). @q is the rcu protected
+ * pointer. That means @q is a valid request_queue pointer as long as we
+ * are rcu read lock.
  *
- * "key" was fetched from blkio_group under blkio_cgroup->lock. That means
+ * @q was fetched from blkio_group under blkio_cgroup->lock. That means
  * it should not be NULL as even if queue was going away, cgroup deltion
  * path got to it first.
  */
-void throtl_unlink_blkio_group(void *key, struct blkio_group *blkg)
+void throtl_unlink_blkio_group(struct request_queue *q,
+                               struct blkio_group *blkg)
 {
         unsigned long flags;
-        struct throtl_data *td = key;
 
-        spin_lock_irqsave(td->queue->queue_lock, flags);
-        throtl_destroy_tg(td, tg_of_blkg(blkg));
-        spin_unlock_irqrestore(td->queue->queue_lock, flags);
+        spin_lock_irqsave(q->queue_lock, flags);
+        throtl_destroy_tg(q->td, tg_of_blkg(blkg));
+        spin_unlock_irqrestore(q->queue_lock, flags);
 }
 
 static bool throtl_clear_queue(struct request_queue *q)
@@ -1054,52 +1054,48 @@ static void throtl_update_blkio_group_common(struct throtl_data *td,
 }
 
 /*
- * For all update functions, key should be a valid pointer because these
+ * For all update functions, @q should be a valid pointer because these
  * update functions are called under blkcg_lock, that means, blkg is
- * valid and in turn key is valid. queue exit path can not race because
+ * valid and in turn @q is valid. queue exit path can not race because
  * of blkcg_lock
  *
  * Can not take queue lock in update functions as queue lock under blkcg_lock
  * is not allowed. Under other paths we take blkcg_lock under queue_lock.
  */
-static void throtl_update_blkio_group_read_bps(void *key,
+static void throtl_update_blkio_group_read_bps(struct request_queue *q,
                                 struct blkio_group *blkg, u64 read_bps)
 {
-        struct throtl_data *td = key;
         struct throtl_grp *tg = tg_of_blkg(blkg);
 
         tg->bps[READ] = read_bps;
-        throtl_update_blkio_group_common(td, tg);
+        throtl_update_blkio_group_common(q->td, tg);
 }
 
-static void throtl_update_blkio_group_write_bps(void *key,
+static void throtl_update_blkio_group_write_bps(struct request_queue *q,
                                 struct blkio_group *blkg, u64 write_bps)
 {
-        struct throtl_data *td = key;
         struct throtl_grp *tg = tg_of_blkg(blkg);
 
         tg->bps[WRITE] = write_bps;
-        throtl_update_blkio_group_common(td, tg);
+        throtl_update_blkio_group_common(q->td, tg);
 }
 
-static void throtl_update_blkio_group_read_iops(void *key,
+static void throtl_update_blkio_group_read_iops(struct request_queue *q,
                         struct blkio_group *blkg, unsigned int read_iops)
 {
-        struct throtl_data *td = key;
         struct throtl_grp *tg = tg_of_blkg(blkg);
 
         tg->iops[READ] = read_iops;
-        throtl_update_blkio_group_common(td, tg);
+        throtl_update_blkio_group_common(q->td, tg);
 }
 
-static void throtl_update_blkio_group_write_iops(void *key,
+static void throtl_update_blkio_group_write_iops(struct request_queue *q,
                         struct blkio_group *blkg, unsigned int write_iops)
 {
-        struct throtl_data *td = key;
         struct throtl_grp *tg = tg_of_blkg(blkg);
 
         tg->iops[WRITE] = write_iops;
-        throtl_update_blkio_group_common(td, tg);
+        throtl_update_blkio_group_common(q->td, tg);
 }
 
 static void throtl_shutdown_wq(struct request_queue *q)
@@ -1306,7 +1302,7 @@ void blk_throtl_exit(struct request_queue *q)
         spin_unlock_irq(q->queue_lock);
 
         /*
-         * Wait for tg->blkg->key accessors to exit their grace periods.
+         * Wait for tg->blkg->q accessors to exit their grace periods.
          * Do this wait only if there are other undestroyed groups out
          * there (other than root group). This can happen if cgroup deletion
          * path claimed the responsibility of cleaning up a group before
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index 0f7a81fc7c73..37e2da9cbb09 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -1020,7 +1020,8 @@ static inline struct cfq_group *cfqg_of_blkg(struct blkio_group *blkg)
         return NULL;
 }
 
-static void cfq_update_blkio_group_weight(void *key, struct blkio_group *blkg,
+static void cfq_update_blkio_group_weight(struct request_queue *q,
+                                          struct blkio_group *blkg,
                                           unsigned int weight)
 {
         struct cfq_group *cfqg = cfqg_of_blkg(blkg);
@@ -1043,10 +1044,10 @@ static void cfq_init_add_cfqg_lists(struct cfq_data *cfqd,
         if (bdi->dev) {
                 sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);
                 cfq_blkiocg_add_blkio_group(blkcg, &cfqg->blkg,
-                                        (void *)cfqd, MKDEV(major, minor));
+                                        cfqd->queue, MKDEV(major, minor));
         } else
                 cfq_blkiocg_add_blkio_group(blkcg, &cfqg->blkg,
-                                        (void *)cfqd, 0);
+                                        cfqd->queue, 0);
 
         cfqd->nr_blkcg_linked_grps++;
         cfqg->weight = blkcg_get_weight(blkcg, cfqg->blkg.dev);
@@ -1097,7 +1098,6 @@ static struct cfq_group *
 cfq_find_cfqg(struct cfq_data *cfqd, struct blkio_cgroup *blkcg)
 {
         struct cfq_group *cfqg = NULL;
-        void *key = cfqd;
         struct backing_dev_info *bdi = &cfqd->queue->backing_dev_info;
         unsigned int major, minor;
 
@@ -1108,7 +1108,8 @@ cfq_find_cfqg(struct cfq_data *cfqd, struct blkio_cgroup *blkcg)
         if (blkcg == &blkio_root_cgroup)
                 cfqg = &cfqd->root_group;
         else
-                cfqg = cfqg_of_blkg(blkiocg_lookup_group(blkcg, key));
+                cfqg = cfqg_of_blkg(blkiocg_lookup_group(blkcg, cfqd->queue,
+                                                         BLKIO_POLICY_PROP));
 
         if (cfqg && !cfqg->blkg.dev && bdi->dev && dev_name(bdi->dev)) {
                 sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);
@@ -1247,21 +1248,22 @@ static bool cfq_release_cfq_groups(struct cfq_data *cfqd)
  * any pending IO in the group is finished.
  *
  * This function is called under rcu_read_lock(). key is the rcu protected
- * pointer. That means "key" is a valid cfq_data pointer as long as we are rcu
- * read lock.
+ * pointer. That means @q is a valid request_queue pointer as long as we
+ * are rcu read lock.
  *
- * "key" was fetched from blkio_group under blkio_cgroup->lock. That means
+ * @q was fetched from blkio_group under blkio_cgroup->lock. That means
  * it should not be NULL as even if elevator was exiting, cgroup deltion
  * path got to it first.
  */
-static void cfq_unlink_blkio_group(void *key, struct blkio_group *blkg)
+static void cfq_unlink_blkio_group(struct request_queue *q,
+                                   struct blkio_group *blkg)
 {
-        unsigned long  flags;
-        struct cfq_data *cfqd = key;
+        struct cfq_data *cfqd = q->elevator->elevator_data;
+        unsigned long flags;
 
-        spin_lock_irqsave(cfqd->queue->queue_lock, flags);
+        spin_lock_irqsave(q->queue_lock, flags);
         cfq_destroy_cfqg(cfqd, cfqg_of_blkg(blkg));
-        spin_unlock_irqrestore(cfqd->queue->queue_lock, flags);
+        spin_unlock_irqrestore(q->queue_lock, flags);
 }
 
 static struct elevator_type iosched_cfq;
@@ -3718,7 +3720,7 @@ static int cfq_init_queue(struct request_queue *q)
         rcu_read_lock();
 
         cfq_blkiocg_add_blkio_group(&blkio_root_cgroup, &cfqg->blkg,
-                                        (void *)cfqd, 0);
+                                    cfqd->queue, 0);
         rcu_read_unlock();
         cfqd->nr_blkcg_linked_grps++;
 
diff --git a/block/cfq.h b/block/cfq.h
index 2a155927e37c..343b78a61df3 100644
--- a/block/cfq.h
+++ b/block/cfq.h
@@ -68,8 +68,9 @@ static inline void cfq_blkiocg_update_completion_stats(struct blkio_group *blkg,
 }
 
 static inline void cfq_blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
-                        struct blkio_group *blkg, void *key, dev_t dev) {
-        blkiocg_add_blkio_group(blkcg, blkg, key, dev, BLKIO_POLICY_PROP);
+                struct blkio_group *blkg, struct request_queue *q, dev_t dev)
+{
+        blkiocg_add_blkio_group(blkcg, blkg, q, dev, BLKIO_POLICY_PROP);
 }
 
 static inline int cfq_blkiocg_del_blkio_group(struct blkio_group *blkg)
@@ -105,7 +106,7 @@ static inline void cfq_blkiocg_update_dispatch_stats(struct blkio_group *blkg,
 static inline void cfq_blkiocg_update_completion_stats(struct blkio_group *blkg, uint64_t start_time, uint64_t io_start_time, bool direction, bool sync) {}
 
 static inline void cfq_blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
-                        struct blkio_group *blkg, void *key, dev_t dev) {}
+                struct blkio_group *blkg, struct request_queue *q, dev_t dev) {}
 static inline int cfq_blkiocg_del_blkio_group(struct blkio_group *blkg)
 {
         return 0;