block: merge blkg_lookup_create and __blkg_lookup_create

No good reason to keep these two functions split.

Acked-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
index bb0607b..6aedb73 100644 (file)
--- a/block/blk-cgroup.c
+++ b/block/blk-cgroup.c
@@ -316,30 +316,35 @@ err_free_blkg:
 }
 
 /**
- * __blkg_lookup_create - lookup blkg, try to create one if not there
+ * blkg_lookup_create - lookup blkg, try to create one if not there
  * @blkcg: blkcg of interest
  * @q: request_queue of interest
  *
  * Lookup blkg for the @blkcg - @q pair.  If it doesn't exist, try to
  * create one.  blkg creation is performed recursively from blkcg_root such
  * that all non-root blkg's have access to the parent blkg.  This function
- * should be called under RCU read lock and @q->queue_lock.
+ * should be called under RCU read lock and takes @q->queue_lock.
  *
  * Returns the blkg or the closest blkg if blkg_create() fails as it walks
  * down from root.
  */
-static struct blkcg_gq *__blkg_lookup_create(struct blkcg *blkcg,
-                                     struct request_queue *q)
+static struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
+               struct request_queue *q)
 {
        struct blkcg_gq *blkg;
+       unsigned long flags;
 
        WARN_ON_ONCE(!rcu_read_lock_held());
-       lockdep_assert_held(&q->queue_lock);
 
-       blkg = __blkg_lookup(blkcg, q, true);
+       blkg = blkg_lookup(blkcg, q);
        if (blkg)
                return blkg;
 
+       spin_lock_irqsave(&q->queue_lock, flags);
+       blkg = __blkg_lookup(blkcg, q, true);
+       if (blkg)
+               goto found;
+
        /*
         * Create blkgs walking down from blkcg_root to @blkcg, so that all
         * non-root blkgs have access to their parents.  Returns the closest
@@ -362,34 +367,16 @@ static struct blkcg_gq *__blkg_lookup_create(struct blkcg *blkcg,
                }
 
                blkg = blkg_create(pos, q, NULL);
-               if (IS_ERR(blkg))
-                       return ret_blkg;
+               if (IS_ERR(blkg)) {
+                       blkg = ret_blkg;
+                       break;
+               }
                if (pos == blkcg)
-                       return blkg;
-       }
-}
-
-/**
- * blkg_lookup_create - find or create a blkg
- * @blkcg: target block cgroup
- * @q: target request_queue
- *
- * This looks up or creates the blkg representing the unique pair
- * of the blkcg and the request_queue.
- */
-static struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
-                                   struct request_queue *q)
-{
-       struct blkcg_gq *blkg = blkg_lookup(blkcg, q);
-
-       if (unlikely(!blkg)) {
-               unsigned long flags;
-
-               spin_lock_irqsave(&q->queue_lock, flags);
-               blkg = __blkg_lookup_create(blkcg, q);
-               spin_unlock_irqrestore(&q->queue_lock, flags);
+                       break;
        }
 
+found:
+       spin_unlock_irqrestore(&q->queue_lock, flags);
        return blkg;
 }