From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id ED558C6FD18 for ; Tue, 28 Mar 2023 15:13:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232715AbjC1PNz (ORCPT ); Tue, 28 Mar 2023 11:13:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53540 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233919AbjC1PNb (ORCPT ); Tue, 28 Mar 2023 11:13:31 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A264EFF23 for ; Tue, 28 Mar 2023 08:12:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016257; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=EO1Gc+65gs0ahiLFrwFbt1R8FOKbz4SZ+dA6YGYHpZ8=; b=dVrUb62lIcpq1uINB9EhgYQZuoi/BhNW+PYPDJokiystEFy7dx+oS8TeVN/83HH78gqm1D PQaRjOBVCQWU99gtQtoUpbeTMQJFua1WNwxmLabiMqpQtsQXKPAO68rt3E3cAyyonupk7h odg0MpLFjMTLxQVgZqCg9myI5PFgavM= Received: from mimecast-mx02.redhat.com (mx3-rdu2.redhat.com [66.187.233.73]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-37-r3840IcWO6iGys5QDdW3vA-1; Tue, 28 Mar 2023 11:10:53 -0400 X-MC-Unique: r3840IcWO6iGys5QDdW3vA-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.rdu2.redhat.com [10.11.54.7]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id B37AC38149B1; Tue, 28 Mar 2023 15:10:50 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id B1FC7140EBF4; Tue, 28 Mar 2023 15:10:49 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 01/16] io_uring: increase io_kiocb->flags into 64bit Date: Tue, 28 Mar 2023 23:09:43 +0800 Message-Id: <20230328150958.1253547-2-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.7 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" The 32bit io_kiocb->flags has been used up, so extend it to 64bit. Signed-off-by: Ming Lei --- include/linux/io_uring_types.h | 65 +++++++++++++++++----------------- io_uring/io_uring.c | 2 +- 2 files changed, 34 insertions(+), 33 deletions(-) diff --git a/include/linux/io_uring_types.h b/include/linux/io_uring_types.h index 561fa421c453..dd8ef886730b 100644 --- a/include/linux/io_uring_types.h +++ b/include/linux/io_uring_types.h @@ -414,68 +414,68 @@ enum { =20 enum { /* ctx owns file */ - REQ_F_FIXED_FILE =3D BIT(REQ_F_FIXED_FILE_BIT), + REQ_F_FIXED_FILE =3D BIT_ULL(REQ_F_FIXED_FILE_BIT), /* drain existing IO first */ - REQ_F_IO_DRAIN =3D BIT(REQ_F_IO_DRAIN_BIT), + REQ_F_IO_DRAIN =3D BIT_ULL(REQ_F_IO_DRAIN_BIT), /* linked sqes */ - REQ_F_LINK =3D BIT(REQ_F_LINK_BIT), + REQ_F_LINK =3D BIT_ULL(REQ_F_LINK_BIT), /* doesn't sever on completion < 0 */ - REQ_F_HARDLINK =3D BIT(REQ_F_HARDLINK_BIT), + REQ_F_HARDLINK =3D BIT_ULL(REQ_F_HARDLINK_BIT), /* IOSQE_ASYNC */ - REQ_F_FORCE_ASYNC =3D BIT(REQ_F_FORCE_ASYNC_BIT), + REQ_F_FORCE_ASYNC =3D BIT_ULL(REQ_F_FORCE_ASYNC_BIT), /* IOSQE_BUFFER_SELECT */ - REQ_F_BUFFER_SELECT =3D BIT(REQ_F_BUFFER_SELECT_BIT), + REQ_F_BUFFER_SELECT =3D BIT_ULL(REQ_F_BUFFER_SELECT_BIT), /* IOSQE_CQE_SKIP_SUCCESS */ - REQ_F_CQE_SKIP =3D BIT(REQ_F_CQE_SKIP_BIT), + REQ_F_CQE_SKIP =3D BIT_ULL(REQ_F_CQE_SKIP_BIT), =20 /* fail rest of links */ - REQ_F_FAIL =3D BIT(REQ_F_FAIL_BIT), + REQ_F_FAIL =3D BIT_ULL(REQ_F_FAIL_BIT), /* on inflight list, should be cancelled and waited on exit reliably */ - REQ_F_INFLIGHT =3D BIT(REQ_F_INFLIGHT_BIT), + REQ_F_INFLIGHT =3D BIT_ULL(REQ_F_INFLIGHT_BIT), /* read/write uses file position */ - REQ_F_CUR_POS =3D BIT(REQ_F_CUR_POS_BIT), + REQ_F_CUR_POS =3D BIT_ULL(REQ_F_CUR_POS_BIT), /* must not punt to workers */ - REQ_F_NOWAIT =3D BIT(REQ_F_NOWAIT_BIT), + REQ_F_NOWAIT =3D BIT_ULL(REQ_F_NOWAIT_BIT), /* has or had linked timeout */ - REQ_F_LINK_TIMEOUT =3D BIT(REQ_F_LINK_TIMEOUT_BIT), + REQ_F_LINK_TIMEOUT =3D BIT_ULL(REQ_F_LINK_TIMEOUT_BIT), /* needs cleanup */ - REQ_F_NEED_CLEANUP =3D BIT(REQ_F_NEED_CLEANUP_BIT), + REQ_F_NEED_CLEANUP =3D BIT_ULL(REQ_F_NEED_CLEANUP_BIT), /* already went through poll handler */ - REQ_F_POLLED =3D BIT(REQ_F_POLLED_BIT), + REQ_F_POLLED =3D BIT_ULL(REQ_F_POLLED_BIT), /* buffer already selected */ - REQ_F_BUFFER_SELECTED =3D BIT(REQ_F_BUFFER_SELECTED_BIT), + REQ_F_BUFFER_SELECTED =3D BIT_ULL(REQ_F_BUFFER_SELECTED_BIT), /* buffer selected from ring, needs commit */ - REQ_F_BUFFER_RING =3D BIT(REQ_F_BUFFER_RING_BIT), + REQ_F_BUFFER_RING =3D BIT_ULL(REQ_F_BUFFER_RING_BIT), /* caller should reissue async */ - REQ_F_REISSUE =3D BIT(REQ_F_REISSUE_BIT), + REQ_F_REISSUE =3D BIT_ULL(REQ_F_REISSUE_BIT), /* supports async reads/writes */ - REQ_F_SUPPORT_NOWAIT =3D BIT(REQ_F_SUPPORT_NOWAIT_BIT), + REQ_F_SUPPORT_NOWAIT =3D BIT_ULL(REQ_F_SUPPORT_NOWAIT_BIT), /* regular file */ - REQ_F_ISREG =3D BIT(REQ_F_ISREG_BIT), + REQ_F_ISREG =3D BIT_ULL(REQ_F_ISREG_BIT), /* has creds assigned */ - REQ_F_CREDS =3D BIT(REQ_F_CREDS_BIT), + REQ_F_CREDS =3D BIT_ULL(REQ_F_CREDS_BIT), /* skip refcounting if not set */ - REQ_F_REFCOUNT =3D BIT(REQ_F_REFCOUNT_BIT), + REQ_F_REFCOUNT =3D BIT_ULL(REQ_F_REFCOUNT_BIT), /* there is a linked timeout that has to be armed */ - REQ_F_ARM_LTIMEOUT =3D BIT(REQ_F_ARM_LTIMEOUT_BIT), + REQ_F_ARM_LTIMEOUT =3D BIT_ULL(REQ_F_ARM_LTIMEOUT_BIT), /* ->async_data allocated */ - REQ_F_ASYNC_DATA =3D BIT(REQ_F_ASYNC_DATA_BIT), + REQ_F_ASYNC_DATA =3D BIT_ULL(REQ_F_ASYNC_DATA_BIT), /* don't post CQEs while failing linked requests */ - REQ_F_SKIP_LINK_CQES =3D BIT(REQ_F_SKIP_LINK_CQES_BIT), + REQ_F_SKIP_LINK_CQES =3D BIT_ULL(REQ_F_SKIP_LINK_CQES_BIT), /* single poll may be active */ - REQ_F_SINGLE_POLL =3D BIT(REQ_F_SINGLE_POLL_BIT), + REQ_F_SINGLE_POLL =3D BIT_ULL(REQ_F_SINGLE_POLL_BIT), /* double poll may active */ - REQ_F_DOUBLE_POLL =3D BIT(REQ_F_DOUBLE_POLL_BIT), + REQ_F_DOUBLE_POLL =3D BIT_ULL(REQ_F_DOUBLE_POLL_BIT), /* request has already done partial IO */ - REQ_F_PARTIAL_IO =3D BIT(REQ_F_PARTIAL_IO_BIT), + REQ_F_PARTIAL_IO =3D BIT_ULL(REQ_F_PARTIAL_IO_BIT), /* fast poll multishot mode */ - REQ_F_APOLL_MULTISHOT =3D BIT(REQ_F_APOLL_MULTISHOT_BIT), + REQ_F_APOLL_MULTISHOT =3D BIT_ULL(REQ_F_APOLL_MULTISHOT_BIT), /* ->extra1 and ->extra2 are initialised */ - REQ_F_CQE32_INIT =3D BIT(REQ_F_CQE32_INIT_BIT), + REQ_F_CQE32_INIT =3D BIT_ULL(REQ_F_CQE32_INIT_BIT), /* recvmsg special flag, clear EPOLLIN */ - REQ_F_CLEAR_POLLIN =3D BIT(REQ_F_CLEAR_POLLIN_BIT), + REQ_F_CLEAR_POLLIN =3D BIT_ULL(REQ_F_CLEAR_POLLIN_BIT), /* hashed into ->cancel_hash_locked, protected by ->uring_lock */ - REQ_F_HASH_LOCKED =3D BIT(REQ_F_HASH_LOCKED_BIT), + REQ_F_HASH_LOCKED =3D BIT_ULL(REQ_F_HASH_LOCKED_BIT), }; =20 typedef void (*io_req_tw_func_t)(struct io_kiocb *req, struct io_tw_state = *ts); @@ -536,7 +536,8 @@ struct io_kiocb { * and after selection it points to the buffer ID itself. */ u16 buf_index; - unsigned int flags; + u32 __pad; + u64 flags; =20 struct io_cqe cqe; =20 diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c index 536940675c67..693558c4b10b 100644 --- a/io_uring/io_uring.c +++ b/io_uring/io_uring.c @@ -4486,7 +4486,7 @@ static int __init io_uring_init(void) BUILD_BUG_ON(SQE_COMMON_FLAGS >=3D (1 << 8)); BUILD_BUG_ON((SQE_VALID_FLAGS | SQE_COMMON_FLAGS) !=3D SQE_VALID_FLAGS); =20 - BUILD_BUG_ON(__REQ_F_LAST_BIT > 8 * sizeof(int)); + BUILD_BUG_ON(__REQ_F_LAST_BIT > 8 * sizeof(u64)); =20 BUILD_BUG_ON(sizeof(atomic_t) !=3D sizeof(u32)); =20 --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CE4A2C76196 for ; Tue, 28 Mar 2023 15:13:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233938AbjC1PNu (ORCPT ); Tue, 28 Mar 2023 11:13:50 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55104 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233918AbjC1PNb (ORCPT ); Tue, 28 Mar 2023 11:13:31 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9069F10415 for ; Tue, 28 Mar 2023 08:12:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016260; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=lK02yM2bzLjmtDa73L1C009IahLiG4RzhCW59S2y7Ds=; b=LBshVTyMLSQIvU6FrXr7WqKeoKNyUAQ8w+rljLStAf33qKTyJChix51cYNIwuCYiz/oh0h qVq4ynVLJBZSeCYxmMO8Y3nfHMyJOLm0oq4f3OJhgTilKkF0S8yNWu06Jv/IG5HI3G0ViZ nNzATlG4kIBrQIWWW8q49TS72RbqpHQ= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-671-SO5CHnfeNDid4SxIcIymSw-1; Tue, 28 Mar 2023 11:10:55 -0400 X-MC-Unique: SO5CHnfeNDid4SxIcIymSw-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.rdu2.redhat.com [10.11.54.2]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 41C4A887413; Tue, 28 Mar 2023 15:10:55 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id BF6584020C82; Tue, 28 Mar 2023 15:10:53 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 02/16] io_uring: add IORING_OP_FUSED_CMD Date: Tue, 28 Mar 2023 23:09:44 +0800 Message-Id: <20230328150958.1253547-3-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.2 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add IORING_OP_FUSED_CMD, it is one special URING_CMD, which has to be SQE128. The 1st SQE(primary) is one 64byte URING_CMD, and the 2nd 64byte SQE(secondary) is another normal 64byte OP. For any OP which needs to support secondary OP, io_issue_defs[op].fused_secondary has to be set as= 1, and its ->issue() needs to retrieve buffer from primary request's fused_cmd_kbuf. Follows the key points of the design/implementation: 1) The primary uring command produces and provides immutable command buffer(struct io_uring_bvec_buf) to the secondary request, and the secondary OP can retrieve any part of this buffer by sqe->addr and sqe->len. 2) Master command is always completed after the secondary request is completed, so secondary request can be thought as serving for primary command. - secondary request borrows primary command's buffer(io_uring_bvec_buf), af= ter secondary request is completed, the buffer is returned back to primary requ= est. - This way also guarantees correct SQE order since the primary request uses secondary request's LINK flag. 3) Master request completion is always notified to driver, so that driver can know when the buffer is done with secondary quest. This way is important since io_uring_bvec_buf represents reference of device io command buffer, and we have to gurantee that reference can not outlive the referent buffer, so far which is represented by bvec. 4) kernel API of io_fused_cmd_start_secondary_req is called by driver for making the buffer of io_uring_bvec_buf and starting to submit secondary request with the provided buffer. The motivation is for supporting zero copy for fuse/ublk, in which the device holds IO request buffer, and IO handling is often normal IO OP(fs, net, ..). With IORING_OP_FUSED_CMD, we can implement this kind of zero copy easily & reliably. Signed-off-by: Ming Lei --- include/linux/io_uring.h | 50 ++++++- include/linux/io_uring_types.h | 12 ++ include/uapi/linux/io_uring.h | 3 + io_uring/Makefile | 2 +- io_uring/fused_cmd.c | 241 +++++++++++++++++++++++++++++++++ io_uring/fused_cmd.h | 11 ++ io_uring/io_uring.c | 26 +++- io_uring/io_uring.h | 3 + io_uring/opdef.c | 12 ++ io_uring/opdef.h | 7 + 10 files changed, 361 insertions(+), 6 deletions(-) create mode 100644 io_uring/fused_cmd.c create mode 100644 io_uring/fused_cmd.h diff --git a/include/linux/io_uring.h b/include/linux/io_uring.h index 35b9328ca335..fdb48fff8313 100644 --- a/include/linux/io_uring.h +++ b/include/linux/io_uring.h @@ -4,6 +4,7 @@ =20 #include #include +#include #include =20 enum io_uring_cmd_flags { @@ -20,6 +21,26 @@ enum io_uring_cmd_flags { IO_URING_F_SQE128 =3D (1 << 8), IO_URING_F_CQE32 =3D (1 << 9), IO_URING_F_IOPOLL =3D (1 << 10), + + /* for FUSED_CMD only */ + IO_URING_F_FUSED_BUF_DEST =3D (1 << 11), /* secondary write to buffer */ + IO_URING_F_FUSED_BUF_SRC =3D (1 << 12), /* secondary read from buffer */ + /* driver incapable of FUSED_CMD should fail cmd when seeing F_FUSED */ + IO_URING_F_FUSED =3D IO_URING_F_FUSED_BUF_DEST | + IO_URING_F_FUSED_BUF_SRC, +}; + +union io_uring_fused_cmd_data { + /* + * In case of secondary request IOSQE_CQE_SKIP_SUCCESS, return the + * result via primary command; otherwise we simply return success + * if buffer is provided, and secondary request will return its result + * via its CQE + */ + s32 secondary_res; + + /* fused cmd private, driver do not touch it */ + struct io_kiocb *__secondary; }; =20 struct io_uring_cmd { @@ -33,10 +54,31 @@ struct io_uring_cmd { }; u32 cmd_op; u32 flags; - u8 pdu[32]; /* available inline for free use */ + + /* for fused command, the available pdu is a bit less */ + union { + struct { + union io_uring_fused_cmd_data data; + u8 pdu[24]; /* available inline for free use */ + } fused; + u8 pdu[32]; /* available inline for free use */ + }; +}; + +struct io_uring_bvec_buf { + unsigned long len; + unsigned int nr_bvecs; + + /* offset in the 1st bvec */ + unsigned int offset; + const struct bio_vec *bvec; + struct bio_vec __bvec[]; }; =20 #if defined(CONFIG_IO_URING) +void io_fused_cmd_start_secondary_req(struct io_uring_cmd *, unsigned, + const struct io_uring_bvec_buf *, + void (*complete_tw_cb)(struct io_uring_cmd *, unsigned)); int io_uring_cmd_import_fixed(u64 ubuf, unsigned long len, int rw, struct iov_iter *iter, void *ioucmd); void io_uring_cmd_done(struct io_uring_cmd *cmd, ssize_t ret, ssize_t res2, @@ -67,6 +109,12 @@ static inline void io_uring_free(struct task_struct *ts= k) __io_uring_free(tsk); } #else +static inline void io_fused_cmd_start_secondary_req(struct io_uring_cmd *, + unsigned issue_flags, const struct io_uring_bvec_buf *, + unsigned int, + void (*complete_tw_cb)(struct io_uring_cmd *, unsigned)) +{ +} static inline int io_uring_cmd_import_fixed(u64 ubuf, unsigned long len, i= nt rw, struct iov_iter *iter, void *ioucmd) { diff --git a/include/linux/io_uring_types.h b/include/linux/io_uring_types.h index dd8ef886730b..9c427f1e00e6 100644 --- a/include/linux/io_uring_types.h +++ b/include/linux/io_uring_types.h @@ -407,6 +407,7 @@ enum { /* keep async read/write and isreg together and in order */ REQ_F_SUPPORT_NOWAIT_BIT, REQ_F_ISREG_BIT, + REQ_F_FUSED_SECONDARY_BIT, =20 /* not a real bit, just to check we're not overflowing the space */ __REQ_F_LAST_BIT, @@ -476,6 +477,8 @@ enum { REQ_F_CLEAR_POLLIN =3D BIT_ULL(REQ_F_CLEAR_POLLIN_BIT), /* hashed into ->cancel_hash_locked, protected by ->uring_lock */ REQ_F_HASH_LOCKED =3D BIT_ULL(REQ_F_HASH_LOCKED_BIT), + /* secondary request in fused cmd, won't be one uring cmd */ + REQ_F_FUSED_SECONDARY =3D BIT_ULL(REQ_F_FUSED_SECONDARY_BIT), }; =20 typedef void (*io_req_tw_func_t)(struct io_kiocb *req, struct io_tw_state = *ts); @@ -558,6 +561,15 @@ struct io_kiocb { * REQ_F_BUFFER_RING is set. */ struct io_buffer_list *buf_list; + + /* + * store kernel (sub)buffer of fused primary request which OP + * is IORING_OP_FUSED_CMD + */ + const struct io_uring_bvec_buf *fused_cmd_kbuf; + + /* store fused command's primary request for the secondary */ + struct io_kiocb *fused_primary_req; }; =20 union { diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h index f8d14d1c58d3..98b7f21623f9 100644 --- a/include/uapi/linux/io_uring.h +++ b/include/uapi/linux/io_uring.h @@ -73,6 +73,8 @@ struct io_uring_sqe { __u16 buf_index; /* for grouped buffer selection */ __u16 buf_group; + /* how many secondary normal SQEs following this fused SQE */ + __u16 nr_secondary; } __attribute__((packed)); /* personality to use, if used */ __u16 personality; @@ -223,6 +225,7 @@ enum io_uring_op { IORING_OP_URING_CMD, IORING_OP_SEND_ZC, IORING_OP_SENDMSG_ZC, + IORING_OP_FUSED_CMD, =20 /* this goes last, obviously */ IORING_OP_LAST, diff --git a/io_uring/Makefile b/io_uring/Makefile index 8cc8e5387a75..5301077e61c5 100644 --- a/io_uring/Makefile +++ b/io_uring/Makefile @@ -7,5 +7,5 @@ obj-$(CONFIG_IO_URING) +=3D io_uring.o xattr.o nop.o fs.o = splice.o \ openclose.o uring_cmd.o epoll.o \ statx.o net.o msg_ring.o timeout.o \ sqpoll.o fdinfo.o tctx.o poll.o \ - cancel.o kbuf.o rsrc.o rw.o opdef.o notif.o + cancel.o kbuf.o rsrc.o rw.o opdef.o notif.o fused_cmd.o obj-$(CONFIG_IO_WQ) +=3D io-wq.o diff --git a/io_uring/fused_cmd.c b/io_uring/fused_cmd.c new file mode 100644 index 000000000000..7af3ddb182c1 --- /dev/null +++ b/io_uring/fused_cmd.c @@ -0,0 +1,241 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "io_uring.h" +#include "opdef.h" +#include "rsrc.h" +#include "uring_cmd.h" +#include "fused_cmd.h" + +static bool io_fused_secondary_valid(const struct io_uring_sqe *sqe, u8 op) +{ + unsigned int sqe_flags =3D READ_ONCE(sqe->flags); + + if (op =3D=3D IORING_OP_FUSED_CMD || op =3D=3D IORING_OP_URING_CMD) + return false; + + if (sqe_flags & REQ_F_BUFFER_SELECT) + return false; + + if (!io_issue_defs[op].fused_secondary) + return false; + + return true; +} + +static inline void io_fused_cmd_update_link_flags(struct io_kiocb *req, + const struct io_kiocb *secondary) +{ + /* + * We have to keep secondary SQE in order, so update primary link flags + * with secondary request's given primary command isn't completed until + * the secondary request is done + */ + if (secondary->flags & (REQ_F_LINK | REQ_F_HARDLINK)) + req->flags |=3D REQ_F_LINK; +} + +int io_fused_cmd_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) + __must_hold(&req->ctx->uring_lock) +{ + struct io_uring_cmd *ioucmd =3D io_kiocb_to_cmd(req, struct io_uring_cmd); + const struct io_uring_sqe *secondary_sqe =3D sqe + 1; + struct io_ring_ctx *ctx =3D req->ctx; + struct io_kiocb *secondary; + u8 secondary_op; + int ret; + + if (unlikely(!(ctx->flags & IORING_SETUP_SQE128))) + return -EINVAL; + + if (unlikely(sqe->__pad1)) + return -EINVAL; + + /* + * So far, only support single secondary request, in future we may + * extend to support multiple secondary requests + */ + if (unlikely(sqe->nr_secondary !=3D 1)) + return -EINVAL; + + ioucmd->flags =3D READ_ONCE(sqe->uring_cmd_flags); + if (unlikely(ioucmd->flags)) + return -EINVAL; + + secondary_op =3D READ_ONCE(secondary_sqe->opcode); + if (unlikely(!io_fused_secondary_valid(secondary_sqe, secondary_op))) + return -EINVAL; + + ioucmd->cmd =3D sqe->cmd; + ioucmd->cmd_op =3D READ_ONCE(sqe->cmd_op); + req->fused_cmd_kbuf =3D NULL; + + /* take one extra reference for the secondary request */ + io_get_task_refs(1); + + ret =3D -ENOMEM; + if (unlikely(!io_alloc_req(ctx, &secondary))) + goto fail; + + ret =3D io_init_secondary_req(ctx, secondary, secondary_sqe); + if (unlikely(ret)) + goto fail_free_req; + + /* + * The secondary request won't be linked to io_uring submission link list, + * so it can't be handled by IORING_OP_LINK_TIMEOUT, however, we can do + * that on primary command directly + */ + io_fused_cmd_update_link_flags(req, secondary); + + ioucmd->fused.data.__secondary =3D secondary; + + return 0; + +fail_free_req: + io_free_req(secondary); +fail: + current->io_uring->cached_refs +=3D 1; + return ret; +} + +int io_fused_cmd(struct io_kiocb *req, unsigned int issue_flags) +{ + struct io_uring_cmd *ioucmd =3D io_kiocb_to_cmd(req, struct io_uring_cmd); + const struct io_kiocb *secondary =3D ioucmd->fused.data.__secondary; + int ret =3D -EINVAL; + + /* + * Pass buffer direction for driver to validate if the requested buffer + * direction is legal + */ + if (io_issue_defs[secondary->opcode].buf_dir) + issue_flags |=3D IO_URING_F_FUSED_BUF_DEST; + else + issue_flags |=3D IO_URING_F_FUSED_BUF_SRC; + + ret =3D io_uring_cmd(req, issue_flags); + if (ret !=3D IOU_ISSUE_SKIP_COMPLETE) + io_free_req(ioucmd->fused.data.__secondary); + + return ret; +} + +int io_import_buf_for_secondary(unsigned long buf_off, unsigned int len, + int dir, struct iov_iter *iter, struct io_kiocb *secondary) +{ + struct io_kiocb *req =3D secondary->fused_primary_req; + const struct io_uring_bvec_buf *kbuf; + unsigned long offset; + + if (unlikely(!(secondary->flags & REQ_F_FUSED_SECONDARY) || !req)) + return -EINVAL; + + if (unlikely(!req->fused_cmd_kbuf)) + return -EINVAL; + + /* req->fused_cmd_kbuf is immutable */ + kbuf =3D req->fused_cmd_kbuf; + offset =3D kbuf->offset; + + if (!kbuf->bvec) + return -EINVAL; + + if (unlikely(buf_off > kbuf->len)) + return -EFAULT; + + if (unlikely(len > kbuf->len - buf_off)) + return -EFAULT; + + /* don't use io_import_fixed which doesn't support multipage bvec */ + offset +=3D buf_off; + iov_iter_bvec(iter, dir, kbuf->bvec, kbuf->nr_bvecs, offset + len); + + if (offset) + iov_iter_advance(iter, offset); + + return 0; +} + +/* + * Called after secondary request is completed, + * + * Return back primary's fused_cmd kbuf, and notify primary request by + * the saved callback. + */ +void io_fused_cmd_return_buf(struct io_kiocb *secondary) +{ + struct io_kiocb *req =3D secondary->fused_primary_req; + struct io_uring_cmd *ioucmd; + + if (unlikely(!req || !(secondary->flags & REQ_F_FUSED_SECONDARY))) + return; + + /* return back the buffer */ + secondary->fused_primary_req =3D NULL; + ioucmd =3D io_kiocb_to_cmd(req, struct io_uring_cmd); + ioucmd->fused.data.__secondary =3D NULL; + + /* + * If secondary OP skips CQE, return the result via primary command; or + * if secondary request is failed, REQ_F_CQE_SKIP will be cleared, return + * result too + */ + if ((secondary->flags & REQ_F_CQE_SKIP) || secondary->cqe.res < 0) + ioucmd->fused.data.secondary_res =3D secondary->cqe.res; + else + ioucmd->fused.data.secondary_res =3D 0; + io_uring_cmd_complete_in_task(ioucmd, ioucmd->task_work_cb); +} + +/* + * Called for starting secondary request after primary command prepared io= buffer. + * + * The io buffer is represented by @fused_cmd_kbuf, which is read only for + * secondary request, however secondary request can retrieve any sub-buffe= r by its + * sqe->addr(offset) & sqe->len. For secondary request, io buffer is impor= ted + * by io_import_buf_for_secondary(). + * + * Slave request borrows primary's io buffer for handling the secondary op= eration, + * and the buffer is returned back via io_fused_cmd_return_buf after the s= econdary + * request is completed. Meantime the primary command is completed from + * io_fused_cmd_return_buf(). And driver gets completion notification by + * the passed callback of @complete_tw_cb. + */ +void io_fused_cmd_start_secondary_req(struct io_uring_cmd *ioucmd, + unsigned issue_flags, + const struct io_uring_bvec_buf *fused_cmd_kbuf, + void (*complete_tw_cb)(struct io_uring_cmd *, unsigned)) +{ + struct io_kiocb *req =3D cmd_to_io_kiocb(ioucmd); + struct io_kiocb *secondary =3D ioucmd->fused.data.__secondary; + struct io_tw_state ts =3D { + .locked =3D !(issue_flags & IO_URING_F_UNLOCKED), + }; + + if (WARN_ON_ONCE(unlikely(!secondary || !(secondary->flags & + REQ_F_FUSED_SECONDARY)))) + return; + + /* + * Once the fused secondary request is completed and the buffer isn't be + * used, the driver will be notified by callback of complete_tw_cb + */ + ioucmd->task_work_cb =3D complete_tw_cb; + + /* now we get the buffer */ + req->fused_cmd_kbuf =3D fused_cmd_kbuf; + secondary->fused_primary_req =3D req; + + trace_io_uring_submit_sqe(secondary, true); + io_req_task_submit(secondary, &ts); +} +EXPORT_SYMBOL_GPL(io_fused_cmd_start_secondary_req); diff --git a/io_uring/fused_cmd.h b/io_uring/fused_cmd.h new file mode 100644 index 000000000000..c75e5d8c5763 --- /dev/null +++ b/io_uring/fused_cmd.h @@ -0,0 +1,11 @@ +// SPDX-License-Identifier: GPL-2.0 +#ifndef IOU_FUSED_CMD_H +#define IOU_FUSED_CMD_H + +int io_fused_cmd_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe= ); +int io_fused_cmd(struct io_kiocb *req, unsigned int issue_flags); +void io_fused_cmd_return_buf(struct io_kiocb *secondary); +int io_import_buf_for_secondary(unsigned long buf, unsigned int len, int d= ir, + struct iov_iter *iter, struct io_kiocb *secondary); + +#endif diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c index 693558c4b10b..ddbc9b9e51d3 100644 --- a/io_uring/io_uring.c +++ b/io_uring/io_uring.c @@ -92,6 +92,7 @@ #include "cancel.h" #include "net.h" #include "notif.h" +#include "fused_cmd.h" =20 #include "timeout.h" #include "poll.h" @@ -111,7 +112,7 @@ =20 #define IO_REQ_CLEAN_FLAGS (REQ_F_BUFFER_SELECTED | REQ_F_NEED_CLEANUP | \ REQ_F_POLLED | REQ_F_INFLIGHT | REQ_F_CREDS | \ - REQ_F_ASYNC_DATA) + REQ_F_ASYNC_DATA | REQ_F_FUSED_SECONDARY) =20 #define IO_REQ_CLEAN_SLOW_FLAGS (REQ_F_REFCOUNT | REQ_F_LINK | REQ_F_HARDL= INK |\ IO_REQ_CLEAN_FLAGS) @@ -971,6 +972,9 @@ static void __io_req_complete_post(struct io_kiocb *req) { struct io_ring_ctx *ctx =3D req->ctx; =20 + if (req->flags & REQ_F_FUSED_SECONDARY) + io_fused_cmd_return_buf(req); + io_cq_lock(ctx); if (!(req->flags & REQ_F_CQE_SKIP)) io_fill_cqe_req(ctx, req); @@ -1855,6 +1859,8 @@ static void io_clean_op(struct io_kiocb *req) spin_lock(&req->ctx->completion_lock); io_put_kbuf_comp(req); spin_unlock(&req->ctx->completion_lock); + } else if (req->flags & REQ_F_FUSED_SECONDARY) { + io_fused_cmd_return_buf(req); } =20 if (req->flags & REQ_F_NEED_CLEANUP) { @@ -2163,8 +2169,8 @@ static void io_init_req_drain(struct io_kiocb *req) } } =20 -static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req, - const struct io_uring_sqe *sqe) +static inline int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *re= q, + const struct io_uring_sqe *sqe, bool secondary) __must_hold(&ctx->uring_lock) { const struct io_issue_def *def; @@ -2217,6 +2223,12 @@ static int io_init_req(struct io_ring_ctx *ctx, stru= ct io_kiocb *req, } } =20 + if (secondary) { + if (!def->fused_secondary) + return -EINVAL; + req->flags |=3D REQ_F_FUSED_SECONDARY; + } + if (!def->ioprio && sqe->ioprio) return -EINVAL; if (!def->iopoll && (ctx->flags & IORING_SETUP_IOPOLL)) @@ -2257,6 +2269,12 @@ static int io_init_req(struct io_ring_ctx *ctx, stru= ct io_kiocb *req, return def->prep(req, sqe); } =20 +int io_init_secondary_req(struct io_ring_ctx *ctx, struct io_kiocb *req, + const struct io_uring_sqe *sqe) +{ + return io_init_req(ctx, req, sqe, true); +} + static __cold int io_submit_fail_init(const struct io_uring_sqe *sqe, struct io_kiocb *req, int ret) { @@ -2301,7 +2319,7 @@ static inline int io_submit_sqe(struct io_ring_ctx *c= tx, struct io_kiocb *req, struct io_submit_link *link =3D &ctx->submit_state.link; int ret; =20 - ret =3D io_init_req(ctx, req, sqe); + ret =3D io_init_req(ctx, req, sqe, false); if (unlikely(ret)) return io_submit_fail_init(sqe, req, ret); =20 diff --git a/io_uring/io_uring.h b/io_uring/io_uring.h index c33f719731ac..dd193c612348 100644 --- a/io_uring/io_uring.h +++ b/io_uring/io_uring.h @@ -78,6 +78,9 @@ bool __io_alloc_req_refill(struct io_ring_ctx *ctx); bool io_match_task_safe(struct io_kiocb *head, struct task_struct *task, bool cancel_all); =20 +int io_init_secondary_req(struct io_ring_ctx *ctx, struct io_kiocb *req, + const struct io_uring_sqe *sqe); + #define io_lockdep_assert_cq_locked(ctx) \ do { \ if (ctx->flags & IORING_SETUP_IOPOLL) { \ diff --git a/io_uring/opdef.c b/io_uring/opdef.c index cca7c5b55208..63b90e8e65f8 100644 --- a/io_uring/opdef.c +++ b/io_uring/opdef.c @@ -33,6 +33,7 @@ #include "poll.h" #include "cancel.h" #include "rw.h" +#include "fused_cmd.h" =20 static int io_no_issue(struct io_kiocb *req, unsigned int issue_flags) { @@ -428,6 +429,12 @@ const struct io_issue_def io_issue_defs[] =3D { .prep =3D io_eopnotsupp_prep, #endif }, + [IORING_OP_FUSED_CMD] =3D { + .needs_file =3D 1, + .plug =3D 1, + .prep =3D io_fused_cmd_prep, + .issue =3D io_fused_cmd, + }, }; =20 =20 @@ -648,6 +655,11 @@ const struct io_cold_def io_cold_defs[] =3D { .fail =3D io_sendrecv_fail, #endif }, + [IORING_OP_FUSED_CMD] =3D { + .name =3D "FUSED_CMD", + .async_size =3D uring_cmd_pdu_size(1), + .prep_async =3D io_uring_cmd_prep_async, + }, }; =20 const char *io_uring_get_opcode(u8 opcode) diff --git a/io_uring/opdef.h b/io_uring/opdef.h index c22c8696e749..bded61ebcbfc 100644 --- a/io_uring/opdef.h +++ b/io_uring/opdef.h @@ -29,6 +29,13 @@ struct io_issue_def { unsigned iopoll_queue : 1; /* opcode specific path will handle ->async_data allocation if needed */ unsigned manual_alloc : 1; + /* can be secondary op of fused command */ + unsigned fused_secondary : 1; + /* + * buffer direction, 0 : read from buffer, 1: write to buffer, used + * for fused_secondary only + */ + unsigned buf_dir : 1; =20 int (*issue)(struct io_kiocb *, unsigned int); int (*prep)(struct io_kiocb *, const struct io_uring_sqe *); --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0A2EDC6FD18 for ; Tue, 28 Mar 2023 15:14:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231332AbjC1PON (ORCPT ); Tue, 28 Mar 2023 11:14:13 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53506 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233931AbjC1PNk (ORCPT ); Tue, 28 Mar 2023 11:13:40 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6634D10252 for ; Tue, 28 Mar 2023 08:12:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016265; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=siKKh0x5p/UqrBQe9QYa+cxMAYrLZPJZiVZtx1DzXec=; b=Yl5FdRpJp7RFWDKyfDFsAPK0F5bnCA7FwbVoN1lxGqUm8CpdNfhfoAY1x7uEyFTPEKdhQH F2DiweAWSTtWmru4/AWrrQIgDg1kJql0vYBrhf3kQ4R0y7lF/nPAf4/p6JoJl1Y8UQv982 MKAAU+B7MLoBUv65rWYxuEv38fuKb0s= Received: from mimecast-mx02.redhat.com (mx3-rdu2.redhat.com [66.187.233.73]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-381-TbRalWqROt-cqgLg3YGivw-1; Tue, 28 Mar 2023 11:11:00 -0400 X-MC-Unique: TbRalWqROt-cqgLg3YGivw-1 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.rdu2.redhat.com [10.11.54.3]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id E82993C17124; Tue, 28 Mar 2023 15:10:58 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 0416C1121330; Tue, 28 Mar 2023 15:10:57 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 03/16] io_uring: support normal SQE for fused command Date: Tue, 28 Mar 2023 23:09:45 +0800 Message-Id: <20230328150958.1253547-4-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.3 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" So far, the secondary sqe is saved in the 2nd 64 byte of primary sqe, which requires that SQE128 has to be enabled. Relax this limit by allowing to fetch secondary SQE from SQ directly. IORING_URING_CMD_FUSED_SPLIT_SQE has to be set for this usage, and userspace has to put secondary SQE following the primary sqe. Signed-off-by: Ming Lei --- include/uapi/linux/io_uring.h | 8 ++++++- io_uring/fused_cmd.c | 42 ++++++++++++++++++++++++++++------- io_uring/io_uring.c | 23 +++++++++++++------ io_uring/io_uring.h | 2 ++ 4 files changed, 59 insertions(+), 16 deletions(-) diff --git a/include/uapi/linux/io_uring.h b/include/uapi/linux/io_uring.h index 98b7f21623f9..b379677dff9d 100644 --- a/include/uapi/linux/io_uring.h +++ b/include/uapi/linux/io_uring.h @@ -235,9 +235,15 @@ enum io_uring_op { * sqe->uring_cmd_flags * IORING_URING_CMD_FIXED use registered buffer; pass this flag * along with setting sqe->buf_index. + * + * IORING_URING_CMD_FUSED_SPLIT_SQE fused command only, secondary sqe is + * provided from another new sqe; without + * setting the flag, secondary sqe is from + * 2nd 64byte of this sqe, so SQE128 has + * to be enabled */ #define IORING_URING_CMD_FIXED (1U << 0) - +#define IORING_URING_CMD_FUSED_SPLIT_SQE (1U << 1) =20 /* * sqe->fsync_flags diff --git a/io_uring/fused_cmd.c b/io_uring/fused_cmd.c index 7af3ddb182c1..25577cbb0e9c 100644 --- a/io_uring/fused_cmd.c +++ b/io_uring/fused_cmd.c @@ -43,18 +43,34 @@ static inline void io_fused_cmd_update_link_flags(struc= t io_kiocb *req, req->flags |=3D REQ_F_LINK; } =20 +static const struct io_uring_sqe *fused_cmd_get_secondary_sqe( + struct io_ring_ctx *ctx, const struct io_uring_sqe *primary, + bool split_sqe) +{ + if (unlikely(!(ctx->flags & IORING_SETUP_SQE128) && !split_sqe)) + return NULL; + + if (split_sqe) { + const struct io_uring_sqe *sqe; + + if (unlikely(!io_get_secondary_sqe(ctx, &sqe))) + return NULL; + return sqe; + } + + return primary + 1; +} + int io_fused_cmd_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) __must_hold(&req->ctx->uring_lock) { struct io_uring_cmd *ioucmd =3D io_kiocb_to_cmd(req, struct io_uring_cmd); - const struct io_uring_sqe *secondary_sqe =3D sqe + 1; + const struct io_uring_sqe *secondary_sqe; struct io_ring_ctx *ctx =3D req->ctx; struct io_kiocb *secondary; u8 secondary_op; int ret; - - if (unlikely(!(ctx->flags & IORING_SETUP_SQE128))) - return -EINVAL; + bool split_sqe; =20 if (unlikely(sqe->__pad1)) return -EINVAL; @@ -67,7 +83,12 @@ int io_fused_cmd_prep(struct io_kiocb *req, const struct= io_uring_sqe *sqe) return -EINVAL; =20 ioucmd->flags =3D READ_ONCE(sqe->uring_cmd_flags); - if (unlikely(ioucmd->flags)) + if (unlikely(ioucmd->flags & ~IORING_URING_CMD_FUSED_SPLIT_SQE)) + return -EINVAL; + + split_sqe =3D ioucmd->flags & IORING_URING_CMD_FUSED_SPLIT_SQE; + secondary_sqe =3D fused_cmd_get_secondary_sqe(ctx, sqe, split_sqe); + if (unlikely(!secondary_sqe)) return -EINVAL; =20 secondary_op =3D READ_ONCE(secondary_sqe->opcode); @@ -78,8 +99,12 @@ int io_fused_cmd_prep(struct io_kiocb *req, const struct= io_uring_sqe *sqe) ioucmd->cmd_op =3D READ_ONCE(sqe->cmd_op); req->fused_cmd_kbuf =3D NULL; =20 - /* take one extra reference for the secondary request */ - io_get_task_refs(1); + /* + * Take one extra reference for the secondary request built from + * builtin SQE since io_uring core code doesn't grab it for us + */ + if (!split_sqe) + io_get_task_refs(1); =20 ret =3D -ENOMEM; if (unlikely(!io_alloc_req(ctx, &secondary))) @@ -103,7 +128,8 @@ int io_fused_cmd_prep(struct io_kiocb *req, const struc= t io_uring_sqe *sqe) fail_free_req: io_free_req(secondary); fail: - current->io_uring->cached_refs +=3D 1; + if (!split_sqe) + current->io_uring->cached_refs +=3D 1; return ret; } =20 diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c index ddbc9b9e51d3..9d9bc5b06ca2 100644 --- a/io_uring/io_uring.c +++ b/io_uring/io_uring.c @@ -2414,7 +2414,8 @@ static void io_commit_sqring(struct io_ring_ctx *ctx) * used, it's important that those reads are done through READ_ONCE() to * prevent a re-load down the line. */ -static bool io_get_sqe(struct io_ring_ctx *ctx, const struct io_uring_sqe = **sqe) +static inline bool io_get_sqe(struct io_ring_ctx *ctx, + const struct io_uring_sqe **sqe) { unsigned head, mask =3D ctx->sq_entries - 1; unsigned sq_idx =3D ctx->cached_sq_head++ & mask; @@ -2443,19 +2444,26 @@ static bool io_get_sqe(struct io_ring_ctx *ctx, con= st struct io_uring_sqe **sqe) return false; } =20 +bool io_get_secondary_sqe(struct io_ring_ctx *ctx, + const struct io_uring_sqe **sqe) +{ + return io_get_sqe(ctx, sqe); +} + int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr) __must_hold(&ctx->uring_lock) { unsigned int entries =3D io_sqring_entries(ctx); - unsigned int left; + unsigned old_head =3D ctx->cached_sq_head; + unsigned int left =3D 0; int ret; =20 if (unlikely(!entries)) return 0; /* make sure SQ entry isn't read before tail */ - ret =3D left =3D min3(nr, ctx->sq_entries, entries); - io_get_task_refs(left); - io_submit_state_start(&ctx->submit_state, left); + ret =3D min3(nr, ctx->sq_entries, entries); + io_get_task_refs(ret); + io_submit_state_start(&ctx->submit_state, ret); =20 do { const struct io_uring_sqe *sqe; @@ -2474,11 +2482,12 @@ int io_submit_sqes(struct io_ring_ctx *ctx, unsigne= d int nr) */ if (unlikely(io_submit_sqe(ctx, req, sqe)) && !(ctx->flags & IORING_SETUP_SUBMIT_ALL)) { - left--; + left =3D 1; break; } - } while (--left); + } while ((ctx->cached_sq_head - old_head) < ret); =20 + left =3D ret - (ctx->cached_sq_head - old_head) - left; if (unlikely(left)) { ret -=3D left; /* try again if it submitted nothing and can't allocate a req */ diff --git a/io_uring/io_uring.h b/io_uring/io_uring.h index dd193c612348..8ede804b3caf 100644 --- a/io_uring/io_uring.h +++ b/io_uring/io_uring.h @@ -78,6 +78,8 @@ bool __io_alloc_req_refill(struct io_ring_ctx *ctx); bool io_match_task_safe(struct io_kiocb *head, struct task_struct *task, bool cancel_all); =20 +bool io_get_secondary_sqe(struct io_ring_ctx *ctx, + const struct io_uring_sqe **sqe); int io_init_secondary_req(struct io_ring_ctx *ctx, struct io_kiocb *req, const struct io_uring_sqe *sqe); =20 --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9D2ACC76196 for ; Tue, 28 Mar 2023 15:28:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234003AbjC1P2x (ORCPT ); Tue, 28 Mar 2023 11:28:53 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49456 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233023AbjC1P2X (ORCPT ); Tue, 28 Mar 2023 11:28:23 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 90F08FF13 for ; Tue, 28 Mar 2023 08:26:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680017161; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=lzFlB5kGsJuuszceCewof5xYnczQcl6NgLt+NqBNBds=; b=YQZV5YwrP3jnWgVjoG9LxDrarpwf0Im1ll8kmCbiG874bdo3ZnvCnWuvqfcSISvmcwrj41 LTPYlqqy34tvaPzo4JF/z1zcW28vnlrTeRGLPMvrFI7D2Z96haEULEBTTucUhWp3WKfjwi 2lHXaPZOE9oEXAgyiyk5Usng4Q8RWsE= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-18-QzwG27TSP_qmvEwynYE1dQ-1; Tue, 28 Mar 2023 11:11:12 -0400 X-MC-Unique: QzwG27TSP_qmvEwynYE1dQ-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.rdu2.redhat.com [10.11.54.2]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 0BF0E801206; Tue, 28 Mar 2023 15:11:09 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 190334020C82; Tue, 28 Mar 2023 15:11:01 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 04/16] io_uring: support OP_READ/OP_WRITE for fused secondary request Date: Tue, 28 Mar 2023 23:09:46 +0800 Message-Id: <20230328150958.1253547-5-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.2 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Start to allow fused secondary request to support OP_READ/OP_WRITE, and the buffer can be retrieved from the primary request. Once the secondary request is completed, the primary request buffer will be returned back. Signed-off-by: Ming Lei --- io_uring/opdef.c | 4 ++++ io_uring/rw.c | 21 +++++++++++++++++++++ 2 files changed, 25 insertions(+) diff --git a/io_uring/opdef.c b/io_uring/opdef.c index 63b90e8e65f8..d81c9afd65ed 100644 --- a/io_uring/opdef.c +++ b/io_uring/opdef.c @@ -235,6 +235,8 @@ const struct io_issue_def io_issue_defs[] =3D { .ioprio =3D 1, .iopoll =3D 1, .iopoll_queue =3D 1, + .fused_secondary =3D 1, + .buf_dir =3D WRITE, .prep =3D io_prep_rw, .issue =3D io_read, }, @@ -248,6 +250,8 @@ const struct io_issue_def io_issue_defs[] =3D { .ioprio =3D 1, .iopoll =3D 1, .iopoll_queue =3D 1, + .fused_secondary =3D 1, + .buf_dir =3D READ, .prep =3D io_prep_rw, .issue =3D io_write, }, diff --git a/io_uring/rw.c b/io_uring/rw.c index 5431caf1e331..d25eeee67c65 100644 --- a/io_uring/rw.c +++ b/io_uring/rw.c @@ -19,6 +19,7 @@ #include "kbuf.h" #include "rsrc.h" #include "rw.h" +#include "fused_cmd.h" =20 struct io_rw { /* NOTE: kiocb has the file as the first member, so don't do it here */ @@ -371,6 +372,18 @@ static struct iovec *__io_import_iovec(int ddir, struc= t io_kiocb *req, size_t sqe_len; ssize_t ret; =20 + /* + * fused_secondary OP passes buffer offset from sqe->addr actually, since + * the fused cmd buf's mapped start address is zero. + */ + if (req->flags & REQ_F_FUSED_SECONDARY) { + ret =3D io_import_buf_for_secondary(rw->addr, rw->len, ddir, + iter, req); + if (ret) + return ERR_PTR(ret); + return NULL; + } + if (opcode =3D=3D IORING_OP_READ_FIXED || opcode =3D=3D IORING_OP_WRITE_F= IXED) { ret =3D io_import_fixed(ddir, iter, req->imu, rw->addr, rw->len); if (ret) @@ -443,11 +456,19 @@ static inline loff_t *io_kiocb_ppos(struct kiocb *kio= cb) */ static ssize_t loop_rw_iter(int ddir, struct io_rw *rw, struct iov_iter *i= ter) { + struct io_kiocb *req =3D cmd_to_io_kiocb(rw); struct kiocb *kiocb =3D &rw->kiocb; struct file *file =3D kiocb->ki_filp; ssize_t ret =3D 0; loff_t *ppos; =20 + /* + * Fused secondary req hasn't user buffer, so ->read/->write can't + * be supported + */ + if (req->flags & REQ_F_FUSED_SECONDARY) + return -EOPNOTSUPP; + /* * Don't support polled IO through this interface, and we can't * support non-blocking either. For the latter, this just causes --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3F47DC77B61 for ; Tue, 28 Mar 2023 15:14:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233947AbjC1PO0 (ORCPT ); Tue, 28 Mar 2023 11:14:26 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54796 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233937AbjC1PNu (ORCPT ); Tue, 28 Mar 2023 11:13:50 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 62A1710A91 for ; Tue, 28 Mar 2023 08:12:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016285; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=B4h73f5q+9OJB7ocdpIjrrTEZsKx6E5zs0QXKOnNU3Q=; b=CyL3lS4lhsNqVZ4rBz+yBJiIAyaeUbwPsTgqiGQqCtlMY6jMD3PEilXOmhug6nu8dx95a3 3YDfl5/UAdPntcpyYvIF/BikeIh1eab4VpKH5db7740fz/zkaG4GGBQxtp32e69OR9+ATH h+QAT1l6pg0qhk8RT/fDw0p2giK4pWU= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-299-IE_ZslxBPuyv2EpFbWcMkQ-1; Tue, 28 Mar 2023 11:11:21 -0400 X-MC-Unique: IE_ZslxBPuyv2EpFbWcMkQ-1 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.rdu2.redhat.com [10.11.54.8]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 2C6981875045; Tue, 28 Mar 2023 15:11:13 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 33C89C15BB8; Tue, 28 Mar 2023 15:11:11 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 05/16] io_uring: support OP_SEND_ZC/OP_RECV for fused secondary request Date: Tue, 28 Mar 2023 23:09:47 +0800 Message-Id: <20230328150958.1253547-6-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.8 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Start to allow fused secondary request to support OP_SEND_ZC/OP_RECV, and the buffer can be retrieved from primary request. Once the secondary request is completed, the primary buffer will be returned back. Signed-off-by: Ming Lei --- io_uring/net.c | 30 ++++++++++++++++++++++++++++-- io_uring/opdef.c | 6 ++++++ 2 files changed, 34 insertions(+), 2 deletions(-) diff --git a/io_uring/net.c b/io_uring/net.c index 4040cf093318..e1c807a6e503 100644 --- a/io_uring/net.c +++ b/io_uring/net.c @@ -16,6 +16,7 @@ #include "net.h" #include "notif.h" #include "rsrc.h" +#include "fused_cmd.h" =20 #if defined(CONFIG_NET) struct io_shutdown { @@ -69,6 +70,13 @@ struct io_sr_msg { struct io_kiocb *notif; }; =20 +#define user_ptr_to_u64(x) ( \ +{ \ + typecheck(void __user *, (x)); \ + (u64)(unsigned long)(x); \ +} \ +) + static inline bool io_check_multishot(struct io_kiocb *req, unsigned int issue_flags) { @@ -379,7 +387,11 @@ int io_send(struct io_kiocb *req, unsigned int issue_f= lags) if (unlikely(!sock)) return -ENOTSOCK; =20 - ret =3D import_ubuf(ITER_SOURCE, sr->buf, sr->len, &msg.msg_iter); + if (!(req->flags & REQ_F_FUSED_SECONDARY)) + ret =3D import_ubuf(ITER_SOURCE, sr->buf, sr->len, &msg.msg_iter); + else + ret =3D io_import_buf_for_secondary(user_ptr_to_u64(sr->buf), + sr->len, ITER_SOURCE, &msg.msg_iter, req); if (unlikely(ret)) return ret; =20 @@ -870,7 +882,11 @@ int io_recv(struct io_kiocb *req, unsigned int issue_f= lags) sr->buf =3D buf; } =20 - ret =3D import_ubuf(ITER_DEST, sr->buf, len, &msg.msg_iter); + if (!(req->flags & REQ_F_FUSED_SECONDARY)) + ret =3D import_ubuf(ITER_DEST, sr->buf, len, &msg.msg_iter); + else + ret =3D io_import_buf_for_secondary(user_ptr_to_u64(sr->buf), + sr->len, ITER_DEST, &msg.msg_iter, req); if (unlikely(ret)) goto out_free; =20 @@ -984,6 +1000,9 @@ int io_send_zc_prep(struct io_kiocb *req, const struct= io_uring_sqe *sqe) if (zc->flags & IORING_RECVSEND_FIXED_BUF) { unsigned idx =3D READ_ONCE(sqe->buf_index); =20 + if (req->flags & REQ_F_FUSED_SECONDARY) + return -EINVAL; + if (unlikely(idx >=3D ctx->nr_user_bufs)) return -EFAULT; idx =3D array_index_nospec(idx, ctx->nr_user_bufs); @@ -1120,8 +1139,15 @@ int io_send_zc(struct io_kiocb *req, unsigned int is= sue_flags) if (unlikely(ret)) return ret; msg.sg_from_iter =3D io_sg_from_iter; + } else if (req->flags & REQ_F_FUSED_SECONDARY) { + ret =3D io_import_buf_for_secondary(user_ptr_to_u64(zc->buf), + zc->len, ITER_SOURCE, &msg.msg_iter, req); + if (unlikely(ret)) + return ret; + msg.sg_from_iter =3D io_sg_from_iter; } else { io_notif_set_extended(zc->notif); + ret =3D import_ubuf(ITER_SOURCE, zc->buf, zc->len, &msg.msg_iter); if (unlikely(ret)) return ret; diff --git a/io_uring/opdef.c b/io_uring/opdef.c index d81c9afd65ed..c31badf4fe45 100644 --- a/io_uring/opdef.c +++ b/io_uring/opdef.c @@ -273,6 +273,8 @@ const struct io_issue_def io_issue_defs[] =3D { .audit_skip =3D 1, .ioprio =3D 1, .manual_alloc =3D 1, + .fused_secondary =3D 1, + .buf_dir =3D READ, #if defined(CONFIG_NET) .prep =3D io_sendmsg_prep, .issue =3D io_send, @@ -287,6 +289,8 @@ const struct io_issue_def io_issue_defs[] =3D { .buffer_select =3D 1, .audit_skip =3D 1, .ioprio =3D 1, + .fused_secondary =3D 1, + .buf_dir =3D WRITE, #if defined(CONFIG_NET) .prep =3D io_recvmsg_prep, .issue =3D io_recv, @@ -413,6 +417,8 @@ const struct io_issue_def io_issue_defs[] =3D { .audit_skip =3D 1, .ioprio =3D 1, .manual_alloc =3D 1, + .fused_secondary =3D 1, + .buf_dir =3D READ, #if defined(CONFIG_NET) .prep =3D io_send_zc_prep, .issue =3D io_send_zc, --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 84AD9C76196 for ; Tue, 28 Mar 2023 15:18:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232571AbjC1PSE (ORCPT ); Tue, 28 Mar 2023 11:18:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53884 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233010AbjC1PRc (ORCPT ); Tue, 28 Mar 2023 11:17:32 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CDFDF10423 for ; Tue, 28 Mar 2023 08:15:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016500; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=2HaaAMVXBOU9npIKRCm63G2Jnf2K0Y8PRLMtIL+XBWM=; b=a013+mhGXq/5KosL/zRRFwMQ7pByfNEnJbMlP3imWYCzL130N1Sfz3dOUg0ibEIsgbAwDF 72FhrjRoxywQc/5y1b9KGakppX5KMPfzupJg+ZDC7Ga4FhzA9wAbiBp9A+VCHH4y5u9t60 vDqn1sQ4chfYt7FDrv0SbtmS6oV+Ars= Received: from mimecast-mx02.redhat.com (mx3-rdu2.redhat.com [66.187.233.73]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-380-EKSnFKTlNW2-26zE5_Z4xw-1; Tue, 28 Mar 2023 11:11:23 -0400 X-MC-Unique: EKSnFKTlNW2-26zE5_Z4xw-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.rdu2.redhat.com [10.11.54.2]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id D375E38149CC; Tue, 28 Mar 2023 15:11:21 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id E684D4020C83; Tue, 28 Mar 2023 15:11:15 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 06/16] block: ublk_drv: add common exit handling Date: Tue, 28 Mar 2023 23:09:48 +0800 Message-Id: <20230328150958.1253547-7-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.2 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Simplify exit handling a bit, and prepare for supporting fused command. Reviewed-by: Ziyang Zhang Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index c73cc57ec547..bc46616710d4 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -655,14 +655,15 @@ static void ublk_complete_rq(struct request *req) struct ublk_queue *ubq =3D req->mq_hctx->driver_data; struct ublk_io *io =3D &ubq->ios[req->tag]; unsigned int unmapped_bytes; + blk_status_t res =3D BLK_STS_OK; =20 /* failed read IO if nothing is read */ if (!io->res && req_op(req) =3D=3D REQ_OP_READ) io->res =3D -EIO; =20 if (io->res < 0) { - blk_mq_end_request(req, errno_to_blk_status(io->res)); - return; + res =3D errno_to_blk_status(io->res); + goto exit; } =20 /* @@ -671,10 +672,8 @@ static void ublk_complete_rq(struct request *req) * * Both the two needn't unmap. */ - if (req_op(req) !=3D REQ_OP_READ && req_op(req) !=3D REQ_OP_WRITE) { - blk_mq_end_request(req, BLK_STS_OK); - return; - } + if (req_op(req) !=3D REQ_OP_READ && req_op(req) !=3D REQ_OP_WRITE) + goto exit; =20 /* for READ request, writing data in iod->addr to rq buffers */ unmapped_bytes =3D ublk_unmap_io(ubq, req, io); @@ -691,6 +690,10 @@ static void ublk_complete_rq(struct request *req) blk_mq_requeue_request(req, true); else __blk_mq_end_request(req, BLK_STS_OK); + + return; +exit: + blk_mq_end_request(req, res); } =20 /* --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3876CC6FD18 for ; Tue, 28 Mar 2023 15:18:13 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233018AbjC1PSL (ORCPT ); Tue, 28 Mar 2023 11:18:11 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53504 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233978AbjC1PRk (ORCPT ); Tue, 28 Mar 2023 11:17:40 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6E14B11666 for ; Tue, 28 Mar 2023 08:16:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016494; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=s89n5MVHIm/yrA8YFK9Xcfzas4VQ/6rU7DsLdSVa7Sk=; b=R+hLP4oOwHMa5sH3Wn8jctL0MltPpLSZ+/bSp9qD+qcEeSp6Lh0k/KWNEYURnPDm4xugs+ KnmHIlyN+zyGILqsXEG+1wJof4k4d3EV7KISRiDmEg8meKgBmuk6U2Kv+iM3OO8cIggBXp ARVxDG4QSe/1xFptzeqtbts/5XKgRnM= Received: from mimecast-mx02.redhat.com (66.187.233.88 [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-637-iqk6bV3lOzq66C24ZkXuIg-1; Tue, 28 Mar 2023 11:11:31 -0400 X-MC-Unique: iqk6bV3lOzq66C24ZkXuIg-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.rdu2.redhat.com [10.11.54.7]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id C0D2D100DEAD; Tue, 28 Mar 2023 15:11:25 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id D553C140EBF4; Tue, 28 Mar 2023 15:11:24 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 07/16] block: ublk_drv: don't consider flush request in map/unmap io Date: Tue, 28 Mar 2023 23:09:49 +0800 Message-Id: <20230328150958.1253547-8-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.7 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" There isn't data in request of REQ_OP_FLUSH always, so don't consider it in both ublk_map_io() and ublk_unmap_io(). Reviewed-by: Ziyang Zhang Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index bc46616710d4..c73b2dba25ce 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -529,15 +529,13 @@ static int ublk_map_io(const struct ublk_queue *ubq, = const struct request *req, struct ublk_io *io) { const unsigned int rq_bytes =3D blk_rq_bytes(req); + /* * no zero copy, we delay copy WRITE request data into ublksrv * context and the big benefit is that pinning pages in current * context is pretty fast, see ublk_pin_user_pages */ - if (req_op(req) !=3D REQ_OP_WRITE && req_op(req) !=3D REQ_OP_FLUSH) - return rq_bytes; - - if (ublk_rq_has_data(req)) { + if (ublk_rq_has_data(req) && req_op(req) =3D=3D REQ_OP_WRITE) { struct ublk_map_data data =3D { .ubq =3D ubq, .rq =3D req, @@ -774,9 +772,7 @@ static inline void __ublk_rq_task_work(struct request *= req, return; } =20 - if (ublk_need_get_data(ubq) && - (req_op(req) =3D=3D REQ_OP_WRITE || - req_op(req) =3D=3D REQ_OP_FLUSH)) { + if (ublk_need_get_data(ubq) && (req_op(req) =3D=3D REQ_OP_WRITE)) { /* * We have not handled UBLK_IO_NEED_GET_DATA command yet, * so immepdately pass UBLK_IO_RES_NEED_GET_DATA to ublksrv --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A66ECC761AF for ; Tue, 28 Mar 2023 15:21:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233333AbjC1PVc (ORCPT ); Tue, 28 Mar 2023 11:21:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38354 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233344AbjC1PVP (ORCPT ); Tue, 28 Mar 2023 11:21:15 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2929311678 for ; Tue, 28 Mar 2023 08:18:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016681; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=litTAfSrcuMc4HupIpacq5wCRTNFJAvtr6mPltpyGGw=; b=UcP1YHm0UEPIZRO1Fpb1sDRNUJxNuC0Y6ZMHr5Y+b0k3Lw8Q7ktfM5p81sEJlJLgmbB79c igEJw1kZee9mYQ0+OQgoQbIdcogcR/LMiK7Hc1Z3rsxSOEU9rxaBHAT/RvH/E9EkFRYX4W oEhoeJx6dDeuB8clcctl5sHGHLsXTcM= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-641-akZKb0QuMtm2nodnVwiDcw-1; Tue, 28 Mar 2023 11:11:30 -0400 X-MC-Unique: akZKb0QuMtm2nodnVwiDcw-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.rdu2.redhat.com [10.11.54.1]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 5C7BB185A7A9; Tue, 28 Mar 2023 15:11:29 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 7679E40B3EDA; Tue, 28 Mar 2023 15:11:28 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 08/16] block: ublk_drv: add two helpers to clean up map/unmap request Date: Tue, 28 Mar 2023 23:09:50 +0800 Message-Id: <20230328150958.1253547-9-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.1 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add two helpers for checking if map/unmap is needed, since we may have passthrough request which needs map or unmap in future, such as for supporting report zones. Meantime don't mark ublk_copy_user_pages as inline since this function is a bit fat now. Reviewed-by: Ziyang Zhang Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index c73b2dba25ce..f87597a7d679 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -488,8 +488,7 @@ static inline unsigned ublk_copy_io_pages(struct ublk_i= o_iter *data, return done; } =20 -static inline int ublk_copy_user_pages(struct ublk_map_data *data, - bool to_vm) +static int ublk_copy_user_pages(struct ublk_map_data *data, bool to_vm) { const unsigned int gup_flags =3D to_vm ? FOLL_WRITE : 0; const unsigned long start_vm =3D data->io->addr; @@ -525,6 +524,16 @@ static inline int ublk_copy_user_pages(struct ublk_map= _data *data, return done; } =20 +static inline bool ublk_need_map_req(const struct request *req) +{ + return ublk_rq_has_data(req) && req_op(req) =3D=3D REQ_OP_WRITE; +} + +static inline bool ublk_need_unmap_req(const struct request *req) +{ + return ublk_rq_has_data(req) && req_op(req) =3D=3D REQ_OP_READ; +} + static int ublk_map_io(const struct ublk_queue *ubq, const struct request = *req, struct ublk_io *io) { @@ -535,7 +544,7 @@ static int ublk_map_io(const struct ublk_queue *ubq, co= nst struct request *req, * context and the big benefit is that pinning pages in current * context is pretty fast, see ublk_pin_user_pages */ - if (ublk_rq_has_data(req) && req_op(req) =3D=3D REQ_OP_WRITE) { + if (ublk_need_map_req(req)) { struct ublk_map_data data =3D { .ubq =3D ubq, .rq =3D req, @@ -556,7 +565,7 @@ static int ublk_unmap_io(const struct ublk_queue *ubq, { const unsigned int rq_bytes =3D blk_rq_bytes(req); =20 - if (req_op(req) =3D=3D REQ_OP_READ && ublk_rq_has_data(req)) { + if (ublk_need_unmap_req(req)) { struct ublk_map_data data =3D { .ubq =3D ubq, .rq =3D req, @@ -772,7 +781,7 @@ static inline void __ublk_rq_task_work(struct request *= req, return; } =20 - if (ublk_need_get_data(ubq) && (req_op(req) =3D=3D REQ_OP_WRITE)) { + if (ublk_need_get_data(ubq) && ublk_need_map_req(req)) { /* * We have not handled UBLK_IO_NEED_GET_DATA command yet, * so immepdately pass UBLK_IO_RES_NEED_GET_DATA to ublksrv --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2B9CFC6FD18 for ; Tue, 28 Mar 2023 15:18:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232621AbjC1PSB (ORCPT ); Tue, 28 Mar 2023 11:18:01 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55098 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233944AbjC1PRi (ORCPT ); Tue, 28 Mar 2023 11:17:38 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8759310AA2 for ; Tue, 28 Mar 2023 08:16:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016500; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Plah9oxK2vEYgPKSe8zMQk868IGL1eXPxQld6RUGB/s=; b=aFe5grvNnlHnopoQloN5mHTBKZryNG+4I15mAezHN8C6K/NVcRNsdjzBCR9kESQ3D3k6RT 7yiH/Ipj2tF71S51z5PpDqMDdt2GegafLv/90InrRkMCArI/B1VTuTZuXhkbjZqDqbOrTG gma6Y2NcxZn2pg1MxfTbp50eTD9umEo= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-552-eIOBpHoaMdCVHdDeJnE0HA-1; Tue, 28 Mar 2023 11:11:34 -0400 X-MC-Unique: eIOBpHoaMdCVHdDeJnE0HA-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.rdu2.redhat.com [10.11.54.7]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 4E2A3100DEBF; Tue, 28 Mar 2023 15:11:33 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 7072214171C3; Tue, 28 Mar 2023 15:11:32 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 09/16] block: ublk_drv: clean up several helpers Date: Tue, 28 Mar 2023 23:09:51 +0800 Message-Id: <20230328150958.1253547-10-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.7 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Convert the following pattern in several helpers if (Z) return true return false into: return Z; Reviewed-by: Ziyang Zhang Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 18 +++++------------- 1 file changed, 5 insertions(+), 13 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index f87597a7d679..1c057003a40a 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -298,9 +298,7 @@ static inline bool ublk_can_use_task_work(const struct = ublk_queue *ubq) =20 static inline bool ublk_need_get_data(const struct ublk_queue *ubq) { - if (ubq->flags & UBLK_F_NEED_GET_DATA) - return true; - return false; + return ubq->flags & UBLK_F_NEED_GET_DATA; } =20 static struct ublk_device *ublk_get_device(struct ublk_device *ub) @@ -349,25 +347,19 @@ static inline int ublk_queue_cmd_buf_size(struct ublk= _device *ub, int q_id) static inline bool ublk_queue_can_use_recovery_reissue( struct ublk_queue *ubq) { - if ((ubq->flags & UBLK_F_USER_RECOVERY) && - (ubq->flags & UBLK_F_USER_RECOVERY_REISSUE)) - return true; - return false; + return (ubq->flags & UBLK_F_USER_RECOVERY) && + (ubq->flags & UBLK_F_USER_RECOVERY_REISSUE); } =20 static inline bool ublk_queue_can_use_recovery( struct ublk_queue *ubq) { - if (ubq->flags & UBLK_F_USER_RECOVERY) - return true; - return false; + return ubq->flags & UBLK_F_USER_RECOVERY; } =20 static inline bool ublk_can_use_recovery(struct ublk_device *ub) { - if (ub->dev_info.flags & UBLK_F_USER_RECOVERY) - return true; - return false; + return ub->dev_info.flags & UBLK_F_USER_RECOVERY; } =20 static void ublk_free_disk(struct gendisk *disk) --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D29CFC6FD18 for ; Tue, 28 Mar 2023 15:21:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232784AbjC1PVf (ORCPT ); Tue, 28 Mar 2023 11:21:35 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38352 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233293AbjC1PVN (ORCPT ); Tue, 28 Mar 2023 11:21:13 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9F6761166A for ; Tue, 28 Mar 2023 08:18:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016681; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=aRW9a0ZHd+MGeZHqXvtwA5Cp/cxaEC4LxuKjGisTMi4=; b=X1kCH05nST6X0m/t4j/0gMwAYi7A41WQWlEFgRHQfuUxBC5cG8+Qvg0RRGDpJoUMGFIQl3 XncI6gxozjvf231AXoHK59MgosrXmYRa7Rvfs07zBDy7/G+449x7m4A3KR5Zsyemaemfxt OuOW6wcPfJPvY0KHG930XCNs5NN08yg= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-437-CwbPgIyQOWK4ebslNp_Dkg-1; Tue, 28 Mar 2023 11:11:37 -0400 X-MC-Unique: CwbPgIyQOWK4ebslNp_Dkg-1 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.rdu2.redhat.com [10.11.54.5]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 2C00E185A791; Tue, 28 Mar 2023 15:11:37 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 304CC440D6; Tue, 28 Mar 2023 15:11:35 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 10/16] block: ublk_drv: cleanup 'struct ublk_map_data' Date: Tue, 28 Mar 2023 23:09:52 +0800 Message-Id: <20230328150958.1253547-11-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.5 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" 'struct ublk_map_data' is passed to ublk_copy_user_pages() for copying data between userspace buffer and request pages. Here what matters is userspace buffer address/len and 'struct request', so replace ->io field with user buffer address, and rename max_bytes as len. Meantime remove 'ubq' field from ublk_map_data, since it isn't used any more. Then code becomes more readable. Reviewed-by: Ziyang Zhang Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index 1c057003a40a..fdccbf5fdaa1 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -420,10 +420,9 @@ static const struct block_device_operations ub_fops = =3D { #define UBLK_MAX_PIN_PAGES 32 =20 struct ublk_map_data { - const struct ublk_queue *ubq; const struct request *rq; - const struct ublk_io *io; - unsigned max_bytes; + unsigned long ubuf; + unsigned int len; }; =20 struct ublk_io_iter { @@ -483,14 +482,14 @@ static inline unsigned ublk_copy_io_pages(struct ublk= _io_iter *data, static int ublk_copy_user_pages(struct ublk_map_data *data, bool to_vm) { const unsigned int gup_flags =3D to_vm ? FOLL_WRITE : 0; - const unsigned long start_vm =3D data->io->addr; + const unsigned long start_vm =3D data->ubuf; unsigned int done =3D 0; struct ublk_io_iter iter =3D { .pg_off =3D start_vm & (PAGE_SIZE - 1), .bio =3D data->rq->bio, .iter =3D data->rq->bio->bi_iter, }; - const unsigned int nr_pages =3D round_up(data->max_bytes + + const unsigned int nr_pages =3D round_up(data->len + (start_vm & (PAGE_SIZE - 1)), PAGE_SIZE) >> PAGE_SHIFT; =20 while (done < nr_pages) { @@ -503,13 +502,13 @@ static int ublk_copy_user_pages(struct ublk_map_data = *data, bool to_vm) iter.pages); if (iter.nr_pages <=3D 0) return done =3D=3D 0 ? iter.nr_pages : done; - len =3D ublk_copy_io_pages(&iter, data->max_bytes, to_vm); + len =3D ublk_copy_io_pages(&iter, data->len, to_vm); for (i =3D 0; i < iter.nr_pages; i++) { if (to_vm) set_page_dirty(iter.pages[i]); put_page(iter.pages[i]); } - data->max_bytes -=3D len; + data->len -=3D len; done +=3D iter.nr_pages; } =20 @@ -538,15 +537,14 @@ static int ublk_map_io(const struct ublk_queue *ubq, = const struct request *req, */ if (ublk_need_map_req(req)) { struct ublk_map_data data =3D { - .ubq =3D ubq, .rq =3D req, - .io =3D io, - .max_bytes =3D rq_bytes, + .ubuf =3D io->addr, + .len =3D rq_bytes, }; =20 ublk_copy_user_pages(&data, true); =20 - return rq_bytes - data.max_bytes; + return rq_bytes - data.len; } return rq_bytes; } @@ -559,17 +557,16 @@ static int ublk_unmap_io(const struct ublk_queue *ubq, =20 if (ublk_need_unmap_req(req)) { struct ublk_map_data data =3D { - .ubq =3D ubq, .rq =3D req, - .io =3D io, - .max_bytes =3D io->res, + .ubuf =3D io->addr, + .len =3D io->res, }; =20 WARN_ON_ONCE(io->res > rq_bytes); =20 ublk_copy_user_pages(&data, false); =20 - return io->res - data.max_bytes; + return io->res - data.len; } return rq_bytes; } --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8AC5FC76196 for ; Tue, 28 Mar 2023 15:31:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233992AbjC1Pba (ORCPT ); Tue, 28 Mar 2023 11:31:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32978 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233986AbjC1PbM (ORCPT ); Tue, 28 Mar 2023 11:31:12 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F39A41117C for ; Tue, 28 Mar 2023 08:29:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680017341; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=NUQtNNFK1AoI7+XEcCF6Kp2M1pxUT3LrqKOWK4i69ow=; b=hvoDJ0B0tQ284eYCF2gMG7wTfAPUtEV+04OVDH8TcgLo9musf2iUEgsY50jPAQsRWulMfn +K0B2JBYGdXHGO4OXZCoq6eylBSMzTeq/o29Jqj75rsVVS/M52yVO30GUHxWkEMuSgf6UF VwvbkIQ1iz2N7RmZEqPo9nFlGn+mL3o= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-672-2NhuttPlMNC5uJPfRoKe4w-1; Tue, 28 Mar 2023 11:11:42 -0400 X-MC-Unique: 2NhuttPlMNC5uJPfRoKe4w-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.rdu2.redhat.com [10.11.54.6]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 9022888740A; Tue, 28 Mar 2023 15:11:41 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 687B62166B26; Tue, 28 Mar 2023 15:11:40 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 11/16] block: ublk_drv: cleanup ublk_copy_user_pages Date: Tue, 28 Mar 2023 23:09:53 +0800 Message-Id: <20230328150958.1253547-12-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.6 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Clean up ublk_copy_user_pages() by using iov iter, and code gets simplified a lot and becomes much more readable than before. Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 112 +++++++++++++++++---------------------- 1 file changed, 49 insertions(+), 63 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index fdccbf5fdaa1..cca0e95a89d8 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -419,49 +419,39 @@ static const struct block_device_operations ub_fops = =3D { =20 #define UBLK_MAX_PIN_PAGES 32 =20 -struct ublk_map_data { - const struct request *rq; - unsigned long ubuf; - unsigned int len; -}; - struct ublk_io_iter { struct page *pages[UBLK_MAX_PIN_PAGES]; - unsigned pg_off; /* offset in the 1st page in pages */ - int nr_pages; /* how many page pointers in pages */ struct bio *bio; struct bvec_iter iter; }; =20 -static inline unsigned ublk_copy_io_pages(struct ublk_io_iter *data, - unsigned max_bytes, bool to_vm) +/* return how many pages are copied */ +static void ublk_copy_io_pages(struct ublk_io_iter *data, + size_t total, size_t pg_off, int dir) { - const unsigned total =3D min_t(unsigned, max_bytes, - PAGE_SIZE - data->pg_off + - ((data->nr_pages - 1) << PAGE_SHIFT)); unsigned done =3D 0; unsigned pg_idx =3D 0; =20 while (done < total) { struct bio_vec bv =3D bio_iter_iovec(data->bio, data->iter); - const unsigned int bytes =3D min3(bv.bv_len, total - done, - (unsigned)(PAGE_SIZE - data->pg_off)); + unsigned int bytes =3D min3(bv.bv_len, (unsigned)total - done, + (unsigned)(PAGE_SIZE - pg_off)); void *bv_buf =3D bvec_kmap_local(&bv); void *pg_buf =3D kmap_local_page(data->pages[pg_idx]); =20 - if (to_vm) - memcpy(pg_buf + data->pg_off, bv_buf, bytes); + if (dir =3D=3D ITER_DEST) + memcpy(pg_buf + pg_off, bv_buf, bytes); else - memcpy(bv_buf, pg_buf + data->pg_off, bytes); + memcpy(bv_buf, pg_buf + pg_off, bytes); =20 kunmap_local(pg_buf); kunmap_local(bv_buf); =20 /* advance page array */ - data->pg_off +=3D bytes; - if (data->pg_off =3D=3D PAGE_SIZE) { + pg_off +=3D bytes; + if (pg_off =3D=3D PAGE_SIZE) { pg_idx +=3D 1; - data->pg_off =3D 0; + pg_off =3D 0; } =20 done +=3D bytes; @@ -475,41 +465,40 @@ static inline unsigned ublk_copy_io_pages(struct ublk= _io_iter *data, data->iter =3D data->bio->bi_iter; } } - - return done; } =20 -static int ublk_copy_user_pages(struct ublk_map_data *data, bool to_vm) +/* + * 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, + struct iov_iter *uiter, int dir) { - const unsigned int gup_flags =3D to_vm ? FOLL_WRITE : 0; - const unsigned long start_vm =3D data->ubuf; - unsigned int done =3D 0; struct ublk_io_iter iter =3D { - .pg_off =3D start_vm & (PAGE_SIZE - 1), - .bio =3D data->rq->bio, - .iter =3D data->rq->bio->bi_iter, + .bio =3D req->bio, + .iter =3D req->bio->bi_iter, }; - const unsigned int nr_pages =3D round_up(data->len + - (start_vm & (PAGE_SIZE - 1)), PAGE_SIZE) >> PAGE_SHIFT; - - while (done < nr_pages) { - const unsigned to_pin =3D min_t(unsigned, UBLK_MAX_PIN_PAGES, - nr_pages - done); - unsigned i, len; - - iter.nr_pages =3D get_user_pages_fast(start_vm + - (done << PAGE_SHIFT), to_pin, gup_flags, - iter.pages); - if (iter.nr_pages <=3D 0) - return done =3D=3D 0 ? iter.nr_pages : done; - len =3D ublk_copy_io_pages(&iter, data->len, to_vm); - for (i =3D 0; i < iter.nr_pages; i++) { - if (to_vm) + size_t done =3D 0; + + while (iov_iter_count(uiter) && iter.bio) { + unsigned nr_pages; + size_t len, off; + int i; + + len =3D iov_iter_get_pages2(uiter, iter.pages, + iov_iter_count(uiter), + UBLK_MAX_PIN_PAGES, &off); + if (len <=3D 0) + return done; + + ublk_copy_io_pages(&iter, len, off, dir); + nr_pages =3D DIV_ROUND_UP(len + off, PAGE_SIZE); + for (i =3D 0; i < nr_pages; i++) { + if (dir =3D=3D ITER_DEST) set_page_dirty(iter.pages[i]); put_page(iter.pages[i]); } - data->len -=3D len; - done +=3D iter.nr_pages; + done +=3D len; } =20 return done; @@ -536,15 +525,14 @@ static int ublk_map_io(const struct ublk_queue *ubq, = const struct request *req, * context is pretty fast, see ublk_pin_user_pages */ if (ublk_need_map_req(req)) { - struct ublk_map_data data =3D { - .rq =3D req, - .ubuf =3D io->addr, - .len =3D rq_bytes, - }; + struct iov_iter iter; + struct iovec iov; + const int dir =3D ITER_DEST; =20 - ublk_copy_user_pages(&data, true); + import_single_range(dir, u64_to_user_ptr(io->addr), rq_bytes, + &iov, &iter); =20 - return rq_bytes - data.len; + return ublk_copy_user_pages(req, &iter, dir); } return rq_bytes; } @@ -556,17 +544,15 @@ static int ublk_unmap_io(const struct ublk_queue *ubq, const unsigned int rq_bytes =3D blk_rq_bytes(req); =20 if (ublk_need_unmap_req(req)) { - struct ublk_map_data data =3D { - .rq =3D req, - .ubuf =3D io->addr, - .len =3D io->res, - }; + struct iov_iter iter; + struct iovec iov; + const int dir =3D ITER_SOURCE; =20 WARN_ON_ONCE(io->res > rq_bytes); =20 - ublk_copy_user_pages(&data, false); - - return io->res - data.len; + import_single_range(dir, u64_to_user_ptr(io->addr), io->res, + &iov, &iter); + return ublk_copy_user_pages(req, &iter, dir); } return rq_bytes; } --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 68BB8C761AF for ; Tue, 28 Mar 2023 15:18:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233034AbjC1PSH (ORCPT ); Tue, 28 Mar 2023 11:18:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55156 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233807AbjC1PRk (ORCPT ); Tue, 28 Mar 2023 11:17:40 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4FD4B11663 for ; Tue, 28 Mar 2023 08:16:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016498; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=F7F6vbrS0gh77HT5XSUWKXsVAOVZJQ/PeMG00WEkJhQ=; b=KzeMfyhP4Q9lN5AceYwVWOh7/sGx+PpH2gkBh+hpirvPZJtKuQTHgACLccsXSB+/3hKH/8 069d7G0QpzI4aVmZK6UnmkK6TAKQIKxhczGcOBj6Rr059sEjdC2Oc6B8aTfU2c1nQVZfLp ixFHaND8R/4WKlA7y0V9vI77PBAKDIg= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-491-4CUDDjSVM8ih_EohNIseDw-1; Tue, 28 Mar 2023 11:11:46 -0400 X-MC-Unique: 4CUDDjSVM8ih_EohNIseDw-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.rdu2.redhat.com [10.11.54.6]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 76BAD887405; Tue, 28 Mar 2023 15:11:45 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 66A462166B26; Tue, 28 Mar 2023 15:11:44 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 12/16] block: ublk_drv: grab request reference when the request is handled by userspace Date: Tue, 28 Mar 2023 23:09:54 +0800 Message-Id: <20230328150958.1253547-13-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.6 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add one reference counter into request pdu data, and hold this reference in the request's lifetime. This way is always safe. In theory, the ublk request won't be completed until fused commands are done. However, it is userspace, and application can submit fused command at will. Prepare for supporting zero copy, which needs to retrieve request buffer by fused command, so we have to guarantee: - the fused command can't succeed unless the request isn't queued - when any fused command is successful, this request can't be freed until all fused commands on this request are done. Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 67 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 64 insertions(+), 3 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index cca0e95a89d8..0dc8eb04b9a5 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -43,6 +43,7 @@ #include #include #include +#include #include =20 #define UBLK_MINORS (1U << MINORBITS) @@ -62,6 +63,17 @@ struct ublk_rq_data { struct llist_node node; struct callback_head work; + + /* + * Only for applying fused command to support zero copy: + * + * - if there is any fused command aiming at this request, not complete + * request until all fused commands are done + * + * - fused command has to fail unless this reference is grabbed + * successfully + */ + struct kref ref; }; =20 struct ublk_uring_cmd_pdu { @@ -180,6 +192,9 @@ struct ublk_params_header { __u32 types; }; =20 +static inline void __ublk_complete_rq(struct request *req); +static void ublk_complete_rq(struct kref *ref); + static dev_t ublk_chr_devt; static struct class *ublk_chr_class; =20 @@ -288,6 +303,35 @@ static int ublk_apply_params(struct ublk_device *ub) return 0; } =20 +static inline bool ublk_support_zc(const struct ublk_queue *ubq) +{ + return ubq->flags & UBLK_F_SUPPORT_ZERO_COPY; +} + +static inline bool ublk_get_req_ref(const struct ublk_queue *ubq, + struct request *req) +{ + if (ublk_support_zc(ubq)) { + struct ublk_rq_data *data =3D blk_mq_rq_to_pdu(req); + + return kref_get_unless_zero(&data->ref); + } + + return true; +} + +static inline void ublk_put_req_ref(const struct ublk_queue *ubq, + struct request *req) +{ + if (ublk_support_zc(ubq)) { + struct ublk_rq_data *data =3D blk_mq_rq_to_pdu(req); + + kref_put(&data->ref, ublk_complete_rq); + } else { + __ublk_complete_rq(req); + } +} + static inline bool ublk_can_use_task_work(const struct ublk_queue *ubq) { if (IS_BUILTIN(CONFIG_BLK_DEV_UBLK) && @@ -632,13 +676,19 @@ static inline bool ubq_daemon_is_dying(struct ublk_qu= eue *ubq) } =20 /* todo: handle partial completion */ -static void ublk_complete_rq(struct request *req) +static inline void __ublk_complete_rq(struct request *req) { struct ublk_queue *ubq =3D req->mq_hctx->driver_data; struct ublk_io *io =3D &ubq->ios[req->tag]; unsigned int unmapped_bytes; blk_status_t res =3D BLK_STS_OK; =20 + /* called from ublk_abort_queue() code path */ + if (io->flags & UBLK_IO_FLAG_ABORTED) { + res =3D BLK_STS_IOERR; + goto exit; + } + /* failed read IO if nothing is read */ if (!io->res && req_op(req) =3D=3D REQ_OP_READ) io->res =3D -EIO; @@ -678,6 +728,15 @@ static void ublk_complete_rq(struct request *req) blk_mq_end_request(req, res); } =20 +static void ublk_complete_rq(struct kref *ref) +{ + struct ublk_rq_data *data =3D container_of(ref, struct ublk_rq_data, + ref); + struct request *req =3D blk_mq_rq_from_pdu(data); + + __ublk_complete_rq(req); +} + /* * Since __ublk_rq_task_work always fails requests immediately during * exiting, __ublk_fail_req() is only called from abort context during @@ -696,7 +755,7 @@ static void __ublk_fail_req(struct ublk_queue *ubq, str= uct ublk_io *io, if (ublk_queue_can_use_recovery_reissue(ubq)) blk_mq_requeue_request(req, false); else - blk_mq_end_request(req, BLK_STS_IOERR); + ublk_put_req_ref(ubq, req); } } =20 @@ -734,6 +793,7 @@ static inline void __ublk_rq_task_work(struct request *= req, unsigned issue_flags) { struct ublk_queue *ubq =3D req->mq_hctx->driver_data; + struct ublk_rq_data *data =3D blk_mq_rq_to_pdu(req); int tag =3D req->tag; struct ublk_io *io =3D &ubq->ios[tag]; unsigned int mapped_bytes; @@ -805,6 +865,7 @@ static inline void __ublk_rq_task_work(struct request *= req, mapped_bytes >> 9; } =20 + kref_init(&data->ref); ubq_complete_io_cmd(io, UBLK_IO_RES_OK, issue_flags); } =20 @@ -1017,7 +1078,7 @@ static void ublk_commit_completion(struct ublk_device= *ub, req =3D blk_mq_tag_to_rq(ub->tag_set.tags[qid], tag); =20 if (req && likely(!blk_should_fake_timeout(req->q))) - ublk_complete_rq(req); + ublk_put_req_ref(ubq, req); } =20 /* --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9AF08C6FD18 for ; Tue, 28 Mar 2023 15:23:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233182AbjC1PXW (ORCPT ); Tue, 28 Mar 2023 11:23:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38358 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233808AbjC1PW5 (ORCPT ); Tue, 28 Mar 2023 11:22:57 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B1AC5EB56 for ; Tue, 28 Mar 2023 08:20:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680016747; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=cTxPpka+LhrPaNriA70AKnPyZgOXWneoLBopgtDoZwU=; b=UgZATod4BzU6rhu1YYWJYatGc2EbZ4XKB3NZFSziMcaGbFbYc/6b6RrIOxflajpKdobhre SNk9eWnwomEbt/FSUzyHi7poNOMjkwrLGaoSBkOgaiqtCFn56vNwQ+4JIeQxiz5XF/9DKc WBER4CLETO4R+aFYdKyafkH+c/iGPXo= Received: from mimecast-mx02.redhat.com (mx3-rdu2.redhat.com [66.187.233.73]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-240-PUrBr7alNgOUiXBQAgnAyQ-1; Tue, 28 Mar 2023 11:11:57 -0400 X-MC-Unique: PUrBr7alNgOUiXBQAgnAyQ-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.rdu2.redhat.com [10.11.54.2]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 8E7052823806; Tue, 28 Mar 2023 15:11:49 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 9EB1D4020C83; Tue, 28 Mar 2023 15:11:48 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 13/16] block: ublk_drv: support to copy any part of request pages Date: Tue, 28 Mar 2023 23:09:55 +0800 Message-Id: <20230328150958.1253547-14-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.2 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add 'offset' to 'struct ublk_map_data', so that ublk_copy_user_pages() can be used to copy any sub-buffer(linear mapped) of the request. Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 31 ++++++++++++++++++++++++------- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index 0dc8eb04b9a5..32304942ab87 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -511,19 +511,36 @@ static void ublk_copy_io_pages(struct ublk_io_iter *d= ata, } } =20 +static bool ublk_advance_io_iter(const struct request *req, + struct ublk_io_iter *iter, unsigned int offset) +{ + struct bio *bio =3D req->bio; + + for_each_bio(bio) { + if (bio->bi_iter.bi_size > offset) { + iter->bio =3D bio; + iter->iter =3D bio->bi_iter; + bio_advance_iter(iter->bio, &iter->iter, offset); + return true; + } + offset -=3D bio->bi_iter.bi_size; + } + return false; +} + /* * 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, - struct iov_iter *uiter, int dir) + unsigned offset, struct iov_iter *uiter, int dir) { - struct ublk_io_iter iter =3D { - .bio =3D req->bio, - .iter =3D req->bio->bi_iter, - }; + struct ublk_io_iter iter; size_t done =3D 0; =20 + if (!ublk_advance_io_iter(req, &iter, offset)) + return 0; + while (iov_iter_count(uiter) && iter.bio) { unsigned nr_pages; size_t len, off; @@ -576,7 +593,7 @@ static int ublk_map_io(const struct ublk_queue *ubq, co= nst struct request *req, import_single_range(dir, u64_to_user_ptr(io->addr), rq_bytes, &iov, &iter); =20 - return ublk_copy_user_pages(req, &iter, dir); + return ublk_copy_user_pages(req, 0, &iter, dir); } return rq_bytes; } @@ -596,7 +613,7 @@ static int ublk_unmap_io(const struct ublk_queue *ubq, =20 import_single_range(dir, u64_to_user_ptr(io->addr), io->res, &iov, &iter); - return ublk_copy_user_pages(req, &iter, dir); + return ublk_copy_user_pages(req, 0, &iter, dir); } return rq_bytes; } --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2AC82C76196 for ; Tue, 28 Mar 2023 15:34:16 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232476AbjC1PeO (ORCPT ); Tue, 28 Mar 2023 11:34:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34760 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229861AbjC1PeM (ORCPT ); Tue, 28 Mar 2023 11:34:12 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D080B1FF5 for ; Tue, 28 Mar 2023 08:33:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680017605; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=epgMYPHiL/drcoyXP4r134WY88eox9+1YtvoGLQRluU=; b=NHRo+SqKYs7tcQB61y0LncFLLval0cSTfgj87QfQWXwo5plf9LO0pT13/xyWC1FJKgb616 8So44BrUrTpwnu0hYf19b9b/CqsnVSznvxG+ob+mrIgFsnIlIYRfmgmc0qh6pc+bxljw5r 0LTucTImXcsnhIiYFoPeZgHI/ZfAxRU= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-35-NUuhNtO5O_SR8Ng9fEVPbQ-1; Tue, 28 Mar 2023 11:11:54 -0400 X-MC-Unique: NUuhNtO5O_SR8Ng9fEVPbQ-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.rdu2.redhat.com [10.11.54.2]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 6211B887403; Tue, 28 Mar 2023 15:11:53 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 57D7E4020C82; Tue, 28 Mar 2023 15:11:51 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 14/16] block: ublk_drv: add read()/write() support for ublk char device Date: Tue, 28 Mar 2023 23:09:56 +0800 Message-Id: <20230328150958.1253547-15-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.2 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" We are going to support zero copy by fused uring command, the userspace can't read from or write to the io buffer any more, it becomes not flexible for applications: 1) some targets need to zero buffer explicitly, such as when reading unmapped qcow2 cluster 2) some targets need to support passthrough command, such as zoned report zones, and still need to read/write the io buffer Support pread()/pwrite() on ublk char device for reading/writing request io buffer, so ublk server can handle the above cases easily. This also can help to make zero copy becoming the primary option, and non-zero-copy will become legacy code path since the added read()/write() can cover non-zero-copy feature. Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 131 ++++++++++++++++++++++++++++++++++ include/uapi/linux/ublk_cmd.h | 31 +++++++- 2 files changed, 161 insertions(+), 1 deletion(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index 32304942ab87..03ad33686808 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -1322,6 +1322,36 @@ static void ublk_handle_need_get_data(struct ublk_de= vice *ub, int q_id, ublk_queue_cmd(ubq, req); } =20 +static inline struct request *__ublk_check_and_get_req(struct ublk_device = *ub, + struct ublk_queue *ubq, int tag, size_t offset) +{ + struct request *req; + + if (!ublk_support_zc(ubq)) + return NULL; + + req =3D blk_mq_tag_to_rq(ub->tag_set.tags[ubq->q_id], tag); + if (!req) + return NULL; + + if (!ublk_get_req_ref(ubq, req)) + return NULL; + + if (unlikely(!blk_mq_request_started(req) || req->tag !=3D tag)) + 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(ubq, req); + return NULL; +} + static int ublk_ch_uring_cmd(struct io_uring_cmd *cmd, unsigned int issue_= flags) { struct ublksrv_io_cmd *ub_cmd =3D (struct ublksrv_io_cmd *)cmd->cmd; @@ -1423,11 +1453,112 @@ static int ublk_ch_uring_cmd(struct io_uring_cmd *= cmd, unsigned int issue_flags) return -EIOCBQUEUED; } =20 +static inline bool ublk_check_ubuf_dir(const struct request *req, + int ubuf_dir) +{ + /* copy ubuf to request pages */ + if (req_op(req) =3D=3D REQ_OP_READ && ubuf_dir =3D=3D ITER_SOURCE) + return true; + + /* copy request pages to ubuf */ + if (req_op(req) =3D=3D REQ_OP_WRITE && ubuf_dir =3D=3D ITER_DEST) + 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_device *ub =3D iocb->ki_filp->private_data; + struct ublk_queue *ubq; + struct request *req; + size_t buf_off; + u16 tag, q_id; + + if (!ub) + return ERR_PTR(-EACCES); + + if (!user_backed_iter(iter)) + return ERR_PTR(-EACCES); + + if (ub->dev_info.state =3D=3D UBLK_S_DEV_DEAD) + return ERR_PTR(-EACCES); + + tag =3D ublk_pos_to_tag(iocb->ki_pos); + q_id =3D ublk_pos_to_hwq(iocb->ki_pos); + buf_off =3D ublk_pos_to_buf_offset(iocb->ki_pos); + + if (q_id >=3D ub->dev_info.nr_hw_queues) + return ERR_PTR(-EINVAL); + + ubq =3D ublk_get_queue(ub, q_id); + if (!ubq) + return ERR_PTR(-EINVAL); + + if (tag >=3D ubq->q_depth) + return ERR_PTR(-EINVAL); + + req =3D __ublk_check_and_get_req(ub, ubq, tag, buf_off); + if (!req) + return ERR_PTR(-EINVAL); + + if (!req->mq_hctx || !req->mq_hctx->driver_data) + goto fail; + + if (!ublk_check_ubuf_dir(req, dir)) + goto fail; + + *off =3D buf_off; + return req; +fail: + ublk_put_req_ref(ubq, req); + return ERR_PTR(-EACCES); +} + +static ssize_t ublk_ch_read_iter(struct kiocb *iocb, struct iov_iter *to) +{ + struct ublk_queue *ubq; + struct request *req; + size_t buf_off; + size_t ret; + + req =3D ublk_check_and_get_req(iocb, to, &buf_off, ITER_DEST); + if (unlikely(IS_ERR(req))) + return PTR_ERR(req); + + ret =3D ublk_copy_user_pages(req, buf_off, to, ITER_DEST); + ubq =3D req->mq_hctx->driver_data; + ublk_put_req_ref(ubq, req); + + return ret; +} + +static ssize_t ublk_ch_write_iter(struct kiocb *iocb, struct iov_iter *fro= m) +{ + struct ublk_queue *ubq; + struct request *req; + size_t buf_off; + size_t ret; + + req =3D ublk_check_and_get_req(iocb, from, &buf_off, ITER_SOURCE); + if (unlikely(IS_ERR(req))) + return PTR_ERR(req); + + ret =3D ublk_copy_user_pages(req, buf_off, from, ITER_SOURCE); + ubq =3D req->mq_hctx->driver_data; + ublk_put_req_ref(ubq, req); + + return ret; +} + static const struct file_operations ublk_ch_fops =3D { .owner =3D THIS_MODULE, .open =3D ublk_ch_open, .release =3D ublk_ch_release, .llseek =3D no_llseek, + .read_iter =3D ublk_ch_read_iter, + .write_iter =3D ublk_ch_write_iter, .uring_cmd =3D ublk_ch_uring_cmd, .mmap =3D ublk_ch_mmap, }; diff --git a/include/uapi/linux/ublk_cmd.h b/include/uapi/linux/ublk_cmd.h index f6238ccc7800..d1a6b3dc0327 100644 --- a/include/uapi/linux/ublk_cmd.h +++ b/include/uapi/linux/ublk_cmd.h @@ -54,7 +54,36 @@ #define UBLKSRV_IO_BUF_OFFSET 0x80000000 =20 /* tag bit is 12bit, so at most 4096 IOs for each queue */ -#define UBLK_MAX_QUEUE_DEPTH 4096 +#define UBLK_TAG_BITS 12 +#define UBLK_MAX_QUEUE_DEPTH (1U << UBLK_TAG_BITS) + +/* used for locating each io buffer for pread()/pwrite() on char device */ +#define UBLK_BUFS_SIZE_BITS 42 +#define UBLK_BUFS_SIZE_MASK ((1ULL << UBLK_BUFS_SIZE_BITS) - 1) +#define UBLK_BUF_SIZE_BITS (UBLK_BUFS_SIZE_BITS - UBLK_TAG_BITS) +#define UBLK_BUF_MAX_SIZE (1ULL << UBLK_BUF_SIZE_BITS) + +static inline __u16 ublk_pos_to_hwq(__u64 pos) +{ + return pos >> UBLK_BUFS_SIZE_BITS; +} + +static inline __u32 ublk_pos_to_buf_offset(__u64 pos) +{ + return (pos & UBLK_BUFS_SIZE_MASK) & (UBLK_BUF_MAX_SIZE - 1); +} + +static inline __u16 ublk_pos_to_tag(__u64 pos) +{ + return (pos & UBLK_BUFS_SIZE_MASK) >> UBLK_BUF_SIZE_BITS; +} + +/* offset of single buffer, which has to be < UBLK_BUX_MAX_SIZE */ +static inline __u64 ublk_pos(__u16 q_id, __u16 tag, __u32 offset) +{ + return (((__u64)q_id) << UBLK_BUFS_SIZE_BITS) | + ((((__u64)tag) << UBLK_BUF_SIZE_BITS) + offset); +} =20 /* * zero copy requires 4k block size, and can remap ublk driver's io --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D5C65C6FD18 for ; Tue, 28 Mar 2023 15:39:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233268AbjC1PjE (ORCPT ); Tue, 28 Mar 2023 11:39:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45764 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234070AbjC1PiT (ORCPT ); Tue, 28 Mar 2023 11:38:19 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 86D4740CA for ; Tue, 28 Mar 2023 08:36:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680017787; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=a+LP/eGObxESjSZtnTg8CVLgYRu7HZvCpWjJZDO48e4=; b=OfQcZ+jXTrBUWoX9WqQe+qCsLP40HO1WUNzMBzUzOJ9YRGpaM9TGDzpZsqiQGGlk7nUkYp +skjykt9OwsqbWMntTp4ZQt0nIuP/KzTInfO5c9QyJtyX98dWnTFlxm0fslUXcfuzgqE/+ 8JkIyWD0k7VvuvdpEyek/HpmEdpQ32M= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-495-MWpvJGt3PZ2YlU4lp9woSA-1; Tue, 28 Mar 2023 11:11:58 -0400 X-MC-Unique: MWpvJGt3PZ2YlU4lp9woSA-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.rdu2.redhat.com [10.11.54.7]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 6D7218028B2; Tue, 28 Mar 2023 15:11:57 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 6355314171BD; Tue, 28 Mar 2023 15:11:56 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 15/16] block: ublk_drv: don't check buffer in case of zero copy Date: Tue, 28 Mar 2023 23:09:57 +0800 Message-Id: <20230328150958.1253547-16-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.7 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" In case of zero copy, ublk server needn't to pre-allocate IO buffer and provide it to driver more. Meantime not set the buffer in case of zero copy any more, and the userspace can use pread()/pwrite() to read from/write to the io request buffer, which is easier & simpler from userspace viewpoint. Signed-off-by: Ming Lei --- drivers/block/ublk_drv.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index 03ad33686808..a49b4de5ae1e 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -1410,25 +1410,30 @@ static int ublk_ch_uring_cmd(struct io_uring_cmd *c= md, unsigned int issue_flags) if (io->flags & UBLK_IO_FLAG_OWNED_BY_SRV) goto out; /* FETCH_RQ has to provide IO buffer if NEED GET DATA is not enabled */ - if (!ub_cmd->addr && !ublk_need_get_data(ubq)) - goto out; + if (!ublk_support_zc(ubq)) { + if (!ub_cmd->addr && !ublk_need_get_data(ubq)) + goto out; + io->addr =3D ub_cmd->addr; + } io->cmd =3D cmd; io->flags |=3D UBLK_IO_FLAG_ACTIVE; - io->addr =3D ub_cmd->addr; - ublk_mark_io_ready(ub, ubq); break; case UBLK_IO_COMMIT_AND_FETCH_REQ: req =3D blk_mq_tag_to_rq(ub->tag_set.tags[ub_cmd->q_id], tag); + + if (!(io->flags & UBLK_IO_FLAG_OWNED_BY_SRV)) + goto out; /* * COMMIT_AND_FETCH_REQ has to provide IO buffer if NEED GET DATA is * not enabled or it is Read IO. */ - if (!ub_cmd->addr && (!ublk_need_get_data(ubq) || req_op(req) =3D=3D REQ= _OP_READ)) - goto out; - if (!(io->flags & UBLK_IO_FLAG_OWNED_BY_SRV)) - goto out; - io->addr =3D ub_cmd->addr; + if (!ublk_support_zc(ubq)) { + if (!ub_cmd->addr && (!ublk_need_get_data(ubq) || + req_op(req) =3D=3D REQ_OP_READ)) + goto out; + io->addr =3D ub_cmd->addr; + } io->flags |=3D UBLK_IO_FLAG_ACTIVE; io->cmd =3D cmd; ublk_commit_completion(ub, ub_cmd); --=20 2.39.2 From nobody Mon Apr 29 19:22:35 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id DAB37C6FD18 for ; Tue, 28 Mar 2023 15:28:36 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232289AbjC1P2e (ORCPT ); Tue, 28 Mar 2023 11:28:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48312 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233344AbjC1P2O (ORCPT ); Tue, 28 Mar 2023 11:28:14 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BC56711E87 for ; Tue, 28 Mar 2023 08:26:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680017127; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=bkrQPrOTJ7X3k65OqTy8qHOS1yB1zs3W4YKYKVIPFZA=; b=Bh798vqDG9/iIUzTNCKKtyi8VvKtdr1zdNmOBMeOdNiit6FcQvMwWieozvTdo6gRiIHDom I6tKp4vcS5h+D/IHU7g+QXO9iaD/ngkSWoKLyIOO2lcF5LeIZUE5sG36OFJDNDSZnnxpOF iTOdfV+SBTTcYak2UMM695KSXtOUCzg= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-381-RElhPhaVNO-sLFZ5mAKV0g-1; Tue, 28 Mar 2023 11:12:02 -0400 X-MC-Unique: RElhPhaVNO-sLFZ5mAKV0g-1 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.rdu2.redhat.com [10.11.54.8]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 99A1D100DEA9; Tue, 28 Mar 2023 15:12:01 +0000 (UTC) Received: from localhost (ovpn-8-20.pek2.redhat.com [10.72.8.20]) by smtp.corp.redhat.com (Postfix) with ESMTP id 2E829C15BA0; Tue, 28 Mar 2023 15:11:59 +0000 (UTC) From: Ming Lei To: Jens Axboe , io-uring@vger.kernel.org, linux-block@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Miklos Szeredi , ZiyangZhang , Xiaoguang Wang , Bernd Schubert , Pavel Begunkov , Stefan Hajnoczi , Dan Williams , Ming Lei Subject: [PATCH V5 16/16] block: ublk_drv: apply io_uring FUSED_CMD for supporting zero copy Date: Tue, 28 Mar 2023 23:09:58 +0800 Message-Id: <20230328150958.1253547-17-ming.lei@redhat.com> In-Reply-To: <20230328150958.1253547-1-ming.lei@redhat.com> References: <20230328150958.1253547-1-ming.lei@redhat.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.1 on 10.11.54.8 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Apply io_uring fused command for supporting zero copy: 1) init the fused cmd buffer(io_mapped_buf) in ublk_map_io(), and deinit it in ublk_unmap_io(), and this buffer is immutable, so it is just fine to retrieve it from concurrent fused command. 1) add sub-command opcode of UBLK_IO_FUSED_SUBMIT_IO for retrieving this fused cmd(zero copy) buffer 2) call io_fused_cmd_start_secondary_req() to provide buffer to secondary request and submit secondary request; meantime setup complete callback via this API, once secondary request is completed, the complete callback is called for freeing the buffer and completing the fused command Also request reference is held during fused command lifetime, and this way guarantees that request buffer won't be freed until all inflight fused commands are completed. userspace(only implement sqe128 fused command): https://github.com/ming1/ubdsrv/tree/fused-cmd-zc-for-v5 liburing test(only implement normal sqe fused command: two 64byte SQEs) https://github.com/ming1/liburing/tree/fused_cmd_miniublk_for_v5 Signed-off-by: Ming Lei --- Documentation/block/ublk.rst | 126 ++++++++++++++++++++-- drivers/block/ublk_drv.c | 192 ++++++++++++++++++++++++++++++++-- include/uapi/linux/ublk_cmd.h | 6 +- 3 files changed, 303 insertions(+), 21 deletions(-) diff --git a/Documentation/block/ublk.rst b/Documentation/block/ublk.rst index 1713b2890abb..7b7aa24e9729 100644 --- a/Documentation/block/ublk.rst +++ b/Documentation/block/ublk.rst @@ -297,18 +297,126 @@ with specified IO tag in the command data: ``UBLK_IO_COMMIT_AND_FETCH_REQ`` to the server, ublkdrv needs to copy the server buffer (pages) read to the IO request pages. =20 -Future development -=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +- ``UBLK_IO_FUSED_SUBMIT_IO`` + + Used for implementing zero copy feature. + + It has to been the primary command of io_uring fused command. This comma= nd + submits the generic secondary IO request with io buffer provided by our = primary + command, and won't be completed until the secondary request is done. + + The provided buffer is represented as ``io_uring_bvec_buf``, which is + actually ublk request buffer's reference, and the reference is shared & + read-only, so the generic secondary request can retrieve any part of the= buffer + by passing buffer offset & length. =20 Zero copy ---------- +=3D=3D=3D=3D=3D=3D=3D=3D=3D + +What is zero copy? +------------------ + +When application submits IO to ``/dev/ublkb*``, userspace buffer(direct io) +or page cache buffer(buffered io) or kernel buffer(meta io often) is used +for submitting data to ublk driver, and all kinds of these buffers are +represented by bio/bvecs(ublk request buffer) finally. Before supporting +zero copy, data in these buffers has to be copied to ublk server userspace +buffer before handling WRITE IO, or after handing READ IO, so that ublk +server can handle IO for ``/dev/ublkb*`` with the copied data. + +The extra copy between ublk request buffer and ublk server userspace buffer +not only increases CPU utilization(such as pinning pages, copy data), but +also consumes memory bandwidth, and the cost could be very big when IO size +is big. It is observed that ublk-null IOPS may be increased to ~5X if the +extra copy can be avoided. + +So zero copy is very important for supporting high performance block device +in userspace. + +Technical requirements +---------------------- + +- ublk request buffer use + +ublk request buffer is represented by bio/bvec, which is immutable, so do +not try to change bvec via buffer reference; data can be read from or +written to the buffer according to buffer direction, but bvec can't be +changed + +- buffer lifetime + +Ublk server borrows ublk request buffer for handling ublk IO, ublk request +buffer reference is used. Reference can't outlive the referent buffer. That +means all request buffer references have to be released by ublk server +before ublk driver completes this request, when request buffer ownership +is transferred to upper layer(FS, application, ...). + +Also after ublk request is completed, any page belonging to this ublk +request can not be written or read any more from ublk server since it is +one block device from kernel viewpoint. + +- buffer direction + +For ublk WRITE request, ublk request buffer should only be accessed as data +source, and the buffer can't be written by ublk server + +For ublk READ request, ublk request buffer should only be accessed as data +destination, and the buffer can't be read by ublk server, otherwise kernel +data is leaked to ublk server, which can be unprivileged application. + +- arbitrary size sub-buffer needs to be retrieved from ublk server + +ublk is one generic framework for implementing block device in userspace, +and typical requirements include logical volume manager(mirror, stripped, = ...), +distributed network storage, compressed target, ... + +ublk server needs to retrieve arbitrary size sub-buffer of ublk request, a= nd +ublk server needs to submit IOs with these sub-buffer(s). That also means +arbitrary size sub-buffer(s) can be used to submit IO multiple times. + +Any sub-buffer is actually one reference of ublk request buffer, which +ownership can't be transferred to upper layer if any reference is held +by ublk server. + +Why slice isn't good for ublk zero copy +--------------------------------------- + +- spliced page from ->splice_read() can't be written + +ublk READ request can't be handled because spliced page can't be written t= o, and +extending splice for ublk zero copy isn't one good solution [#splice_exten= d]_ + +- it is very hard to meet above requirements wrt. request buffer lifetime + +splice/pipe focuses on page reference lifetime, but ublk zero copy pays mo= re +attention to ublk request buffer lifetime. If is very inefficient to respe= ct +request buffer lifetime by using all pipe buffer's ->release() which requi= res +all pipe buffers and pipe to be kept when ublk server handles IO. That mea= ns +one single dedicated ``pipe_inode_info`` has to be allocated runtime for e= ach +provided buffer, and the pipe needs to be populated with pages in ublk req= uest +buffer. + + +io_uring fused command based zero copy +-------------------------------------- + +io_uring fused command includes one primary command(uring command) and one +generic secondary request. The primary command is responsible for submitti= ng +secondary request with provided buffer from ublk request, and primary comm= and +won't be completed until the secondary request is completed. + +Typical ublk IO handling includes network and FS IO, so it is usual enough +for io_uring net & fs to support IO with provided buffer from primary comm= and. =20 -Zero copy is a generic requirement for nbd, fuse or similar drivers. A -problem [#xiaoguang]_ Xiaoguang mentioned is that pages mapped to userspace -can't be remapped any more in kernel with existing mm interfaces. This can -occurs when destining direct IO to ``/dev/ublkb*``. Also, he reported that -big requests (IO size >=3D 256 KB) may benefit a lot from zero copy. +Once primary command is submitted successfully, ublk driver guarantees that +the ublk request buffer won't be gone away since secondary request actually +grabs the buffer's reference. This way also guarantees that multiple +concurrent fused commands associated with same request buffer works fine, +as the provided buffer reference is shared & read-only. =20 +Also buffer usage direction flag is passed to primary command from userspa= ce, +so ublk driver can validate if it is legal to use buffer with requested +direction. =20 References =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D @@ -323,4 +431,4 @@ References =20 .. [#stefan] https://lore.kernel.org/linux-block/YoOr6jBfgVm8GvWg@stefanha= -x1.localdomain/ =20 -.. [#xiaoguang] https://lore.kernel.org/linux-block/YoOr6jBfgVm8GvWg@stefa= nha-x1.localdomain/ +.. [#splice_extend] https://lore.kernel.org/linux-block/CAHk-=3DwgJsi7t7YY= puo6ewXGnHz2nmj67iWR6KPGoz5TBu34mWQ@mail.gmail.com/ diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c index a49b4de5ae1e..52b0a6e2be6e 100644 --- a/drivers/block/ublk_drv.c +++ b/drivers/block/ublk_drv.c @@ -74,10 +74,15 @@ struct ublk_rq_data { * successfully */ struct kref ref; + bool allocated_bvec; + struct io_uring_bvec_buf buf[0]; }; =20 struct ublk_uring_cmd_pdu { - struct ublk_queue *ubq; + union { + struct ublk_queue *ubq; + struct request *req; + }; }; =20 /* @@ -565,6 +570,69 @@ static size_t ublk_copy_user_pages(const struct reques= t *req, return done; } =20 +/* + * The built command buffer is immutable, so it is fine to feed it to + * concurrent io_uring fused commands + */ +static int ublk_init_zero_copy_buffer(struct request *rq) +{ + struct ublk_rq_data *data =3D blk_mq_rq_to_pdu(rq); + struct io_uring_bvec_buf *imu =3D data->buf; + struct req_iterator rq_iter; + unsigned int nr_bvecs =3D 0; + struct bio_vec *bvec; + unsigned int offset; + struct bio_vec bv; + + if (!ublk_rq_has_data(rq)) + goto exit; + + rq_for_each_bvec(bv, rq, rq_iter) + nr_bvecs++; + + if (!nr_bvecs) + goto exit; + + if (rq->bio !=3D rq->biotail) { + int idx =3D 0; + + bvec =3D kvmalloc_array(sizeof(struct bio_vec), nr_bvecs, + GFP_NOIO); + if (!bvec) + return -ENOMEM; + + offset =3D 0; + rq_for_each_bvec(bv, rq, rq_iter) + bvec[idx++] =3D bv; + data->allocated_bvec =3D true; + } else { + struct bio *bio =3D rq->bio; + + offset =3D bio->bi_iter.bi_bvec_done; + bvec =3D __bvec_iter_bvec(bio->bi_io_vec, bio->bi_iter); + } + imu->bvec =3D bvec; + imu->nr_bvecs =3D nr_bvecs; + imu->offset =3D offset; + imu->len =3D blk_rq_bytes(rq); + + return 0; +exit: + imu->bvec =3D NULL; + return 0; +} + +static void ublk_deinit_zero_copy_buffer(struct request *rq) +{ + struct ublk_rq_data *data =3D blk_mq_rq_to_pdu(rq); + struct io_uring_bvec_buf *imu =3D data->buf; + + if (data->allocated_bvec) { + kvfree(imu->bvec); + data->allocated_bvec =3D false; + } +} + static inline bool ublk_need_map_req(const struct request *req) { return ublk_rq_has_data(req) && req_op(req) =3D=3D REQ_OP_WRITE; @@ -575,11 +643,23 @@ static inline bool ublk_need_unmap_req(const struct r= equest *req) return ublk_rq_has_data(req) && req_op(req) =3D=3D REQ_OP_READ; } =20 -static int ublk_map_io(const struct ublk_queue *ubq, const struct request = *req, +static int ublk_map_io(const struct ublk_queue *ubq, struct request *req, struct ublk_io *io) { const unsigned int rq_bytes =3D blk_rq_bytes(req); =20 + if (ublk_support_zc(ubq)) { + int ret =3D ublk_init_zero_copy_buffer(req); + + /* + * The only failure is -ENOMEM for allocating fused cmd + * buffer, return zero so that we can requeue this req. + */ + if (unlikely(ret)) + return 0; + return rq_bytes; + } + /* * no zero copy, we delay copy WRITE request data into ublksrv * context and the big benefit is that pinning pages in current @@ -599,11 +679,17 @@ static int ublk_map_io(const struct ublk_queue *ubq, = const struct request *req, } =20 static int ublk_unmap_io(const struct ublk_queue *ubq, - const struct request *req, + struct request *req, struct ublk_io *io) { const unsigned int rq_bytes =3D blk_rq_bytes(req); =20 + if (ublk_support_zc(ubq)) { + ublk_deinit_zero_copy_buffer(req); + + return rq_bytes; + } + if (ublk_need_unmap_req(req)) { struct iov_iter iter; struct iovec iov; @@ -687,6 +773,12 @@ static inline struct ublk_uring_cmd_pdu *ublk_get_urin= g_cmd_pdu( return (struct ublk_uring_cmd_pdu *)&ioucmd->pdu; } =20 +static inline struct ublk_uring_cmd_pdu *ublk_get_uring_fused_cmd_pdu( + struct io_uring_cmd *ioucmd) +{ + return (struct ublk_uring_cmd_pdu *)&ioucmd->fused.pdu; +} + static inline bool ubq_daemon_is_dying(struct ublk_queue *ubq) { return ubq->ubq_daemon->flags & PF_EXITING; @@ -742,6 +834,7 @@ static inline void __ublk_complete_rq(struct request *r= eq) =20 return; exit: + ublk_deinit_zero_copy_buffer(req); blk_mq_end_request(req, res); } =20 @@ -1352,6 +1445,68 @@ static inline struct request *__ublk_check_and_get_r= eq(struct ublk_device *ub, return NULL; } =20 +static void ublk_fused_cmd_done_cb(struct io_uring_cmd *cmd, + unsigned issue_flags) +{ + struct ublk_uring_cmd_pdu *pdu =3D ublk_get_uring_fused_cmd_pdu(cmd); + struct request *req =3D pdu->req; + struct ublk_queue *ubq =3D req->mq_hctx->driver_data; + + ublk_put_req_ref(ubq, req); + io_uring_cmd_done(cmd, cmd->fused.data.secondary_res, 0, issue_flags); +} + +static inline bool ublk_check_fused_buf_dir(const struct request *req, + unsigned int flags) +{ + flags &=3D IO_URING_F_FUSED; + + if (req_op(req) =3D=3D REQ_OP_READ && flags =3D=3D IO_URING_F_FUSED_BUF_D= EST) + return true; + + if (req_op(req) =3D=3D REQ_OP_WRITE && flags =3D=3D IO_URING_F_FUSED_BUF_= SRC) + return true; + + return false; +} + +static int ublk_handle_fused_cmd(struct io_uring_cmd *cmd, + struct ublk_queue *ubq, int tag, unsigned int issue_flags) +{ + struct ublk_uring_cmd_pdu *pdu =3D ublk_get_uring_fused_cmd_pdu(cmd); + struct ublk_device *ub =3D cmd->file->private_data; + struct ublk_rq_data *data; + struct request *req; + + if (!ub) + return -EPERM; + + if (!(issue_flags & IO_URING_F_FUSED)) + goto exit; + + req =3D __ublk_check_and_get_req(ub, ubq, tag, 0); + if (!req) + goto exit; + + pr_devel("%s: qid %d tag %u request bytes %u, issue flags %x\n", + __func__, tag, ubq->q_id, blk_rq_bytes(req), + issue_flags); + + if (!ublk_check_fused_buf_dir(req, issue_flags)) + goto exit_put_ref; + + pdu->req =3D req; + data =3D blk_mq_rq_to_pdu(req); + io_fused_cmd_start_secondary_req(cmd, !(issue_flags & IO_URING_F_UNLOCKED= ), + data->buf, ublk_fused_cmd_done_cb); + return -EIOCBQUEUED; + +exit_put_ref: + ublk_put_req_ref(ubq, req); +exit: + return -EINVAL; +} + static int ublk_ch_uring_cmd(struct io_uring_cmd *cmd, unsigned int issue_= flags) { struct ublksrv_io_cmd *ub_cmd =3D (struct ublksrv_io_cmd *)cmd->cmd; @@ -1367,6 +1522,10 @@ static int ublk_ch_uring_cmd(struct io_uring_cmd *cm= d, unsigned int issue_flags) __func__, cmd->cmd_op, ub_cmd->q_id, tag, ub_cmd->result); =20 + if ((issue_flags & IO_URING_F_FUSED) && + cmd_op !=3D UBLK_IO_FUSED_SUBMIT_IO) + return -EOPNOTSUPP; + if (ub_cmd->q_id >=3D ub->dev_info.nr_hw_queues) goto out; =20 @@ -1374,7 +1533,12 @@ static int ublk_ch_uring_cmd(struct io_uring_cmd *cm= d, unsigned int issue_flags) if (!ubq || ub_cmd->q_id !=3D ubq->q_id) goto out; =20 - if (ubq->ubq_daemon && ubq->ubq_daemon !=3D current) + /* + * The fused command reads the io buffer data structure only, so it + * is fine to be issued from other context. + */ + if ((ubq->ubq_daemon && ubq->ubq_daemon !=3D current) && + (cmd_op !=3D UBLK_IO_FUSED_SUBMIT_IO)) goto out; =20 if (tag >=3D ubq->q_depth) @@ -1397,6 +1561,9 @@ static int ublk_ch_uring_cmd(struct io_uring_cmd *cmd= , unsigned int issue_flags) goto out; =20 switch (cmd_op) { + case UBLK_IO_FUSED_SUBMIT_IO: + return ublk_handle_fused_cmd(cmd, ubq, tag, issue_flags); + case UBLK_IO_FETCH_REQ: /* UBLK_IO_FETCH_REQ is only allowed before queue is setup */ if (ublk_queue_ready(ubq)) { @@ -1726,11 +1893,14 @@ static void ublk_align_max_io_size(struct ublk_devi= ce *ub) =20 static int ublk_add_tag_set(struct ublk_device *ub) { + int zc =3D !!(ub->dev_info.flags & UBLK_F_SUPPORT_ZERO_COPY); + struct ublk_rq_data *data; + ub->tag_set.ops =3D &ublk_mq_ops; ub->tag_set.nr_hw_queues =3D ub->dev_info.nr_hw_queues; ub->tag_set.queue_depth =3D ub->dev_info.queue_depth; ub->tag_set.numa_node =3D NUMA_NO_NODE; - ub->tag_set.cmd_size =3D sizeof(struct ublk_rq_data); + ub->tag_set.cmd_size =3D struct_size(data, buf, zc); ub->tag_set.flags =3D BLK_MQ_F_SHOULD_MERGE; ub->tag_set.driver_data =3D ub; return blk_mq_alloc_tag_set(&ub->tag_set); @@ -1946,12 +2116,18 @@ static int ublk_ctrl_add_dev(struct io_uring_cmd *c= md) */ ub->dev_info.flags &=3D UBLK_F_ALL; =20 + /* + * NEED_GET_DATA doesn't make sense any more in case that + * ZERO_COPY is requested. Another reason is that userspace + * can read/write io request buffer by pread()/pwrite() with + * each io buffer's position. + */ + if (ub->dev_info.flags & UBLK_F_SUPPORT_ZERO_COPY) + ub->dev_info.flags &=3D ~UBLK_F_NEED_GET_DATA; + if (!IS_BUILTIN(CONFIG_BLK_DEV_UBLK)) ub->dev_info.flags |=3D UBLK_F_URING_CMD_COMP_IN_TASK; =20 - /* We are not ready to support zero copy */ - ub->dev_info.flags &=3D ~UBLK_F_SUPPORT_ZERO_COPY; - ub->dev_info.nr_hw_queues =3D min_t(unsigned int, ub->dev_info.nr_hw_queues, nr_cpu_ids); ublk_align_max_io_size(ub); diff --git a/include/uapi/linux/ublk_cmd.h b/include/uapi/linux/ublk_cmd.h index d1a6b3dc0327..c4f3465399cf 100644 --- a/include/uapi/linux/ublk_cmd.h +++ b/include/uapi/linux/ublk_cmd.h @@ -44,6 +44,7 @@ #define UBLK_IO_FETCH_REQ 0x20 #define UBLK_IO_COMMIT_AND_FETCH_REQ 0x21 #define UBLK_IO_NEED_GET_DATA 0x22 +#define UBLK_IO_FUSED_SUBMIT_IO 0x23 =20 /* only ABORT means that no re-fetch */ #define UBLK_IO_RES_OK 0 @@ -85,10 +86,7 @@ static inline __u64 ublk_pos(__u16 q_id, __u16 tag, __u3= 2 offset) ((((__u64)tag) << UBLK_BUF_SIZE_BITS) + offset); } =20 -/* - * zero copy requires 4k block size, and can remap ublk driver's io - * request into ublksrv's vm space - */ +/* io_uring fused command based zero copy */ #define UBLK_F_SUPPORT_ZERO_COPY (1ULL << 0) =20 /* --=20 2.39.2