Make target send correct io limits
Subsystems (2)
v3 cover Make target send correct io limits
Currently iblock always reports MAXIMUM TRANSFER LENGTH in 512b units regardless of the LU block size.
Target block size:
target:~ # fdisk -l /dev/nullb0
Disk /dev/nullb0: 250 GiB, 268435456000 bytes, 65536000 sectors
Units: sectors of 1 * 4096 = 4096 bytes
Sector size (logical/physical): 4096 bytes / 4096 bytes I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Initiator block size:
initiator:~ # fdisk -l /dev/sdc
Disk /dev/sdc: 250 GiB, 268435456000 bytes, 65536000 sectors Disk model: nullb0
Units: sectors of 1 * 4096 = 4096 bytes
Sector size (logical/physical): 4096 bytes / 4096 bytes I/O size (minimum/optimal): 4096 bytes / 131072 bytes
target max transfer length limit:
target:~ # cat /sys/block/nullb0/queue/max_hw_sectors_kb 128
So the maximum transfer length should be 128 * 1024 / 4096 = 32 blocks But the target sends MTL in 512b units, so the initiators see 256 blocks instead.
initiator:~ # sg_inq -p 0xb0 /dev/sdc
VPD INQUIRY: Block limits page (SBC)
Maximum compare and write length: 1 blocks Optimal transfer length granularity: 1 blocks Maximum transfer length: 256 blocks
Optimal transfer length: 32 blocks
Maximum prefetch transfer length: 0 blocks [ignored]
This happens because MAXIMUM TRANSFER LENGTH field in VPD Block Limits page is derived from dev->dev_attrib.hw_max_sectors which happens to be in 512b units for iblock. This patch series fixes this issue and removes some special-casing for other backstores.
Changes since v1:
Sinse the v1 patch series, some variables was renamed, the checkpatch script was run and issues with debug logs was fixed, some refactoring was done.
Changes since v2:
Since the v2 patch series, a kernel bot found some issues with building a kernel for i386. The problem was that division 64 bit number make GCC generate __udivdi3 which is missing on i386.
Anastasia Kovaleva (3):
target: core: Send mtl in blocks
target: core: make hw_max_sectors store the sectors amount in blocks
target: core: Change the way target_xcopy_do_work sets restiction on
max io
drivers/target/target_core_configfs.c | 2 - drivers/target/target_core_file.c | 1 - drivers/target/target_core_iblock.c | 4 +- drivers/target/target_core_spc.c | 6 +- drivers/target/target_core_xcopy.c | 97 +++++++++++++++------------ drivers/target/target_core_xcopy.h | 2 +- include/target/target_core_base.h | 1 - 7 files changed, 62 insertions(+), 51 deletions(-)
Signature · 1 line
2.38.1
PATCH v3 1/3 target: core: Send mtl in blocks
A MAXIMUM TRANSFER LENGTH value indicates the maximum transfer length in logical blocks that the device server accepts for a single command. Fix function sending the length in sectors instead of blocks.
This patch also removes the special casing for fileio in block_size_store since this logic in now unified in spc_emulate_evpd_b0() for all backends.
--- drivers/target/target_core_configfs.c | 2 -- drivers/target/target_core_file.c | 1 - drivers/target/target_core_spc.c | 6 +++++- include/target/target_core_base.h | 1 - 4 files changed, 5 insertions(+), 5 deletions(-)
drivers/target/target_core_configfs.c +0 -2
@@ -1101,8 +1101,6 @@ static ssize_t block_size_store(struct config_item *item, } da->block_size = val; -if (da->max_bytes_per_io) - da->hw_max_sectors = da->max_bytes_per_io / val;pr_debug ("dev[%p]: SE Device block_size changed to %u\n" , da->da_dev, val);
drivers/target/target_core_file.c +0 -1
@@ -193,7 +193,6 @@ static int fd_configure_device(struct se_device *dev) } dev->dev_attrib.hw_block_size = fd_dev->fd_block_size; - dev->dev_attrib.max_bytes_per_io =FD_MAX_BYTES ; dev->dev_attrib.hw_max_sectors =FD_MAX_BYTES / fd_dev->fd_block_size; dev->dev_attrib.hw_queue_depth =FD_MAX_DEVICE_QUEUE_DEPTH ;
drivers/target/target_core_spc.c +5 -1
@@ -519,6 +519,7 @@ spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)struct se_device *dev = cmd->se_dev;u32 mtl =0 ;int have_tp =0 , opt, min; +u32 io_max_blocks;/* * Following spc3r22 section 6.5.3 Block Limits VPD page, when
@@ -557,7 +558,10 @@ spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf) mtl = (cmd->se_tfo->max_data_sg_nents *PAGE_SIZE ) / dev->dev_attrib.block_size; } -put_unaligned_be32 (min_not_zero (mtl, dev->dev_attrib.hw_max_sectors), &buf[8 ]); + io_max_blocks =mult_frac (dev->dev_attrib.hw_max_sectors, + dev->dev_attrib.hw_block_size, + dev->dev_attrib.block_size); +put_unaligned_be32 (min_not_zero (mtl, io_max_blocks), &buf[8 ]);/* * Set OPTIMAL TRANSFER LENGTH
include/target/target_core_base.h +0 -1
@@ -712,7 +712,6 @@ struct se_dev_attrib {u32 unmap_granularity;u32 unmap_granularity_alignment;u32 max_write_same_len; -u32 max_bytes_per_io;struct se_device *da_dev;struct config_group da_group; };
Signature · 1 line
2.38.1
PATCH v3 2/3 target: core: make hw_max_sectors store the sectors amount in blocks
In reply to Anastasia KovalevaBy default, hw_max_sectors stores its value in 512 blocks in iblock, despite the fact that the block size can be 4096 bytes. Change hw_max_sectors to store the number of sectors in hw_block_size blocks.
--- drivers/target/target_core_iblock.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/target/target_core_iblock.c +3 -1
@@ -124,7 +124,9 @@ static int iblock_configure_device(struct se_device *dev) q =bdev_get_queue (bd); dev->dev_attrib.hw_block_size =bdev_logical_block_size (bd); - dev->dev_attrib.hw_max_sectors =queue_max_hw_sectors (q); + dev->dev_attrib.hw_max_sectors =mult_frac (queue_max_hw_sectors (q), +SECTOR_SIZE , + dev->dev_attrib.hw_block_size); dev->dev_attrib.hw_queue_depth = q->nr_requests;/*
Signature · 1 line
2.38.1
PATCH v3 3/3 target: core: Change the way target_xcopy_do_work sets restiction on max io
In reply to Anastasia KovalevaTo determine how many blocks sends in one command, the minimum value is selected from the hw_max_sectors of both devices. In target_xcopy_do_work, hw_max_sectors are used as blocks, not sectors; it also ignores the fact that sectors can be of different sizes, for example 512 and 4096 bytes. Because of this, a number of blocks can be transmitted that the device will not be able to accept.
Change the selection of max transmission size into bytes.
---
v2:
rename some variables
fix warnings of checkpatch script
make sone refactoring
v3:
fix kernel build failing on i386
--- drivers/target/target_core_xcopy.c | 97 ++++++++++++++++-------------- drivers/target/target_core_xcopy.h | 2 +- 2 files changed, 54 insertions(+), 45 deletions(-)
drivers/target/target_core_xcopy.c +53 -44
@@ -582,11 +582,11 @@ static int target_xcopy_read_source(struct xcopy_op *xop, struct se_device *src_dev, sector_t src_lba, - u32 src_sectors) + u32 src_bytes) { struct xcopy_pt_cmd xpt_cmd;struct se_cmd *se_cmd = &xpt_cmd.se_cmd; -u32 length = (src_sectors * src_dev->dev_attrib.block_size); +u32 transfer_length_block = src_bytes / src_dev->dev_attrib.block_size;int rc;unsigned char cdb[16 ];bool remote_port = (xop->op_origin ==XCOL_DEST_RECV_OP );
@@ -597,11 +597,11 @@ static int target_xcopy_read_source(memset (&cdb[0 ],0 ,16 ); cdb[0 ] =READ_16 ;put_unaligned_be64 (src_lba, &cdb[2 ]); -put_unaligned_be32 (src_sectors, &cdb[10 ]); -pr_debug ("XCOPY: Built READ_16: LBA: %llu Sectors: %u Length: %u\n" , - (unsigned long long )src_lba, src_sectors, length); +put_unaligned_be32 (transfer_length_block, &cdb[10 ]); +pr_debug ("XCOPY: Built READ_16: LBA: %llu Blocks: %u Length: %u\n" , + (unsigned long long )src_lba, transfer_length_block, src_bytes); -__target_init_cmd (se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, length, +__target_init_cmd (se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, src_bytes,DMA_FROM_DEVICE ,0 , &xpt_cmd.sense_buffer[0 ],0 ); rc = target_xcopy_setup_pt_cmd(&xpt_cmd, xop, src_dev, &cdb[0],
@@ -627,11 +627,11 @@ static int target_xcopy_write_destination(struct xcopy_op *xop, struct se_device *dst_dev, sector_t dst_lba, - u32 dst_sectors) + u32 dst_bytes) { struct xcopy_pt_cmd xpt_cmd;struct se_cmd *se_cmd = &xpt_cmd.se_cmd; -u32 length = (dst_sectors * dst_dev->dev_attrib.block_size); +u32 transfer_length_block = dst_bytes / dst_dev->dev_attrib.block_size;int rc;unsigned char cdb[16 ];bool remote_port = (xop->op_origin ==XCOL_SOURCE_RECV_OP );
@@ -642,11 +642,11 @@ static int target_xcopy_write_destination(memset (&cdb[0 ],0 ,16 ); cdb[0 ] =WRITE_16 ;put_unaligned_be64 (dst_lba, &cdb[2 ]); -put_unaligned_be32 (dst_sectors, &cdb[10 ]); -pr_debug ("XCOPY: Built WRITE_16: LBA: %llu Sectors: %u Length: %u\n" , - (unsigned long long )dst_lba, dst_sectors, length); +put_unaligned_be32 (transfer_length_block, &cdb[10 ]); +pr_debug ("XCOPY: Built WRITE_16: LBA: %llu Blocks: %u Length: %u\n" , + (unsigned long long )dst_lba, transfer_length_block, dst_bytes); -__target_init_cmd (se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, length, +__target_init_cmd (se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, dst_bytes,DMA_TO_DEVICE ,0 , &xpt_cmd.sense_buffer[0 ],0 ); rc = target_xcopy_setup_pt_cmd(&xpt_cmd, xop, dst_dev, &cdb[0],
@@ -670,9 +670,10 @@ static void target_xcopy_do_work(struct work_struct *work)struct se_cmd *ec_cmd = xop->xop_se_cmd;struct se_device *src_dev, *dst_dev;sector_t src_lba, dst_lba, end_lba; -unsigned int max_sectors; +unsigned long long max_bytes, max_bytes_src, max_bytes_dst, max_blocks;int rc =0 ; -unsigned short nolb, max_nolb, copied_nolb =0 ; +unsigned short nolb; +unsigned int copied_bytes =0 ;sense_reason_t sense_rc; sense_rc =target_parse_xcopy_cmd (xop);
@@ -691,23 +692,31 @@ static void target_xcopy_do_work(struct work_struct *work) nolb = xop->nolb; end_lba = src_lba + nolb;/* -* Break up XCOPY I/O into hw_max_sectors sized I/O based on the -* smallest max_sectors between src_dev + dev_dev, or +* Break up XCOPY I/O into hw_max_sectors * hw_block_size sized +* I/O based on the smallest max_bytes between src_dev + dst_dev */ - max_sectors =min (src_dev->dev_attrib.hw_max_sectors, - dst_dev->dev_attrib.hw_max_sectors); - max_sectors =min_t (u32, max_sectors,XCOPY_MAX_SECTORS ); + max_bytes_src = (unsigned long long ) src_dev->dev_attrib.hw_max_sectors * + src_dev->dev_attrib.hw_block_size; + max_bytes_dst = (unsigned long long ) dst_dev->dev_attrib.hw_max_sectors * + dst_dev->dev_attrib.hw_block_size; - max_nolb =min_t (u16, max_sectors, ((u16)(~0U ))); + max_bytes =min_t (u64, max_bytes_src, max_bytes_dst); + max_bytes =min_t (u64, max_bytes,XCOPY_MAX_BYTES ); -pr_debug ("target_xcopy_do_work: nolb: %hu, max_nolb: %hu end_lba: %llu\n" , - nolb, max_nolb, (unsigned long long )end_lba); -pr_debug ("target_xcopy_do_work: Starting src_lba: %llu, dst_lba: %llu\n" , +/* +* Using shift instead of the division because otherwise GCC +* generates __udivdi3 that is missing on i386 +*/ + max_blocks = max_bytes >>ilog2 (src_dev->dev_attrib.block_size); + +pr_debug ("%s: nolb: %u, max_blocks: %llu end_lba: %llu\n" , __func__, + nolb, max_blocks, (unsigned long long )end_lba); +pr_debug ("%s: Starting src_lba: %llu, dst_lba: %llu\n" , __func__, (unsigned long long )src_lba, (unsigned long long )dst_lba); -while (src_lba < end_lba) { -unsigned short cur_nolb =min (nolb, max_nolb); -u32 cur_bytes = cur_nolb * src_dev->dev_attrib.block_size; +while (nolb) { +u32 cur_bytes =min_t (u64, max_bytes, nolb * src_dev->dev_attrib.block_size); +unsigned short cur_nolb = cur_bytes / src_dev->dev_attrib.block_size;if (cur_bytes != xop->xop_data_bytes) {/*
@@ -724,43 +733,43 @@ static void target_xcopy_do_work(struct work_struct *work) xop->xop_data_bytes = cur_bytes; } -pr_debug ("target_xcopy_do_work: Calling read src_dev: %p src_lba: %llu," -" cur_nolb: %hu\n" , src_dev, (unsigned long long )src_lba, cur_nolb); +pr_debug ("%s: Calling read src_dev: %p src_lba: %llu, cur_nolb: %hu\n" , + __func__, src_dev, (unsigned long long )src_lba, cur_nolb); - rc =target_xcopy_read_source (ec_cmd, xop, src_dev, src_lba, cur_nolb); + rc =target_xcopy_read_source (ec_cmd, xop, src_dev, src_lba, cur_bytes);if (rc <0 ) goto out; - src_lba += cur_nolb; -pr_debug ("target_xcopy_do_work: Incremented READ src_lba to %llu\n" , + src_lba += cur_bytes / src_dev->dev_attrib.block_size; +pr_debug ("%s: Incremented READ src_lba to %llu\n" , __func__, (unsigned long long )src_lba); -pr_debug ("target_xcopy_do_work: Calling write dst_dev: %p dst_lba: %llu," -" cur_nolb: %hu\n" , dst_dev, (unsigned long long )dst_lba, cur_nolb); +pr_debug ("%s: Calling write dst_dev: %p dst_lba: %llu, cur_nolb: %u\n" , + __func__, dst_dev, (unsigned long long )dst_lba, cur_nolb); rc =target_xcopy_write_destination (ec_cmd, xop, dst_dev, - dst_lba, cur_nolb); + dst_lba, cur_bytes);if (rc <0 ) goto out; - dst_lba += cur_nolb; -pr_debug ("target_xcopy_do_work: Incremented WRITE dst_lba to %llu\n" , + dst_lba += cur_bytes / dst_dev->dev_attrib.block_size; +pr_debug ("%s: Incremented WRITE dst_lba to %llu\n" , __func__, (unsigned long long )dst_lba); - copied_nolb += cur_nolb; - nolb -= cur_nolb; + copied_bytes += cur_bytes; + nolb -= cur_bytes / src_dev->dev_attrib.block_size; }xcopy_pt_undepend_remotedev (xop);target_free_sgl (xop->xop_data_sg, xop->xop_data_nents);kfree (xop); -pr_debug ("target_xcopy_do_work: Final src_lba: %llu, dst_lba: %llu\n" , +pr_debug ("%s: Final src_lba: %llu, dst_lba: %llu\n" , __func__, (unsigned long long )src_lba, (unsigned long long )dst_lba); -pr_debug ("target_xcopy_do_work: Blocks copied: %hu, Bytes Copied: %u\n" , - copied_nolb, copied_nolb * dst_dev->dev_attrib.block_size); +pr_debug ("%s: Blocks copied: %u, Bytes Copied: %u\n" , __func__, + copied_bytes / dst_dev->dev_attrib.block_size, copied_bytes); -pr_debug ("target_xcopy_do_work: Setting X-COPY GOOD status -> sending response\n" ); +pr_debug ("%s: Setting X-COPY GOOD status -> sending response\n" , __func__);target_complete_cmd (ec_cmd,SAM_STAT_GOOD );return ;
@@ -776,8 +785,8 @@ static void target_xcopy_do_work(struct work_struct *work) err_free:kfree (xop); -pr_warn_ratelimited ("target_xcopy_do_work: rc: %d, sense: %u, XCOPY operation failed\n" , - rc, sense_rc); +pr_warn_ratelimited ("%s: rc: %d, sense: %u, XCOPY operation failed\n" , + __func__, rc, sense_rc);target_complete_cmd_with_sense (ec_cmd,SAM_STAT_CHECK_CONDITION , sense_rc); }
drivers/target/target_core_xcopy.h +1 -1
@@ -5,7 +5,7 @@#define XCOPY_TARGET_DESC_LEN 32#define XCOPY_SEGMENT_DESC_LEN 28#define XCOPY_NAA_IEEE_REGEX_LEN 16 -#define XCOPY_MAX_SECTORS 4096 +#define XCOPY_MAX_BYTES 16777216/* 16 MB */ /* * SPC4r37 6.4.6.1
Signature · 1 line
2.38.1
Quoted 39 lines · Anastasia Kovaleva
Currently iblock always reports MAXIMUM TRANSFER LENGTH in 512b units regardless of the LU block size.
Target block size:
target:~ # fdisk -l/dev/nullb0
Disk/dev/nullb0: 250 GiB, 268435456000 bytes, 65536000 sectors
Units: sectors of 1 * 4096 = 4096 bytes
Sector size (logical/physical): 4096 bytes / 4096 bytes I/O size (minimum/optimal): 4096 bytes / 4096 bytesInitiator block size:
initiator:~ # fdisk -l/dev/sdc
Disk/dev/sdc: 250 GiB, 268435456000 bytes, 65536000 sectors Disk model: nullb0
Units: sectors of 1 * 4096 = 4096 bytes
Sector size (logical/physical): 4096 bytes / 4096 bytes I/O size (minimum/optimal): 4096 bytes / 131072 bytestarget max transfer length limit:
target:~ # cat/sys/block/nullb0/queue/max_hw_sectors_kb128So the maximum transfer length should be 128 * 1024 / 4096 = 32 blocks But the target sends MTL in 512b units, so the initiators see 256 blocks instead.
initiator:~ #
sg_inq-p0xb0/dev/sdc
VPD INQUIRY: Block limits page (SBC)
Maximum compare and write length: 1 blocks Optimal transfer length granularity: 1 blocks Maximum transfer length: 256 blocks
Optimal transfer length: 32 blocks
Maximum prefetch transfer length: 0 blocks [ignored]This happens because MAXIMUM TRANSFER LENGTH field in VPD Block Limits page is derived from
dev->dev_attrib.hw_max_sectorswhich happens to be in 512b units for iblock. This patch series fixes this issue and removes some special-casing for other backstores.
Quoted 5 lines
Changes since v1:
Sinse the v1 patch series, some variables was renamed, the checkpatch script was run and issues with debug logs was fixed, some refactoring was done.
You forgot the tabbing/spacing issue I mentioned (checkpatch --strict reports them for example). It's probably not a big enough deal to hold this up though.
Martin K. Petersen
AppliedQuoted 11 lines · Anastasia Kovaleva
Currently iblock always reports MAXIMUM TRANSFER LENGTH in 512b units regardless of the LU block size.
Target block size:
target:~ # fdisk -l/dev/nullb0
Disk/dev/nullb0: 250 GiB, 268435456000 bytes, 65536000 sectors
Units: sectors of 1 * 4096 = 4096 bytes
Sector size (logical/physical): 4096 bytes / 4096 bytes I/O size (minimum/optimal): 4096 bytes / 4096 bytes[...]
Applied to 6.2/scsi-queue, thanks!
[1/3] target: core: Send mtl in blocks
https://git.kernel.org/mkp/scsi/c/7870d2481789 [2/3] target: core: make hw_max_sectors store the sectors amount in blocks https://git.kernel.org/mkp/scsi/c/9375031ee40b [3/3] target: core: Change the way target_xcopy_do_work sets restiction on max io https://git.kernel.org/mkp/scsi/c/689d94ec208c
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering