scsi: scsi_debug: fix zoned write validation
v11 cover scsi: scsi_debug: fix zoned write validation
This series fixes scsi_debug with regards to writes to a ZBC drive, and to WRITE ATOMIC (16). Each patch describes the problem that it fixes.
Two configurations are refused rather than emulated, and those two patches come first, as the rest of the series relies on what they
exclude: a zoned device whose lowest aligned LBA is not zero, which no host writing in units of the reported zone write granularity could ever write, and atomic writes on a zoned device, which no drive supports.
Little of this is reachable in a default configuration. Most of it needs physblk_exp, atomic_wr or logical block provisioning to be set, or an initiator that does not provide a data buffer matching the transfer length of the command.
The series is based on 7.4/scsi-staging rather than 7.3/scsi-fixes (as Damien suggested on v1) to avoid a build failure that would have happened if this series was simply merged with linux-next:
error: too many arguments to function 'mk_sense_buffer'
Tested on a zoned scsi_debug device with 512 byte logical blocks and a 4096 byte physical block, and on a device that is not zoned for the WRITE ATOMIC (16) patches. The notes below each patch describe what was observed before and after it.
Changes since v10:
- Patch 3 is new. A negative physblk_exp was accepted, and the driver shifts by it. Sashiko pointed this out.
- Patch 6 caps the offset at the length of the buffer rather than at U32_MAX, which is -1 as an off_t on 32-bit architectures, as Sashiko pointed out.
- Patch 7 only sets the residual when it is non-zero, as Damien suggested. Picked up his Reviewed-by.
- Patch 11 cites SBC-6 4.28.2 in the comment above the new check, as John suggested. Picked up his Reviewed-by.
Niklas Cassel (13):
scsi: scsi_debug: Refuse a zoned device with a non-zero lowest aligned
LBA
scsi: scsi_debug: Make atomic writes and ZBC emulation mutually
exclusive
scsi: scsi_debug: Refuse a negative physblk_exp
scsi: scsi_debug: Take the zone metadata lock before the data lock
scsi: scsi_debug: Evaluate scsi_debug_lbp() only once
scsi: scsi_debug: Avoid 32-bit overflow in WRITE SCATTERED offsets
scsi: scsi_debug: Report the residual of a write
scsi: scsi_debug: Enforce physical block alignment of zoned writes
scsi: scsi_debug: Do not write a partial physical block to a zoned
device
scsi: scsi_debug: Advance the write pointer over the data written
scsi: scsi_debug: Refuse a short WRITE ATOMIC (16) before writing it
scsi: scsi_debug: Map the region written by WRITE ATOMIC (16)
scsi: scsi_debug: Validate the access parameters of WRITE ATOMIC (16)
drivers/scsi/scsi_debug.c | 143 ++++++++++++++++++++++++++++++-------- 1 file changed, 115 insertions(+), 28 deletions(-)
base-commit: f09d2c7485b32adb82336d0d748935c8237a649e
Signature · 1 line
2.55.0
PATCH v11 1/13 scsi: scsi_debug: Refuse a zoned device with a non-zero lowest aligned LBA
scsi_debug reports the lowest_aligned module parameter in the LOWEST ALIGNED LOGICAL BLOCK ADDRESS field, see SBC-6 r02 (T10/BSR INCITS 587), 5.20.2, but nothing else in the driver acts on it.
On a zoned device a non-zero value puts the start of every zone in the middle of a physical block. ZBC requires a write to a sequential write required zone to end on a physical block boundary, so a host writing in units of the reported zone write granularity could never write such a zone at all.
Refuse the combination rather than emulate a device that cannot be used.
---
Tested by loading the module with each combination:
zbc=managed lowest_aligned=8 refused, -EINVAL zbc=aware lowest_aligned=8 refused, -EINVAL zbc=managed lowest_aligned=0 loads lowest_aligned=8 loads, as the device is not zoned --- drivers/scsi/scsi_debug.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/scsi/scsi_debug.c +5 -0
@@ -8734,6 +8734,11 @@ static int __init scsi_debug_init(void) sdebug_dev_size_mb =DEF_ZBC_DEV_SIZE_MB ; } +if (sdeb_zbc_in_use && sdebug_lowest_aligned) { +pr_err ("lowest_aligned is not supported by a zoned device\n" ); +return -EINVAL ; + } +if (sdebug_dev_size_mb ==DEF_DEV_SIZE_PRE_INIT ) sdebug_dev_size_mb =DEF_DEV_SIZE_MB ;if (sdebug_dev_size_mb <1 )
Signature · 1 line
2.55.0
PATCH v11 2/13 scsi: scsi_debug: Make atomic writes and ZBC emulation mutually exclusive
In reply to Niklas CasselThere are no SMR drives that support atomic writes, so emulating a device with both emulates something a user cannot encounter, and means maintaining the zone handling of a command that no zoned device implements.
Nothing in the standards forbids the combination, and for a host managed drive whose logical block size equals its physical block size there is no problem in it either: the vendor only has to give atomic writes an alignment that makes sense with regards to ZBC. This is a choice not to complicate scsi_debug.
Refuse the combination at initialisation. It can be changed back if such drives ever appear.
---
Tested by loading the module with each combination:
zbc=managed atomic_wr=1 refused, -EINVAL zbc=aware atomic_wr=1 refused, -EINVAL zbc=managed loads atomic_wr=1 loads --- drivers/scsi/scsi_debug.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/scsi/scsi_debug.c +5 -0
@@ -8739,6 +8739,11 @@ static int __init scsi_debug_init(void)return -EINVAL ; } +if (sdeb_zbc_in_use && sdebug_atomic_wr) { +pr_err ("atomic_wr is not supported by a zoned device\n" ); +return -EINVAL ; + } +if (sdebug_dev_size_mb ==DEF_DEV_SIZE_PRE_INIT ) sdebug_dev_size_mb =DEF_DEV_SIZE_MB ;if (sdebug_dev_size_mb <1 )
Signature · 1 line
2.55.0
PATCH v11 3/13 scsi: scsi_debug: Refuse a negative physblk_exp
In reply to Niklas Casselsdebug_init() refuses a physblk_exp above 15, but the parameter is a signed int, so a negative value is accepted. The driver then shifts by it when it builds the Block Limits VPD page, which is undefined behaviour, and READ CAPACITY (16) reports an exponent of 15 for -1.
Refuse a negative value as well, and print it as a signed value.
---
Tested by loading the module with physblk_exp=-1. Before this patch it loads, and READ CAPACITY (16) reports a logical blocks per physical block exponent of 15. After it the module is refused with -EINVAL and "invalid physblk_exp -1".
--- drivers/scsi/scsi_debug.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/scsi/scsi_debug.c +2 -2
@@ -8656,8 +8656,8 @@ static int __init scsi_debug_init(void)return -EINVAL ; } -if (sdebug_physblk_exp >15 ) { -pr_err ("invalid physblk_exp %u\n" , sdebug_physblk_exp); +if (sdebug_physblk_exp <0 || sdebug_physblk_exp >15 ) { +pr_err ("invalid physblk_exp %d\n" , sdebug_physblk_exp);return -EINVAL ; }
Signature · 1 line
2.55.0
PATCH v11 4/13 scsi: scsi_debug: Take the zone metadata lock before the data lock
In reply to Niklas Casselresp_comp_write() takes the data lock and then the zone metadata lock, while every other command that takes both takes the metadata lock first and reaches the data lock through do_device_access(). A COMPARE AND WRITE and any other write to the same store can therefore deadlock each other.
Take the locks in the same order as everywhere else.
Correct the comment above map_region() while here: the provisioning map is covered by the metadata lock rather than the data lock, which is why resp_unmap() takes only the metadata lock.
---
Tested with:
modprobe scsi_debug sector_size=512 dev_size_mb=128 lbpu=1 lbpws=1
COMPARE AND WRITE completes, and a READ(16) of the block that it wrote returns, so the reordered locks are still taken and released correctly.
The deadlock itself was not reproduced. This kernel is built without lockdep, and the window needs a COMPARE AND WRITE and another write to the same store to interleave between the two acquisitions. Found by review.
--- drivers/scsi/scsi_debug.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/scsi/scsi_debug.c +3 -3
@@ -5575,8 +5575,8 @@ static int resp_comp_write(struct scsi_cmnd *scp,"indicated=%u, IO sent=%d bytes\n" , my_name, dnum * lb_size, ret); -sdeb_data_write_lock (sip);sdeb_meta_write_lock (sip); +sdeb_data_write_lock (sip);if (!comp_write_worker (sip, lba, num, arr, false)) {mk_sense_buffer (scp,MISCOMPARE ,MISCOMPARE_DURING_VERIFY_OPERATION );
@@ -5584,12 +5584,12 @@ static int resp_comp_write(struct scsi_cmnd *scp, goto cleanup_unlock; } -/* Cover sip->map_storep (which map_region()) sets with data lock */ +/* Cover sip->map_storep (which map_region() sets) with the meta lock */ if (scsi_debug_lbp ())map_region (sip, lba, num); cleanup_unlock: -sdeb_meta_write_unlock (sip);sdeb_data_write_unlock (sip); +sdeb_meta_write_unlock (sip); cleanup_free:kfree (arr);return retval;
Signature · 1 line
2.55.0
PATCH v11 5/13 scsi: scsi_debug: Evaluate scsi_debug_lbp() only once
In reply to Niklas Casselcorrupt_lbas(), resp_write_dt0() and resp_write_same() call scsi_debug_lbp() to decide whether to take the zone metadata lock, and call it again to decide whether to touch the provisioning map that the lock protects.
The result is not constant: scsi_debug_lbp() is false while fake_rw is set, and fake_rw is writable at runtime, both as a module parameter and through its driver attribute. The second call can therefore touch the map after the first decided not to take the lock.
Call it once and use the result throughout.
---
Tested with:
modprobe scsi_debug sector_size=512 dev_size_mb=128 lbpu=1 lbpws=1
A WRITE(16) completes and GET LBA STATUS then reports the region as mapped, which covers resp_write_dt0(). A WRITE SAME and a WRITE SAME with the UNMAP bit set complete, and GET LBA STATUS reports the first region as mapped and the second as deallocated, which covers all three uses of the result in resp_write_same().
corrupt_lbas() is not covered. It is reached by writing to the corrupt file in debugfs, and that interface rejected the requests that were tried, for a reason that has nothing to do with this patch.
The window that the change closes was not reproduced. It needs fake_rw to be written between two calls, and was found by review.
--- drivers/scsi/scsi_debug.c | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-)
drivers/scsi/scsi_debug.c +10 -11
@@ -4953,12 +4953,11 @@ static int corrupt_lbas(struct sdebug_dev_info *devip, u64 lba, u32 num, {struct sdeb_store_info *sip =devip2sip (devip, false);bool meta_data_locked = false; +bool lbp =scsi_debug_lbp ();u32 block, num_mapped, b, i;int error =0 ; -if (sdebug_dev_is_zoned (devip) || - sdebug_dix || -scsi_debug_lbp ()) { +if (sdebug_dev_is_zoned (devip) || sdebug_dix || lbp) {sdeb_meta_write_lock (sip); meta_data_locked = true; }
@@ -4975,8 +4974,7 @@ static int corrupt_lbas(struct sdebug_dev_info *devip, u64 lba, u32 num, goto out_unlock; } -if (scsi_debug_lbp () && - (!map_state (sip, lba, &num_mapped) || num > num_mapped)) { +if (lbp && (!map_state (sip, lba, &num_mapped) || num > num_mapped)) {pr_err ("can't modify unmapped logical blocks: %llu:%u" , lba, num); error = -EINVAL ;
@@ -5035,6 +5033,7 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)struct sdeb_store_info *sip =devip2sip (devip, true);u8 *cmd = scp->cmnd;bool meta_data_locked = false; +bool lbp =scsi_debug_lbp ();if (unlikely (sdebug_opts &SDEBUG_OPT_UNALIGNED_WRITE &&atomic_read (&sdeb_inject_pending))) {
@@ -5101,8 +5100,7 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) }if (sdebug_dev_is_zoned (devip) || - (sdebug_dix &&scsi_prot_sg_count (scp)) || -scsi_debug_lbp ()) { + (sdebug_dix &&scsi_prot_sg_count (scp)) || lbp) {sdeb_meta_write_lock (sip); meta_data_locked = true; }
@@ -5147,7 +5145,7 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) } ret =do_device_access (sip, scp,0 , lba, num, group, true, false); -if (unlikely (scsi_debug_lbp ())) +if (unlikely (lbp))map_region (sip, lba, num);/* If ZBC zone then bump its write pointer */
@@ -5374,8 +5372,9 @@ static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,u8 *fs1p;u8 *fsp;bool meta_data_locked = false; +bool lbp =scsi_debug_lbp (); -if (sdebug_dev_is_zoned (devip) ||scsi_debug_lbp ()) { +if (sdebug_dev_is_zoned (devip) || lbp) {sdeb_meta_write_lock (sip); meta_data_locked = true; }
@@ -5384,7 +5383,7 @@ static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,if (ret) goto out; -if (unmap &&scsi_debug_lbp ()) { +if (unmap && lbp) {unmap_region (sip, lba, num); goto out; }
@@ -5414,7 +5413,7 @@ static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num, block =do_div (lbaa, sdebug_store_sectors);memmove (fsp + (block * lb_size), fs1p, lb_size); } -if (scsi_debug_lbp ()) +if (lbp)map_region (sip, lba, num);/* If ZBC zone then bump its write pointer */ if (sdebug_dev_is_zoned (devip))
Signature · 1 line
2.55.0
PATCH v11 6/13 scsi: scsi_debug: Avoid 32-bit overflow in WRITE SCATTERED offsets
In reply to Niklas Casselresp_write_scat() computes the length of an LBA range in bytes as a 32-bit product, num_by = num * lb_size, and adds it to sg_off, the 32-bit offset of the next range in the data-out buffer. The product wraps for a range of 4 GiB or more, which check_device_access_params() allows once the store is that large, and sg_off wraps once the ranges add up to 4 GiB, which neither their number nor their overlap prevents. The ranges that follow are then written from the wrong offset in the buffer.
Make num_by and sg_off 64-bit, and pass do_device_access() sg_off capped at the length of the buffer. An offset at the end of the buffer copies nothing, and sg_copy_buffer(), which takes it as an off_t, is never given one larger than the buffer that it copies.
---
Tested with:
modprobe scsi_debug sector_size=512 dev_size_mb=128
issuing a WRITE SCATTERED (16) through SG_IO with 33 LBA range
descriptors: 32 of 262144 blocks at LBA 0, which add up to 4 GiB, and one of 8 blocks at LBA 200000. The 9728 byte buffer holds the parameter list and 16 blocks, so the first range consumes all of it. Before this patch the offset wrapped, and the last range was written with the data of the first; after it the last range is left as it was.
Changes since v10: sg_off is capped at the length of the buffer rather than at U32_MAX, which becomes -1 as an off_t on 32-bit architectures, and the commit message no longer claims that the store has to be 4 GiB.
--- drivers/scsi/scsi_debug.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
drivers/scsi/scsi_debug.c +8 -5
@@ -5197,7 +5197,8 @@ static int resp_write_scat(struct scsi_cmnd *scp,struct sdeb_store_info *sip =devip2sip (devip, true);u8 wrprotect;u16 lbdof, num_lrd, k; -u32 num, num_by, bt_len, lbdof_blen, sg_off, cum_lb; +u32 num, bt_len, lbdof_blen, cum_lb; +u64 num_by, sg_off;u32 lb_size = sdebug_sector_size;u32 ei_lba;u64 lba;
@@ -5273,14 +5274,14 @@ static int resp_write_scat(struct scsi_cmnd *scp, num =get_unaligned_be32 (up +8 );if (sdebug_verbose)sdev_printk (KERN_INFO , scp->device, -"%s: k=%d LBA=0x%llx num=%u sg_off=%u\n" , +"%s: k=%d LBA=0x%llx num=%u sg_off=%llu\n" , my_name, k, lba, num, sg_off);if (num ==0 )continue ; ret =check_device_access_params (scp, lba, num, true);if (ret) goto err_out_unlock; - num_by = num * lb_size; + num_by = (u64 )num * lb_size; ei_lba = is_16 ?0 :get_unaligned_be32 (up +12 );if ((cum_lb + num) > bt_len) {
@@ -5311,7 +5312,9 @@ static int resp_write_scat(struct scsi_cmnd *scp,* Write ranges atomically to keep as close to pre-atomic * writes behaviour as possible. */ - ret =do_device_access (sip, scp, sg_off, lba, num, group, true, true); + ret =do_device_access (sip, scp, +min_t (u64, sg_off,scsi_bufflen (scp)), + lba, num, group, true, true);/* If ZBC zone then bump its write pointer */ if (sdebug_dev_is_zoned (devip))zbc_inc_wp (devip, lba, num);
@@ -5322,7 +5325,7 @@ static int resp_write_scat(struct scsi_cmnd *scp, goto err_out_unlock; }else if (unlikely (sdebug_verbose && (ret < num_by)))sdev_printk (KERN_INFO , scp->device, -"%s: write: cdb indicated=%u, IO sent=%d bytes\n" , +"%s: write: cdb indicated=%llu, IO sent=%d bytes\n" , my_name, num_by, ret); if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
Signature · 1 line
2.55.0
PATCH v11 7/13 scsi: scsi_debug: Report the residual of a write
In reply to Niklas CasselDocumentation/scsi/scsi_mid_low_api.rst defines the residual as the length of the data buffer less the number of bytes actually transferred, so a write whose data buffer is larger than its transfer length leaves one. resp_read_dt0() and resp_write_tape() report it, but the write paths for a disk do not, so such a write completes with GOOD status and a residual of zero while a READ of the same length into the same buffer reports it correctly.
Report it in resp_write_dt0(), resp_write_scat() and resp_atomic_write().
resp_write_scat() differs twice over. Its data-out buffer also holds the parameter list header and the LBA range descriptors, so what the command consumed is sg_off rather than the bytes that the last range transferred; and sg_off counts what was asked for rather than what was transferred, so it can exceed the buffer and needs a guard. A command with no LBA range descriptors or a buffer transfer length of zero transfers nothing, so the whole buffer is residual. An error, real or injected, can end the command after some ranges have been written, so the residual is reported on every exit once the parameter list has been fetched.
---
Tested with:
modprobe scsi_debug zbc=managed sector_size=512 physblk_exp=3 \
zone_size_mb=8 dev_size_mb=128 zone_nr_conv=2An eight logical block WRITE(16) with a 5000 byte buffer reports resid=904, having transferred 4096. A READ(16) of the same length into the same buffer reported that before this patch and the WRITE reported
0. A buffer of exactly 4096 bytes reports 0, as does a 512 byte buffer, which is consumed in its entirety. WRITE ATOMIC (16) behaves like the WRITE, on a device that is not zoned.
WRITE SCATTERED (16) with one LBA range descriptor of eight blocks and a 5632 byte buffer reports resid=1024, having consumed 512 bytes of parameter list and 4096 bytes of data. The same command with a 1024 byte buffer completes and reports resid=0: sg_off reaches 4608, past the end of the buffer, and without the guard the residual would have been reported as 4294963712.
Changes since v10: the residual is only set when it is non-zero in resp_write_dt0() and resp_atomic_write(), as Damien suggested.
--- drivers/scsi/scsi_debug.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)
drivers/scsi/scsi_debug.c +18 -1
@@ -5162,6 +5162,9 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)"%s: write: cdb indicated=%u, IO sent=%d bytes\n" , my_name, num * sdebug_sector_size, ret); +if (ret <scsi_bufflen (scp)) +scsi_set_resid (scp,scsi_bufflen (scp) - ret); +if (unlikely ((sdebug_opts &SDEBUG_OPT_RECOV_DIF_DIX ) &&atomic_read (&sdeb_inject_pending))) {if (sdebug_opts &SDEBUG_OPT_RECOVERED_ERR ) {
@@ -5234,8 +5237,10 @@ static int resp_write_scat(struct scsi_cmnd *scp, "Unprotected WR to DIF device\n"); } } -if ((num_lrd ==0 ) || (bt_len ==0 )) +if (num_lrd ==0 || bt_len ==0 ) { +scsi_set_resid (scp,scsi_bufflen (scp));return 0 ;/* T10 says these do-nothings are not errors */ + }if (lbdof ==0 ) {if (sdebug_verbose) sdev_printk(KERN_INFO, scp->device,
@@ -5330,6 +5335,8 @@ static int resp_write_scat(struct scsi_cmnd *scp,if (unlikely ((sdebug_opts &SDEBUG_OPT_RECOV_DIF_DIX ) &&atomic_read (&sdeb_inject_pending))) { +/* This range has been written */ + sg_off += num_by;if (sdebug_opts &SDEBUG_OPT_RECOVERED_ERR ) {mk_sense_buffer (scp,RECOVERED_ERROR ,FAILURE_PREDICTION_THRESHOLD_EXCEEDED );
@@ -5355,6 +5362,13 @@ static int resp_write_scat(struct scsi_cmnd *scp, } ret =0 ; err_out_unlock: +/* +* sg_off counts what the command asked for, which can exceed the +* buffer: lbdof is not validated against it, and a range is counted +* in full even if do_device_access() copied less. +*/ +if (scsi_bufflen (scp) > sg_off) +scsi_set_resid (scp,scsi_bufflen (scp) - sg_off);sdeb_meta_write_unlock (sip); err_out:kfree (lrdp);
@@ -6209,6 +6223,9 @@ static int resp_atomic_write(struct scsi_cmnd *scp,return DID_ERROR <<16 ;if (unlikely (ret != len * sdebug_sector_size))return DID_ERROR <<16 ; + +if (ret <scsi_bufflen (scp)) +scsi_set_resid (scp,scsi_bufflen (scp) - ret);return 0 ; }
Signature · 1 line
2.55.0
PATCH v11 8/13 scsi: scsi_debug: Enforce physical block alignment of zoned writes
In reply to Niklas CasselZBC-3 r06 (T10/BSR INCITS 579), 4.5.3.3.2, requires a write to a sequential write required zone to be terminated with ILLEGAL REQUEST / UNALIGNED WRITE COMMAND both when it does not start at the write pointer and when it does not end on a physical block boundary. That is why sd_zbc_read_zones() sets the zone_write_granularity queue limit to the physical block size of a host-managed device.
check_zbc_access_params() implements the first condition but not the second. So with zbc=managed sector_size=512 physblk_exp=3, a write of a single logical block at the write pointer is accepted and advances the write pointer by one logical block, leaving it off the granularity that was advertised: nothing can write at it any more, and the zone can only be used again after being reset.
Check the ending LBA as well, with the same sense data, as the standard gives both conditions the same. An entire medium write same command, which the standard excludes, needs no special case: the preceding check already terminates it with WRITE BOUNDARY VIOLATION. Sequential write preferred zones are left alone, as writes to them need not be sequential, and with the default physblk_exp=0 the check is a no-op.
---
Tested with:
modprobe scsi_debug zbc=managed sector_size=512 physblk_exp=3 \
zone_size_mb=8 dev_size_mb=128 zone_nr_conv=2Before this patch, a one logical block WRITE(16) at the write pointer of an empty sequential write required zone completes with GOOD status and leaves the write pointer at LBA 0x18001, which is not a multiple of the 4096 byte zone_write_granularity reported for the device. After it, the same command is terminated with ILLEGAL REQUEST / UNALIGNED WRITE COMMAND and the zone is left EMPTY, while an aligned eight block write is still accepted.
--- drivers/scsi/scsi_debug.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
drivers/scsi/scsi_debug.c +10 -0
@@ -3980,6 +3980,16 @@ static int check_zbc_access_params(struct scsi_cmnd *scp, UNALIGNED_WRITE_COMMAND);return check_condition_result; } +/* +* Writes must end on a physical block boundary, that is, the +* transfer length must be a multiple of the physical block +* size. +*/ +if (!IS_ALIGNED (lba + num,1U << sdebug_physblk_exp)) { +mk_sense_buffer (scp,ILLEGAL_REQUEST , +UNALIGNED_WRITE_COMMAND ); +return check_condition_result; + } }/* Handle implicit open of closed and empty zones */
Signature · 1 line
2.55.0
PATCH v11 9/13 scsi: scsi_debug: Do not write a partial physical block to a zoned device
In reply to Niklas Casseldo_device_access() copies one logical block at a time and stops at the first short copy, so a data-out buffer smaller than the transfer length of the command can leave part of a physical block written. An initiator can arrange that with SG_IO.
That is acceptable everywhere but a sequential write required zone, where ZBC-3 r06 (T10/BSR INCITS 579), 4.5.3.3.2, requires a write to end on a physical block boundary.
For such a zone, stop at the last whole physical block that the buffer holds. The bytes left over are not written, and are reported to the initiator as part of the residual.
---
Tested with:
modprobe scsi_debug zbc=managed sector_size=512 physblk_exp=3 \
zone_size_mb=8 dev_size_mb=128 zone_nr_conv=2issuing a sixteen logical block WRITE(16) through SG_IO with a buffer of twelve blocks. To a sequential write required zone it now transfers eight blocks, one whole physical block, and reports the remaining 2048 bytes as the residual; before this patch it transferred twelve. To a conventional zone it still transfers all twelve and reports no residual.
With physblk_exp=0 an eight block write with a buffer of one block still transfers one block, wherever it is addressed.
--- drivers/scsi/scsi_debug.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
drivers/scsi/scsi_debug.c +21 -0
@@ -4273,6 +4273,8 @@ static int do_device_access(struct sdeb_store_info *sip, struct scsi_cmnd *scp,u64 block;enum dma_data_direction dir;struct scsi_data_buffer *sdb = &scp->sdb; +struct scsi_device *sdp = scp->device; +struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;u8 *fsp;int i, total =0 ;
@@ -4300,6 +4302,25 @@ static int do_device_access(struct sdeb_store_info *sip, struct scsi_cmnd *scp, fsp = sip->storep; +/* +* A write to a sequential write required zone has to end on a physical +* block boundary, so if the data-out buffer does not hold all of the +* data that the command asks for, write up to the last whole physical +* block that it does hold. What is left over is reported as part of +* the residual. +*/ +if (do_write &&sdebug_dev_is_zoned (devip)) { +struct sdeb_zone_state *zsp =zbc_zone (devip, lba); + +if (zsp->z_type ==ZBC_ZTYPE_SWR ) { +u32 avail = (sdb->length - sg_skip) + >>ilog2 (sdebug_sector_size); + +if (avail < num) + num =round_down (avail,1U << sdebug_physblk_exp); + } + } + block =do_div (lba, sdebug_store_sectors);/* Only allow 1x atomic write or multiple non-atomic writes at any given time */
Signature · 1 line
2.55.0
PATCH v11 10/13 scsi: scsi_debug: Advance the write pointer over the data written
In reply to Niklas Casselresp_write_dt0() and resp_write_scat() advance the write pointer of a sequential write required zone by the transfer length of the command without looking at what do_device_access() returned, which is -1 when the data direction of the command does not match the operation, and a short byte count when the data-out buffer is smaller than the transfer length. An initiator can produce both with SG_IO.
The zone then describes more data than is on the medium, and a write at the position where the data really ends is terminated with UNALIGNED WRITE COMMAND, so the zone has to be reset before it can be written to again.
Advance the write pointer over the data that was written instead. As do_device_access() does not write a partial physical block to such a zone, that leaves the write pointer where a write can end.
---
Tested with:
modprobe scsi_debug zbc=managed sector_size=512 physblk_exp=3 \
zone_size_mb=8 dev_size_mb=128 zone_nr_conv=2issuing WRITE(16) through SG_IO with a data-out buffer shorter than the transfer length of the command. A sixteen block write with a buffer of twelve blocks leaves the write pointer of an empty sequential write required zone eight blocks on, which is where the data it wrote ends, and a following eight block write continues from there. An eight block write with a buffer of one block writes nothing and leaves the write pointer where it was.
Before this patch both advanced the write pointer by the full transfer length, and a write at the end of the data that had actually been written was then terminated with UNALIGNED WRITE COMMAND.
--- drivers/scsi/scsi_debug.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-)
drivers/scsi/scsi_debug.c +7 -6
@@ -5179,9 +5179,9 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)if (unlikely (lbp))map_region (sip, lba, num); -/* If ZBC zone then bump its write pointer */ -if (sdebug_dev_is_zoned (devip)) -zbc_inc_wp (devip, lba, num); +/* If ZBC zone then bump its write pointer over the data written */ +if (sdebug_dev_is_zoned (devip) && ret >0 ) +zbc_inc_wp (devip, lba, ret >>ilog2 (sdebug_sector_size));if (meta_data_locked)sdeb_meta_write_unlock (sip);
@@ -5351,9 +5351,10 @@ static int resp_write_scat(struct scsi_cmnd *scp, ret =do_device_access (sip, scp,min_t (u64, sg_off,scsi_bufflen (scp)), lba, num, group, true, true); -/* If ZBC zone then bump its write pointer */ -if (sdebug_dev_is_zoned (devip)) -zbc_inc_wp (devip, lba, num); +/* If ZBC zone then bump its write pointer over the data written */ +if (sdebug_dev_is_zoned (devip) && ret >0 ) +zbc_inc_wp (devip, lba, + ret >>ilog2 (sdebug_sector_size));if (unlikely (scsi_debug_lbp ()))map_region (sip, lba, num);if (unlikely (-1 == ret)) {
Signature · 1 line
2.55.0
PATCH v11 11/13 scsi: scsi_debug: Refuse a short WRITE ATOMIC (16) before writing it
In reply to Niklas CasselA write whose data-out buffer is shorter than its transfer length is short. An ordinary write transfers what the buffer holds and reports the rest as a residual, but an atomic write cannot be short: SBC-6 r02 (T10/BSR INCITS 587), 4.28.1, requires each atomic write operation to write either all of its data or none of it, and 4.28.2 requires one that cannot complete to leave the LBAs that it specifies unaltered.
resp_atomic_write() does fail a short WRITE ATOMIC (16) with DID_ERROR, but only after do_device_access() has returned, and do_device_access() copies one logical block at a time, so by then the blocks that the buffer did hold have been written. An eight block WRITE ATOMIC (16) with a buffer of four fails having overwritten the first four.
Check the length of the buffer before writing anything, and fail the command with the same DID_ERROR as before.
---
Tested with:
modprobe scsi_debug sector_size=512 physblk_exp=3 dev_size_mb=128 \
atomic_wr=1 lbpu=1issuing a WRITE ATOMIC (16) of eight blocks through SG_IO with a buffer of four blocks of 0xaa. It fails with DID_ERROR before and after this patch, but before it the first four blocks read back as 0xaa afterwards, and after it all eight read back as they were. A WRITE ATOMIC (16) with a full buffer writes all eight blocks, as before.
Changes since v10: the comment above the check also cites SBC-6 4.28.2, as John suggested.
--- drivers/scsi/scsi_debug.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/scsi/scsi_debug.c +8 -0
@@ -6250,6 +6250,14 @@ static int resp_atomic_write(struct scsi_cmnd *scp, } } +/* +* Short atomic writes are not allowed: SBC-6 4.28.2 requires an +* atomic write that cannot complete to leave its LBAs unaltered, and +* do_device_access() would already have written part of it. +*/ +if (scsi_bufflen (scp) < len * sdebug_sector_size) +return DID_ERROR <<16 ; + ret =do_device_access (sip, scp,0 , lba, len,0 , true, true);if (unlikely (ret ==-1 ))return DID_ERROR <<16 ;
Signature · 1 line
2.55.0
PATCH v11 12/13 scsi: scsi_debug: Map the region written by WRITE ATOMIC (16)
In reply to Niklas CasselWhen logical block provisioning is enabled, every command that writes user data calls map_region() so that GET LBA STATUS reports the region as mapped. resp_atomic_write() does not, so GET LBA STATUS keeps reporting a region as deallocated after a WRITE ATOMIC (16) has written it.
Call map_region() the way resp_write_dt0() does, holding the zone metadata write lock across the access. That lock is what serialises the map against resp_unmap(), which does nothing unless logical block provisioning is enabled.
---
Tested with:
modprobe scsi_debug sector_size=512 physblk_exp=3 dev_size_mb=128 \
atomic_wr=1 lbpu=1GET LBA STATUS reports a region that has never been written as deallocated, and reports it as mapped after a WRITE ATOMIC (16) of eight blocks. Only an ordinary WRITE did so before this patch.
--- drivers/scsi/scsi_debug.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
drivers/scsi/scsi_debug.c +14 -0
@@ -4876,6 +4876,11 @@ static unsigned int map_state(struct sdeb_store_info *sip, sector_t lba,return mapped; } +/* +* Callers may map the whole range of a write without checking how much of +* it was written. SBC-6 4.7.4.6.2 allows a deallocated LBA to become mapped +* at any time, and only requires an LBA that was written to be mapped. +*/ static void map_region (struct sdeb_store_info *sip,sector_t lba,unsigned int len) {
@@ -6206,6 +6211,7 @@ static int resp_atomic_write(struct scsi_cmnd *scp,u8 *cmd = scp->cmnd;u16 boundary, len;u64 lba, lba_tmp; +bool lbp =scsi_debug_lbp ();int ret;if (!scsi_debug_atomic_write ()) {
@@ -6258,7 +6264,15 @@ static int resp_atomic_write(struct scsi_cmnd *scp,if (scsi_bufflen (scp) < len * sdebug_sector_size)return DID_ERROR <<16 ; +if (lbp) +sdeb_meta_write_lock (sip); + ret =do_device_access (sip, scp,0 , lba, len,0 , true, true); +if (lbp) { +map_region (sip, lba, len); +sdeb_meta_write_unlock (sip); + } +if (unlikely (ret ==-1 ))return DID_ERROR <<16 ;if (unlikely (ret != len * sdebug_sector_size))
Signature · 1 line
2.55.0
PATCH v11 13/13 scsi: scsi_debug: Validate the access parameters of WRITE ATOMIC (16)
In reply to Niklas Casselresp_atomic_write() validates the fields that are specific to an atomic write, but never the range that the command addresses. Every other command that writes user data calls check_device_access_params() first, which rejects a transfer that ends beyond the capacity of the device, one whose length exceeds the size of the store, and any write to a write protected device.
Call check_device_access_params(). The zone checks that it ends with are unreachable, as atomic writes and ZBC emulation are mutually exclusive.
---
Tested with:
modprobe scsi_debug sector_size=512 physblk_exp=3 dev_size_mb=128 \
atomic_wr=1The device has a capacity of 262144 logical blocks. A WRITE ATOMIC (16) of eight blocks at LBA 262140 is now terminated with ILLEGAL REQUEST / LOGICAL BLOCK ADDRESS OUT OF RANGE; before this patch it completed with GOOD status, having written eight blocks at LBA 0 instead.
With the wp module parameter set to 1, a WRITE ATOMIC (16) is now terminated with DATA PROTECT / LOGICAL UNIT SOFTWARE WRITE PROTECTED, which is what an ordinary WRITE(16) has always returned; before this patch it completed with GOOD status and wrote the data.
--- drivers/scsi/scsi_debug.c | 4 ++++ 1 file changed, 4 insertions(+)
drivers/scsi/scsi_debug.c +4 -0
@@ -6256,6 +6256,10 @@ static int resp_atomic_write(struct scsi_cmnd *scp, } } + ret =check_device_access_params (scp, lba, len, true); +if (ret) +return ret; +/* * Short atomic writes are not allowed: SBC-6 4.28.2 requires an * atomic write that cannot complete to leave its LBAs unaltered, and
Signature · 1 line
2.55.0
Re: [PATCH v11 03/13] scsi: scsi_debug: Refuse a negative physblk_exp
In reply to Niklas CasselQuoted 10 lines · Niklas Cassel
sdebug_init()refuses aphysblk_expabove 15, but the parameter is a signed int, so a negative value is accepted. The driver then shifts by it when it builds the Block Limits VPD page, which is undefined behaviour, and READ CAPACITY (16) reports an exponent of 15 for -1.Refuse a negative value as well, and print it as a signed value.
Assisted-by LLMFixes ea61fca58c13 ("scsi_debug: Add support for physical block exponent and alignment")Signed-off-by Niklas Cassel <[email protected]>
Another way of fixing this would be to declare sdebug_physblk_exp as unsigned int. But this works too.
Signature · 2 lines
Damien Le Moal Western Digital Research
Re: [PATCH v11 06/13] scsi: scsi_debug: Avoid 32-bit overflow in WRITE SCATTERED offsets
In reply to Niklas CasselQuoted 9 lines · Niklas Cassel
resp_write_scat()computes the length of an LBA range in bytes as a 32-bit product,num_by= num *lb_size, and adds it tosg_off, the 32-bit offset of the next range in the data-out buffer. The product wraps for a range of 4 GiB or more, whichcheck_device_access_params()allows once the store is that large, andsg_offwraps once the ranges add up to 4 GiB, which neither their number nor their overlap prevents. The ranges that follow are then written from the wrong offset in the buffer.
Quoted 8 lines
Make
num_byandsg_off64-bit, and passdo_device_access()sg_offcapped at the length of the buffer. An offset at the end of the buffer copies nothing, andsg_copy_buffer(), which takes it as anoff_t, is never given one larger than the buffer that it copies.Assisted-by LLMFixes 481b5e5c7949 ("scsi: scsi_debug: add resp_write_scat function")Signed-off-by Niklas Cassel <[email protected]>
Signature · 2 lines
Damien Le Moal Western Digital Research
Niklas,
Quoted 3 lines
This series fixes
scsi_debugwith regards to writes to a ZBC drive, and to WRITE ATOMIC (16). Each patch describes the problem that it fixes.
Applied to 7.4/scsi-staging, thanks!
Signature · 1 line
Martin K. Petersen
Quoted 10 lines · Niklas Cassel
This series fixes
scsi_debugwith regards to writes to a ZBC drive, and to WRITE ATOMIC (16). Each patch describes the problem that it fixes.Two configurations are refused rather than emulated, and those two patches come first, as the rest of the series relies on what they
exclude: a zoned device whose lowest aligned LBA is not zero, which no host writing in units of the reported zone write granularity could ever write, and atomic writes on a zoned device, which no drive supports.[...]
Applied to 7.4/scsi-queue, thanks!
[01/13] scsi: scsi_debug: Refuse a zoned device with a non-zero lowest aligned LBA
https://git.kernel.org/mkp/scsi/c/45ce384be0cd [02/13] scsi: scsi_debug: Make atomic writes and ZBC emulation mutually exclusive https://git.kernel.org/mkp/scsi/c/e5ebe632be40 [03/13] scsi: scsi_debug: Refuse a negative physblk_exp https://git.kernel.org/mkp/scsi/c/a349876633f7 [04/13] scsi: scsi_debug: Take the zone metadata lock before the data lock https://git.kernel.org/mkp/scsi/c/c9aedbcbff0f [05/13] scsi: scsi_debug: Evaluate scsi_debug_lbp() only once https://git.kernel.org/mkp/scsi/c/1809f9bf3da2 [06/13] scsi: scsi_debug: Avoid 32-bit overflow in WRITE SCATTERED offsets https://git.kernel.org/mkp/scsi/c/92feb036a2d3 [07/13] scsi: scsi_debug: Report the residual of a write https://git.kernel.org/mkp/scsi/c/7c000c4ad2c0 [08/13] scsi: scsi_debug: Enforce physical block alignment of zoned writes https://git.kernel.org/mkp/scsi/c/63cb3900be26 [09/13] scsi: scsi_debug: Do not write a partial physical block to a zoned device https://git.kernel.org/mkp/scsi/c/b8fad9f02485 [10/13] scsi: scsi_debug: Advance the write pointer over the data written https://git.kernel.org/mkp/scsi/c/cb2d2a7c80c6 [11/13] scsi: scsi_debug: Refuse a short WRITE ATOMIC (16) before writing it https://git.kernel.org/mkp/scsi/c/b81608b17c5d [12/13] scsi: scsi_debug: Map the region written by WRITE ATOMIC (16) https://git.kernel.org/mkp/scsi/c/491bd55c35cb [13/13] scsi: scsi_debug: Validate the access parameters of WRITE ATOMIC (16) https://git.kernel.org/mkp/scsi/c/a6c339feb830
Signature · 1 line
Martin K. Petersen