Merge branch 'for-3.17/core' of git://git.kernel.dk/linux-block

Pull block core bits from Jens Axboe:
 "Small round this time, after the massive blk-mq dump for 3.16.  This
  pull request contains:

   - Fixes for max_sectors overflow in ioctls from Akinoby Mita.

   - Partition off-by-one bug fix in aix partitions from Dan Carpenter.

   - Various small partition cleanups from Fabian Frederick.

   - Fix for the block integrity code sometimes returning the wrong
     vector count from Gu Zheng.

   - Cleanup an re-org of the blk-mq queue enter/exit percpu counters
     from Tejun.  Dependent on the percpu pull for 3.17 (which was in
     the block tree too), that you have already pulled in.

   - A blkcg oops fix, also from Tejun"

* 'for-3.17/core' of git://git.kernel.dk/linux-block:
  partitions: aix.c: off by one bug
  blkcg: don't call into policy draining if root_blkg is already gone
  Revert "bio: modify __bio_add_page() to accept pages that don't start a new segment"
  bio: modify __bio_add_page() to accept pages that don't start a new segment
  block: fix SG_[GS]ET_RESERVED_SIZE ioctl when max_sectors is huge
  block: fix BLKSECTGET ioctl when max_sectors is greater than USHRT_MAX
  block/partitions/efi.c: kerneldoc fixing
  block/partitions/msdos.c: code clean-up
  block/partitions/amiga.c: replace nolevel printk by pr_err
  block/partitions/aix.c: replace count*size kzalloc by kcalloc
  bio-integrity: add "bip_max_vcnt" into struct bio_integrity_payload
  blk-mq: use percpu_ref for mq usage count
  blk-mq: collapse __blk_mq_drain_queue() into blk_mq_freeze_queue()
  blk-mq: decouble blk-mq freezing from generic bypassing
  block, blk-mq: draining can't be skipped even if bypass_depth was non-zero
  blk-mq: fix a memory ordering bug in blk_mq_queue_enter()

12 files changed, 102 insertions, 109 deletions

diff --git a/block/bio-integrity.c b/block/bio-integrity.c
index 9e241063a616..bc423f7b02da 100644
--- a/block/bio-integrity.c
+++ b/block/bio-integrity.c
@@ -70,8 +70,10 @@ struct bio_integrity_payload *bio_integrity_alloc(struct bio *bio,
                                           bs->bvec_integrity_pool);
                 if (!bip->bip_vec)
                         goto err;
+                bip->bip_max_vcnt = bvec_nr_vecs(idx);
         } else {
                 bip->bip_vec = bip->bip_inline_vecs;
+                bip->bip_max_vcnt = inline_vecs;
         }
 
         bip->bip_slab = idx;
@@ -114,14 +116,6 @@ void bio_integrity_free(struct bio *bio)
 }
 EXPORT_SYMBOL(bio_integrity_free);
 
