ublk: add support for integrity data
Subsystems (3)
v4 cover ublk: add support for integrity data
Much work has recently gone into supporting block device integrity data (sometimes called "metadata") in Linux. Many NVMe devices these days support metadata transfers and/or automatic protection information generation and verification. However, ublk devices can't yet advertise integrity data capabilities. This patch series wires up support for integrity data in ublk. The ublk feature is referred to as "integrity" rather than "metadata" to match the block layer's name for it and to avoid confusion with the existing and unrelated UBLK_IO_F_META.
To advertise support for integrity data, a ublk server fills out the struct ublk_params's integrity field and sets UBLK_PARAM_TYPE_INTEGRITY. The struct ublk_param_integrity flags and csum_type fields use the existing LBMD_PI_* constants from the linux/fs.h UAPI header. The ublk driver fills out a corresponding struct blk_integrity.
When a request with integrity data is issued to the ublk device, the ublk driver sets UBLK_IO_F_INTEGRITY in struct ublksrv_io_desc's op_flags field. This is necessary for a ublk server for which bi_offload_capable() returns true to distinguish requests with integrity data from those without.
Integrity data transfers can currently only be performed via the ublk user copy mechanism. The overhead of zero-copy buffer registration makes it less appealing for the small transfers typical of integrity data. Additionally, neither io_uring NVMe passthru nor IORING_RW_ATTR_FLAG_PI currently allow an io_uring registered buffer for the integrity data. The ki_pos field of the struct kiocb passed to the user copy ->{read,write}_iter() callback gains a bit UBLKSRV_IO_INTEGRITY_FLAG for a ublk server to indicate whether to access the request's data or integrity data.
Not yet supported is an analogue for the IO_INTEGRITY_CHK_*/BIP_CHECK_* flags to ask the ublk server to verify the guard, reftag, and/or apptag of a request's protection information. The user copy mechanism currently forbids a ublk server from reading the data/integrity buffer of a read-direction request. We could potentially relax this restriction for integrity data on reads. Alternatively, the ublk driver could verify the requested fields as part of the user copy operation.
v4:
- Add max_integrity_segments to struct ublk_param_integrity (Ming)
- Move UBLKSRV_IO_INTEGRITY_FLAG to avoid overflow from
QID + UBLKSRV_IO_BUF_OFFSET (Ming)
- Check UBLK_F_INTEGRITY when UBLKSRV_IO_INTEGRITY_FLAG is used (Ming)
- Initialize integrity backing file to disable integrity checks (Ming)
v3:
- Drop support for communicating BIP_CHECK_* for now until the interface is decided
- Add Reviewed-by tags
v2:
- Communicate BIP_CHECK_* flags and expected reftag seed and app tag to ublk server
- Add UBLK_F_INTEGRITY feature flag (Ming)
- Don't change the definition of UBLKSRV_IO_BUF_TOTAL_BITS (Ming)
- Drop patches already applied
- Add Reviewed-by tags
Caleb Sander Mateos (16):
blk-integrity: take const pointer in blk_integrity_rq()
ublk: move ublk flag check functions earlier
ublk: set UBLK_IO_F_INTEGRITY in ublksrv_io_desc
ublk: split out ublk_copy_user_bvec() helper
ublk: split out ublk_user_copy() helper
ublk: inline ublk_check_and_get_req() into ublk_user_copy()
ublk: move offset check out of __ublk_check_and_get_req()
ublk: optimize ublk_user_copy() on daemon task
selftests: ublk: display UBLK_F_INTEGRITY support
selftests: ublk: add utility to get block device metadata size
selftests: ublk: add kublk support for integrity params
selftests: ublk: implement integrity user copy in kublk
selftests: ublk: support non-O_DIRECT backing files
selftests: ublk: add integrity data support to loop target
selftests: ublk: add integrity params test
selftests: ublk: add end-to-end integrity test
Stanley Zhang (3):
ublk: support UBLK_PARAM_TYPE_INTEGRITY in device creation
ublk: implement integrity user copy
ublk: support UBLK_F_INTEGRITY
drivers/block/ublk_drv.c | 358 +++++++++++++------ include/linux/blk-integrity.h | 6 +- include/uapi/linux/ublk_cmd.h | 25 ++ tools/testing/selftests/ublk/Makefile | 7 +- tools/testing/selftests/ublk/common.c | 4 +- tools/testing/selftests/ublk/fault_inject.c | 1 + tools/testing/selftests/ublk/file_backed.c | 90 ++++- tools/testing/selftests/ublk/kublk.c | 90 ++++- tools/testing/selftests/ublk/kublk.h | 37 +- tools/testing/selftests/ublk/metadata_size.c | 36 ++ tools/testing/selftests/ublk/null.c | 1 + tools/testing/selftests/ublk/stripe.c | 6 +- tools/testing/selftests/ublk/test_common.sh | 10 + tools/testing/selftests/ublk/test_loop_08.sh | 111 ++++++ tools/testing/selftests/ublk/test_null_04.sh | 166 +++++++++ 15 files changed, 817 insertions(+), 131 deletions(-) create mode 100644 tools/testing/selftests/ublk/metadata_size.c create mode 100755 tools/testing/selftests/ublk/test_loop_08.sh create mode 100755 tools/testing/selftests/ublk/test_null_04.sh
Signature · 1 line
2.45.2
PATCH v4 1/19 blk-integrity: take const pointer in blk_integrity_rq()
blk_integrity_rq() doesn't modify the struct request passed in, so allow a const pointer to be passed. Use a matching signature for the !CONFIG_BLK_DEV_INTEGRITY version.
--- include/linux/blk-integrity.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
include/linux/blk-integrity.h +3 -3
@@ -89,11 +89,11 @@ static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi, unsigned int sectors) {return bio_integrity_intervals (bi, sectors) * bi->metadata_size; } -static inline bool blk_integrity_rq (struct request *rq) +static inline bool blk_integrity_rq (const struct request *rq) {return rq->cmd_flags &REQ_INTEGRITY ; }/*
@@ -166,13 +166,13 @@ static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,static inline unsigned int bio_integrity_bytes (struct blk_integrity *bi,unsigned int sectors) {return 0 ; } -static inline int blk_integrity_rq (struct request *rq) +static inline bool blk_integrity_rq (const struct request *rq) { -return 0 ; +return false; }static inline struct bio_vec rq_integrity_vec (struct request *rq) {/* the optimizer will remove all calls to this function */
Signature · 1 line
2.45.2
PATCH v4 2/19 ublk: move ublk flag check functions earlier
In reply to Caleb Sander Mateosublk_dev_support_user_copy() will be used in ublk_validate_params(). Move these functions next to ublk_{dev,queue}_is_zoned() to avoid needing to forward-declare them.
--- drivers/block/ublk_drv.c | 60 ++++++++++++++++++++-------------------- 1 file changed, 30 insertions(+), 30 deletions(-)
drivers/block/ublk_drv.c +30 -30
@@ -273,10 +273,40 @@ static inline struct ublksrv_io_desc * ublk_get_iod(const struct ublk_queue *ubq, unsigned tag) {return &ubq->io_cmd_buf[tag]; } +static inline bool ublk_support_zero_copy (const struct ublk_queue *ubq) +{ +return ubq->flags &UBLK_F_SUPPORT_ZERO_COPY ; +} + +static inline bool ublk_dev_support_zero_copy (const struct ublk_device *ub) +{ +return ub->dev_info.flags &UBLK_F_SUPPORT_ZERO_COPY ; +} + +static inline bool ublk_support_auto_buf_reg (const struct ublk_queue *ubq) +{ +return ubq->flags &UBLK_F_AUTO_BUF_REG ; +} + +static inline bool ublk_dev_support_auto_buf_reg (const struct ublk_device *ub) +{ +return ub->dev_info.flags &UBLK_F_AUTO_BUF_REG ; +} + +static inline bool ublk_support_user_copy (const struct ublk_queue *ubq) +{ +return ubq->flags &UBLK_F_USER_COPY ; +} + +static inline bool ublk_dev_support_user_copy (const struct ublk_device *ub) +{ +return ub->dev_info.flags &UBLK_F_USER_COPY ; +} +static inline bool ublk_dev_is_zoned (const struct ublk_device *ub) {return ub->dev_info.flags &UBLK_F_ZONED ; }
@@ -671,40 +701,10 @@ static void ublk_apply_params(struct ublk_device *ub)if (ub->params.types &UBLK_PARAM_TYPE_ZONED )ublk_dev_param_zoned_apply (ub); } -static inline bool ublk_support_zero_copy (const struct ublk_queue *ubq) -{ -return ubq->flags &UBLK_F_SUPPORT_ZERO_COPY ; -} - -static inline bool ublk_dev_support_zero_copy (const struct ublk_device *ub) -{ -return ub->dev_info.flags &UBLK_F_SUPPORT_ZERO_COPY ; -} - -static inline bool ublk_support_auto_buf_reg (const struct ublk_queue *ubq) -{ -return ubq->flags &UBLK_F_AUTO_BUF_REG ; -} - -static inline bool ublk_dev_support_auto_buf_reg (const struct ublk_device *ub) -{ -return ub->dev_info.flags &UBLK_F_AUTO_BUF_REG ; -} - -static inline bool ublk_support_user_copy (const struct ublk_queue *ubq) -{ -return ubq->flags &UBLK_F_USER_COPY ; -} - -static inline bool ublk_dev_support_user_copy (const struct ublk_device *ub) -{ -return ub->dev_info.flags &UBLK_F_USER_COPY ; -} -static inline bool ublk_need_map_io (const struct ublk_queue *ubq) {return !ublk_support_user_copy (ubq) && !ublk_support_zero_copy (ubq) && !ublk_support_auto_buf_reg (ubq); }
Signature · 1 line
2.45.2
PATCH v4 3/19 ublk: support UBLK_PARAM_TYPE_INTEGRITY in device creation
In reply to Caleb Sander MateosFrom: Stanley Zhang <[email protected]>
Add a feature flag UBLK_F_INTEGRITY for a ublk server to request integrity/metadata support when creating a ublk device. The ublk server can also check for the feature flag on the created device or the result of UBLK_U_CMD_GET_FEATURES to tell if the ublk driver supports it. UBLK_F_INTEGRITY requires UBLK_F_USER_COPY, as user copy is the only data copy mode initially supported for integrity data.
Add UBLK_PARAM_TYPE_INTEGRITY and struct ublk_param_integrity to struct ublk_params to specify the integrity params of a ublk device. UBLK_PARAM_TYPE_INTEGRITY requires UBLK_F_INTEGRITY and a nonzero metadata_size. The LBMD_PI_CAP_* and LBMD_PI_CSUM_* values from the linux/fs.h UAPI header are used for the flags and csum_type fields. If the UBLK_PARAM_TYPE_INTEGRITY flag is set, validate the integrity parameters and apply them to the blk_integrity limits.
The struct ublk_param_integrity validations are based on the checks in blk_validate_integrity_limits(). Any invalid parameters should be rejected before being applied to struct blk_integrity.
[csander: drop redundant pi_tuple_size field, use block metadata UAPI
constants, add param validation]
--- drivers/block/ublk_drv.c | 101 +++++++++++++++++++++++++++++++++- include/uapi/linux/ublk_cmd.h | 19 +++++++ 2 files changed, 119 insertions(+), 1 deletion(-)
drivers/block/ublk_drv.c +100 -1
@@ -42,10 +42,12 @@#include <linux/mm.h> #include <asm/page.h> #include <linux/task_work.h> #include <linux/namei.h> #include <linux/kref.h> +#include <linux/blk-integrity.h> +#include <uapi/linux/fs.h> #include <uapi/linux/ublk_cmd.h> #define UBLK_MINORS (1U << MINORBITS)#define UBLK_INVALID_BUF_IDX ((u16)-1)
@@ -81,11 +83,12 @@/* All UBLK_PARAM_TYPE_* should be included here */ #define UBLK_PARAM_TYPE_ALL \ (UBLK_PARAM_TYPE_BASIC | UBLK_PARAM_TYPE_DISCARD | \ UBLK_PARAM_TYPE_DEVT | UBLK_PARAM_TYPE_ZONED | \ - UBLK_PARAM_TYPE_DMA_ALIGN | UBLK_PARAM_TYPE_SEGMENT) + UBLK_PARAM_TYPE_DMA_ALIGN | UBLK_PARAM_TYPE_SEGMENT | \ + UBLK_PARAM_TYPE_INTEGRITY)struct ublk_uring_cmd_pdu {/* * Store requests in same batch temporarily for queuing them to * daemon context.
@@ -313,10 +316,15 @@ static inline bool ublk_dev_is_zoned(const struct ublk_device *ub)static inline bool ublk_queue_is_zoned (const struct ublk_queue *ubq) {return ubq->flags &UBLK_F_ZONED ; } +static inline bool ublk_dev_support_integrity (const struct ublk_device *ub) +{ +return ub->dev_info.flags &UBLK_F_INTEGRITY ; +} + #ifdef CONFIG_BLK_DEV_ZONED struct ublk_zoned_report_desc { __u64 sector; __u32 operation;
@@ -628,10 +636,57 @@ static void ublk_dev_param_basic_apply(struct ublk_device *ub)set_disk_ro (ub->ub_disk, true);set_capacity (ub->ub_disk, p->dev_sectors); } +static int ublk_integrity_flags (u32 flags) +{ +int ret_flags =0 ; + +if (flags &LBMD_PI_CAP_INTEGRITY ) { + flags &= ~LBMD_PI_CAP_INTEGRITY ; + ret_flags |=BLK_INTEGRITY_DEVICE_CAPABLE ; + } +if (flags &LBMD_PI_CAP_REFTAG ) { + flags &= ~LBMD_PI_CAP_REFTAG ; + ret_flags |=BLK_INTEGRITY_REF_TAG ; + } +return flags ? -EINVAL : ret_flags; +} + +static int ublk_integrity_pi_tuple_size (u8 csum_type) +{ +switch (csum_type) { +case LBMD_PI_CSUM_NONE : +return 0 ; +case LBMD_PI_CSUM_IP : +case LBMD_PI_CSUM_CRC16_T10DIF : +return 8 ; +case LBMD_PI_CSUM_CRC64_NVME : +return 16 ; +default : +return -EINVAL ; + } +} + +static enum blk_integrity_checksum ublk_integrity_csum_type (u8 csum_type) +{ +switch (csum_type) { +case LBMD_PI_CSUM_NONE : +return BLK_INTEGRITY_CSUM_NONE ; +case LBMD_PI_CSUM_IP : +return BLK_INTEGRITY_CSUM_IP ; +case LBMD_PI_CSUM_CRC16_T10DIF : +return BLK_INTEGRITY_CSUM_CRC ; +case LBMD_PI_CSUM_CRC64_NVME : +return BLK_INTEGRITY_CSUM_CRC64 ; +default : +WARN_ON_ONCE (1 ); +return BLK_INTEGRITY_CSUM_NONE ; + } +} +static int ublk_validate_params (const struct ublk_device *ub) {/* basic param is the only one which must be set */ if (ub->params.types &UBLK_PARAM_TYPE_BASIC ) {const struct ublk_param_basic *p = &ub->params.basic;
@@ -690,10 +745,33 @@ static int ublk_validate_params(const struct ublk_device *ub)return -EINVAL ;if (p->max_segment_size <UBLK_MIN_SEGMENT_SIZE )return -EINVAL ; } +if (ub->params.types &UBLK_PARAM_TYPE_INTEGRITY ) { +const struct ublk_param_integrity *p = &ub->params.integrity; +int pi_tuple_size =ublk_integrity_pi_tuple_size (p->csum_type); +int flags =ublk_integrity_flags (p->flags); + +if (!ublk_dev_support_integrity (ub)) +return -EINVAL ; +if (flags <0 ) +return flags; +if (pi_tuple_size <0 ) +return pi_tuple_size; +if (!p->metadata_size) +return -EINVAL ; +if (p->csum_type ==LBMD_PI_CSUM_NONE && + p->flags &LBMD_PI_CAP_REFTAG ) +return -EINVAL ; +if (p->pi_offset + pi_tuple_size > p->metadata_size) +return -EINVAL ; +if (p->interval_exp <SECTOR_SHIFT || + p->interval_exp > ub->params.basic.logical_bs_shift) +return -EINVAL ; + } +return 0 ; }static void ublk_apply_params (struct ublk_device *ub) {
@@ -2941,10 +3019,27 @@ static int ublk_ctrl_start_dev(struct ublk_device *ub, lim.seg_boundary_mask = ub->params.seg.seg_boundary_mask; lim.max_segment_size = ub->params.seg.max_segment_size; lim.max_segments = ub->params.seg.max_segments; } +if (ub->params.types &UBLK_PARAM_TYPE_INTEGRITY ) { +const struct ublk_param_integrity *p = &ub->params.integrity; +int pi_tuple_size =ublk_integrity_pi_tuple_size (p->csum_type); + + lim.max_integrity_segments = + p->max_integrity_segments ?:USHRT_MAX ; + lim.integrity = (struct blk_integrity ) { + .flags =ublk_integrity_flags (p->flags), + .csum_type =ublk_integrity_csum_type (p->csum_type), + .metadata_size = p->metadata_size, + .pi_offset = p->pi_offset, + .interval_exp = p->interval_exp, + .tag_size = p->tag_size, + .pi_tuple_size = pi_tuple_size, + }; + } +if (wait_for_completion_interruptible (&ub->completion) !=0 )return -EINTR ;if (ub->ublksrv_tgid != ublksrv_pid)return -EINVAL ;
@@ -3131,10 +3226,14 @@ static int ublk_ctrl_add_dev(const struct ublksrv_ctrl_cmd *header)if (info.flags & (UBLK_F_USER_COPY |UBLK_F_SUPPORT_ZERO_COPY |UBLK_F_AUTO_BUF_REG ))return -EINVAL ; } +/* User copy is required to access integrity buffer */ +if (info.flags &UBLK_F_INTEGRITY && !(info.flags &UBLK_F_USER_COPY )) +return -EINVAL ; +/* the created device is always owned by current user */ ublk_store_owner_uid_gid (&info.owner_uid, &info.owner_gid);if (header->dev_id != info.dev_id) { pr_warn("%s: dev id not match %u %u\n",
include/uapi/linux/ublk_cmd.h +19 -0
@@ -309,10 +309,16 @@* the I/O's daemon task. The q_id and tag of the registered buffer are required * in UBLK_U_IO_UNREGISTER_IO_BUF's ublksrv_io_cmd. */ #define UBLK_F_BUF_REG_OFF_DAEMON (1ULL << 14) +/* +* ublk device supports requests with integrity/metadata buffer. +* Requires UBLK_F_USER_COPY. +*/ +#define UBLK_F_INTEGRITY (1ULL << 16) +/* device state */ #define UBLK_S_DEV_DEAD 0#define UBLK_S_DEV_LIVE 1#define UBLK_S_DEV_QUIESCED 2#define UBLK_S_DEV_FAIL_IO 3
@@ -598,10 +604,21 @@ struct ublk_param_segment {__u32 max_segment_size;__u16 max_segments;__u8 pad[2 ]; }; +struct ublk_param_integrity { +__u32 flags;/* LBMD_PI_CAP_* from linux/fs.h */ +__u16 max_integrity_segments;/* 0 means no limit */ +__u8 interval_exp; +__u8 metadata_size;/* UBLK_PARAM_TYPE_INTEGRITY requires nonzero */ +__u8 pi_offset; +__u8 csum_type;/* LBMD_PI_CSUM_* from linux/fs.h */ +__u8 tag_size; +__u8 pad[5 ]; +}; +struct ublk_params {/* * Total length of parameters, userspace has to set 'len' for both * SET_PARAMS and GET_PARAMS command, and driver may update len * if two sides use different version of 'ublk_params', same with
@@ -612,16 +629,18 @@ struct ublk_params {#define UBLK_PARAM_TYPE_DISCARD (1 << 1)#define UBLK_PARAM_TYPE_DEVT (1 << 2)#define UBLK_PARAM_TYPE_ZONED (1 << 3)#define UBLK_PARAM_TYPE_DMA_ALIGN (1 << 4)#define UBLK_PARAM_TYPE_SEGMENT (1 << 5) +#define UBLK_PARAM_TYPE_INTEGRITY (1 << 6)/* requires UBLK_F_INTEGRITY */ __u32 types;/* types of parameter included */ struct ublk_param_basic basic;struct ublk_param_discard discard;struct ublk_param_devt devt;struct ublk_param_zoned zoned;struct ublk_param_dma_align dma;struct ublk_param_segment seg; + struct ublk_param_integrity integrity; };#endif
Signature · 1 line
2.45.2
Re: [PATCH v4 03/19] ublk: support UBLK_PARAM_TYPE_INTEGRITY in device creation
Quoted 19 lines · Caleb Sander Mateos
From: Stanley Zhang <[email protected]>
Add a feature flag
UBLK_F_INTEGRITYfor a ublk server to request integrity/metadata support when creating a ublk device. The ublk server can also check for the feature flag on the created device or the result ofUBLK_U_CMD_GET_FEATURESto tell if the ublk driver supports it.UBLK_F_INTEGRITYrequiresUBLK_F_USER_COPY, as user copy is the only data copy mode initially supported for integrity data.
AddUBLK_PARAM_TYPE_INTEGRITYand structublk_param_integrityto structublk_paramsto specify the integrity params of a ublk device.UBLK_PARAM_TYPE_INTEGRITYrequiresUBLK_F_INTEGRITYand a nonzerometadata_size. The LBMD_PI_CAP_* and LBMD_PI_CSUM_* values from thelinux/fs.hUAPI header are used for the flags andcsum_typefields. If theUBLK_PARAM_TYPE_INTEGRITYflag is set, validate the integrity parameters and apply them to theblk_integritylimits.
The structublk_param_integrityvalidations are based on the checks inblk_validate_integrity_limits(). Any invalid parameters should be rejected before being applied to structblk_integrity.
Quoted 4 lines
Signed-off-by Stanley Zhang <[email protected]>[csander: drop redundant
pi_tuple_sizefield, use block metadata UAPI
constants, add param validation]Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks,
Ming
PATCH v4 4/19 ublk: set UBLK_IO_F_INTEGRITY in ublksrv_io_desc
In reply to Caleb Sander MateosIndicate to the ublk server when an incoming request has integrity data by setting UBLK_IO_F_INTEGRITY in the ublksrv_io_desc's op_flags field.
--- drivers/block/ublk_drv.c | 3 +++ include/uapi/linux/ublk_cmd.h | 2 ++ 2 files changed, 5 insertions(+)
drivers/block/ublk_drv.c +3 -0
@@ -1125,10 +1125,13 @@ static inline unsigned int ublk_req_build_flags(struct request *req) flags |=UBLK_IO_F_NOUNMAP ;if (req->cmd_flags &REQ_SWAP ) flags |=UBLK_IO_F_SWAP ; +if (blk_integrity_rq (req)) + flags |=UBLK_IO_F_INTEGRITY ; +return flags; }static blk_status_t ublk_setup_iod (struct ublk_queue *ubq,struct request *req) {
include/uapi/linux/ublk_cmd.h +2 -0
@@ -412,10 +412,12 @@ struct ublksrv_ctrl_dev_info {* * ublk server has to check this flag if UBLK_AUTO_BUF_REG_FALLBACK is * passed in. */ #define UBLK_IO_F_NEED_REG_BUF (1U << 17) +/* Request has an integrity data buffer */ +#define UBLK_IO_F_INTEGRITY (1UL << 18)/* * io cmd is described by this structure, and stored in share memory, indexed * by request tag. *
Signature · 1 line
2.45.2
PATCH v4 5/19 ublk: split out ublk_copy_user_bvec() helper
In reply to Caleb Sander MateosFactor a helper function ublk_copy_user_bvec() out of ublk_copy_user_pages(). It will be used for copying integrity data too.
--- drivers/block/ublk_drv.c | 52 +++++++++++++++++++++++----------------- 1 file changed, 30 insertions(+), 22 deletions(-)
drivers/block/ublk_drv.c +30 -22
@@ -1005,10 +1005,39 @@ static const struct block_device_operations ub_fops = { .open = ublk_open, .free_disk = ublk_free_disk, .report_zones = ublk_report_zones, }; +static bool ublk_copy_user_bvec (const struct bio_vec *bv,unsigned *offset, +struct iov_iter *uiter,int dir,size_t *done) +{ +unsigned len; +void *bv_buf; +size_t copied; + +if (*offset >= bv->bv_len) { + *offset -= bv->bv_len; +return true; + } + + len = bv->bv_len - *offset; + bv_buf =kmap_local_page (bv->bv_page) + bv->bv_offset + *offset; +if (dir ==ITER_DEST ) + copied =copy_to_iter (bv_buf, len, uiter); +else + copied =copy_from_iter (bv_buf, len, uiter); + +kunmap_local (bv_buf); + + *done += copied; +if (copied < len) +return false; + + *offset =0 ; +return true; +} +/* * Copy data between request pages and io_iter, and 'offset' * is the start point of linear offset of request. */ static size_t ublk_copy_user_pages(const struct request *req,
@@ -1017,33 +1046,12 @@ static size_t ublk_copy_user_pages(const struct request *req,struct req_iterator iter;struct bio_vec bv;size_t done =0 ;rq_for_each_segment (bv, req, iter) { -unsigned len; -void *bv_buf; -size_t copied; - -if (offset >= bv.bv_len) { - offset -= bv.bv_len; -continue ; - } - - len = bv.bv_len - offset; - bv_buf =kmap_local_page (bv.bv_page) + bv.bv_offset + offset; -if (dir ==ITER_DEST ) - copied =copy_to_iter (bv_buf, len, uiter); -else - copied =copy_from_iter (bv_buf, len, uiter); - -kunmap_local (bv_buf); - - done += copied; -if (copied < len) +if (!ublk_copy_user_bvec (&bv, &offset, uiter, dir, &done))break ; - - offset =0 ; }return done; }static inline bool ublk_need_map_req (const struct request *req)
Signature · 1 line
2.45.2
PATCH v4 6/19 ublk: split out ublk_user_copy() helper
In reply to Caleb Sander Mateosublk_ch_read_iter() and ublk_ch_write_iter() are nearly identical except for the iter direction. Split out a helper function ublk_user_copy() to reduce the code duplication as these functions are about to get larger.
--- drivers/block/ublk_drv.c | 26 ++++++++++---------------- 1 file changed, 10 insertions(+), 16 deletions(-)
drivers/block/ublk_drv.c +10 -16
@@ -2700,42 +2700,36 @@ static struct request *ublk_check_and_get_req(struct kiocb *iocb, fail:ublk_put_req_ref (*io, req);return ERR_PTR (-EACCES ); } -static ssize_t ublk_ch_read_iter (struct kiocb *iocb,struct iov_iter *to) +static ssize_t +ublk_user_copy (struct kiocb *iocb,struct iov_iter *iter,int dir) {struct request *req;struct ublk_io *io;size_t buf_off;size_t ret; - req =ublk_check_and_get_req (iocb, to, &buf_off,ITER_DEST , &io); + req =ublk_check_and_get_req (iocb, iter, &buf_off, dir, &io);if (IS_ERR (req))return PTR_ERR (req); - ret =ublk_copy_user_pages (req, buf_off, to,ITER_DEST ); + ret =ublk_copy_user_pages (req, buf_off, iter, dir);ublk_put_req_ref (io, req);return ret; } -static ssize_t ublk_ch_write_iter (struct kiocb *iocb,struct iov_iter *from) +static ssize_t ublk_ch_read_iter (struct kiocb *iocb,struct iov_iter *to) { -struct request *req; -struct ublk_io *io; -size_t buf_off; -size_t ret; - - req =ublk_check_and_get_req (iocb, from, &buf_off,ITER_SOURCE , &io); -if (IS_ERR (req)) -return PTR_ERR (req); - - ret =ublk_copy_user_pages (req, buf_off, from,ITER_SOURCE ); -ublk_put_req_ref (io, req); +return ublk_user_copy (iocb, to,ITER_DEST ); +} -return ret; +static ssize_t ublk_ch_write_iter (struct kiocb *iocb,struct iov_iter *from) +{ +return ublk_user_copy (iocb, from,ITER_SOURCE ); }static const struct file_operations ublk_ch_fops = { .owner =THIS_MODULE , .open = ublk_ch_open,
Signature · 1 line
2.45.2
PATCH v4 7/19 ublk: inline ublk_check_and_get_req() into ublk_user_copy()
In reply to Caleb Sander Mateosublk_check_and_get_req() has a single callsite in ublk_user_copy(). It takes a ton of arguments in order to pass local variables from ublk_user_copy() to ublk_check_and_get_req() and vice versa. And more are about to be added. Combine the functions to reduce the argument passing noise.
--- drivers/block/ublk_drv.c | 51 ++++++++++++++-------------------------- 1 file changed, 18 insertions(+), 33 deletions(-)
drivers/block/ublk_drv.c +18 -33
@@ -2655,70 +2655,55 @@ static inline bool ublk_check_ubuf_dir(const struct request *req,return true;return false; } -static struct request *ublk_check_and_get_req (struct kiocb *iocb, -struct iov_iter *iter,size_t *off,int dir, -struct ublk_io **io) +static ssize_t +ublk_user_copy (struct kiocb *iocb,struct iov_iter *iter,int dir) {struct ublk_device *ub = iocb->ki_filp->private_data;struct ublk_queue *ubq;struct request *req; +struct ublk_io *io;size_t buf_off;u16 tag, q_id; +ssize_t ret;if (!user_backed_iter (iter)) -return ERR_PTR (-EACCES ); +return -EACCES ;if (ub->dev_info.state ==UBLK_S_DEV_DEAD ) -return ERR_PTR (-EACCES ); +return -EACCES ; tag =ublk_pos_to_tag (iocb->ki_pos); q_id =ublk_pos_to_hwq (iocb->ki_pos); buf_off =ublk_pos_to_buf_off (iocb->ki_pos);if (q_id >= ub->dev_info.nr_hw_queues) -return ERR_PTR (-EINVAL ); +return -EINVAL ; ubq =ublk_get_queue (ub, q_id);if (!ublk_dev_support_user_copy (ub)) -return ERR_PTR (-EACCES ); +return -EACCES ;if (tag >= ub->dev_info.queue_depth) -return ERR_PTR (-EINVAL ); +return -EINVAL ; - *io = &ubq->ios[tag]; - req =__ublk_check_and_get_req (ub, q_id, tag, *io, buf_off); + io = &ubq->ios[tag]; + req =__ublk_check_and_get_req (ub, q_id, tag, io, buf_off);if (!req) -return ERR_PTR (-EINVAL ); - -if (!ublk_check_ubuf_dir (req, dir)) - goto fail; - - *off = buf_off; -return req; -fail: -ublk_put_req_ref (*io, req); -return ERR_PTR (-EACCES ); -} - -static ssize_t -ublk_user_copy (struct kiocb *iocb,struct iov_iter *iter,int dir) -{ -struct request *req; -struct ublk_io *io; -size_t buf_off; -size_t ret; +return -EINVAL ; - req =ublk_check_and_get_req (iocb, iter, &buf_off, dir, &io); -if (IS_ERR (req)) -return PTR_ERR (req); +if (!ublk_check_ubuf_dir (req, dir)) { + ret = -EACCES ; + goto out; + } ret =ublk_copy_user_pages (req, buf_off, iter, dir); -ublk_put_req_ref (io, req); +out: +ublk_put_req_ref (io, req);return ret; }static ssize_t ublk_ch_read_iter (struct kiocb *iocb,struct iov_iter *to) {
Signature · 1 line
2.45.2
PATCH v4 8/19 ublk: move offset check out of __ublk_check_and_get_req()
In reply to Caleb Sander Mateos__ublk_check_and_get_req() checks that the passed in offset is within the data length of the specified ublk request. However, only user copy (ublk_check_and_get_req()) supports accessing ublk request data at a nonzero offset. Zero-copy buffer registration (ublk_register_io_buf()) always passes 0 for the offset, so the check is unnecessary. Move the check from __ublk_check_and_get_req() to ublk_check_and_get_req().
--- drivers/block/ublk_drv.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)
drivers/block/ublk_drv.c +9 -7
@@ -253,11 +253,11 @@ struct ublk_params_header {static void ublk_io_release (void *priv);static void ublk_stop_dev_unlocked (struct ublk_device *ub);static void ublk_abort_queue (struct ublk_device *ub,struct ublk_queue *ubq);static inline struct request *__ublk_check_and_get_req (struct ublk_device *ub, -u16 q_id,u16 tag,struct ublk_io *io,size_t offset); +u16 q_id,u16 tag,struct ublk_io *io);static inline unsigned int ublk_req_build_flags (struct request *req);static void ublk_partition_scan_work (struct work_struct *work) { struct ublk_device *ub =
@@ -2288,11 +2288,11 @@ static int ublk_register_io_buf(struct io_uring_cmd *cmd,int ret;if (!ublk_dev_support_zero_copy (ub))return -EINVAL ; - req =__ublk_check_and_get_req (ub, q_id, tag, io,0 ); + req =__ublk_check_and_get_req (ub, q_id, tag, io);if (!req)return -EINVAL ; ret =io_buffer_register_bvec (cmd, req, ublk_io_release, index, issue_flags);
@@ -2582,11 +2582,11 @@ static int ublk_ch_uring_cmd_local(struct io_uring_cmd *cmd, __func__, cmd_op, tag, ret, io ? io->flags : 0);return ret; }static inline struct request *__ublk_check_and_get_req (struct ublk_device *ub, -u16 q_id,u16 tag,struct ublk_io *io,size_t offset) +u16 q_id,u16 tag,struct ublk_io *io) {struct request *req;/* * can't use io->req in case of concurrent UBLK_IO_COMMIT_AND_FETCH_REQ,
@@ -2603,13 +2603,10 @@ static inline struct request *__ublk_check_and_get_req(struct ublk_device *ub, goto fail_put;if (!ublk_rq_has_data (req)) goto fail_put; -if (offset >blk_rq_bytes (req)) - goto fail_put; -return req; fail_put:ublk_put_req_ref (io, req);return NULL ; }
@@ -2687,14 +2684,19 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir)if (tag >= ub->dev_info.queue_depth)return -EINVAL ; io = &ubq->ios[tag]; - req =__ublk_check_and_get_req (ub, q_id, tag, io, buf_off); + req =__ublk_check_and_get_req (ub, q_id, tag, io);if (!req)return -EINVAL ; +if (buf_off >blk_rq_bytes (req)) { + ret = -EINVAL ; + goto out; + } +if (!ublk_check_ubuf_dir (req, dir)) { ret = -EACCES ; goto out; }
Signature · 1 line
2.45.2
Re: [PATCH v4 08/19] ublk: move offset check out of __ublk_check_and_get_req()
Quoted 19 lines · Caleb Sander Mateos
__ublk_check_and_get_req()checks that the passed in offset is within the data length of the specified ublk request. However, only user copy (ublk_check_and_get_req()) supports accessing ublk request data at a nonzero offset. Zero-copy buffer registration (ublk_register_io_buf()) always passes 0 for the offset, so the check is unnecessary. Move the check from__ublk_check_and_get_req()toublk_check_and_get_req().Signed-off-by Caleb Sander Mateos <[email protected]>Reviewed-by Ming Lei <[email protected]>--- drivers/block/ublk_drv.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)drivers/block/ublk_drv.c +0
-0@@ -253,11 +253,11 @@ struct ublk_params_header {
[snip]
Quoted 20 lines
drivers/block/ublk_drv.c +0
-3@@ -2603,13 +2603,10 @@ static inline struct request *__ublk_check_and_get_req(struct ublk_device *ub, goto fail_put;if (!ublk_rq_has_data (req)) goto fail_put; -if (offset >blk_rq_bytes (req)) - goto fail_put; -return req; fail_put:ublk_put_req_ref (io, req);return NULL ; }@@ -2687,14 +2684,19 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir)if (tag >= ub->dev_info.queue_depth)return -EINVAL ; io = &ubq->ios[tag];
drivers/block/ublk_drv.c ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir) · line 2697
Quoted 10 lines
drivers/block/ublk_drv.c +6
-1- req =__ublk_check_and_get_req (ub, q_id, tag, io, buf_off); + req =__ublk_check_and_get_req (ub, q_id, tag, io);if (!req)return -EINVAL ; +if (buf_off >blk_rq_bytes (req)) { + ret = -EINVAL ; + goto out; + } +
Offset is zero based, bytes are count so it should be >= here.
It will work this way but for buf_off == blk_rq_bytes(req) user will get 0 instead of EINVAL.
static size_t ublk_copy_user_pages(const struct request *req,
unsigned offset, struct iov_iter *uiter, int dir)
{
size_t done = 0;
...
rq_for_each_segment(bv, req, iter) {...
if (offset >= bv.bv_len) {
offset -= bv.bv_len; // bv_len is same asblk_rq_bytes(req)
continue; // this breaks the loop when ==
}
...
}
return done; // done is never incremented
}Quoted 4 lines
drivers/block/ublk_drv.c +0
-0if (!ublk_check_ubuf_dir (req, dir)) { ret = -EACCES ; goto out; }
Signature · 2 lines
have fun, alex
Re: [PATCH v4 08/19] ublk: move offset check out of __ublk_check_and_get_req()
Quoted 57 lines · Alexander Atanasov
Quoted 19 lines · Caleb Sander Mateos
__ublk_check_and_get_req()checks that the passed in offset is within the data length of the specified ublk request. However, only user copy (ublk_check_and_get_req()) supports accessing ublk request data at a nonzero offset. Zero-copy buffer registration (ublk_register_io_buf()) always passes 0 for the offset, so the check is unnecessary. Move the check from__ublk_check_and_get_req()toublk_check_and_get_req().Signed-off-by Caleb Sander Mateos <[email protected]>Reviewed-by Ming Lei <[email protected]>--- drivers/block/ublk_drv.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)drivers/block/ublk_drv.c +0
-0@@ -253,11 +253,11 @@ struct ublk_params_header {[snip]
Quoted 20 lines
drivers/block/ublk_drv.c +0
-3@@ -2603,13 +2603,10 @@ static inline struct request *__ublk_check_and_get_req(struct ublk_device *ub, goto fail_put;if (!ublk_rq_has_data (req)) goto fail_put; -if (offset >blk_rq_bytes (req)) - goto fail_put; -return req; fail_put:ublk_put_req_ref (io, req);return NULL ; }@@ -2687,14 +2684,19 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir)if (tag >= ub->dev_info.queue_depth)return -EINVAL ; io = &ubq->ios[tag];drivers/block/ublk_drv.c ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir) · line 2697
Quoted 10 lines
drivers/block/ublk_drv.c +6
-1- req =__ublk_check_and_get_req (ub, q_id, tag, io, buf_off); + req =__ublk_check_and_get_req (ub, q_id, tag, io);if (!req)return -EINVAL ; +if (buf_off >blk_rq_bytes (req)) { + ret = -EINVAL ; + goto out; + } +Offset is zero based, bytes are count so it should be >= here.
Quoted 2 lines
It will work this way but for
buf_off==blk_rq_bytes(req)user will get 0 instead of EINVAL.
This is the existing behavior in __ublk_check_and_get_req(). I agree allowing buf_off == blk_rq_bytes(req) seems odd, but changing it now could break ublk servers relying on the current behavior.
Best,
Caleb
Quoted 28 lines
static
size_tublk_copy_user_pages(const struct request *req,
unsigned offset, structiov_iter*uiter, int dir){ size_t done = 0; ... rq_for_each_segment(bv, req, iter) {...
if (offset >= bv.bv_len) {
offset -= bv.bv_len; //bv_lenis same asblk_rq_bytes(req)continue; // this breaks the loop when == }...
}
return done; // done is never incremented
}drivers/block/ublk_drv.c ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir) · line 2701
Quoted 4 lines
drivers/block/ublk_drv.c +0
-0if (!ublk_check_ubuf_dir (req, dir)) { ret = -EACCES ; goto out; }--
have fun,
alex
Re: [PATCH v4 08/19] ublk: move offset check out of __ublk_check_and_get_req()
Quoted 58 lines · Caleb Sander Mateos
Quoted 57 lines · Alexander Atanasov
Quoted 19 lines · Caleb Sander Mateos
__ublk_check_and_get_req()checks that the passed in offset is within the data length of the specified ublk request. However, only user copy (ublk_check_and_get_req()) supports accessing ublk request data at a nonzero offset. Zero-copy buffer registration (ublk_register_io_buf()) always passes 0 for the offset, so the check is unnecessary. Move the check from__ublk_check_and_get_req()toublk_check_and_get_req().Signed-off-by Caleb Sander Mateos <[email protected]>Reviewed-by Ming Lei <[email protected]>--- drivers/block/ublk_drv.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)drivers/block/ublk_drv.c +0
-0@@ -253,11 +253,11 @@ struct ublk_params_header {[snip]
Quoted 20 lines
drivers/block/ublk_drv.c +0
-3@@ -2603,13 +2603,10 @@ static inline struct request *__ublk_check_and_get_req(struct ublk_device *ub, goto fail_put;if (!ublk_rq_has_data (req)) goto fail_put; -if (offset >blk_rq_bytes (req)) - goto fail_put; -return req; fail_put:ublk_put_req_ref (io, req);return NULL ; }@@ -2687,14 +2684,19 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir)if (tag >= ub->dev_info.queue_depth)return -EINVAL ; io = &ubq->ios[tag];drivers/block/ublk_drv.c ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir) · line 2697
Quoted 10 lines
drivers/block/ublk_drv.c +6
-1- req =__ublk_check_and_get_req (ub, q_id, tag, io, buf_off); + req =__ublk_check_and_get_req (ub, q_id, tag, io);if (!req)return -EINVAL ; +if (buf_off >blk_rq_bytes (req)) { + ret = -EINVAL ; + goto out; + } +Offset is zero based, bytes are count so it should be >= here.
Quoted 6 lines
Quoted 2 lines
It will work this way but for
buf_off==blk_rq_bytes(req)user will get 0 instead of EINVAL.This is the existing behavior in
__ublk_check_and_get_req(). I agree allowingbuf_off==blk_rq_bytes(req)seems odd, but changing it now could break ublk servers relying on the current behavior.
I saw it came from the existing version but I doubt that any existing server rely on this. In general no code expects to get EOF from a block device. It is a user error, classic off by one, to give offset equal to the end. If the server have sane error handling it should either detect it has a bug and fix it, or does not care at all and work as expected.
The usual pattern is variation of:
while (left > 0) {
ret = read|write(buf+offset, ....);
if (ret < 0) goto err;
left -= ret;
offset += ret;
}This gets into a nice infinite loop, and I have actually hit this kind of bug in other unrelated code inside the kernel - I guess it is present in the original code this is based on.
For example there is/was a case in ext4 that initially returned 0 for a write in some edge case but that was changed to return a proper -EAGAIN later on iirc to avoid such confusion.
So, if it is not required to be like this by some standard, it might be worth considering to change.
Quoted 31 lines
Best,
CalebQuoted 28 lines
static
size_tublk_copy_user_pages(const struct request *req,
unsigned offset, structiov_iter*uiter, int dir){ size_t done = 0; ... rq_for_each_segment(bv, req, iter) {...
if (offset >= bv.bv_len) {
offset -= bv.bv_len; //bv_lenis same asblk_rq_bytes(req)continue; // this breaks the loop when == }...
}
return done; // done is never incremented
}drivers/block/ublk_drv.c ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir) · line 2701
Quoted 4 lines
drivers/block/ublk_drv.c +0
-0if (!ublk_check_ubuf_dir (req, dir)) { ret = -EACCES ; goto out; }--
have fun,
alex
Signature · 2 lines
have fun, alex
PATCH v4 9/19 ublk: implement integrity user copy
In reply to Caleb Sander MateosFrom: Stanley Zhang <[email protected]>
Add a function ublk_copy_user_integrity() to copy integrity information between a request and a user iov_iter. This mirrors the existing ublk_copy_user_pages() but operates on request integrity data instead of regular data. Check UBLKSRV_IO_INTEGRITY_FLAG in iocb->ki_pos in ublk_user_copy() to choose between copying data or integrity data.
[csander: change offset units from data bytes to integrity data bytes,
fix CONFIG_BLK_DEV_INTEGRITY=n build, rebase on user copy refactor]
--- drivers/block/ublk_drv.c | 53 +++++++++++++++++++++++++++++++++-- include/uapi/linux/ublk_cmd.h | 4 +++ 2 files changed, 55 insertions(+), 2 deletions(-)
drivers/block/ublk_drv.c +51 -2
@@ -1052,10 +1052,37 @@ static size_t ublk_copy_user_pages(const struct request *req,break ; }return done; } +#ifdef CONFIG_BLK_DEV_INTEGRITY +static size_t ublk_copy_user_integrity (const struct request *req, +unsigned offset,struct iov_iter *uiter,int dir) +{ +size_t done =0 ; +struct bio *bio = req->bio; +struct bvec_iter iter; +struct bio_vec iv; + +if (!blk_integrity_rq (req)) +return 0 ; + +bio_for_each_integrity_vec (iv, bio, iter) { +if (!ublk_copy_user_bvec (&iv, &offset, uiter, dir, &done)) +break ; + } + +return done; +} +#else /* #ifdef CONFIG_BLK_DEV_INTEGRITY */ +static size_t ublk_copy_user_integrity (const struct request *req, +unsigned offset,struct iov_iter *uiter,int dir) +{ +return 0 ; +} +#endif /* #ifdef CONFIG_BLK_DEV_INTEGRITY */ +static inline bool ublk_need_map_req (const struct request *req) {return ublk_rq_has_data (req) &&req_op (req) ==REQ_OP_WRITE ; }
@@ -2659,10 +2686,12 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir) {struct ublk_device *ub = iocb->ki_filp->private_data;struct ublk_queue *ubq;struct request *req;struct ublk_io *io; +unsigned data_len; +bool is_integrity;size_t buf_off;u16 tag, q_id;ssize_t ret;if (!user_backed_iter (iter))
@@ -2672,10 +2701,14 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir)return -EACCES ; tag =ublk_pos_to_tag (iocb->ki_pos); q_id =ublk_pos_to_hwq (iocb->ki_pos); buf_off =ublk_pos_to_buf_off (iocb->ki_pos); + is_integrity = !!(iocb->ki_pos &UBLKSRV_IO_INTEGRITY_FLAG ); + +if (unlikely (!ublk_dev_support_integrity (ub) && is_integrity)) +return -EINVAL ;if (q_id >= ub->dev_info.nr_hw_queues)return -EINVAL ; ubq =ublk_get_queue (ub, q_id);
@@ -2688,21 +2721,31 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir) io = &ubq->ios[tag]; req =__ublk_check_and_get_req (ub, q_id, tag, io);if (!req)return -EINVAL ; -if (buf_off >blk_rq_bytes (req)) { +if (is_integrity) { +struct blk_integrity *bi = &req->q->limits.integrity; + + data_len =bio_integrity_bytes (bi,blk_rq_sectors (req)); + }else { + data_len =blk_rq_bytes (req); + } +if (buf_off > data_len) { ret = -EINVAL ; goto out; }if (!ublk_check_ubuf_dir (req, dir)) { ret = -EACCES ; goto out; } - ret =ublk_copy_user_pages (req, buf_off, iter, dir); +if (is_integrity) + ret =ublk_copy_user_integrity (req, buf_off, iter, dir); +else + ret =ublk_copy_user_pages (req, buf_off, iter, dir); out:ublk_put_req_ref (io, req);return ret; }
@@ -3939,10 +3982,16 @@ static int __init ublk_init(void) {int ret;BUILD_BUG_ON ((u64 )UBLKSRV_IO_BUF_OFFSET +UBLKSRV_IO_BUF_TOTAL_SIZE <UBLKSRV_IO_BUF_OFFSET ); +/* +* Ensure UBLKSRV_IO_BUF_OFFSET + UBLKSRV_IO_BUF_TOTAL_SIZE +* doesn't overflow into UBLKSRV_IO_INTEGRITY_FLAG +*/ +BUILD_BUG_ON (UBLKSRV_IO_BUF_OFFSET +UBLKSRV_IO_BUF_TOTAL_SIZE >= +UBLKSRV_IO_INTEGRITY_FLAG );BUILD_BUG_ON (sizeof (struct ublk_auto_buf_reg ) !=8 );init_waitqueue_head (&ublk_idr_wq); ret =misc_register (&ublk_misc);
include/uapi/linux/ublk_cmd.h +4 -0
@@ -132,10 +132,14 @@#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS)#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS)#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) +/* Copy to/from request integrity buffer instead of data buffer */ +#define UBLK_INTEGRITY_FLAG_OFF 62 +#define UBLKSRV_IO_INTEGRITY_FLAG (1ULL << UBLK_INTEGRITY_FLAG_OFF) +/* * ublk server can register data buffers for incoming I/O requests with a sparse * io_uring buffer table. The request buffer can then be used as the data buffer * for io_uring operations via the fixed buffer index. * Note that the ublk server can never directly access the request data memory.
Signature · 1 line
2.45.2
Re: [PATCH v4 09/19] ublk: implement integrity user copy
Quoted 8 lines · Caleb Sander Mateos
From: Stanley Zhang <[email protected]>
Add a function
ublk_copy_user_integrity()to copy integrity information between a request and a useriov_iter. This mirrors the existingublk_copy_user_pages()but operates on request integrity data instead of regular data. CheckUBLKSRV_IO_INTEGRITY_FLAGiniocb->ki_posinublk_user_copy()to choose between copying data or integrity data.
Quoted 4 lines
Signed-off-by Stanley Zhang <[email protected]>[csander: change offset units from data bytes to integrity data bytes,
fixCONFIG_BLK_DEV_INTEGRITY=nbuild, rebase on user copy refactor]Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks,
Ming
PATCH v4 10/19 ublk: support UBLK_F_INTEGRITY
In reply to Caleb Sander MateosFrom: Stanley Zhang <[email protected]>
Now that all the components of the ublk integrity feature have been implemented, add UBLK_F_INTEGRITY to UBLK_F_ALL, conditional on block layer integrity support (CONFIG_BLK_DEV_INTEGRITY). This allows ublk servers to create ublk devices with UBLK_F_INTEGRITY set and UBLK_U_CMD_GET_FEATURES to report the feature as supported.
--- drivers/block/ublk_drv.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/block/ublk_drv.c +2 -1
@@ -73,11 +73,12 @@ | UBLK_F_USER_RECOVERY_FAIL_IO \ | UBLK_F_UPDATE_SIZE \ | UBLK_F_AUTO_BUF_REG \ | UBLK_F_QUIESCE \ | UBLK_F_PER_IO_DAEMON \ - | UBLK_F_BUF_REG_OFF_DAEMON) + | UBLK_F_BUF_REG_OFF_DAEMON \ + | (IS_ENABLED(CONFIG_BLK_DEV_INTEGRITY) ? UBLK_F_INTEGRITY : 0))#define UBLK_F_ALL_RECOVERY_FLAGS (UBLK_F_USER_RECOVERY \ | UBLK_F_USER_RECOVERY_REISSUE \ | UBLK_F_USER_RECOVERY_FAIL_IO)
Signature · 1 line
2.45.2
PATCH v4 11/19 ublk: optimize ublk_user_copy() on daemon task
In reply to Caleb Sander Mateosublk user copy syscalls may be issued from any task, so they take a reference count on the struct ublk_io to check whether it is owned by the ublk server and prevent a concurrent UBLK_IO_COMMIT_AND_FETCH_REQ from completing the request. However, if the user copy syscall is issued on the io's daemon task, a concurrent UBLK_IO_COMMIT_AND_FETCH_REQ isn't possible, so the atomic reference count dance is unnecessary. Check for UBLK_IO_FLAG_OWNED_BY_SRV to ensure the request is dispatched to the sever and obtain the request from ublk_io's req field instead of looking it up on the tagset. Skip the reference count increment and decrement. Commit 8a8fe42d765b ("ublk: optimize UBLK_IO_REGISTER_IO_BUF on daemon task") made an analogous optimization for ublk zero copy buffer registration.
--- drivers/block/ublk_drv.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-)
drivers/block/ublk_drv.c +18 -5
@@ -181,11 +181,11 @@ struct ublk_io {/* * The number of uses of this I/O by the ublk server * if user copy or zero copy are enabled: * - UBLK_REFCOUNT_INIT from dispatch to the server * until UBLK_IO_COMMIT_AND_FETCH_REQ -* - 1 for each inflight ublk_ch_{read,write}_iter() call +* - 1 for each inflight ublk_ch_{read,write}_iter() call not on task * - 1 for each io_uring registered buffer not registered on task * The I/O can only be completed once all references are dropped. * User copy and buffer registration operations are only permitted * if the reference count is nonzero. */
@@ -2689,10 +2689,11 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir)struct ublk_queue *ubq;struct request *req;struct ublk_io *io;unsigned data_len;bool is_integrity; +bool on_daemon;size_t buf_off;u16 tag, q_id;ssize_t ret;if (!user_backed_iter (iter))
@@ -2718,13 +2719,24 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir)if (tag >= ub->dev_info.queue_depth)return -EINVAL ; io = &ubq->ios[tag]; - req =__ublk_check_and_get_req (ub, q_id, tag, io); -if (!req) -return -EINVAL ; + on_daemon = current ==READ_ONCE (io->task); +if (on_daemon) { +/* On daemon, io can't be completed concurrently, so skip ref */ +if (!(io->flags &UBLK_IO_FLAG_OWNED_BY_SRV )) +return -EINVAL ; + + req = io->req; +if (!ublk_rq_has_data (req)) +return -EINVAL ; + }else { + req =__ublk_check_and_get_req (ub, q_id, tag, io); +if (!req) +return -EINVAL ; + }if (is_integrity) {struct blk_integrity *bi = &req->q->limits.integrity; data_len =bio_integrity_bytes (bi,blk_rq_sectors (req));
@@ -2745,11 +2757,12 @@ ublk_user_copy(struct kiocb *iocb, struct iov_iter *iter, int dir) ret =ublk_copy_user_integrity (req, buf_off, iter, dir); else ret =ublk_copy_user_pages (req, buf_off, iter, dir); out: -ublk_put_req_ref (io, req); +if (!on_daemon) +ublk_put_req_ref (io, req);return ret; }static ssize_t ublk_ch_read_iter (struct kiocb *iocb,struct iov_iter *to) {
Signature · 1 line
2.45.2
PATCH v4 12/19 selftests: ublk: display UBLK_F_INTEGRITY support
In reply to Caleb Sander MateosAdd support for printing the UBLK_F_INTEGRITY feature flag in the human-readable kublk features output.
--- tools/testing/selftests/ublk/kublk.c | 1 + 1 file changed, 1 insertion(+)
tools/testing/selftests/ublk/kublk.c +1 -0
@@ -1452,10 +1452,11 @@ static int cmd_dev_get_features(void)FEAT_NAME (UBLK_F_UPDATE_SIZE ),FEAT_NAME (UBLK_F_AUTO_BUF_REG ),FEAT_NAME (UBLK_F_QUIESCE ),FEAT_NAME (UBLK_F_PER_IO_DAEMON ),FEAT_NAME (UBLK_F_BUF_REG_OFF_DAEMON ), + FEAT_NAME(UBLK_F_INTEGRITY), };struct ublk_dev *dev;__u64 features =0 ;int ret;
Signature · 1 line
2.45.2
PATCH v4 13/19 selftests: ublk: add utility to get block device metadata size
In reply to Caleb Sander MateosSome block device integrity parameters are available in sysfs, but others are only accessible using the FS_IOC_GETLBMD_CAP ioctl. Add a metadata_size utility program to print out the logical block metadata size, PI offset, and PI size within the metadata. Example output:
$ metadata_size /dev/ublkb0 metadata_size: 64 pi_offset: 56 pi_tuple_size: 8
--- tools/testing/selftests/ublk/Makefile | 5 +-- tools/testing/selftests/ublk/metadata_size.c | 36 ++++++++++++++++++++ 2 files changed, 39 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/ublk/metadata_size.c
tools/testing/selftests/ublk/Makefile +3 -2
@@ -47,14 +47,15 @@ TEST_PROGS += test_stress_03.sh TEST_PROGS += test_stress_04.sh TEST_PROGS += test_stress_05.sh TEST_PROGS += test_stress_06.sh TEST_PROGS += test_stress_07.sh -TEST_GEN_PROGS_EXTENDED = kublk +TEST_GEN_PROGS_EXTENDED = kublk metadata_size +STANDALONE_UTILS := metadata_size.c LOCAL_HDRS += $(wildcard *.h) include ../lib.mk -$(TEST_GEN_PROGS_EXTENDED): $(wildcard *.c) +$(OUTPUT)/kublk: $(filter-out $(STANDALONE_UTILS),$(wildcard *.c)) check: shellcheck -x -f gcc *.sh
tools/testing/selftests/ublk/metadata_size.c new file +36 -0
@@ -0,0 +1,36 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <fcntl.h> +#include <linux/fs.h> +#include <stdio.h> +#include <sys/ioctl.h> + +int main (int argc,char **argv) +{ +struct logical_block_metadata_cap cap = {}; +const char *filename; +int fd; +int result; + +if (argc !=2 ) { +fprintf (stderr,"Usage: %s BLOCK_DEVICE\n" , argv[0 ]); +return 1 ; + } + + filename = argv[1 ]; + fd =open (filename,O_RDONLY ); +if (fd <0 ) { +perror (filename); +return 1 ; + } + + result =ioctl (fd,FS_IOC_GETLBMD_CAP , &cap); +if (result <0 ) { +perror ("ioctl" ); +return 1 ; + } + +printf ("metadata_size: %u\n" , cap.lbmd_size); +printf ("pi_offset: %u\n" , cap.lbmd_pi_offset); +printf ("pi_tuple_size: %u\n" , cap.lbmd_pi_size); +return 0 ; +}
Signature · 1 line
2.45.2
Re: [PATCH v4 13/19] selftests: ublk: add utility to get block device metadata size
Quoted 10 lines · Caleb Sander Mateos
Some block device integrity parameters are available in sysfs, but others are only accessible using the
FS_IOC_GETLBMD_CAPioctl. Add ametadata_sizeutility program to print out the logical block metadata size, PI offset, and PI size within the metadata. Example output:$ metadata_size /dev/ublkb0 metadata_size: 64 pi_offset: 56 pi_tuple_size: 8Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks
Ming
PATCH v4 14/19 selftests: ublk: add kublk support for integrity params
In reply to Caleb Sander MateosAdd integrity param command line arguments to kublk. Plumb these to struct ublk_params for the null and fault_inject targets, as they don't need to actually read or write the integrity data. Forbid the integrity params for loop or stripe until the integrity data copy is implemented.
--- tools/testing/selftests/ublk/fault_inject.c | 1 + tools/testing/selftests/ublk/file_backed.c | 4 ++ tools/testing/selftests/ublk/kublk.c | 47 +++++++++++++++++++++ tools/testing/selftests/ublk/kublk.h | 21 +++++++++ tools/testing/selftests/ublk/null.c | 1 + tools/testing/selftests/ublk/stripe.c | 4 ++ 6 files changed, 78 insertions(+)
tools/testing/selftests/ublk/fault_inject.c +1 -0
@@ -31,10 +31,11 @@ static int ublk_fault_inject_tgt_init(const struct dev_ctx *ctx, .io_min_shift = 9, .max_sectors = info->max_io_buf_bytes >> 9, .dev_sectors = dev_size >> 9, }, }; +ublk_set_integrity_params (ctx, &dev->tgt.params); dev->private_data = (void *)(unsigned long )(ctx->fault_inject.delay_us *1000 );return 0 ; }
tools/testing/selftests/ublk/file_backed.c +4 -0
@@ -156,10 +156,14 @@ static int ublk_loop_tgt_init(const struct dev_ctx *ctx, struct ublk_dev *dev)if (ctx->auto_zc_fallback) {ublk_err ("%s: not support auto_zc_fallback\n" , __func__);return -EINVAL ; } +if (ctx->metadata_size) { +ublk_err ("%s: integrity not supported\n" , __func__); +return -EINVAL ; + } ret =backing_file_tgt_init (dev);if (ret)return ret;
tools/testing/selftests/ublk/kublk.c +47 -0
107 lines not on this page · raw message
tools/testing/selftests/ublk/kublk.h +21 -0
@@ -76,10 +76,15 @@ struct dev_ctx { unsigned int fg:1; unsigned int recovery:1; unsigned int auto_zc_fallback:1; unsigned int per_io_tasks:1; unsigned int no_ublk_fixed_fd:1; +__u32 integrity_flags; +__u8 metadata_size; +__u8 pi_offset; +__u8 csum_type; +__u8 tag_size;int _evtfd;int _shmid;/* built from shmem, only for ublk_dump_dev() */
@@ -200,10 +205,26 @@ struct ublk_dev {void *private_data; };extern int ublk_queue_io_cmd (struct ublk_thread *t,struct ublk_io *io); +static inline void ublk_set_integrity_params (const struct dev_ctx *ctx, +struct ublk_params *params) +{ +if (!ctx->metadata_size) +return ; + + params->types |=UBLK_PARAM_TYPE_INTEGRITY ; + params->integrity = (struct ublk_param_integrity ) { + .flags = ctx->integrity_flags, + .interval_exp = params->basic.logical_bs_shift, + .metadata_size = ctx->metadata_size, + .pi_offset = ctx->pi_offset, + .csum_type = ctx->csum_type, + .tag_size = ctx->tag_size, + }; +}static inline int ublk_io_auto_zc_fallback (const struct ublksrv_io_desc *iod) {return !!(iod->op_flags &UBLK_IO_F_NEED_REG_BUF ); }
tools/testing/selftests/ublk/null.c +1 -0
@@ -34,10 +34,11 @@ static int ublk_null_tgt_init(const struct dev_ctx *ctx, struct ublk_dev *dev) .seg_boundary_mask = 4095, .max_segment_size = 32 << 10, .max_segments = 32, }, }; +ublk_set_integrity_params (ctx, &dev->tgt.params);if (info->flags &UBLK_F_SUPPORT_ZERO_COPY ) dev->tgt.sq_depth = dev->tgt.cq_depth =2 * info->queue_depth;return 0 ; }
tools/testing/selftests/ublk/stripe.c +4 -0
@@ -296,10 +296,14 @@ static int ublk_stripe_tgt_init(const struct dev_ctx *ctx, struct ublk_dev *dev)if (ctx->auto_zc_fallback) {ublk_err ("%s: not support auto_zc_fallback\n" , __func__);return -EINVAL ; } +if (ctx->metadata_size) { +ublk_err ("%s: integrity not supported\n" , __func__); +return -EINVAL ; + }if ((chunk_size & (chunk_size -1 )) || !chunk_size) {ublk_err ("invalid chunk size %u\n" , chunk_size);return -EINVAL ; }
Signature · 1 line
2.45.2
Re: [PATCH v4 14/19] selftests: ublk: add kublk support for integrity params
Quoted 6 lines · Caleb Sander Mateos
Add integrity param command line arguments to kublk. Plumb these to struct
ublk_paramsfor the null andfault_injecttargets, as they don't need to actually read or write the integrity data. Forbid the integrity params for loop or stripe until the integrity data copy is implemented.Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks,
Ming
PATCH v4 15/19 selftests: ublk: implement integrity user copy in kublk
In reply to Caleb Sander MateosIf integrity data is enabled for kublk, allocate an integrity buffer for each I/O. Extend ublk_user_copy() to copy the integrity data between the ublk request and the integrity buffer if the ublksrv_io_desc indicates that the request has integrity data.
--- tools/testing/selftests/ublk/kublk.c | 41 ++++++++++++++++++++++++---- tools/testing/selftests/ublk/kublk.h | 14 ++++++++++ 2 files changed, 50 insertions(+), 5 deletions(-)
tools/testing/selftests/ublk/kublk.c +36 -5
@@ -414,12 +414,14 @@ static void ublk_queue_deinit(struct ublk_queue *q)int nr_ios = q->q_depth;if (q->io_cmd_buf)munmap (q->io_cmd_buf,ublk_queue_cmd_buf_sz (q)); -for (i =0 ; i < nr_ios; i++) +for (i =0 ; i < nr_ios; i++) {free (q->ios[i].buf_addr); +free (q->ios[i].integrity_buf); + } }static void ublk_thread_deinit (struct ublk_thread *t) {io_uring_unregister_buffers (&t->ring);
@@ -431,23 +433,25 @@ static void ublk_thread_deinit(struct ublk_thread *t)close (t->ring.ring_fd); t->ring.ring_fd =-1 ; } } -static int ublk_queue_init (struct ublk_queue *q,unsigned long long extra_flags) +static int ublk_queue_init (struct ublk_queue *q,unsigned long long extra_flags, +__u8 metadata_size) {struct ublk_dev *dev = q->dev;int depth = dev->dev_info.queue_depth;int i; -int cmd_buf_size, io_buf_size; +int cmd_buf_size, io_buf_size, integrity_size;unsigned long off; q->tgt_ops = dev->tgt.ops; q->flags =0 ; q->q_depth = depth; q->flags = dev->dev_info.flags; q->flags |= extra_flags; + q->metadata_size = metadata_size;/* Cache fd in queue for fast path access */ q->ublk_fd = dev->fds[0 ]; cmd_buf_size =ublk_queue_cmd_buf_sz (q);
@@ -459,15 +463,27 @@ static int ublk_queue_init(struct ublk_queue *q, unsigned long long extra_flags) q->dev->dev_info.dev_id, q->q_id); goto fail; } io_buf_size = dev->dev_info.max_io_buf_bytes; + integrity_size =ublk_integrity_len (q, io_buf_size);for (i =0 ; i < q->q_depth; i++) { q->ios[i].buf_addr =NULL ; q->ios[i].flags =UBLKS_IO_NEED_FETCH_RQ |UBLKS_IO_FREE ; q->ios[i].tag = i; +if (integrity_size) { + q->ios[i].integrity_buf =malloc (integrity_size); +if (!q->ios[i].integrity_buf) { +ublk_err ("ublk dev %d queue %d io %d malloc(%d) failed: %m\n" , + dev->dev_info.dev_id, q->q_id, i, + integrity_size); + goto fail; + } + } + +if (ublk_queue_no_buf (q))continue ;if (posix_memalign ((void **)&q->ios[i].buf_addr,getpagesize (), io_buf_size)) {
@@ -606,17 +622,17 @@ static void ublk_user_copy(const struct ublk_io *io, __u8 match_ublk_op)const struct ublksrv_io_desc *iod =ublk_get_iod (q, io->tag);__u64 off =ublk_user_copy_offset (q->q_id, io->tag);__u8 ublk_op =ublksrv_get_op (iod);__u32 len = iod->nr_sectors <<9 ;void *addr = io->buf_addr; +ssize_t copied;if (ublk_op != match_ublk_op)return ;while (len) {__u32 copy_len =min (len,UBLK_USER_COPY_LEN ); -ssize_t copied;if (ublk_op ==UBLK_IO_OP_WRITE ) copied =pread (q->ublk_fd, addr, copy_len, off);else if (ublk_op ==UBLK_IO_OP_READ ) copied =pwrite (q->ublk_fd, addr, copy_len, off);
@@ -625,10 +641,24 @@ static void ublk_user_copy(const struct ublk_io *io, __u8 match_ublk_op)assert (copied == (ssize_t )copy_len); addr += copy_len; off += copy_len; len -= copy_len; } + +if (!(iod->op_flags &UBLK_IO_F_INTEGRITY )) +return ; + + len =ublk_integrity_len (q, iod->nr_sectors <<9 ); + off =ublk_user_copy_offset (q->q_id, io->tag); + off |=UBLKSRV_IO_INTEGRITY_FLAG ; +if (ublk_op ==UBLK_IO_OP_WRITE ) + copied =pread (q->ublk_fd, io->integrity_buf, len, off); +else if (ublk_op ==UBLK_IO_OP_READ ) + copied =pwrite (q->ublk_fd, io->integrity_buf, len, off); +else +assert (0 ); +assert (copied == (ssize_t )len); }int ublk_queue_io_cmd (struct ublk_thread *t,struct ublk_io *io) {struct ublk_queue *q =ublk_io_to_queue (io);
@@ -1011,11 +1041,12 @@ static int ublk_start_daemon(const struct dev_ctx *ctx, struct ublk_dev *dev)for (i =0 ; i < dinfo->nr_hw_queues; i++) { dev->q[i].dev = dev; dev->q[i].q_id = i; - ret =ublk_queue_init (&dev->q[i], extra_flags); + ret =ublk_queue_init (&dev->q[i], extra_flags, + ctx->metadata_size);if (ret) {ublk_err ("ublk dev %d queue %d init queue failed\n" , dinfo->dev_id, i); goto fail; }
tools/testing/selftests/ublk/kublk.h +14 -0
@@ -110,10 +110,11 @@ struct ublk_ctrl_cmd_data {__u32 len; };struct ublk_io {char *buf_addr; +void *integrity_buf;#define UBLKS_IO_NEED_FETCH_RQ (1UL << 0)#define UBLKS_IO_NEED_COMMIT_RQ_COMP (1UL << 1)#define UBLKS_IO_FREE (1UL << 2)#define UBLKS_IO_NEED_GET_DATA (1UL << 3)
@@ -173,10 +174,11 @@ struct ublk_queue {/* borrow one bit of ublk uapi flags, which may never be used */ #define UBLKS_Q_AUTO_BUF_REG_FALLBACK (1ULL << 63)#define UBLKS_Q_NO_UBLK_FIXED_FD (1ULL << 62)__u64 flags;int ublk_fd;/* cached ublk char device fd */ +__u8 metadata_size;struct ublk_io ios[UBLK_QUEUE_DEPTH ]; };struct ublk_thread {struct ublk_dev *dev;
@@ -222,10 +224,22 @@ static inline void ublk_set_integrity_params(const struct dev_ctx *ctx, .csum_type = ctx->csum_type, .tag_size = ctx->tag_size, }; } +static inline size_t ublk_integrity_len (const struct ublk_queue *q,size_t len) +{ +/* All targets currently use interval_exp = logical_bs_shift = 9 */ +return (len >>9 ) * q->metadata_size; +} + +static inline size_t +ublk_integrity_data_len (const struct ublk_queue *q,size_t integrity_len) +{ +return (integrity_len / q->metadata_size) <<9 ; +} +static inline int ublk_io_auto_zc_fallback (const struct ublksrv_io_desc *iod) {return !!(iod->op_flags &UBLK_IO_F_NEED_REG_BUF ); }
Signature · 1 line
2.45.2
Re: [PATCH v4 15/19] selftests: ublk: implement integrity user copy in kublk
Quoted 6 lines · Caleb Sander Mateos
If integrity data is enabled for kublk, allocate an integrity buffer for each I/O. Extend
ublk_user_copy()to copy the integrity data between the ublk request and the integrity buffer if theublksrv_io_descindicates that the request has integrity data.Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks,
Ming
PATCH v4 16/19 selftests: ublk: support non-O_DIRECT backing files
In reply to Caleb Sander MateosA subsequent commit will add support for using a backing file to store integrity data. Since integrity data is accessed in intervals of metadata_size, which may be much smaller than a logical block on the backing device, direct I/O cannot be used. Add an argument to backing_file_tgt_init() to specify the number of files to open for direct I/O. The remaining files will use buffered I/O. For now, continue to request direct I/O for all the files.
--- tools/testing/selftests/ublk/common.c | 4 ++-- tools/testing/selftests/ublk/file_backed.c | 2 +- tools/testing/selftests/ublk/kublk.h | 2 +- tools/testing/selftests/ublk/stripe.c | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-)
tools/testing/selftests/ublk/common.c +2 -2
@@ -10,11 +10,11 @@ void backing_file_tgt_deinit(struct ublk_dev *dev)fsync (dev->fds[i]);close (dev->fds[i]); } } -int backing_file_tgt_init (struct ublk_dev *dev) +int backing_file_tgt_init (struct ublk_dev *dev,unsigned int nr_direct) {int fd, i;assert (dev->nr_fds ==1 );
@@ -23,11 +23,11 @@ int backing_file_tgt_init(struct ublk_dev *dev)unsigned long bytes;struct stat st;ublk_dbg (UBLK_DBG_DEV ,"%s: file %d: %s\n" , __func__, i, file); - fd =open (file,O_RDWR |O_DIRECT ); + fd =open (file,O_RDWR | (i < nr_direct ?O_DIRECT :0 ));if (fd <0 ) {ublk_err ("%s: backing file %s can't be opened: %s\n" , __func__, file,strerror (errno));return -EBADF ; }
tools/testing/selftests/ublk/file_backed.c +1 -1
@@ -161,11 +161,11 @@ static int ublk_loop_tgt_init(const struct dev_ctx *ctx, struct ublk_dev *dev)if (ctx->metadata_size) {ublk_err ("%s: integrity not supported\n" , __func__);return -EINVAL ; } - ret =backing_file_tgt_init (dev); + ret =backing_file_tgt_init (dev,1 );if (ret)return ret;if (dev->tgt.nr_backing_files !=1 )return -EINVAL ;
tools/testing/selftests/ublk/kublk.h +1 -1
@@ -460,8 +460,8 @@ extern const struct ublk_tgt_ops null_tgt_ops;extern const struct ublk_tgt_ops loop_tgt_ops;extern const struct ublk_tgt_ops stripe_tgt_ops;extern const struct ublk_tgt_ops fault_inject_tgt_ops;void backing_file_tgt_deinit (struct ublk_dev *dev); -int backing_file_tgt_init (struct ublk_dev *dev); +int backing_file_tgt_init (struct ublk_dev *dev,unsigned int nr_direct);#endif
tools/testing/selftests/ublk/stripe.c +1 -1
@@ -313,11 +313,11 @@ static int ublk_stripe_tgt_init(const struct dev_ctx *ctx, struct ublk_dev *dev)return -EINVAL ; } chunk_shift =ilog2 (chunk_size); - ret =backing_file_tgt_init (dev); + ret =backing_file_tgt_init (dev, dev->tgt.nr_backing_files);if (ret)return ret;if (!dev->tgt.nr_backing_files || dev->tgt.nr_backing_files >NR_STRIPE )return -EINVAL ;
Signature · 1 line
2.45.2
Re: [PATCH v4 16/19] selftests: ublk: support non-O_DIRECT backing files
Quoted 9 lines · Caleb Sander Mateos
A subsequent commit will add support for using a backing file to store integrity data. Since integrity data is accessed in intervals of
metadata_size, which may be much smaller than a logical block on the backing device, direct I/O cannot be used. Add an argument tobacking_file_tgt_init()to specify the number of files to open for direct I/O. The remaining files will use buffered I/O. For now, continue to request direct I/O for all the files.Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks,
Ming
PATCH v4 17/19 selftests: ublk: add integrity data support to loop target
In reply to Caleb Sander MateosTo perform and end-to-end test of integrity information through a ublk device, we need to actually store it somewhere and retrieve it. Add this support to kublk's loop target. It uses a second backing file for the integrity data corresponding to the data stored in the first file. The integrity file is initialized with byte 0xFF, which ensures the app and reference tags are set to the "escape" pattern to disable the bio-integrity-auto guard and reftag checks until the blocks are written. The integrity file is opened without O_DIRECT since it will be accessed at sub-block granularity. Each incoming read/write results in a pair of reads/writes, one to the data file, and one to the integrity file. If either backing I/O fails, the error is propagated to the ublk request. If both backing I/Os read/write some bytes, the ublk request is completed with the smaller of the number of blocks accessed by each I/O.
--- tools/testing/selftests/ublk/file_backed.c | 92 +++++++++++++++++----- 1 file changed, 74 insertions(+), 18 deletions(-)
tools/testing/selftests/ublk/file_backed.c +74 -18
@@ -33,48 +33,62 @@ static int loop_queue_tgt_rw_io(struct ublk_thread *t, struct ublk_queue *q,unsigned ublk_op =ublksrv_get_op (iod);unsigned zc =ublk_queue_use_zc (q);unsigned auto_zc =ublk_queue_use_auto_zc (q);enum io_uring_op op =ublk_to_uring_op (iod, zc | auto_zc);struct ublk_io *io =ublk_get_io (q, tag); +__u64 offset = iod->start_sector <<9 ; +__u32 len = iod->nr_sectors <<9 ;struct io_uring_sqe *sqe[3 ];void *addr = io->buf_addr; +if (iod->op_flags &UBLK_IO_F_INTEGRITY ) { +ublk_io_alloc_sqes (t, sqe,1 ); +/* Use second backing file for integrity data */ +io_uring_prep_rw (op, sqe[0 ],ublk_get_registered_fd (q,2 ), + io->integrity_buf, +ublk_integrity_len (q, len), +ublk_integrity_len (q, offset)); + sqe[0 ]->flags =IOSQE_FIXED_FILE ; +/* tgt_data = 1 indicates integrity I/O */ + sqe[0 ]->user_data =build_user_data (tag, ublk_op,1 , q->q_id,1 ); + } +if (!zc || auto_zc) {ublk_io_alloc_sqes (t, sqe,1 );if (!sqe[0 ])return -ENOMEM ;io_uring_prep_rw (op, sqe[0 ],ublk_get_registered_fd (q,1 )/*fds[1]*/ , addr, - iod->nr_sectors <<9 , - iod->start_sector <<9 ); + len, + offset);if (auto_zc) sqe[0 ]->buf_index = tag;io_uring_sqe_set_flags (sqe[0 ],IOSQE_FIXED_FILE );/* bit63 marks us as tgt io */ sqe[0 ]->user_data =build_user_data (tag, ublk_op,0 , q->q_id,1 ); -return 1 ; +return !!(iod->op_flags &UBLK_IO_F_INTEGRITY ) +1 ; }ublk_io_alloc_sqes (t, sqe,3 );io_uring_prep_buf_register (sqe[0 ], q, tag, q->q_id, io->buf_index); sqe[0 ]->flags |=IOSQE_CQE_SKIP_SUCCESS |IOSQE_IO_HARDLINK ; sqe[0 ]->user_data =build_user_data (tag,ublk_cmd_op_nr (sqe[0 ]->cmd_op),0 , q->q_id,1 );io_uring_prep_rw (op, sqe[1 ],ublk_get_registered_fd (q,1 )/*fds[1]*/ ,0 , - iod->nr_sectors <<9 , - iod->start_sector <<9 ); + len, + offset); sqe[1 ]->buf_index = tag; sqe[1 ]->flags |=IOSQE_FIXED_FILE |IOSQE_IO_HARDLINK ; sqe[1 ]->user_data =build_user_data (tag, ublk_op,0 , q->q_id,1 );io_uring_prep_buf_unregister (sqe[2 ], q, tag, q->q_id, io->buf_index); sqe[2 ]->user_data =build_user_data (tag,ublk_cmd_op_nr (sqe[2 ]->cmd_op),0 , q->q_id,1 ); -return 2 ; +return !!(iod->op_flags &UBLK_IO_F_INTEGRITY ) +2 ; }static int loop_queue_tgt_io (struct ublk_thread *t,struct ublk_queue *q,int tag) {const struct ublksrv_io_desc *iod =ublk_get_iod (q, tag);
@@ -117,29 +131,55 @@ static void ublk_loop_io_done(struct ublk_thread *t, struct ublk_queue *q, {unsigned tag =user_data_to_tag (cqe->user_data);unsigned op =user_data_to_op (cqe->user_data);struct ublk_io *io =ublk_get_io (q, tag); -if (cqe->res <0 || op !=ublk_cmd_op_nr (UBLK_U_IO_UNREGISTER_IO_BUF )) { -if (!io->result) - io->result = cqe->res; -if (cqe->res <0 ) -ublk_err ("%s: io failed op %x user_data %lx\n" , - __func__, op, cqe->user_data); +if (cqe->res <0 ) { + io->result = cqe->res; +ublk_err ("%s: io failed op %x user_data %lx\n" , + __func__, op, cqe->user_data); + }else if (op !=ublk_cmd_op_nr (UBLK_U_IO_UNREGISTER_IO_BUF )) { +__s32 data_len =user_data_to_tgt_data (cqe->user_data) + ?ublk_integrity_data_len (q, cqe->res) + : cqe->res; + +if (!io->result || data_len < io->result) + io->result = data_len; }/* buffer register op is IOSQE_CQE_SKIP_SUCCESS */ if (op ==ublk_cmd_op_nr (UBLK_U_IO_REGISTER_IO_BUF )) io->tgt_ios +=1 ;if (ublk_completed_tgt_io (t, q, tag))ublk_complete_io (t, q, tag, io->result); } +static int ublk_loop_memset_file (int fd,__u8 byte,size_t len) +{ +off_t offset =0 ; +__u8 buf[4096 ]; + +memset (buf, byte,sizeof (buf)); +while (len) { +int ret =pwrite (fd, buf,min (len,sizeof (buf)), offset); + +if (ret <0 ) +return -errno; +if (!ret) +return -EIO ; + + len -= ret; + offset += ret; + } +return 0 ; +} +static int ublk_loop_tgt_init (const struct dev_ctx *ctx,struct ublk_dev *dev) {unsigned long long bytes; +unsigned long blocks;int ret;struct ublk_params p = { .types =UBLK_PARAM_TYPE_BASIC |UBLK_PARAM_TYPE_DMA_ALIGN , .basic = { .attrs =UBLK_ATTR_VOLATILE_CACHE ,
@@ -152,27 +192,43 @@ static int ublk_loop_tgt_init(const struct dev_ctx *ctx, struct ublk_dev *dev) .dma = { .alignment = 511, }, }; +ublk_set_integrity_params (ctx, &p);if (ctx->auto_zc_fallback) {ublk_err ("%s: not support auto_zc_fallback\n" , __func__);return -EINVAL ; } -if (ctx->metadata_size) { -ublk_err ("%s: integrity not supported\n" , __func__); -return -EINVAL ; - } +/* Use O_DIRECT only for data file */ ret =backing_file_tgt_init (dev,1 );if (ret)return ret; -if (dev->tgt.nr_backing_files !=1 ) +/* Expect a second file for integrity data */ +if (dev->tgt.nr_backing_files !=1 + !!ctx->metadata_size)return -EINVAL ; - bytes = dev->tgt.backing_file_size[0 ]; + blocks = dev->tgt.backing_file_size[0 ] >> p.basic.logical_bs_shift; +if (ctx->metadata_size) { +unsigned long metadata_blocks = + dev->tgt.backing_file_size[1 ] / ctx->metadata_size; +unsigned long integrity_len; + +/* Ensure both data and integrity data fit in backing files */ + blocks =min (blocks, metadata_blocks); + integrity_len = blocks * ctx->metadata_size; +/* +* Initialize PI app tag and ref tag to 0xFF +* to disable bio-integrity-auto checks +*/ + ret =ublk_loop_memset_file (dev->fds[2 ],0xFF , integrity_len); +if (ret) +return ret; + } + bytes = blocks << p.basic.logical_bs_shift; dev->tgt.dev_size = bytes; p.basic.dev_sectors = bytes >>9 ; dev->tgt.params = p;return 0 ;
Signature · 1 line
2.45.2
Re: [PATCH v4 17/19] selftests: ublk: add integrity data support to loop target
Quoted 14 lines · Caleb Sander Mateos
To perform and end-to-end test of integrity information through a ublk device, we need to actually store it somewhere and retrieve it. Add this support to kublk's loop target. It uses a second backing file for the integrity data corresponding to the data stored in the first file. The integrity file is initialized with byte
0xFF, which ensures the app and reference tags are set to the "escape" pattern to disable the bio-integrity-auto guard and reftag checks until the blocks are written. The integrity file is opened withoutO_DIRECTsince it will be accessed at sub-block granularity. Each incoming read/write results in a pair of reads/writes, one to the data file, and one to the integrity file. If either backing I/O fails, the error is propagated to the ublk request. If both backing I/Os read/write some bytes, the ublk request is completed with the smaller of the number of blocks accessed by each I/O.
Quoted 1 line
Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks,
Ming
PATCH v4 18/19 selftests: ublk: add integrity params test
In reply to Caleb Sander MateosAdd test case null_04 to exercise all the different integrity params. It creates 4 different ublk devices with different combinations of integrity arguments and verifies their integrity limits via sysfs and the metadata_size utility.
--- tools/testing/selftests/ublk/Makefile | 1 + tools/testing/selftests/ublk/test_common.sh | 10 ++ tools/testing/selftests/ublk/test_null_04.sh | 166 +++++++++++++++++++ 3 files changed, 177 insertions(+) create mode 100755 tools/testing/selftests/ublk/test_null_04.sh
tools/testing/selftests/ublk/Makefile +1 -0
@@ -25,10 +25,11 @@ TEST_PROGS += test_generic_14.sh TEST_PROGS += test_generic_15.sh TEST_PROGS += test_null_01.sh TEST_PROGS += test_null_02.sh TEST_PROGS += test_null_03.sh +TEST_PROGS += test_null_04.sh TEST_PROGS += test_loop_01.sh TEST_PROGS += test_loop_02.sh TEST_PROGS += test_loop_03.sh TEST_PROGS += test_loop_04.sh TEST_PROGS += test_loop_05.sh
tools/testing/selftests/ublk/test_common.sh +10 -0
@@ -382,10 +382,20 @@ run_io_and_recover() _ublk_test_top_dir() { cd "$(dirname "$0")" && pwd } +METADATA_SIZE_PROG="$(_ublk_test_top_dir)/metadata_size" + +_get_metadata_size() +{ + local dev_id=$1 + local field=$2 + + "$METADATA_SIZE_PROG" "/dev/ublkb$dev_id" | grep "$field" | grep -o "[0-9]*" +} + UBLK_PROG=$(_ublk_test_top_dir)/kublk UBLK_TEST_QUIET=1 UBLK_TEST_SHOW_RESULT=1 UBLK_BACKFILES=() export UBLK_PROG
tools/testing/selftests/ublk/test_null_04.sh new file +166 -0
166 lines not on this page · raw message
Signature · 1 line
2.45.2
Re: [PATCH v4 18/19] selftests: ublk: add integrity params test
Quoted 6 lines · Caleb Sander Mateos
Add test case
null_04to exercise all the different integrity params. It creates 4 different ublk devices with different combinations of integrity arguments and verifies their integrity limits via sysfs and themetadata_sizeutility.Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks,
Ming
PATCH v4 19/19 selftests: ublk: add end-to-end integrity test
In reply to Caleb Sander MateosAdd test case loop_08 to verify the ublk integrity data flow. It uses the kublk loop target to create a ublk device with integrity on top of backing data and integrity files. It then writes to the whole device with fio configured to generate integrity data. Then it reads back the whole device with fio configured to verify the integrity data. It also verifies that injected guard, reftag, and apptag corruptions are correctly detected.
--- tools/testing/selftests/ublk/Makefile | 1 + tools/testing/selftests/ublk/test_loop_08.sh | 111 +++++++++++++++++++ 2 files changed, 112 insertions(+) create mode 100755 tools/testing/selftests/ublk/test_loop_08.sh
tools/testing/selftests/ublk/Makefile +1 -0
@@ -33,10 +33,11 @@ TEST_PROGS += test_loop_02.sh TEST_PROGS += test_loop_03.sh TEST_PROGS += test_loop_04.sh TEST_PROGS += test_loop_05.sh TEST_PROGS += test_loop_06.sh TEST_PROGS += test_loop_07.sh +TEST_PROGS += test_loop_08.sh TEST_PROGS += test_stripe_01.sh TEST_PROGS += test_stripe_02.sh TEST_PROGS += test_stripe_03.sh TEST_PROGS += test_stripe_04.sh TEST_PROGS += test_stripe_05.sh
tools/testing/selftests/ublk/test_loop_08.sh new file +111 -0
111 lines not on this page · raw message
Signature · 1 line
2.45.2
Re: [PATCH v4 19/19] selftests: ublk: add end-to-end integrity test
Quoted 9 lines · Caleb Sander Mateos
Add test case
loop_08to verify the ublk integrity data flow. It uses the kublk loop target to create a ublk device with integrity on top of backing data and integrity files. It then writes to the whole device with fio configured to generate integrity data. Then it reads back the whole device with fio configured to verify the integrity data. It also verifies that injected guard, reftag, and apptag corruptions are correctly detected.Signed-off-by Caleb Sander Mateos <[email protected]>
Thanks,
Ming
Quoted 39 lines · Caleb Sander Mateos
Much work has recently gone into supporting block device integrity data (sometimes called "metadata") in Linux. Many NVMe devices these days support metadata transfers and/or automatic protection information generation and verification. However, ublk devices can't yet advertise integrity data capabilities. This patch series wires up support for integrity data in ublk. The ublk feature is referred to as "integrity" rather than "metadata" to match the block layer's name for it and to avoid confusion with the existing and unrelated
UBLK_IO_F_META.To advertise support for integrity data, a ublk server fills out the struct ublk_params's integrity field and sets
UBLK_PARAM_TYPE_INTEGRITY. The structublk_param_integrityflags andcsum_typefields use the existing LBMD_PI_* constants from thelinux/fs.hUAPI header. The ublk driver fills out a corresponding structblk_integrity.When a request with integrity data is issued to the ublk device, the ublk driver sets
UBLK_IO_F_INTEGRITYin struct ublksrv_io_desc'sop_flagsfield. This is necessary for a ublk server for whichbi_offload_capable()returns true to distinguish requests with integrity data from those without.Integrity data transfers can currently only be performed via the ublk user copy mechanism. The overhead of zero-copy buffer registration makes it less appealing for the small transfers typical of integrity data. Additionally, neither
io_uringNVMe passthru norIORING_RW_ATTR_FLAG_PIcurrently allow anio_uringregistered buffer for the integrity data. Theki_posfield of the struct kiocb passed to the user copy ->{read,write}_iter() callback gains a bitUBLKSRV_IO_INTEGRITY_FLAGfor a ublk server to indicate whether to access the request's data or integrity data.Not yet supported is an analogue for the IO_INTEGRITY_CHK_*/BIP_CHECK_* flags to ask the ublk server to verify the guard, reftag, and/or apptag of a request's protection information. The user copy mechanism currently forbids a ublk server from reading the data/integrity buffer of a read-direction request. We could potentially relax this restriction for integrity data on reads. Alternatively, the ublk driver could verify the requested fields as part of the user copy operation.
Quoted 6 lines
v4:
- Addmax_integrity_segmentsto structublk_param_integrity(Ming)
- MoveUBLKSRV_IO_INTEGRITY_FLAGto avoid overflow from
QID +UBLKSRV_IO_BUF_OFFSET(Ming)
- CheckUBLK_F_INTEGRITYwhenUBLKSRV_IO_INTEGRITY_FLAGis used (Ming)
- Initialize integrity backing file to disable integrity checks (Ming)
Hi Jens,
Can you consider to queue V4 into for-7.0/block if you are fine? So I can rebase my BATCH_IO patchset against this one.
Thanks,
Ming
Quoted 10 lines · Caleb Sander Mateos
Much work has recently gone into supporting block device integrity data (sometimes called "metadata") in Linux. Many NVMe devices these days support metadata transfers and/or automatic protection information generation and verification. However, ublk devices can't yet advertise integrity data capabilities. This patch series wires up support for integrity data in ublk. The ublk feature is referred to as "integrity" rather than "metadata" to match the block layer's name for it and to avoid confusion with the existing and unrelated
UBLK_IO_F_META.[...]
Applied, thanks!
[01/19] blk-integrity: take const pointer in blk_integrity_rq()
commit: 835042fb1971b1cc6acb46d53b8862643fd7d0a8
[02/19] ublk: move ublk flag check functions earlier
commit: e859e7c26a5c4689083f161a52d039b9b454e403
[03/19] ublk: support UBLK_PARAM_TYPE_INTEGRITY in device creation
commit: 98bf2256855eb682433a33e6a7c4bce35191ca99
[04/19] ublk: set UBLK_IO_F_INTEGRITY in ublksrv_io_desc
commit: f82f0a16a8270b17211254beeb123d11a0f279cd
[05/19] ublk: split out ublk_copy_user_bvec() helper
commit: fc652d415cd8b45e9a534d1c019da175cca4c95a
[06/19] ublk: split out ublk_user_copy() helper
commit: 5bfbbc9938f5dee7f252ef05f47b9a26f05f281a
[07/19] ublk: inline ublk_check_and_get_req() into ublk_user_copy()
commit: ca80afd8708fa22f6d3a1e0306ae12a64e5291b5
[08/19] ublk: move offset check out of __ublk_check_and_get_req()
commit: fd5a005fa6a261762292a2d89ef8d0174b66f541
[09/19] ublk: implement integrity user copy
commit: be82a89066d595da334f6e153ababcedc3f92ad6
[10/19] ublk: support UBLK_F_INTEGRITY
commit: b2503e936b598b993cb09005194dc77d2fa3f082
[11/19] ublk: optimize ublk_user_copy() on daemon task
commit: bfe1255712a3b1c1f7418c5504a1bf53735d3848
[12/19] selftests: ublk: display UBLK_F_INTEGRITY support
commit: c1d7c0f9cdf6690eff4518f1c17a37d5ee647cd1
[13/19] selftests: ublk: add utility to get block device metadata size
commit: 261b67f4e34716e793b0b95d2722b2fe780ed5f4
[14/19] selftests: ublk: add kublk support for integrity params
commit: 6ed6476c4aefa9ee3ba90f39bcc002dd034f6e03
[15/19] selftests: ublk: implement integrity user copy in kublk
commit: 24f8a44b797f03dfadb455138930523599d3c22a
[16/19] selftests: ublk: support non-O_DIRECT backing files
commit: a1805442674b85ff9d626965f828e4fd71a82b28
[17/19] selftests: ublk: add integrity data support to loop target
commit: f48250dc5ba8368ccb587093eb20d1c7baecaacf
[18/19] selftests: ublk: add integrity params test
commit: 9e9f635525b12f055558a7cfe2e54d109839d030
[19/19] selftests: ublk: add end-to-end integrity test
commit: 78796b6bae8684b753b658f431b5b1ee24300d64Best regards,
Signature · 1 line
Jens Axboe