From 9bf2130b629cd0332aae1c17c7cc87214ff2e6f0 Mon Sep 17 00:00:00 2001 From: Salvatore Bonaccorso Date: Wed, 21 Aug 2019 21:39:21 +0200 Subject: [PATCH] dm: disable DISCARD if the underlying storage no longer supports it Closes: #934331 --- debian/changelog | 4 + ...rlying-storage-no-longer-supports-it.patch | 120 ++++++++++++++++++ debian/patches/series | 1 + 3 files changed, 125 insertions(+) create mode 100644 debian/patches/bugfix/all/dm-disable-discard-if-the-underlying-storage-no-longer-supports-it.patch diff --git a/debian/changelog b/debian/changelog index f93d88397..f986ce2cd 100644 --- a/debian/changelog +++ b/debian/changelog @@ -2185,6 +2185,10 @@ linux (4.19.67-1) UNRELEASED; urgency=medium - mm/zswap: Do not disable preemption in zswap_frontswap_store() * Bump ABI to 6 + [ Salvatore Bonaccorso ] + * dm: disable DISCARD if the underlying storage no longer supports it + (Closes: #934331) + -- Salvatore Bonaccorso Sun, 23 Jun 2019 16:15:17 +0200 linux (4.19.37-5+deb10u2) buster-security; urgency=high diff --git a/debian/patches/bugfix/all/dm-disable-discard-if-the-underlying-storage-no-longer-supports-it.patch b/debian/patches/bugfix/all/dm-disable-discard-if-the-underlying-storage-no-longer-supports-it.patch new file mode 100644 index 000000000..1e7d14946 --- /dev/null +++ b/debian/patches/bugfix/all/dm-disable-discard-if-the-underlying-storage-no-longer-supports-it.patch @@ -0,0 +1,120 @@ +From: Mike Snitzer +Date: Wed, 3 Apr 2019 12:23:11 -0400 +Subject: dm: disable DISCARD if the underlying storage no longer supports it +Origin: https://git.kernel.org/linus/bcb44433bba5eaff293888ef22ffa07f1f0347d6 +Bug-Debian: https://bugs.debian.org/934331 + +Storage devices which report supporting discard commands like +WRITE_SAME_16 with unmap, but reject discard commands sent to the +storage device. This is a clear storage firmware bug but it doesn't +change the fact that should a program cause discards to be sent to a +multipath device layered on this buggy storage, all paths can end up +failed at the same time from the discards, causing possible I/O loss. + +The first discard to a path will fail with Illegal Request, Invalid +field in cdb, e.g.: + kernel: sd 8:0:8:19: [sdfn] tag#0 FAILED Result: hostbyte=DID_OK driverbyte=DRIVER_SENSE + kernel: sd 8:0:8:19: [sdfn] tag#0 Sense Key : Illegal Request [current] + kernel: sd 8:0:8:19: [sdfn] tag#0 Add. Sense: Invalid field in cdb + kernel: sd 8:0:8:19: [sdfn] tag#0 CDB: Write same(16) 93 08 00 00 00 00 00 a0 08 00 00 00 80 00 00 00 + kernel: blk_update_request: critical target error, dev sdfn, sector 10487808 + +The SCSI layer converts this to the BLK_STS_TARGET error number, the sd +device disables its support for discard on this path, and because of the +BLK_STS_TARGET error multipath fails the discard without failing any +path or retrying down a different path. But subsequent discards can +cause path failures. Any discards sent to the path which already failed +a discard ends up failing with EIO from blk_cloned_rq_check_limits with +an "over max size limit" error since the discard limit was set to 0 by +the sd driver for the path. As the error is EIO, this now fails the +path and multipath tries to send the discard down the next path. This +cycle continues as discards are sent until all paths fail. + +Fix this by training DM core to disable DISCARD if the underlying +storage already did so. + +Also, fix branching in dm_done() and clone_endio() to reflect the +mutually exclussive nature of the IO operations in question. + +Cc: stable@vger.kernel.org +Reported-by: David Jeffery +Signed-off-by: Mike Snitzer +[Salvatore Bonaccorso: backported to 4.19: Adjust for context changes in +drivers/md/dm-core.h] +Signed-off-by: Salvatore Bonaccorso +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/md/dm-core.h | 1 + + drivers/md/dm-rq.c | 11 +++++++---- + drivers/md/dm.c | 20 ++++++++++++++++---- + 3 files changed, 24 insertions(+), 8 deletions(-) + +--- a/drivers/md/dm-core.h ++++ b/drivers/md/dm-core.h +@@ -130,6 +130,7 @@ struct mapped_device { + }; + + int md_in_flight(struct mapped_device *md); ++void disable_discard(struct mapped_device *md); + void disable_write_same(struct mapped_device *md); + void disable_write_zeroes(struct mapped_device *md); + +--- a/drivers/md/dm-rq.c ++++ b/drivers/md/dm-rq.c +@@ -295,11 +295,14 @@ static void dm_done(struct request *clon + } + + if (unlikely(error == BLK_STS_TARGET)) { +- if (req_op(clone) == REQ_OP_WRITE_SAME && +- !clone->q->limits.max_write_same_sectors) ++ if (req_op(clone) == REQ_OP_DISCARD && ++ !clone->q->limits.max_discard_sectors) ++ disable_discard(tio->md); ++ else if (req_op(clone) == REQ_OP_WRITE_SAME && ++ !clone->q->limits.max_write_same_sectors) + disable_write_same(tio->md); +- if (req_op(clone) == REQ_OP_WRITE_ZEROES && +- !clone->q->limits.max_write_zeroes_sectors) ++ else if (req_op(clone) == REQ_OP_WRITE_ZEROES && ++ !clone->q->limits.max_write_zeroes_sectors) + disable_write_zeroes(tio->md); + } + +--- a/drivers/md/dm.c ++++ b/drivers/md/dm.c +@@ -910,6 +910,15 @@ static void dec_pending(struct dm_io *io + } + } + ++void disable_discard(struct mapped_device *md) ++{ ++ struct queue_limits *limits = dm_get_queue_limits(md); ++ ++ /* device doesn't really support DISCARD, disable it */ ++ limits->max_discard_sectors = 0; ++ blk_queue_flag_clear(QUEUE_FLAG_DISCARD, md->queue); ++} ++ + void disable_write_same(struct mapped_device *md) + { + struct queue_limits *limits = dm_get_queue_limits(md); +@@ -935,11 +944,14 @@ static void clone_endio(struct bio *bio) + dm_endio_fn endio = tio->ti->type->end_io; + + if (unlikely(error == BLK_STS_TARGET) && md->type != DM_TYPE_NVME_BIO_BASED) { +- if (bio_op(bio) == REQ_OP_WRITE_SAME && +- !bio->bi_disk->queue->limits.max_write_same_sectors) ++ if (bio_op(bio) == REQ_OP_DISCARD && ++ !bio->bi_disk->queue->limits.max_discard_sectors) ++ disable_discard(md); ++ else if (bio_op(bio) == REQ_OP_WRITE_SAME && ++ !bio->bi_disk->queue->limits.max_write_same_sectors) + disable_write_same(md); +- if (bio_op(bio) == REQ_OP_WRITE_ZEROES && +- !bio->bi_disk->queue->limits.max_write_zeroes_sectors) ++ else if (bio_op(bio) == REQ_OP_WRITE_ZEROES && ++ !bio->bi_disk->queue->limits.max_write_zeroes_sectors) + disable_write_zeroes(md); + } + diff --git a/debian/patches/series b/debian/patches/series index f16fdecea..5496f8b54 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -103,6 +103,7 @@ bugfix/all/kbuild-include-addtree-remove-quotes-before-matching-path.patch debian/revert-objtool-fix-config_stack_validation-y-warning.patch bugfix/all/mt76-use-the-correct-hweight8-function.patch bugfix/all/rtc-s35390a-set-uie_unsupported.patch +bugfix/all/dm-disable-discard-if-the-underlying-storage-no-longer-supports-it.patch # Miscellaneous features