-static inline unsigned int bip_integrity_vecs(struct bio_integrity_payload *bip)
-{
-        if (bip->bip_slab == BIO_POOL_NONE)
-                return BIP_INLINE_VECS;
-
-        return bvec_nr_vecs(bip->bip_slab);
-}
-
 /**
  * bio_integrity_add_page - Attach integrity metadata
  * @bio:        bio to update
@@ -137,7 +131,7 @@ int bio_integrity_add_page(struct bio *bio, struct page *page,
         struct bio_integrity_payload *bip = bio->bi_integrity;
         struct bio_vec *iv;
 
-        if (bip->bip_vcnt >= bip_integrity_vecs(bip)) {
+        if (bip->bip_vcnt >= bip->bip_max_vcnt) {
                 printk(KERN_ERR "%s: bip_vec full\n", __func__);
                 return 0;
         }
diff --git a/block/blk-core.c b/block/blk-core.c
index 6f8dba161bfe..c359d72e9d76 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -438,14 +438,17 @@ static void __blk_drain_queue(struct request_queue *q, bool drain_all)
  */
 void blk_queue_bypass_start(struct request_queue *q)
 {
-        bool drain;
-
         spin_lock_irq(q->queue_lock);
-        drain = !q->bypass_depth++;
+        q->bypass_depth++;
         queue_flag_set(QUEUE_FLAG_BYPASS, q);
         spin_unlock_irq(q->queue_lock);
 
-        if (drain) {
+        /*
+         * Queues start drained.  Skip actual draining till init is
+         * complete.  This avoids lenghty delays during queue init which
+         * can happen many times during boot.
+         */
+        if (blk_queue_init_done(q)) {
                 spin_lock_irq(q->queue_lock);
                 __blk_drain_queue(q, false);
                 spin_unlock_irq(q->queue_lock);
@@ -511,7 +514,7 @@ void blk_cleanup_queue(struct request_queue *q)
          * prevent that q->request_fn() gets invoked after draining finished.
          */
         if (q->mq_ops) {
-                blk_mq_drain_queue(q);
+                blk_mq_freeze_queue(q);
                 spin_lock_irq(lock);
         } else {
                 spin_lock_irq(lock);
diff --git a/block/blk-mq.c b/block/blk-mq.c
index ad69ef657e85..5189cb1e478a 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -78,68 +78,47 @@ static void blk_mq_hctx_clear_pending(struct blk_mq_hw_ctx *hctx,
 
 static int blk_mq_queue_enter(struct request_queue *q)
 {
-        int ret;
-
-        __percpu_counter_add(&q->mq_usage_counter, 1, 1000000);
-        smp_wmb();
-
-        /* we have problems freezing the queue if it's initializing */
-        if (!blk_queue_dying(q) &&
-            (!blk_queue_bypass(q) || !blk_queue_init_done(q)))
-                return 0;
-
-        __percpu_counter_add(&q->mq_usage_counter, -1, 1000000);
+        while (true) {
+                int ret;
 
-        spin_lock_irq(q->queue_lock);
-        ret = wait_event_interruptible_lock_irq(q->mq_freeze_wq,
-                !blk_queue_bypass(q) || blk_queue_dying(q),
-                *q->queue_lock);
-        /* inc usage with lock hold to avoid freeze_queue runs here */
-        if (!ret && !blk_queue_dying(q))
-                __percpu_counter_add(&q->mq_usage_counter, 1, 1000000);
-        else if (blk_queue_dying(q))
-                ret = -ENODEV;
-        spin_unlock_irq(q->queue_lock);
+                if (percpu_ref_tryget_live(&q->mq_usage_counter))
+                        return 0;
 
-        return ret;
+                ret = wait_event_interruptible(q->mq_freeze_wq,
+                                !q->mq_freeze_depth || blk_queue_dying(q));
+                if (blk_queue_dying(q))
+                        return -ENODEV;
+                if (ret)
+                        return ret;
+        }
 }
 
 static void blk_mq_queue_exit(struct request_queue *q)
 {
-        __percpu_counter_add(&q->mq_usage_counter, -1, 1000000);
+        percpu_ref_put(&q->mq_usage_counter);
 }
 
-void blk_mq_drain_queue(struct request_queue *q)
+static void blk_mq_usage_counter_release(struct percpu_ref *ref)
 {
-        while (true) {
-                s64 count;
-
-                spin_lock_irq(q->queue_lock);
-                count = percpu_counter_sum(&q->mq_usage_counter);
-                spin_unlock_irq(q->queue_lock);
+        struct request_queue *q =
+                container_of(ref, struct request_queue, mq_usage_counter);
 
-                if (count == 0)
-                        break;
-                blk_mq_start_hw_queues(q);
-                msleep(10);
-        }
+        wake_up_all(&q->mq_freeze_wq);
 }
 
 /*
  * Guarantee no request is in use, so we can change any data structure of
  * the queue afterward.
  */
-static void blk_mq_freeze_queue(struct request_queue *q)
+void blk_mq_freeze_queue(struct request_queue *q)
 {
-        bool drain;
-
         spin_lock_irq(q->queue_lock);
-        drain = !q->bypass_depth++;
-        queue_flag_set(QUEUE_FLAG_BYPASS, q);
+        q->mq_freeze_depth++;
         spin_unlock_irq(q->queue_lock);