diff --git a/block/blk-core.c b/block/blk-core.c
index 60dc9552ef8d..ef0c437e8f43 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -131,7 +131,6 @@ static const char *const blk_op_name[] = {
 	REQ_OP_NAME(DISCARD),
 	REQ_OP_NAME(SECURE_ERASE),
 	REQ_OP_NAME(ZONE_RESET),
-	REQ_OP_NAME(ZONE_RESET_ALL),
 	REQ_OP_NAME(ZONE_OPEN),
 	REQ_OP_NAME(ZONE_CLOSE),
 	REQ_OP_NAME(ZONE_FINISH),
@@ -944,10 +943,6 @@ generic_make_request_checks(struct bio *bio)
 		if (!blk_queue_is_zoned(q))
 			goto not_supported;
 		break;
-	case REQ_OP_ZONE_RESET_ALL:
-		if (!blk_queue_is_zoned(q) || !blk_queue_zone_resetall(q))
-			goto not_supported;
-		break;
 	case REQ_OP_WRITE_ZEROES:
 		if (!q->limits.max_write_zeroes_sectors)
 			goto not_supported;
diff --git a/block/blk-zoned.c b/block/blk-zoned.c
index 05741c6f618b..c0b883ed5fdf 100644
--- a/block/blk-zoned.c
+++ b/block/blk-zoned.c
@@ -123,16 +123,16 @@ int blkdev_report_zones(struct block_device *bdev, sector_t sector,
 }
 EXPORT_SYMBOL_GPL(blkdev_report_zones);
 
-static inline bool blkdev_allow_reset_all_zones(struct block_device *bdev,
-						sector_t sector,
-						sector_t nr_sectors)
+static inline bool blkdev_do_all_zones_mgmt(struct block_device *bdev,
+					    sector_t sector,
+					    sector_t nr_sectors)
 {
-	if (!blk_queue_zone_resetall(bdev_get_queue(bdev)))
+	if (!blk_queue_all_zones_mgmt(bdev_get_queue(bdev)))
 		return false;
 
 	/*
-	 * REQ_OP_ZONE_RESET_ALL can be executed only if the number of sectors
-	 * of the applicable zone range is the entire disk.
+	 * Zone management operations can be executed on all zones only if the
+	 * number of sectors of the applicable zone range is the entire disk.
 	 */
 	return !sector && nr_sectors == get_capacity(bdev->bd_disk);
 }
@@ -162,6 +162,7 @@ int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
 	sector_t capacity = get_capacity(bdev->bd_disk);
 	sector_t end_sector = sector + nr_sectors;
 	struct bio *bio = NULL;
+	bool all_zones_mgmt;
 	int ret;
 
 	if (!blk_queue_is_zoned(q))
@@ -184,22 +185,21 @@ int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
 	if ((nr_sectors & (zone_sectors - 1)) && end_sector != capacity)
 		return -EINVAL;
 
-	while (sector < end_sector) {
-		bio = blk_next_bio(bio, 0, gfp_mask);
-		bio_set_dev(bio, bdev);
+	all_zones_mgmt = blkdev_do_all_zones_mgmt(bdev, sector, nr_sectors);
 
+	while (sector < end_sector) {
 		/*
-		 * Special case for the zone reset operation that reset all
-		 * zones, this is useful for applications like mkfs.
+		 * There is no point in retrying failed zone management
+		 * requests so fail them fast.
 		 */
-		if (op == REQ_OP_ZONE_RESET &&
-		    blkdev_allow_reset_all_zones(bdev, sector, nr_sectors)) {
-			bio->bi_opf = REQ_OP_ZONE_RESET_ALL;
+		bio = blk_next_bio(bio, 0, gfp_mask);
+		bio_set_dev(bio, bdev);
+		bio->bi_opf = op | REQ_SYNC | REQ_FAILFAST_DEV;
+		bio->bi_iter.bi_sector = sector;
+		if (all_zones_mgmt) {
+			bio->bi_opf |= REQ_ALL_ZONES;
 			break;
 		}
-
-		bio->bi_opf = op | REQ_SYNC;
-		bio->bi_iter.bi_sector = sector;
 		sector += zone_sectors;
 
 		/* This may take a while, so be nice to others */
diff --git a/drivers/block/null_blk_main.c b/drivers/block/null_blk_main.c
index 133060431dbd..6665f905169a 100644
--- a/drivers/block/null_blk_main.c
+++ b/drivers/block/null_blk_main.c
@@ -1746,7 +1746,7 @@ static int null_add_dev(struct nullb_device *dev)
 			goto out_cleanup_blk_queue;
 
 		nullb->q->limits.zoned = BLK_ZONED_HM;
-		blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, nullb->q);
+		blk_queue_flag_set(QUEUE_FLAG_ALL_ZONES_MGMT, nullb->q);
 		blk_queue_required_elevator_features(nullb->q,
 						ELEVATOR_F_ZBD_SEQ_WRITE);
 	}
diff --git a/drivers/block/null_blk_zoned.c b/drivers/block/null_blk_zoned.c
index ed34785dd64b..43b01d58d366 100644
--- a/drivers/block/null_blk_zoned.c
+++ b/drivers/block/null_blk_zoned.c
@@ -151,59 +151,142 @@ static blk_status_t null_zone_write(struct nullb_cmd *cmd, sector_t sector,
 	return BLK_STS_OK;
 }
 
+static inline void __null_zone_reset(struct blk_zone *zone)
+{
+	zone->cond = BLK_ZONE_COND_EMPTY;
+	zone->wp = zone->start;
+}
+
+static blk_status_t null_zone_reset(struct nullb_device *dev,
+				    struct blk_zone *zone, bool all)
+{
+	if (all) {
+		int i;
+
+		/* Reset all sequential zones */
+		for (i = dev->zone_nr_conv; i < dev->nr_zones; i++)
+			__null_zone_reset(&zone[i]);
+		return BLK_STS_OK;
+	}
+
+	__null_zone_reset(zone);
+
+	return BLK_STS_OK;
+}
+
+static inline void __null_zone_open(struct blk_zone *zone)
+{
+	zone->cond = BLK_ZONE_COND_EXP_OPEN;
+}
+
+static blk_status_t null_zone_open(struct nullb_device *dev,
+				   struct blk_zone *zone, bool all)
+{
+	if (all) {
+		int i;
+
+		/* Explicitly open all non-full zones */
+		for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) {
+			if (zone->cond != BLK_ZONE_COND_FULL)
+				__null_zone_open(&zone[i]);
+		}
+		return BLK_STS_OK;
+	}
+
+	if (zone->cond == BLK_ZONE_COND_FULL)
+		return BLK_STS_IOERR;
+
+	__null_zone_open(zone);
+
+	return BLK_STS_OK;
+}
+
+static inline void __null_zone_close(struct blk_zone *zone)
+{
+	if (zone->wp == zone->start)
+		zone->cond = BLK_ZONE_COND_EMPTY;
+	else
+		zone->cond = BLK_ZONE_COND_CLOSED;
+}
+
+static blk_status_t null_zone_close(struct nullb_device *dev,
+				    struct blk_zone *zone, bool all)
+{
+	if (all) {
+		int i;
+
+		/* Close all non-full zones */
+		for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) {
+			if (zone->cond != BLK_ZONE_COND_FULL)
+				__null_zone_close(&zone[i]);
+		}
+		return BLK_STS_OK;
+	}
+
+	if (zone->cond == BLK_ZONE_COND_FULL)
+		return BLK_STS_IOERR;
+
+	__null_zone_close(zone);
+
+	return BLK_STS_OK;
+}
+
+static inline void __null_zone_finish(struct blk_zone *zone)
+{
+	zone->cond = BLK_ZONE_COND_FULL;
+	zone->wp = zone->start + zone->len;
+}
+
+static blk_status_t null_zone_finish(struct nullb_device *dev,
+				     struct blk_zone *zone, bool all)
+{
+	if (all) {
+		int i;
+
+		/* Finish all open (implicit and explicit) and closed zones */
+		for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) {
+			if (zone->cond != BLK_ZONE_COND_EMPTY)
+				__null_zone_finish(&zone[i]);
+		}
+		return BLK_STS_OK;
+	}
+
+	__null_zone_finish(zone);
+
+	return BLK_STS_OK;
+}
+
 static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_opf op,
 				   sector_t sector)
 {
 	struct nullb_device *dev = cmd->nq->dev;
 	struct blk_zone *zone = &dev->zones[null_zone_no(dev, sector)];
-	size_t i;
+	bool all;
+
+	if (cmd->bio)
+		all = cmd->bio->bi_opf & REQ_ALL_ZONES;
+	else
+		all = cmd->rq->cmd_flags & REQ_ALL_ZONES;
+
+	/*
+	 * Conventional zones are ignored for an all zones management operation
+	 * but they cannot be targeted for a single zone operation.
+	 */
+	if (!all && zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
+		return BLK_STS_IOERR;
 
 	switch (op) {
-	case REQ_OP_ZONE_RESET_ALL:
-		for (i = 0; i < dev->nr_zones; i++) {
-			if (zone[i].type == BLK_ZONE_TYPE_CONVENTIONAL)
-				continue;
-			zone[i].cond = BLK_ZONE_COND_EMPTY;
-			zone[i].wp = zone[i].start;
-		}
-		break;
 	case REQ_OP_ZONE_RESET:
-		if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
-			return BLK_STS_IOERR;
-
-		zone->cond = BLK_ZONE_COND_EMPTY;
-		zone->wp = zone->start;
-		break;
+		return null_zone_reset(dev, zone, all);
 	case REQ_OP_ZONE_OPEN:
-		if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
-			return BLK_STS_IOERR;
-		if (zone->cond == BLK_ZONE_COND_FULL)
-			return BLK_STS_IOERR;
-
-		zone->cond = BLK_ZONE_COND_EXP_OPEN;
-		break;
+		return null_zone_open(dev, zone, all);
 	case REQ_OP_ZONE_CLOSE:
-		if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
-			return BLK_STS_IOERR;
-		if (zone->cond == BLK_ZONE_COND_FULL)
-			return BLK_STS_IOERR;
-
-		if (zone->wp == zone->start)
-			zone->cond = BLK_ZONE_COND_EMPTY;
-		else
-			zone->cond = BLK_ZONE_COND_CLOSED;
-		break;
+		return null_zone_close(dev, zone, all);
 	case REQ_OP_ZONE_FINISH:
-		if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
-			return BLK_STS_IOERR;
-
-		zone->cond = BLK_ZONE_COND_FULL;
-		zone->wp = zone->start + zone->len;
-		break;
+		return null_zone_finish(dev, zone, all);
 	default:
 		return BLK_STS_NOTSUPP;
 	}
-	return BLK_STS_OK;
 }
 
 blk_status_t null_handle_zoned(struct nullb_cmd *cmd, enum req_opf op,
@@ -213,7 +296,6 @@ blk_status_t null_handle_zoned(struct nullb_cmd *cmd, enum req_opf op,
 	case REQ_OP_WRITE:
 		return null_zone_write(cmd, sector, nr_sectors);
 	case REQ_OP_ZONE_RESET:
-	case REQ_OP_ZONE_RESET_ALL:
 	case REQ_OP_ZONE_OPEN:
 	case REQ_OP_ZONE_CLOSE:
 	case REQ_OP_ZONE_FINISH:
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 8ca9299ffd36..9fc4ebd64752 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1289,17 +1289,13 @@ static blk_status_t sd_init_command(struct scsi_cmnd *cmd)
 	case REQ_OP_WRITE:
 		return sd_setup_read_write_cmnd(cmd);
 	case REQ_OP_ZONE_RESET:
-		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER,
-						   false);
-	case REQ_OP_ZONE_RESET_ALL:
-		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER,
-						   true);
+		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER);
 	case REQ_OP_ZONE_OPEN:
-		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_OPEN_ZONE, false);
+		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_OPEN_ZONE);
 	case REQ_OP_ZONE_CLOSE:
-		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_CLOSE_ZONE, false);
+		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_CLOSE_ZONE);
 	case REQ_OP_ZONE_FINISH:
-		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_FINISH_ZONE, false);
+		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_FINISH_ZONE);
 	default:
 		WARN_ON_ONCE(1);
 		return BLK_STS_NOTSUPP;
@@ -1964,7 +1960,6 @@ static int sd_done(struct scsi_cmnd *SCpnt)
 	case REQ_OP_WRITE_ZEROES:
 	case REQ_OP_WRITE_SAME:
 	case REQ_OP_ZONE_RESET:
-	case REQ_OP_ZONE_RESET_ALL:
 	case REQ_OP_ZONE_OPEN:
 	case REQ_OP_ZONE_CLOSE:
 	case REQ_OP_ZONE_FINISH:
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index 50fff0bf8c8e..17bca569f68d 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -210,7 +210,7 @@ static inline int sd_is_zoned(struct scsi_disk *sdkp)
 extern int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buffer);
 extern void sd_zbc_print_zones(struct scsi_disk *sdkp);
 blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd,
-					 unsigned char op, bool all);
+					 unsigned char op);
 extern void sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
 			    struct scsi_sense_hdr *sshdr);
 int sd_zbc_report_zones(struct gendisk *disk, sector_t sector,
@@ -227,8 +227,7 @@ static inline int sd_zbc_read_zones(struct scsi_disk *sdkp,
 static inline void sd_zbc_print_zones(struct scsi_disk *sdkp) {}
 
 static inline blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd,
-						       unsigned char op,
-						       bool all)
+						       unsigned char op)
 {
 	return BLK_STS_TARGET;
 }
diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c
index f45c22b09726..23099d37f78e 100644
--- a/drivers/scsi/sd_zbc.c
+++ b/drivers/scsi/sd_zbc.c
@@ -214,18 +214,18 @@ int sd_zbc_report_zones(struct gendisk *disk, sector_t sector,
  *			can be RESET WRITE POINTER, OPEN, CLOSE or FINISH.
  * @cmd: the command to setup
  * @op: Operation to be performed
- * @all: All zones control
  *
- * Called from sd_init_command() for REQ_OP_ZONE_RESET, REQ_OP_ZONE_RESET_ALL,
- * REQ_OP_ZONE_OPEN, REQ_OP_ZONE_CLOSE or REQ_OP_ZONE_FINISH requests.
+ * Called from sd_init_command() for REQ_OP_ZONE_RESET, REQ_OP_ZONE_OPEN,
+ * REQ_OP_ZONE_CLOSE or REQ_OP_ZONE_FINISH requests.
  */
 blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd,
-					 unsigned char op, bool all)
+					 unsigned char op)
 {
 	struct request *rq = cmd->request;
 	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 	sector_t sector = blk_rq_pos(rq);
 	sector_t block = sectors_to_logical(sdkp->device, sector);
+	bool all = rq->cmd_flags & REQ_ALL_ZONES;
 
 	if (!sd_is_zoned(sdkp))
 		/* Not a zoned device */
@@ -407,7 +407,7 @@ int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
 		goto err;
 
 	/* The drive satisfies the kernel restrictions: set it up */
-	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, sdkp->disk->queue);
+	blk_queue_flag_set(QUEUE_FLAG_ALL_ZONES_MGMT, sdkp->disk->queue);
 	blk_queue_required_elevator_features(sdkp->disk->queue,
 					     ELEVATOR_F_ZBD_SEQ_WRITE);
 	nr_zones = round_up(sdkp->capacity, zone_blocks) >> ilog2(zone_blocks);
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 70254ae11769..48a464724500 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -286,8 +286,6 @@ enum req_opf {
 	REQ_OP_ZONE_RESET	= 6,
 	/* write the same sector many times */
 	REQ_OP_WRITE_SAME	= 7,
-	/* reset all the zone present on the device */
-	REQ_OP_ZONE_RESET_ALL	= 8,
 	/* write the zero filled sector many times */
 	REQ_OP_WRITE_ZEROES	= 9,
 	/* Open a zone */
@@ -338,6 +336,12 @@ enum req_flag_bits {
 
 	__REQ_HIPRI,
 
+	/*
+	 * For REQ_OP_ZONE_[RESET|OPEN|CLOSE|FINISH]: tell the driver that
+	 * the request operation must target all zones.
+	 */
+	__REQ_ALL_ZONES,
+
 	/* for driver use */
 	__REQ_DRV,
 	__REQ_SWAP,		/* swapping request. */
@@ -363,6 +367,7 @@ enum req_flag_bits {
 
 #define REQ_NOUNMAP		(1ULL << __REQ_NOUNMAP)
 #define REQ_HIPRI		(1ULL << __REQ_HIPRI)
+#define REQ_ALL_ZONES		(1ULL << __REQ_ALL_ZONES)
 
 #define REQ_DRV			(1ULL << __REQ_DRV)
 #define REQ_SWAP		(1ULL << __REQ_SWAP)
@@ -425,10 +430,7 @@ static inline bool op_is_discard(unsigned int op)
 }
 
 /*
- * Check if a bio or request operation is a zone management operation, with
- * the exception of REQ_OP_ZONE_RESET_ALL which is treated as a special case
- * due to its different handling in the block layer and device response in
- * case of command failure.
+ * Check if a bio or request operation is a zone management operation.
  */
 static inline bool op_is_zone_mgmt(enum req_opf op)
 {
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index f629d40c645c..3ef3bd6df579 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -610,7 +610,7 @@ struct request_queue {
 #define QUEUE_FLAG_SCSI_PASSTHROUGH 23	/* queue supports SCSI commands */
 #define QUEUE_FLAG_QUIESCED	24	/* queue has been quiesced */
 #define QUEUE_FLAG_PCI_P2PDMA	25	/* device supports PCI p2p requests */
-#define QUEUE_FLAG_ZONE_RESETALL 26	/* supports Zone Reset All */
+#define QUEUE_FLAG_ALL_ZONES_MGMT 26	/* device supports all zones zone mgmt */
 #define QUEUE_FLAG_RQ_ALLOC_TIME 27	/* record rq->alloc_time_ns */
 
 #define QUEUE_FLAG_MQ_DEFAULT	((1 << QUEUE_FLAG_IO_STAT) |		\
@@ -631,8 +631,8 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q);
 #define blk_queue_io_stat(q)	test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
 #define blk_queue_add_random(q)	test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
 #define blk_queue_discard(q)	test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
-#define blk_queue_zone_resetall(q)	\
-	test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags)
+#define blk_queue_all_zones_mgmt(q)	\
+	test_bit(QUEUE_FLAG_ALL_ZONES_MGMT, &(q)->queue_flags)
 #define blk_queue_secure_erase(q) \
 	(test_bit(QUEUE_FLAG_SECERASE, &(q)->queue_flags))
 #define blk_queue_dax(q)	test_bit(QUEUE_FLAG_DAX, &(q)->queue_flags)
