scsi_debug: add support to corrupt data and/or reftag v2
This will be used for testing PI support in xfstests.
Changes since v1:
- use match_int to parse the reftag_adjust option
- don't bypass error cleanup on parsing failure
- allow to corrupt the entire capacity
- set the bug_if_fake_rw to devip2sip to false
- fix the check for unmapped LBAs
- require DIX for reftag corruption injection
- make the kernel messages a bit less verbose
- add calls to sdeb_data_lock and sdeb_data_sector_lock
PATCH 1/1 scsi_debug: add support to corrupt data and/or reftag
Add a new debugfs file to inject corruptions of the data and/or reftag. This will be used to detect that protection information and/or file system checksumming can detect random bit errors or misplaced writes.
To use this echo the start LBA, number of logical blocks and type of corruption into the new "corrupt" debugfs file for each scsi_debug device.
For example:
echo lba=42,num=1,bit_errors=2 > /sys/kernel/debug/scsi_debug/1:0:0:0/corrupt or echo lba=2,num=4,reftag_adjust=8 > /sys/kernel/debug/scsi_debug/1:0:0:0/corrupt
The injection will be used by new xfstests test cases.
--- drivers/scsi/scsi_debug.c | 163 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 163 insertions(+)
drivers/scsi/scsi_debug.c +163 -0
@@ -44,6 +44,7 @@#include <linux/debugfs.h> #include <linux/async.h> #include <linux/cleanup.h> +#include <linux/parser.h> #include <net/checksum.h>
@@ -1214,6 +1215,95 @@ static const struct file_operations sdebug_error_fops = { .release = single_release, }; +enum corrupt_options { + Opt_lba = (1u <<0 ), + Opt_num = (1u <<1 ), + Opt_bit_errors = (1u <<2 ), + Opt_reftag_adjust = (1u <<3 ), + + Opt_invalid, +}; + +static const match_table_t corrupt_tokens = { + { Opt_lba,"lba=%u" }, + { Opt_num,"num=%u" }, + { Opt_bit_errors,"bit_errors=%u" }, + { Opt_reftag_adjust,"reftag_adjust=%d" }, + { Opt_invalid,NULL , }, +}; + +static int corrupt_lbas (struct sdebug_dev_info *devip,u64 lba,u32 num, +u32 nr_bit_errors,s32 reftag_adjust); +static ssize_t sdebug_corrupt_write (struct file *file,const char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct scsi_device *sdev = file->f_inode->i_private; +struct sdebug_dev_info *devip = sdev->hostdata; +substring_t args[MAX_OPT_ARGS ]; +char *buf, *options, *p; +int error =0 ; +u64 lba =0 ; +u32 num =1 ; +u32 nr_bit_errors =0 ; +s32 reftag_adjust =0 ; + + buf =memdup_user_nul (ubuf, count); +if (IS_ERR (buf)) +return PTR_ERR (buf); + + options = buf; +while ((p =strsep (&options,",\n" )) !=NULL ) { +if (!*p) +continue ; +switch (match_token (p, corrupt_tokens, args)) { +case Opt_lba: + error =match_u64 (args, &lba); +break ; +case Opt_num: + error =match_uint (args, &num); +break ; +case Opt_bit_errors: + error =match_uint (args, &nr_bit_errors); +break ; +case Opt_reftag_adjust: + error =match_int (args, &reftag_adjust); +break ; +default : +pr_warn ("unknown parameter or missing value '%s'\n" , p); + error = -EINVAL ; + } +if (error) + goto out_free_buf; + } + +if (num ==0 ) { +pr_warn ("invalid number of logical blocks: %u\n" , num); + error = -EINVAL ; + goto out_free_buf; + } + +if (reftag_adjust && + (!sdebug_dix || + (sdebug_dif !=T10_PI_TYPE1_PROTECTION && + sdebug_dif !=T10_PI_TYPE2_PROTECTION ))) { +pr_warn ("reftag adjust requires type 1 or type 2 PI with DIX\n" ); + error = -EINVAL ; + goto out_free_buf; + } + + error =corrupt_lbas (devip, lba, num, nr_bit_errors, reftag_adjust); + +out_free_buf: +kfree (buf); +if (error) +return error; +return count; +} + +static const struct file_operations sdebug_corrupt_fops = { + .write = sdebug_corrupt_write, +}; +static int sdebug_target_reset_fail_show (struct seq_file *m,void *p) {struct scsi_target *starget = (struct scsi_target *)m->private;
@@ -4908,6 +4998,77 @@ static int resp_write_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)return 0 ; } +static int corrupt_lbas (struct sdebug_dev_info *devip,u64 lba,u32 num, +u32 nr_bit_errors,s32 reftag_adjust) +{ +struct sdeb_store_info *sip =devip2sip (devip, false); +bool meta_data_locked = false; +u8 *fsp = sip->storep; +u32 block, num_mapped, b, i; +int error =0 ; + +if (sdebug_dev_is_zoned (devip) || + sdebug_dix || +scsi_debug_lbp ()) { +sdeb_meta_write_lock (sip); + meta_data_locked = true; + } + +if (num > sdebug_capacity || lba > sdebug_capacity - num) { +pr_err ("logical blocks out of bounds: %llu:%u" , lba, num); + error = -EINVAL ; + goto out_unlock; + } + +if (scsi_debug_lbp () && + (!map_state (sip, lba, &num_mapped) || num > num_mapped)) { +pr_err ("can't modify unmapped logical blocks: %llu:%u" , + lba, num); + error = -EINVAL ; + goto out_unlock; + } + +/* +* For each possible bit error, flip the same bit in each corrupted +* block to simulate repeated patterns like errors in cables. +*/ +sdeb_data_lock (sip, false); +for (b =0 ; b < nr_bit_errors; b++) { +unsigned int bit; + + bit =get_random_u32_below (sdebug_sector_size *BITS_PER_BYTE ); +pr_info ("flipping bit %u in LBAs %llu:%llu\n" , + bit, lba, lba + num -1 ); + +div_u64_rem (lba, sdebug_store_sectors, &block); +for (i =0 ; i < num; i++) { +u8 *p = fsp + (block * sdebug_sector_size); + +sdeb_data_sector_lock (sip, true); + p[bit /BITS_PER_BYTE ] ^= (1 << (bit %BITS_PER_BYTE )); +sdeb_data_sector_unlock (sip, true); +if (++block >= sdebug_store_sectors) + block =0 ; + } + } + +if (reftag_adjust) { +pr_info ("adjusting reftag by %d sectors for LBAs %llu:%llu\n" , + reftag_adjust, lba, lba + num -1 ); +for (i =0 ; i < num; i++) { +struct t10_pi_tuple *sdt =dif_store (sip, lba + i); + +be32_add_cpu (&sdt->ref_tag, reftag_adjust); + } + } +sdeb_data_unlock (sip, false); + +out_unlock: +if (meta_data_locked) +sdeb_meta_write_unlock (sip); +return error; +} +static int resp_write_dt0 (struct scsi_cmnd *scp,struct sdebug_dev_info *devip) {bool check_prot;
@@ -6674,6 +6835,8 @@ static int scsi_debug_sdev_configure(struct scsi_device *sdp,if (IS_ERR_OR_NULL (dentry))pr_info ("failed to create error file for device %s\n" ,dev_name (&sdp->sdev_gendev)); +debugfs_create_file ("corrupt" ,0600 , devip->debugfs_entry, sdp, + &sdebug_corrupt_fops);return 0 ; }
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH] scsi_debug: add support to corrupt data and/or reftag
Thank you for your contribution! Sashiko AI review found 5 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 5 potential issue(s) to consider:
New issues:
- [High] Unbounded nested loops in corrupt_lbas() executed with preemption disabled allow users to cause CPU lockups.
- [High] Unconditional dereference of sip in corrupt_lbas() when initialized with fake I/O (fake_rw=1).
- [Medium] Flawed map state validation in corrupt_lbas() rejects valid wrapping corruption requests.
Pre-existing issues:
- [High] Pre-existing out-of-bounds array access in map_state() when using large virtual LBAs.
- [High] Toggling fake_rw from 1 to 0 at runtime causes a pre-existing NULL pointer dereference in LBP operations. --
--- Patch [1]: [PATCH] scsi_debug: add support to corrupt data and/or reftag --- commit b674d4afbf6311bc89a7d69aaa16a3947e8d3546
Author: Christoph Hellwig <[email protected]>scsi_debug: add support to corrupt data and/or reftag
Add a new debugfs file to inject corruptions of the data and/or reftag. This will be used to detect that protection information and/or file system checksumming can detect random bit errors or misplaced writes.
Quoted 4 lines
drivers/scsi/scsi_debug.c +0
-0
[ ... ]
drivers/scsi/scsi_debug.c static int resp_write_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) · line 4960
Quoted 10 lines
drivers/scsi/scsi_debug.c +6
-0@@ -4862,6 +4952,77 @@ static int resp_write_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)return 0 ; } +static int corrupt_lbas (struct sdebug_dev_info *devip,u64 lba,u32 num, +u32 nr_bit_errors,s32 reftag_adjust) +{ +struct sdeb_store_info *sip =devip2sip (devip, false); +bool meta_data_locked = false; +u8 *fsp = sip->storep;
[Severity: High]
Does this unconditionally dereference sip if devip2sip() returns NULL?
If the scsi_debug module is loaded or toggled with fake_rw=1, devip2sip() explicitly returns NULL. The sip->storep assignment then dereferences it before any validation occurs, which will cause a kernel panic.
Quoted 8 lines
drivers/scsi/scsi_debug.c +8
-0+u32 block, num_mapped, b, i; +int error =0 ; + +if (sdebug_dev_is_zoned (devip) || + sdebug_dix || +scsi_debug_lbp ()) { +sdeb_meta_write_lock (sip); + meta_data_locked = true;
drivers/scsi/scsi_debug.c static int resp_write_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) · line 5024
Quoted 10 lines
drivers/scsi/scsi_debug.c +10
-0+ } + +if (num > sdebug_capacity || lba > sdebug_capacity - num) { +pr_err ("logical blocks out of bounds: %llu:%u" , lba, num); + error = -EINVAL ; + goto out_unlock; + } + +if (scsi_debug_lbp () && + (!map_state (sip, lba, &num_mapped) || num > num_mapped)) {
[Severity: High]
This is a pre-existing issue, but can map_state() perform an out-of-bounds array access when called with large virtual LBAs?
If sdebug_virtual_gb is configured, sdebug_capacity exceeds the physical sdebug_store_sectors. A command passing a large LBA generates an index larger than map_size:
drivers/scsi/scsi_debug.c:map_state() {
...
index = lba_to_map_index(lba);
mapped = test_bit(index, sip->map_storep);
...
}This causes test_bit and subsequent bit operations to access memory outside the allocated sip->map_storep array.
[Severity: Medium]
Does this check incorrectly reject valid corruption requests that cross the physical storage boundary?
If a user requests corruption across the physical store boundary (for example, an lba near sdebug_store_sectors with a num crossing it), map_state() limits the returned contiguous blocks to the physical boundary:
drivers/scsi/scsi_debug.c:map_state() {
...
end = min_t(sector_t, sdebug_store_sectors, map_index_to_lba(next));
*num = end - lba;
...
}This causes the num > num_mapped condition to trigger and abort the request, even though the underlying data loops correctly use div_u64_rem to wrap around the physical bounds.
[Severity: High]
This is a pre-existing issue, but does toggling fake_rw from 1 to 0 at runtime cause a NULL pointer dereference in LBP operations?
If fake_rw is toggled from 1 to 0 via sysfs, fake_rw_store() calls sdebug_add_store() before updating sdebug_fake_rw to 0:
drivers/scsi/scsi_debug.c:fake_rw_store() {
...
idx = sdebug_add_store();
...
sdebug_fake_rw = n;
...
}Inside sdebug_add_store(), scsi_debug_lbp() returns false because sdebug_fake_rw is still 1, so sip->map_storep remains unallocated. Once the transition completes, fake_rw is 0 and LBP becomes active. Any subsequent command using LBP calls map_state(), which crashes when dereferencing the NULL sip->map_storep.
Quoted 10 lines
drivers/scsi/scsi_debug.c +10
-0+pr_err ("can't modify unmapped logical blocks: %llu:%u" , + lba, num); + error = -EINVAL ; + goto out_unlock; + } + +/* +* For each possible bit error, flip the same bit in each corrupted +* block to simulate repeated patterns like errors in cables. +*/
drivers/scsi/scsi_debug.c static int resp_write_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip) · line 5044
Quoted 10 lines
drivers/scsi/scsi_debug.c +10
-0+sdeb_data_lock (sip, false); +for (b =0 ; b < nr_bit_errors; b++) { +unsigned int bit; + + bit =get_random_u32_below (sdebug_sector_size *BITS_PER_BYTE ); +pr_info ("flipping bit %u in LBAs %llu:%llu\n" , + bit, lba, lba + num -1 ); + +div_u64_rem (lba, sdebug_store_sectors, &block); +for (i =0 ; i < num; i++) {
[Severity: High]
Can these unbounded nested loops cause a CPU lockup since they run with preemption disabled?
A user can write large values for num and nr_bit_errors into the corrupt debugfs file. The sdeb_data_lock() function calls read_lock(), which disables preemption. The function then enters these loops, potentially stalling the CPU for an extended period of time if the inputs are large.
Quoted 9 lines
drivers/scsi/scsi_debug.c +9
-0+u8 *p = fsp + (block * sdebug_sector_size); + +sdeb_data_sector_lock (sip, true); + p[bit /BITS_PER_BYTE ] ^= (1 << (bit %BITS_PER_BYTE )); +sdeb_data_sector_unlock (sip, true); +if (++block >= sdebug_store_sectors) + block =0 ; + } + }
[ ... ]
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Re: [PATCH] scsi_debug: add support to corrupt data and/or reftag
In reply to Christoph Hellwigdrivers/scsi/scsi_debug.c static const struct file_operations sdebug_error_fops = { · line 1236
Quoted 2 lines · Christoph Hellwig
drivers/scsi/scsi_debug.c +2
-0+static int corrupt_lbas (struct sdebug_dev_info *devip,u64 lba,u32 num, +u32 nr_bit_errors,s32 reftag_adjust);
Can the corrupt_lbas() definition be moved here such that the forward declaration of this function can be removed?
Thanks,
Bart.
Re: [PATCH] scsi_debug: add support to corrupt data and/or reftag
Quoted 6 lines · Bart Van Assche
drivers/scsi/scsi_debug.c static const struct file_operations sdebug_error_fops = { · line 1236
Quoted 2 lines · Christoph Hellwig
drivers/scsi/scsi_debug.c +2
-0+static int corrupt_lbas (struct sdebug_dev_info *devip,u64 lba,u32 num, +u32 nr_bit_errors,s32 reftag_adjust);Can the
corrupt_lbas()definition be moved here such that the forward declaration of this function can be removed?
Not without reordering the entire file unfortunately. It depends on various helpers further down the file, while the debugfs registration happens further up. I've tried a few approaches to sort this out, but failed to come up with something simple enough.