Make target send correct io limits
Subsystems (2)
v2 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.
The last time this patch set was sent, a kernel bot found some issues with building a kernel for i586 and m68k using a cross-compiler. I tried to reproduce this issues locally but didn't succeed. Even with given configs all things are built correctly without errors. For m68k I used m68k-linux-gnu-gcc version 11.2.0, for i586 I used i586-unknown-linux-gnu-gcc version 8.3.0. It would be great if you could share the kernel bot's cross-compilers.
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 | 96 ++++++++++++++------------- drivers/target/target_core_xcopy.h | 2 +- include/target/target_core_base.h | 1 - 7 files changed, 59 insertions(+), 53 deletions(-)
Signature · 1 line
2.30.2
PATCH v2 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
@@ -1100,8 +1100,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
@@ -709,7 +709,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.30.2
PATCH v2 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.30.2
PATCH v2 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.
--- drivers/target/target_core_xcopy.c | 96 ++++++++++++++++-------------- drivers/target/target_core_xcopy.h | 2 +- 2 files changed, 51 insertions(+), 47 deletions(-)
drivers/target/target_core_xcopy.c +50 -46
@@ -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,26 @@ 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_nolb =min_t (u16, max_sectors, ((u16)(~0U ))); - -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" , + 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_bytes =min_t (u64, max_bytes_src, max_bytes_dst); + max_bytes =min_t (u64, max_bytes,XCOPY_MAX_BYTES ); + max_blocks = max_bytes / 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 +728,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 +780,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.30.2