1 files changed, 60 insertions, 8 deletions

diff --git a/drivers/md/dm-zoned-target.c b/drivers/md/dm-zoned-target.c
index 51d029bbb740..31478fef6032 100644
--- a/drivers/md/dm-zoned-target.c
+++ b/drivers/md/dm-zoned-target.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (C) 2017 Western Digital Corporation or its affiliates.
  *
@@ -133,6 +134,8 @@ static int dmz_submit_bio(struct dmz_target *dmz, struct dm_zone *zone,
 
         refcount_inc(&bioctx->ref);
         generic_make_request(clone);
+        if (clone->bi_status == BLK_STS_IOERR)
+                return -EIO;
 
         if (bio_op(bio) == REQ_OP_WRITE && dmz_is_seq(zone))
                 zone->wp_block += nr_blocks;
@@ -277,8 +280,8 @@ static int dmz_handle_buffered_write(struct dmz_target *dmz,
 
         /* Get the buffer zone. One will be allocated if needed */
         bzone = dmz_get_chunk_buffer(zmd, zone);
-        if (!bzone)
-                return -ENOSPC;
+        if (IS_ERR(bzone))
+                return PTR_ERR(bzone);
 
         if (dmz_is_readonly(bzone))
                 return -EROFS;
@@ -389,6 +392,11 @@ static void dmz_handle_bio(struct dmz_target *dmz, struct dm_chunk_work *cw,
 
         dmz_lock_metadata(zmd);
 
+        if (dmz->dev->flags & DMZ_BDEV_DYING) {
+                ret = -EIO;
+                goto out;
+        }
+
         /*
          * Get the data zone mapping the chunk. There may be no
          * mapping for read and discard. If a mapping is obtained,
@@ -493,6 +501,8 @@ static void dmz_flush_work(struct work_struct *work)
 
         /* Flush dirty metadata blocks */
         ret = dmz_flush_metadata(dmz->metadata);
+        if (ret)
+                dmz_dev_debug(dmz->dev, "Metadata flush failed, rc=%d\n", ret);
 
         /* Process queued flush requests */
         while (1) {
@@ -513,22 +523,24 @@ static void dmz_flush_work(struct work_struct *work)
  * Get a chunk work and start it to process a new BIO.
  * If the BIO chunk has no work yet, create one.
  */
-static void dmz_queue_chunk_work(struct dmz_target *dmz, struct bio *bio)
+static int dmz_queue_chunk_work(struct dmz_target *dmz, struct bio *bio)
 {
         unsigned int chunk = dmz_bio_chunk(dmz->dev, bio);
         struct dm_chunk_work *cw;
+        int ret = 0;
 
         mutex_lock(&dmz->chunk_lock);
 
         /* Get the BIO chunk work. If one is not active yet, create one */
         cw = radix_tree_lookup(&dmz->chunk_rxtree, chunk);
         if (!cw) {
-                int ret;
 
                 /* Create a new chunk work */
                 cw = kmalloc(sizeof(struct dm_chunk_work), GFP_NOIO);
-                if (!cw)
+                if (unlikely(!cw)) {
+                        ret = -ENOMEM;
                         goto out;
+                }
 
                 INIT_WORK(&cw->work, dmz_chunk_work);
                 refcount_set(&cw->refcount, 0);
@@ -539,7 +551,6 @@ static void dmz_queue_chunk_work(struct dmz_target *dmz, struct bio *bio)
                 ret = radix_tree_insert(&dmz->chunk_rxtree, chunk, cw);
                 if (unlikely(ret)) {
                         kfree(cw);
-                        cw = NULL;
                         goto out;
                 }
         }
@@ -547,10 +558,38 @@ static void dmz_queue_chunk_work(struct dmz_target *dmz, struct bio *bio)
         bio_list_add(&cw->bio_list, bio);
         dmz_get_chunk_work(cw);
 
+        dmz_reclaim_bio_acc(dmz->reclaim);
         if (queue_work(dmz->chunk_wq, &cw->work))
                 dmz_get_chunk_work(cw);
 out:
         mutex_unlock(&dmz->chunk_lock);
+        return ret;
+}
+
+/*
+ * Check the backing device availability. If it's on the way out,
+ * start failing I/O. Reclaim and metadata components also call this
+ * function to cleanly abort operation in the event of such failure.
+ */
+bool dmz_bdev_is_dying(struct dmz_dev *dmz_dev)
+{
+        struct gendisk *disk;
+
+        if (!(dmz_dev->flags & DMZ_BDEV_DYING)) {
+                disk = dmz_dev->bdev->bd_disk;
+                if (blk_queue_dying(bdev_get_queue(dmz_dev->bdev))) {
+                        dmz_dev_warn(dmz_dev, "Backing device queue dying");
+                        dmz_dev->flags |= DMZ_BDEV_DYING;
+                } else if (disk->fops->check_events) {
+                        if (disk->fops->check_events(disk, 0) &
+                                        DISK_EVENT_MEDIA_CHANGE) {
+                                dmz_dev_warn(dmz_dev, "Backing device offline");
+                                dmz_dev->flags |= DMZ_BDEV_DYING;
+                        }
+                }
+        }
+
+        return dmz_dev->flags & DMZ_BDEV_DYING;
 }
 
 /*
@@ -564,6 +603,10 @@ static int dmz_map(struct dm_target *ti, struct bio *bio)
         sector_t sector = bio->bi_iter.bi_sector;
         unsigned int nr_sectors = bio_sectors(bio);
         sector_t chunk_sector;
+        int ret;
+
+        if (dmz_bdev_is_dying(dmz->dev))
+                return DM_MAPIO_KILL;
 
         dmz_dev_debug(dev, "BIO op %d sector %llu + %u => chunk %llu, block %llu, %u blocks",
                       bio_op(bio), (unsigned long long)sector, nr_sectors,
@@ -601,8 +644,14 @@ static int dmz_map(struct dm_target *ti, struct bio *bio)
                 dm_accept_partial_bio(bio, dev->zone_nr_sectors - chunk_sector);
 
         /* Now ready to handle this BIO */
-        dmz_reclaim_bio_acc(dmz->reclaim);
-        dmz_queue_chunk_work(dmz, bio);
+        ret = dmz_queue_chunk_work(dmz, bio);
+        if (ret) {
+                dmz_dev_debug(dmz->dev,
+                              "BIO op %d, can't process chunk %llu, err %i\n",
+                              bio_op(bio), (u64)dmz_bio_chunk(dmz->dev, bio),
+                              ret);
+                return DM_MAPIO_REQUEUE;
+        }
 
         return DM_MAPIO_SUBMITTED;
 }
@@ -855,6 +904,9 @@ static int dmz_prepare_ioctl(struct dm_target *ti, struct block_device **bdev)
 {
         struct dmz_target *dmz = ti->private;
 
+        if (dmz_bdev_is_dying(dmz->dev))
+                return -ENODEV;
+
         *bdev = dmz->dev->bdev;
 
         return 0;