From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=100.103.45.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1793831800; b=F2N9gB8H6btsRayNts+JgbiV8vZzxep7LJ1cm70dMdI0b2dfDti7jh0FhXwtdT73GVwU 4ZDT9Yvc9yjQQqk0GH+e9TMwzpajij9rNlNHLq921BzZZPvlGnBE+OFifITrWrhaK5ipY wCy2yns3tKZJvsuxc253mmrzLInXFrDDgMF4eXX9pwK4YmdsYAILUTtZH7NLojpQafKHE KWwWhQksDUgFEy7i5dSwYnbo1xf4BOMiScCmFDaBDWlZnCnWhDdMmr8nRmhDab+oDc+y5 p/uXdFp59sJ75FFWpvE+k80sI558+ZShyxCgTiOtoqVyKmRNkX0n/YeyzTvDnU8QL9A== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1793831800; h=Received:DKIM-Signature:From:To:Cc:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:User-Agent:X-stable:X-Patchwork-Hint: MIME-Version:Content-Transfer-Encoding; bh=Kdb8eYw9DEpXWmzZm54P0rZWIlst6n2sHCVp8HnMJ/I=; b=NZFuuaqV9XogPiZ8tYw3cJBu16hf79P51gKH3Y5dzugAskBI+kwOlSpiRB5sMwUdh1tF EUOrUp4hxu20XObK0eKl0+Y4cK8t98QJ2jfdf13hXL6EuN3FWxiBumvSUAhQ/JkZKaWaf gLO1Kl8OyleZ+4O/Z0wfF2WfW/VQSWr5pYeAvSI/ub6zTA4IVrOK0YAoVRgieQ4TQcZAl jtSv5pocd2vr2NDF/cNpBboNTs3CT9UqRmVoopXXMPrwyDJjdj0Xvyj1bVcqS47a6nRmd ZT+2JRkQzOsKSwmTaOWOnmmCR82Yy4KubtWGkyvntP/ExAU1V8NCFfognfKCQvVPsFg== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass header.d=linuxfoundation.org header.i=@linuxfoundation.org header.a=rsa-sha256 header.s=korg header.b=jMaOo4x8; arc=none smtp.remote-ip=100.103.45.18 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AE61D606A841; Wed, 4 Nov 2026 22:36:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key, unprotected) header.d=linuxfoundation.org header.i=@linuxfoundation.org header.a=rsa-sha256 header.s=korg header.b=jMaOo4x8 Received: by smtp.kernel.org (Postfix) with ESMTPSA id 56DDB1F000C1; Wed, 4 Nov 2026 22:36:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linuxfoundation.org; s=korg; t=1793831799; bh=Kdb8eYw9DEpXWmzZm54P0rZWIlst6n2sHCVp8HnMJ/I=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=jMaOo4x8NESXaVG8hWRUZSGDynk+pGCqAENhdKX+jSzVWT1uv6/R6/WrxxPJXJAhC E1H25Ncb+BdH/XWNyU1SYCCFT12siYra06n2ylDoKhATM8pH+KwMKj5QAa1d0kmmtf 8X6jM+gUbhshsu+4TGjZ+7elgUkTtYgQJl6WLW6U= From: Greg Kroah-Hartman To: stable@vger.kernel.org Cc: Greg Kroah-Hartman , patches@lists.linux.dev, David Laight , David Howells , Marc Dionne , Eric Dumazet , "David S. Miller" , Jakub Kicinski , Paolo Abeni , Simon Horman , linux-afs@lists.infradead.org Subject: [PATCH 6.18 0919/1005] rxrpc: Fix lack of short-send handling in rxrpc_kernel_send_data() Date: Wed, 4 Nov 2026 16:10:52 -0500 Message-ID: <20261104211108.894444023@linuxfoundation.org> X-Mailer: git-send-email 2.56.0 In-Reply-To: <20261104211043.516122098@linuxfoundation.org> References: <20261104211043.516122098@linuxfoundation.org> User-Agent: quilt/0.69 X-stable: review X-Patchwork-Hint: ignore X-Mailing-List: patches@lists.linux.dev List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Transfer-Encoding: 8bit 6.18-stable review patch. If anyone has any objections, please let me know. ------------------ From: David Howells commit af208f36ae22440cf6011a43cb3064fd525d85b4 upstream. Fix rxrpc_kernel_send_data() to loop around if it detects a short send. David Laight suggested doing it here rather than wrapping all the calls in loops. Further, remove the len argument and use the iterator count instead and return 0 on success, not the amount copied. Note this is also a prerequisite for changing the way rxrpc_send_data() works to return a short send rather than an error if some data was buffered. Fixes: 651350d10f93 ("[AF_RXRPC]: Add an interface to the AF_RXRPC module for the AFS filesystem to use") Link: https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20260824091645.415423-1-dhowells%40redhat.com Suggested-by: David Laight Signed-off-by: David Howells cc: Marc Dionne cc: Eric Dumazet cc: "David S. Miller" cc: Jakub Kicinski cc: Paolo Abeni cc: Simon Horman cc: linux-afs@lists.infradead.org cc: stable@vger.kernel.org Link: https://patch.msgid.link/20261006133011.531806-5-dhowells@redhat.com Signed-off-by: Paolo Abeni Signed-off-by: Greg Kroah-Hartman --- Documentation/networking/rxrpc.rst | 8 +++++--- fs/afs/rxrpc.c | 32 +++++++++++++------------------- include/net/af_rxrpc.h | 5 ++--- net/rxrpc/rxperf.c | 25 ++++++++++--------------- net/rxrpc/sendmsg.c | 27 +++++++++++++++++++-------- 5 files changed, 49 insertions(+), 48 deletions(-) --- a/Documentation/networking/rxrpc.rst +++ b/Documentation/networking/rxrpc.rst @@ -870,7 +870,6 @@ The kernel interface functions are as fo int rxrpc_kernel_send_data(struct socket *sock, struct rxrpc_call *call, struct msghdr *msg, - size_t len, rxrpc_notify_end_tx_t notify_end_rx); This is used to supply either the request part of a client call or the @@ -879,14 +878,17 @@ The kernel interface functions are as fo exclusively to in-kernel virtual addresses. msg.msg_flags may be given MSG_MORE if there will be subsequent data sends for this call. - The msg must not specify a destination address, control data or any flags - other than MSG_MORE. len is the total amount of data to transmit. + msg must not specify a destination address, control data or any flags + other than MSG_MORE or MSG_WAITALL. notify_end_rx can be NULL or it can be used to specify a function to be called when the call changes state to end the Tx phase. This function is called with a spinlock held to prevent the last DATA packet from being transmitted until the function returns. + It returns 0 if all the provided data has been buffered and a negative + error code on failure. + (#) Receive data from a call:: int rxrpc_kernel_recv_data(struct socket *sock, --- a/fs/afs/rxrpc.c +++ b/fs/afs/rxrpc.c @@ -412,8 +412,7 @@ void afs_make_call(struct afs_call *call msg.msg_controllen = 0; msg.msg_flags = MSG_WAITALL | (call->write_iter ? MSG_MORE : 0); - ret = rxrpc_kernel_send_data(call->net->socket, rxcall, - &msg, call->request_size, + ret = rxrpc_kernel_send_data(call->net->socket, rxcall, &msg, afs_notify_end_request_tx); if (ret < 0) goto error_do_abort; @@ -425,7 +424,6 @@ void afs_make_call(struct afs_call *call ret = rxrpc_kernel_send_data(call->net->socket, call->rxcall, &msg, - iov_iter_count(&msg.msg_iter), afs_notify_end_request_tx); *call->write_iter = msg.msg_iter; @@ -871,7 +869,7 @@ void afs_send_empty_reply(struct afs_cal msg.msg_controllen = 0; msg.msg_flags = 0; - switch (rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, 0, + switch (rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, afs_notify_end_reply_tx)) { case 0: _leave(" [replied]"); @@ -897,7 +895,7 @@ void afs_send_simple_reply(struct afs_ca struct afs_net *net = call->net; struct msghdr msg; struct kvec iov[1]; - int n; + int ret; _enter(""); @@ -912,21 +910,17 @@ void afs_send_simple_reply(struct afs_ca msg.msg_controllen = 0; msg.msg_flags = 0; - n = rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, len, - afs_notify_end_reply_tx); - if (n >= 0) { - /* Success */ - _leave(" [replied]"); - return; - } - - if (n == -ENOMEM) { - _debug("oom"); - rxrpc_kernel_abort_call(net->socket, call->rxcall, - RXGEN_SS_MARSHAL, -ENOMEM, - afs_abort_oom); + ret = rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, + afs_notify_end_reply_tx); + if (ret < 0) { + if (ret == -ENOMEM) { + _debug("oom"); + rxrpc_kernel_abort_call(net->socket, call->rxcall, + RXGEN_SS_MARSHAL, -ENOMEM, + afs_abort_oom); + } + _leave(" [error]"); } - _leave(" [error]"); } /* --- a/include/net/af_rxrpc.h +++ b/include/net/af_rxrpc.h @@ -64,9 +64,8 @@ struct rxrpc_call *rxrpc_kernel_begin_ca bool upgrade, enum rxrpc_interruptibility interruptibility, unsigned int debug_id); -int rxrpc_kernel_send_data(struct socket *, struct rxrpc_call *, - struct msghdr *, size_t, - rxrpc_notify_end_tx_t); +int rxrpc_kernel_send_data(struct socket *sock, struct rxrpc_call *call, + struct msghdr *msg, rxrpc_notify_end_tx_t notify_end_tx); int rxrpc_kernel_recv_data(struct socket *, struct rxrpc_call *, struct iov_iter *, size_t *, bool, u32 *, u16 *); bool rxrpc_kernel_abort_call(struct socket *, struct rxrpc_call *, --- a/net/rxrpc/rxperf.c +++ b/net/rxrpc/rxperf.c @@ -513,8 +513,8 @@ static int rxperf_process_call(struct rx struct msghdr msg = {}; struct bio_vec bv; struct kvec iov[1]; - ssize_t n; size_t reply_len = call->reply_len, len; + int ret; rxrpc_kernel_set_tx_length(rxperf_socket, call->rxcall, reply_len + sizeof(rxperf_magic_cookie)); @@ -524,13 +524,11 @@ static int rxperf_process_call(struct rx bvec_set_page(&bv, ZERO_PAGE(0), len, 0); iov_iter_bvec(&msg.msg_iter, WRITE, &bv, 1, len); msg.msg_flags = MSG_MORE; - n = rxrpc_kernel_send_data(rxperf_socket, call->rxcall, &msg, - len, rxperf_notify_end_reply_tx); - if (n < 0) - return n; - if (n == 0) - return -EIO; - reply_len -= n; + ret = rxrpc_kernel_send_data(rxperf_socket, call->rxcall, &msg, + rxperf_notify_end_reply_tx); + if (ret < 0) + return ret; + reply_len -= len; } len = sizeof(rxperf_magic_cookie); @@ -538,16 +536,13 @@ static int rxperf_process_call(struct rx iov[0].iov_len = len; iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, len); msg.msg_flags = 0; - n = rxrpc_kernel_send_data(rxperf_socket, call->rxcall, &msg, len, - rxperf_notify_end_reply_tx); - if (n >= 0) - return 0; /* Success */ - - if (n == -ENOMEM) + ret = rxrpc_kernel_send_data(rxperf_socket, call->rxcall, &msg, + rxperf_notify_end_reply_tx); + if (ret == -ENOMEM) rxrpc_kernel_abort_call(rxperf_socket, call->rxcall, RXGEN_SS_MARSHAL, -ENOMEM, rxperf_abort_oom); - return n; + return ret; } /* --- a/net/rxrpc/sendmsg.c +++ b/net/rxrpc/sendmsg.c @@ -793,7 +793,6 @@ error_release_sock: * @sock: The socket the call is on * @call: The call to send data through * @msg: The data to send - * @len: The amount of data to send * @notify_end_tx: Notification that the last packet is queued. * * Allow a kernel service to send data on a call. The call must be in an state @@ -804,8 +803,7 @@ error_release_sock: * Return: %0 if successful and a negative error code otherwise. */ int rxrpc_kernel_send_data(struct socket *sock, struct rxrpc_call *call, - struct msghdr *msg, size_t len, - rxrpc_notify_end_tx_t notify_end_tx) + struct msghdr *msg, rxrpc_notify_end_tx_t notify_end_tx) { int ret; @@ -814,12 +812,25 @@ int rxrpc_kernel_send_data(struct socket ASSERTCMP(msg->msg_name, ==, NULL); ASSERTCMP(msg->msg_control, ==, NULL); - mutex_lock(&call->user_mutex); + for (;;) { + mutex_lock(&call->user_mutex); + + ret = rxrpc_send_data(rxrpc_sk(sock->sk), call, msg, + msg_data_left(msg), notify_end_tx); + if (ret == -ESHUTDOWN) + ret = call->error; + if (ret < 0) + break; + if (msg_data_left(msg) == 0) { + ret = 0; + break; + } + if (ret == 0) { + ret = -EIO; + break; + } + } - ret = rxrpc_send_data(rxrpc_sk(sock->sk), call, msg, len, - notify_end_tx); - if (ret == -ESHUTDOWN) - ret = call->error; _leave(" = %d", ret); return ret; }