md: Fix possible deadlock with multiple mempool allocations.

It is not safe to allocate from a mempool while holding an item
previously allocated from that mempool as that can deadlock when the
mempool is close to exhaustion.

So don't use a bio list to collect the bios to write to multiple
devices in raid1 and raid10.
Instead queue each bio as it becomes available so an unplug will
activate all previously allocated bios and so a new bio has a chance
of being allocated.

This means we must set the 'remaining' count to '1' before submitting
any requests, then when all are submitted, decrement 'remaining' and
possible handle the write completion at that point.

Reported-by: Torsten Kaiser <just.for.lkml@googlemail.com>
Tested-by: Torsten Kaiser <just.for.lkml@googlemail.com>
Signed-off-by: NeilBrown <neilb@suse.de>

1 files changed, 12 insertions, 13 deletions

diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 387fe4b4fab7..8f5543a62416 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -801,7 +801,6 @@ static int make_request(mddev_t *mddev, struct bio * bio)
         const int rw = bio_data_dir(bio);
         const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);
         const unsigned long do_fua = (bio->bi_rw & REQ_FUA);
-        struct bio_list bl;
         unsigned long flags;
         mdk_rdev_t *blocked_rdev;
 
@@ -950,9 +949,9 @@ static int make_request(mddev_t *mddev, struct bio * bio)
                 goto retry_write;
         }
 
-        atomic_set(&r10_bio->remaining, 0);
+        atomic_set(&r10_bio->remaining, 1);
+        bitmap_startwrite(mddev->bitmap, bio->bi_sector, r10_bio->sectors, 0);
 
-        bio_list_init(&bl);
         for (i = 0; i < conf->copies; i++) {
                 struct bio *mbio;
                 int d = r10_bio->devs[i].devnum;
@@ -970,22 +969,22 @@ static int make_request(mddev_t *mddev, struct bio * bio)
                 mbio->bi_private = r10_bio;
 
                 atomic_inc(&r10_bio->remaining);
-                bio_list_add(&bl, mbio);
+                spin_lock_irqsave(&conf->device_lock, flags);
+                bio_list_add(&conf->pending_bio_list, mbio);
+                blk_plug_device(mddev->queue);
+                spin_unlock_irqrestore(&conf->device_lock, flags);
         }
 
-        if (unlikely(!atomic_read(&r10_bio->remaining))) {
-                /* the array is dead */
+        if (atomic_dec_and_test(&r10_bio->remaining)) {
+                /* This matches the end of raid10_end_write_request() */
+                bitmap_endwrite(r10_bio->mddev->bitmap, r10_bio->sector,
+                                r10_bio->sectors,
+                                !test_bit(R10BIO_Degraded, &r10_bio->state),
+                                0);
                 md_write_end(mddev);
                 raid_end_bio_io(r10_bio);
-                return 0;
         }
 
-        bitmap_startwrite(mddev->bitmap, bio->bi_sector, r10_bio->sectors, 0);
-        spin_lock_irqsave(&conf->device_lock, flags);
-        bio_list_merge(&conf->pending_bio_list, &bl);
-        blk_plug_device(mddev->queue);
-        spin_unlock_irqrestore(&conf->device_lock, flags);
-
         /* In case raid10d snuck in to freeze_array */
         wake_up(&conf->wait_barrier);