* [PATCH v3 0/3] Make target send correct io limits
@ 2022-11-14 10:24 Anastasia Kovaleva
2022-11-14 10:24 ` [PATCH v3 1/3] target: core: Send mtl in blocks Anastasia Kovaleva
` (4 more replies)
0 siblings, 5 replies; 6+ messages in thread
From: Anastasia Kovaleva @ 2022-11-14 10:24 UTC (permalink / raw)
To: target-devel; +Cc: linux-scsi, linux
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(-)
--
2.38.1
^ permalink raw reply [flat|nested] 6+ messages in thread* [PATCH v3 1/3] target: core: Send mtl in blocks 2022-11-14 10:24 [PATCH v3 0/3] Make target send correct io limits Anastasia Kovaleva @ 2022-11-14 10:24 ` Anastasia Kovaleva 2022-11-14 10:24 ` [PATCH v3 2/3] target: core: make hw_max_sectors store the sectors amount " Anastasia Kovaleva ` (3 subsequent siblings) 4 siblings, 0 replies; 6+ messages in thread From: Anastasia Kovaleva @ 2022-11-14 10:24 UTC (permalink / raw) To: target-devel; +Cc: linux-scsi, linux 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. Reviewed-by: Konstantin Shelekhin <k.shelekhin@yadro.com> Reviewed-by: Dmitriy Bogdanov <d.bogdanov@yadro.com> Signed-off-by: Anastasia Kovaleva <a.kovaleva@yadro.com> --- 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(-) diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c index 533524299ed6..0175893ea56a 100644 --- a/drivers/target/target_core_configfs.c +++ b/drivers/target/target_core_configfs.c @@ -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); diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c index 28aa643be5d5..f9aed9fa8ced 100644 --- a/drivers/target/target_core_file.c +++ b/drivers/target/target_core_file.c @@ -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; diff --git a/drivers/target/target_core_spc.c b/drivers/target/target_core_spc.c index ffe02e195733..f4f02a47a403 100644 --- a/drivers/target/target_core_spc.c +++ b/drivers/target/target_core_spc.c @@ -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 diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h index 0c1e43980985..12c9ba16217e 100644 --- a/include/target/target_core_base.h +++ b/include/target/target_core_base.h @@ -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; }; -- 2.38.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH v3 2/3] target: core: make hw_max_sectors store the sectors amount in blocks 2022-11-14 10:24 [PATCH v3 0/3] Make target send correct io limits Anastasia Kovaleva 2022-11-14 10:24 ` [PATCH v3 1/3] target: core: Send mtl in blocks Anastasia Kovaleva @ 2022-11-14 10:24 ` Anastasia Kovaleva 2022-11-14 10:25 ` [PATCH v3 3/3] target: core: Change the way target_xcopy_do_work sets restiction on max io Anastasia Kovaleva ` (2 subsequent siblings) 4 siblings, 0 replies; 6+ messages in thread From: Anastasia Kovaleva @ 2022-11-14 10:24 UTC (permalink / raw) To: target-devel; +Cc: linux-scsi, linux By 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. Reviewed-by: Konstantin Shelekhin <k.shelekhin@yadro.com> Reviewed-by: Dmitriy Bogdanov <d.bogdanov@yadro.com> Signed-off-by: Anastasia Kovaleva <a.kovaleva@yadro.com> --- drivers/target/target_core_iblock.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c index 8351c974cee3..2a704926edb9 100644 --- a/drivers/target/target_core_iblock.c +++ b/drivers/target/target_core_iblock.c @@ -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; /* -- 2.38.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH v3 3/3] target: core: Change the way target_xcopy_do_work sets restiction on max io 2022-11-14 10:24 [PATCH v3 0/3] Make target send correct io limits Anastasia Kovaleva 2022-11-14 10:24 ` [PATCH v3 1/3] target: core: Send mtl in blocks Anastasia Kovaleva 2022-11-14 10:24 ` [PATCH v3 2/3] target: core: make hw_max_sectors store the sectors amount " Anastasia Kovaleva @ 2022-11-14 10:25 ` Anastasia Kovaleva 2022-11-14 21:03 ` [PATCH v3 0/3] Make target send correct io limits Mike Christie 2022-11-26 3:27 ` Martin K. Petersen 4 siblings, 0 replies; 6+ messages in thread From: Anastasia Kovaleva @ 2022-11-14 10:25 UTC (permalink / raw) To: target-devel; +Cc: linux-scsi, linux To 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. Reviewed-by: Konstantin Shelekhin <k.shelekhin@yadro.com> Reviewed-by: Dmitriy Bogdanov <d.bogdanov@yadro.com> Signed-off-by: Anastasia Kovaleva <a.kovaleva@yadro.com> --- 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(-) diff --git a/drivers/target/target_core_xcopy.c b/drivers/target/target_core_xcopy.c index edf522208285..49eaee022ef1 100644 --- a/drivers/target/target_core_xcopy.c +++ b/drivers/target/target_core_xcopy.c @@ -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); } diff --git a/drivers/target/target_core_xcopy.h b/drivers/target/target_core_xcopy.h index e5f20005179a..0aad7dc65895 100644 --- a/drivers/target/target_core_xcopy.h +++ b/drivers/target/target_core_xcopy.h @@ -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 -- 2.38.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH v3 0/3] Make target send correct io limits 2022-11-14 10:24 [PATCH v3 0/3] Make target send correct io limits Anastasia Kovaleva ` (2 preceding siblings ...) 2022-11-14 10:25 ` [PATCH v3 3/3] target: core: Change the way target_xcopy_do_work sets restiction on max io Anastasia Kovaleva @ 2022-11-14 21:03 ` Mike Christie 2022-11-26 3:27 ` Martin K. Petersen 4 siblings, 0 replies; 6+ messages in thread From: Mike Christie @ 2022-11-14 21:03 UTC (permalink / raw) To: Anastasia Kovaleva, target-devel; +Cc: linux-scsi, linux On 11/14/22 4:24 AM, Anastasia Kovaleva wrote: > 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. > 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. Reviewed-by: Mike Christie <michael.christie@oracle.com> ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH v3 0/3] Make target send correct io limits 2022-11-14 10:24 [PATCH v3 0/3] Make target send correct io limits Anastasia Kovaleva ` (3 preceding siblings ...) 2022-11-14 21:03 ` [PATCH v3 0/3] Make target send correct io limits Mike Christie @ 2022-11-26 3:27 ` Martin K. Petersen 4 siblings, 0 replies; 6+ messages in thread From: Martin K. Petersen @ 2022-11-26 3:27 UTC (permalink / raw) To: target-devel, Anastasia Kovaleva; +Cc: Martin K . Petersen, linux, linux-scsi On Mon, 14 Nov 2022 13:24:57 +0300, Anastasia Kovaleva wrote: > 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 -- Martin K. Petersen Oracle Linux Engineering ^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2022-11-26 3:27 UTC | newest] Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2022-11-14 10:24 [PATCH v3 0/3] Make target send correct io limits Anastasia Kovaleva 2022-11-14 10:24 ` [PATCH v3 1/3] target: core: Send mtl in blocks Anastasia Kovaleva 2022-11-14 10:24 ` [PATCH v3 2/3] target: core: make hw_max_sectors store the sectors amount " Anastasia Kovaleva 2022-11-14 10:25 ` [PATCH v3 3/3] target: core: Change the way target_xcopy_do_work sets restiction on max io Anastasia Kovaleva 2022-11-14 21:03 ` [PATCH v3 0/3] Make target send correct io limits Mike Christie 2022-11-26 3:27 ` Martin K. Petersen
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).