Merge branch 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jdelv...

[~andy/linux] / drivers / md / dm.c

diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index eaa3af0e0632af0c96c5c17566024265578e2303..0cf68b478878f327598fb756fe2da173d5443468 100644 (file)
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -477,7 +477,8 @@ static void start_io_acct(struct dm_io *io)
        cpu = part_stat_lock();
        part_round_stats(cpu, &dm_disk(md)->part0);
        part_stat_unlock();
-       dm_disk(md)->part0.in_flight[rw] = atomic_inc_return(&md->pending[rw]);
+       atomic_set(&dm_disk(md)->part0.in_flight[rw],
+               atomic_inc_return(&md->pending[rw]));
 }
 
 static void end_io_acct(struct dm_io *io)
@@ -497,8 +498,8 @@ static void end_io_acct(struct dm_io *io)
         * After this is decremented the bio must not be touched if it is
         * a flush.
         */
-       dm_disk(md)->part0.in_flight[rw] = pending =
-               atomic_dec_return(&md->pending[rw]);
+       pending = atomic_dec_return(&md->pending[rw]);
+       atomic_set(&dm_disk(md)->part0.in_flight[rw], pending);
        pending += atomic_read(&md->pending[rw^0x1]);
 
        /* nudge anyone waiting on suspend queue */
@@ -807,8 +808,6 @@ void dm_requeue_unmapped_request(struct request *clone)
        dm_unprep_request(rq);
 
        spin_lock_irqsave(q->queue_lock, flags);
-       if (elv_queue_empty(q))
-               blk_plug_device(q);
        blk_requeue_request(q, rq);
        spin_unlock_irqrestore(q->queue_lock, flags);
 
@@ -1613,10 +1612,10 @@ static void dm_request_fn(struct request_queue *q)
         * number of in-flight I/Os after the queue is stopped in
         * dm_suspend().
         */
-       while (!blk_queue_plugged(q) && !blk_queue_stopped(q)) {
+       while (!blk_queue_stopped(q)) {
                rq = blk_peek_request(q);
                if (!rq)
-                       goto plug_and_out;
+                       goto delay_and_out;
 
                /* always use block 0 to find the target for flushes for now */
                pos = 0;
@@ -1627,7 +1626,7 @@ static void dm_request_fn(struct request_queue *q)
                BUG_ON(!dm_target_is_valid(ti));
 
                if (ti->type->busy && ti->type->busy(ti))
-                       goto plug_and_out;
+                       goto delay_and_out;
 
                blk_start_request(rq);
                clone = rq->special;
@@ -1647,11 +1646,8 @@ requeued:
        BUG_ON(!irqs_disabled());
        spin_lock(q->queue_lock);
 
-plug_and_out:
-       if (!elv_queue_empty(q))
-               /* Some requests still remain, retry later */
-               blk_plug_device(q);
-
+delay_and_out:
+       blk_delay_queue(q, HZ / 10);
 out:
        dm_table_put(map);
 
@@ -1680,20 +1676,6 @@ static int dm_lld_busy(struct request_queue *q)
        return r;
 }
 
-static void dm_unplug_all(struct request_queue *q)
-{
-       struct mapped_device *md = q->queuedata;
-       struct dm_table *map = dm_get_live_table(md);
-
-       if (map) {
-               if (dm_request_based(md))
-                       generic_unplug_device(q);
-
-               dm_table_unplug_all(map);
-               dm_table_put(map);
-       }
-}
-
 static int dm_any_congested(void *congested_data, int bdi_bits)
 {
        int r = bdi_bits;
@@ -1817,7 +1799,6 @@ static void dm_init_md_queue(struct mapped_device *md)
        md->queue->backing_dev_info.congested_data = md;
        blk_queue_make_request(md->queue, dm_request);
        blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
-       md->queue->unplug_fn = dm_unplug_all;
        blk_queue_merge_bvec(md->queue, dm_merge_bvec);
        blk_queue_flush(md->queue, REQ_FLUSH | REQ_FUA);
 }
@@ -2263,8 +2244,6 @@ static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
        int r = 0;
        DECLARE_WAITQUEUE(wait, current);
 
-       dm_unplug_all(md->queue);
-
        add_wait_queue(&md->wait, &wait);
 
        while (1) {
@@ -2539,7 +2518,6 @@ int dm_resume(struct mapped_device *md)
 
        clear_bit(DMF_SUSPENDED, &md->flags);
 
-       dm_table_unplug_all(map);
        r = 0;
 out:
        dm_table_put(map);
@@ -2643,9 +2621,10 @@ int dm_noflush_suspending(struct dm_target *ti)
 }
 EXPORT_SYMBOL_GPL(dm_noflush_suspending);
 
-struct dm_md_mempools *dm_alloc_md_mempools(unsigned type)
+struct dm_md_mempools *dm_alloc_md_mempools(unsigned type, unsigned integrity)
 {
        struct dm_md_mempools *pools = kmalloc(sizeof(*pools), GFP_KERNEL);
+       unsigned int pool_size = (type == DM_TYPE_BIO_BASED) ? 16 : MIN_IOS;
 
        if (!pools)
                return NULL;
@@ -2662,13 +2641,18 @@ struct dm_md_mempools *dm_alloc_md_mempools(unsigned type)
        if (!pools->tio_pool)
                goto free_io_pool_and_out;
 
-       pools->bs = (type == DM_TYPE_BIO_BASED) ?
-                   bioset_create(16, 0) : bioset_create(MIN_IOS, 0);
+       pools->bs = bioset_create(pool_size, 0);
        if (!pools->bs)
                goto free_tio_pool_and_out;
 
+       if (integrity && bioset_integrity_create(pools->bs, pool_size))
+               goto free_bioset_and_out;
+
        return pools;
 
+free_bioset_and_out:
+       bioset_free(pools->bs);
+
 free_tio_pool_and_out:
        mempool_destroy(pools->tio_pool);