From patchwork Sat Feb 1 00:34:41 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13955975 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D6D8817C91 for ; Sat, 1 Feb 2025 00:34:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370091; cv=none; b=FFrOBSwiuk3BcMgJf0c7898ThflvSfWHkDiX7XqFJZE9FltbTL7NXYYk5CmQp3VhopKFNXAUK5CwgOblrXRk/9KYtsITo8hS0vl7xNImUtRBw10Hgo3/kWqoc0JH+zf/D0FNHsQn0Gq4QVvBc1mc/AiN6KQVtwfX1bG+uwOnGPo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370091; c=relaxed/simple; bh=VuC02b5yS8ke6mLcq3O5RcDiTMROgA0M5SpWwePwFhw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=hj/lUm/hvyeqrdQsZ2qnQU8SZ6tjpBka3HG62ZScCK4XjX28VH0tu7VuOsl2McLoePZybMgvOMduW16O3yX2kNpPACScW/y5Wco7LT9cqQIRcNHK1+mW4cvGuLsmSWr8/Lh0fkf9VLbH17XgbIxJwD2OCX9XvSKNYHJMQ/FioY8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Z6AD3IAL; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Z6AD3IAL" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A8D44C4CEE4; Sat, 1 Feb 2025 00:34:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1738370091; bh=VuC02b5yS8ke6mLcq3O5RcDiTMROgA0M5SpWwePwFhw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Z6AD3IALukk0HdYsYyHN5Dpn1JI96f+wbRxuc5KxL8Evd7QN2x0F9fs+8xXbxjp83 xHmNDnneOWEZYgkB4jTVCR5nV1HZo9dPOjhK4Q7SjuxV0Z0O6tXd2ywEl4fNm46x0r 3yhNsWSeprETLV0CvvZy58wajHcwQcn5to7Z56CFtDv4P90JWqkM9NyKKM1d7SsPld 3/yOWVoHbDBSu0D4uGOyVS4bGgkzjmEADtj7kuDjsAuH+H8t1eB7Ng/7HyVsP/uFuA Gcg+4Oo1HXl6CVcw42rvklukonMzTXYJ63/1VVlAUSq+a6w1WkYYBEvkK7tCyKrop6 NR5TnVCtpNhsg== From: cel@kernel.org To: Trond Myklebust , Anna Schumaker Cc: , Chuck Lever , Jeff Layton , Benjamin Coddington , Olga Kornievskaia Subject: [PATCH v4 1/7] NFS: CB_OFFLOAD can return NFS4ERR_DELAY Date: Fri, 31 Jan 2025 19:34:41 -0500 Message-ID: <20250201003447.54614-2-cel@kernel.org> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20250201003447.54614-1-cel@kernel.org> References: <20250201003447.54614-1-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Chuck Lever RFC 7862 permits the callback service to respond to a CB_OFFLOAD operation with NFS4ERR_DELAY. Use that instead of NFS4ERR_SERVERFAULT for temporary memory allocation failure, as that is more consistent with how other operations report memory allocation failure. Reviewed-by: Jeff Layton Reviewed-by: Benjamin Coddington Reviewed-by: Olga Kornievskaia Tested-by: Olga Kornievskaia Signed-off-by: Chuck Lever --- fs/nfs/callback_proc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c index 7832fb0369a1..8397c43358bd 100644 --- a/fs/nfs/callback_proc.c +++ b/fs/nfs/callback_proc.c @@ -718,7 +718,7 @@ __be32 nfs4_callback_offload(void *data, void *dummy, copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_KERNEL); if (!copy) - return htonl(NFS4ERR_SERVERFAULT); + return cpu_to_be32(NFS4ERR_DELAY); spin_lock(&cps->clp->cl_lock); rcu_read_lock(); From patchwork Sat Feb 1 00:34:42 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13955976 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D09AC1E49B for ; Sat, 1 Feb 2025 00:34:52 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370092; cv=none; b=X7s5vvA91QTLwuQAhJsXcPD18eknow6IKGn3ZPo7Z/brfPnsw61vP9wkY/luwO3SIHzbAQlvcMFVV1YB68XR9fCFrztuJR+PPFBg7C95Q4MeOzNtd07+2hOEq/4INmWYHBc/h15TepCbHGjVLeEcYm+YknNSSq/HPwZcftchL+k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370092; c=relaxed/simple; bh=hyCBCfEmDPq7d/RcBpFUjMqx1ZszABML+5Yr6MXyhPU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rP0x1j70XTJCarP/z20V0u9u1e1nWinrq60akG8+6LZvdhu4XRKQCBApDRrPu6m4L7/Cob35H/UnUyWXIFzt7M3F2F3lf+mnKcZTk7GGUKwGQ8ryUNBkfuX9r2tOEdwBmmmGc9OvycxcfWhdLPGdpq6Th5t7QpHUS5dxI8j7wj0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=l6Mt2KqN; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="l6Mt2KqN" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9054BC4CEE7; Sat, 1 Feb 2025 00:34:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1738370092; bh=hyCBCfEmDPq7d/RcBpFUjMqx1ZszABML+5Yr6MXyhPU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=l6Mt2KqN6BbFyti4uBeDOzgB/4i9m4oonl+tTO2ZGS2gJAnQhr4GIH1RlIOcsH3EO 9M8oCBjGQPe9CGRCXbaKR7gtbiRS5fyvGPhrZDTQREXLKdNKfumimkOWXh2MeJT5MY e2NttadS8eO+M+S38H8qkkld4hPv59gvuUw9UghFPi0RcmqdJWgIL6ZiF2UEoltnXW NWIQoy4iKCoNC4y+TjKdmBKA7hTdwaGGYhBZHQCWUeW2r4j50hvetaQOZQKD3I4wiP D7hO9q5CfiLuN7Kl8tJxb33aAQyazs20vHqKO6futwn+nhmodfnngqQjexB8ojc1XT e2c7HhbKbC0+w== From: cel@kernel.org To: Trond Myklebust , Anna Schumaker Cc: , Chuck Lever , Jeff Layton , Benjamin Coddington , Olga Kornievskaia Subject: [PATCH v4 2/7] NFS: Fix typo in OFFLOAD_CANCEL comment Date: Fri, 31 Jan 2025 19:34:42 -0500 Message-ID: <20250201003447.54614-3-cel@kernel.org> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20250201003447.54614-1-cel@kernel.org> References: <20250201003447.54614-1-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Chuck Lever Reviewed-by: Jeff Layton Reviewed-by: Benjamin Coddington Reviewed-by: Olga Kornievskaia Tested-by: Olga Kornievskaia Signed-off-by: Chuck Lever --- fs/nfs/nfs42xdr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fs/nfs/nfs42xdr.c b/fs/nfs/nfs42xdr.c index 9e3ae53e2205..ef5730c5e704 100644 --- a/fs/nfs/nfs42xdr.c +++ b/fs/nfs/nfs42xdr.c @@ -549,7 +549,7 @@ static void nfs4_xdr_enc_copy(struct rpc_rqst *req, } /* - * Encode OFFLOAD_CANEL request + * Encode OFFLOAD_CANCEL request */ static void nfs4_xdr_enc_offload_cancel(struct rpc_rqst *req, struct xdr_stream *xdr, From patchwork Sat Feb 1 00:34:43 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13955977 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 528B31EEE0 for ; Sat, 1 Feb 2025 00:34:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370093; cv=none; b=IMyStKJ5SDSsitxmCCuN60ZO5Ca+3ItdVpcci7LAo9GKkcDmVH1LQIiApucDyfDf58MujKsVG9Lbj3n0Uv2F1Z94WbCY9F8rbFVcSMaBtQXLSWNS9s9GJqRL8DHEusscFf3+FiHjrkSE9Y/xHDiBIIKVv9fIg9DYQZNtGGV2pjc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370093; c=relaxed/simple; bh=63BRiQlFZojSSHTPedH2KCeSDjViMmDI71oqe+w2B6w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=m7kBcB82kFpegx7oXnudxWVPEGXEHyj3vE/sHRkgDVgQBcEOA/VtsXw6aUHnfTclYKDjN7vkHY2qw/9FcjIUYD7Dr4US4wMml9aHDKmHWigDkYyQ7SJHFoGyZNuw+2Bf5mSjqtxxMUqFfdaX2AThidlujbm5nqRXcpHz5f+tMS4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=rwEBYksW; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="rwEBYksW" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7FDC9C4CEE1; Sat, 1 Feb 2025 00:34:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1738370093; bh=63BRiQlFZojSSHTPedH2KCeSDjViMmDI71oqe+w2B6w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=rwEBYksWdaWv3C1pQh56wFv1Qd4orp0jbKJiczAclkTT0Meo+OKeurZ5IVqjbS/P0 dSyWUB1OdoaXyeuxtlkvL7GN3JGpuoCCDfa66tfS4CtbkirsLVkUqSujt/j9WnyTZO yrIpzinRJHv0n6ZB/smcMz/jowjHG/V0Ruj9HXVjo3zJYE7rVsuyrAR5uDb9ptlijm E+gq6OI8GVXQUYpYorv6hiJpJcgdOVu5YsGYtHKC5pYzHeR52fsgOoow1V/GJPFhRV DJyK37eJ0NP3bJm6R2eCv9g67oGoUeJyBmKN+e65GJ88AVIyYlHxc66xwR/8sa2awy h+zehL4GkshBQ== From: cel@kernel.org To: Trond Myklebust , Anna Schumaker Cc: , Chuck Lever , Jeff Layton , Benjamin Coddington , Olga Kornievskaia Subject: [PATCH v4 3/7] NFS: Rename struct nfs4_offloadcancel_data Date: Fri, 31 Jan 2025 19:34:43 -0500 Message-ID: <20250201003447.54614-4-cel@kernel.org> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20250201003447.54614-1-cel@kernel.org> References: <20250201003447.54614-1-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Chuck Lever Refactor: This struct can be used unchanged for the new OFFLOAD_STATUS implementation, so give it a more generic name. Reviewed-by: Jeff Layton Reviewed-by: Benjamin Coddington Reviewed-by: Olga Kornievskaia Tested-by: Olga Kornievskaia Signed-off-by: Chuck Lever --- fs/nfs/nfs42proc.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c index 531c9c20ef1d..9d716907cf30 100644 --- a/fs/nfs/nfs42proc.c +++ b/fs/nfs/nfs42proc.c @@ -498,15 +498,15 @@ ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src, return err; } -struct nfs42_offloadcancel_data { +struct nfs42_offload_data { struct nfs_server *seq_server; struct nfs42_offload_status_args args; struct nfs42_offload_status_res res; }; -static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata) +static void nfs42_offload_prepare(struct rpc_task *task, void *calldata) { - struct nfs42_offloadcancel_data *data = calldata; + struct nfs42_offload_data *data = calldata; nfs4_setup_sequence(data->seq_server->nfs_client, &data->args.osa_seq_args, @@ -515,7 +515,7 @@ static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata) static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata) { - struct nfs42_offloadcancel_data *data = calldata; + struct nfs42_offload_data *data = calldata; trace_nfs4_offload_cancel(&data->args, task->tk_status); nfs41_sequence_done(task, &data->res.osr_seq_res); @@ -525,22 +525,22 @@ static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata) rpc_restart_call_prepare(task); } -static void nfs42_free_offloadcancel_data(void *data) +static void nfs42_offload_release(void *data) { kfree(data); } static const struct rpc_call_ops nfs42_offload_cancel_ops = { - .rpc_call_prepare = nfs42_offload_cancel_prepare, + .rpc_call_prepare = nfs42_offload_prepare, .rpc_call_done = nfs42_offload_cancel_done, - .rpc_release = nfs42_free_offloadcancel_data, + .rpc_release = nfs42_offload_release, }; static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *stateid) { struct nfs_server *dst_server = NFS_SERVER(file_inode(dst)); - struct nfs42_offloadcancel_data *data = NULL; + struct nfs42_offload_data *data = NULL; struct nfs_open_context *ctx = nfs_file_open_context(dst); struct rpc_task *task; struct rpc_message msg = { @@ -559,7 +559,7 @@ static int nfs42_do_offload_cancel_async(struct file *dst, if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL)) return -EOPNOTSUPP; - data = kzalloc(sizeof(struct nfs42_offloadcancel_data), GFP_KERNEL); + data = kzalloc(sizeof(struct nfs42_offload_data), GFP_KERNEL); if (data == NULL) return -ENOMEM; From patchwork Sat Feb 1 00:34:44 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13955978 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3B8CA2557A for ; Sat, 1 Feb 2025 00:34:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370094; cv=none; b=MqhO2x14E1pH+ovMzTwYVL5gkbU21Mjhs1lCnQBzv93EbURA0iX76vx8BDouJeBxJwTChCBoOCtzv0zdTFBBwxniR9yne3ioW6X5HXRx4bBF8DDal7V2W0bHOZg204V3eWAtvXluVBQxKUd8EJ8uC9W9xpUdgszKvYR3wUPeRbs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370094; c=relaxed/simple; bh=8eL1Tb2beTUUm3TNd3LRnT0hx/9PzGxwV9y3Lh0JmHs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=S2OjngB0HgalY5bYshfVSd198ImROZU8iKWsoxRt7iASpdurcvOjVg0seaHoi66cXF4XUjAtQzZ08k/rTMnmlmrbZipq+LOpe9AQkj6wRWDfgZOEF66ID16VlpaZu2VNbbCzYQ3hhieW163wQ4VJyZz+sm5FZZ1+JwI+udD23hc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Hn4MUKz2; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Hn4MUKz2" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6A489C4CEE5; Sat, 1 Feb 2025 00:34:53 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1738370094; bh=8eL1Tb2beTUUm3TNd3LRnT0hx/9PzGxwV9y3Lh0JmHs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Hn4MUKz2oDKHRHDvEsXR4W3XrpupskMGa1h94d6IaJuOKczvrbHQUhFH9eg+//Rm0 KqpQwZPWuy9d2ODiBQ0Us+UW5qhqAUJCbE+Q+vEfXTFOU61UUsbY5HeM3lbN8H6acG FVthIk+b6IOsALw7f6GlZJsYhXZf3eG81hu+h4AOogvjR+Pss1ncxB0GzBXyJEDBKV mJPGybLMOvT0YS49Qe8jZ+gYUywX+cVzdT5sEXrq0Q90Ryx+2DFzp3eQA5FBy/7OhY FfncesNzXenrfR91t1YBzWbv+ImFpZZ5hZ+HD0vA7EoDCDlkVdlZ5NKIiaRJvB9Ubc lKoTPhRJduIcg== From: cel@kernel.org To: Trond Myklebust , Anna Schumaker Cc: , Chuck Lever , Jeff Layton , Benjamin Coddington , Olga Kornievskaia Subject: [PATCH v4 4/7] NFS: Implement NFSv4.2's OFFLOAD_STATUS XDR Date: Fri, 31 Jan 2025 19:34:44 -0500 Message-ID: <20250201003447.54614-5-cel@kernel.org> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20250201003447.54614-1-cel@kernel.org> References: <20250201003447.54614-1-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Chuck Lever Add XDR encoding and decoding functions for the NFSv4.2 OFFLOAD_STATUS operation. Reviewed-by: Jeff Layton Reviewed-by: Benjamin Coddington Reviewed-by: Olga Kornievskaia Tested-by: Olga Kornievskaia Signed-off-by: Chuck Lever --- fs/nfs/nfs42xdr.c | 86 +++++++++++++++++++++++++++++++++++++++++ fs/nfs/nfs4xdr.c | 1 + include/linux/nfs4.h | 1 + include/linux/nfs_xdr.h | 5 ++- 4 files changed, 91 insertions(+), 2 deletions(-) diff --git a/fs/nfs/nfs42xdr.c b/fs/nfs/nfs42xdr.c index ef5730c5e704..a928b7f90e59 100644 --- a/fs/nfs/nfs42xdr.c +++ b/fs/nfs/nfs42xdr.c @@ -35,6 +35,11 @@ #define encode_offload_cancel_maxsz (op_encode_hdr_maxsz + \ XDR_QUADLEN(NFS4_STATEID_SIZE)) #define decode_offload_cancel_maxsz (op_decode_hdr_maxsz) +#define encode_offload_status_maxsz (op_encode_hdr_maxsz + \ + XDR_QUADLEN(NFS4_STATEID_SIZE)) +#define decode_offload_status_maxsz (op_decode_hdr_maxsz + \ + 2 /* osr_count */ + \ + 2 /* osr_complete */) #define encode_copy_notify_maxsz (op_encode_hdr_maxsz + \ XDR_QUADLEN(NFS4_STATEID_SIZE) + \ 1 + /* nl4_type */ \ @@ -143,6 +148,14 @@ decode_sequence_maxsz + \ decode_putfh_maxsz + \ decode_offload_cancel_maxsz) +#define NFS4_enc_offload_status_sz (compound_encode_hdr_maxsz + \ + encode_sequence_maxsz + \ + encode_putfh_maxsz + \ + encode_offload_status_maxsz) +#define NFS4_dec_offload_status_sz (compound_decode_hdr_maxsz + \ + decode_sequence_maxsz + \ + decode_putfh_maxsz + \ + decode_offload_status_maxsz) #define NFS4_enc_copy_notify_sz (compound_encode_hdr_maxsz + \ encode_putfh_maxsz + \ encode_copy_notify_maxsz) @@ -343,6 +356,14 @@ static void encode_offload_cancel(struct xdr_stream *xdr, encode_nfs4_stateid(xdr, &args->osa_stateid); } +static void encode_offload_status(struct xdr_stream *xdr, + const struct nfs42_offload_status_args *args, + struct compound_hdr *hdr) +{ + encode_op_hdr(xdr, OP_OFFLOAD_STATUS, decode_offload_status_maxsz, hdr); + encode_nfs4_stateid(xdr, &args->osa_stateid); +} + static void encode_copy_notify(struct xdr_stream *xdr, const struct nfs42_copy_notify_args *args, struct compound_hdr *hdr) @@ -567,6 +588,25 @@ static void nfs4_xdr_enc_offload_cancel(struct rpc_rqst *req, encode_nops(&hdr); } +/* + * Encode OFFLOAD_STATUS request + */ +static void nfs4_xdr_enc_offload_status(struct rpc_rqst *req, + struct xdr_stream *xdr, + const void *data) +{ + const struct nfs42_offload_status_args *args = data; + struct compound_hdr hdr = { + .minorversion = nfs4_xdr_minorversion(&args->osa_seq_args), + }; + + encode_compound_hdr(xdr, req, &hdr); + encode_sequence(xdr, &args->osa_seq_args, &hdr); + encode_putfh(xdr, args->osa_src_fh, &hdr); + encode_offload_status(xdr, args, &hdr); + encode_nops(&hdr); +} + /* * Encode COPY_NOTIFY request */ @@ -919,6 +959,26 @@ static int decode_offload_cancel(struct xdr_stream *xdr, return decode_op_hdr(xdr, OP_OFFLOAD_CANCEL); } +static int decode_offload_status(struct xdr_stream *xdr, + struct nfs42_offload_status_res *res) +{ + ssize_t result; + int status; + + status = decode_op_hdr(xdr, OP_OFFLOAD_STATUS); + if (status) + return status; + /* osr_count */ + if (xdr_stream_decode_u64(xdr, &res->osr_count) < 0) + return -EIO; + /* osr_complete<1> */ + result = xdr_stream_decode_uint32_array(xdr, &res->osr_complete, 1); + if (result < 0) + return -EIO; + res->complete_count = result; + return 0; +} + static int decode_copy_notify(struct xdr_stream *xdr, struct nfs42_copy_notify_res *res) { @@ -1368,6 +1428,32 @@ static int nfs4_xdr_dec_offload_cancel(struct rpc_rqst *rqstp, return status; } +/* + * Decode OFFLOAD_STATUS response + */ +static int nfs4_xdr_dec_offload_status(struct rpc_rqst *rqstp, + struct xdr_stream *xdr, + void *data) +{ + struct nfs42_offload_status_res *res = data; + struct compound_hdr hdr; + int status; + + status = decode_compound_hdr(xdr, &hdr); + if (status) + goto out; + status = decode_sequence(xdr, &res->osr_seq_res, rqstp); + if (status) + goto out; + status = decode_putfh(xdr); + if (status) + goto out; + status = decode_offload_status(xdr, res); + +out: + return status; +} + /* * Decode COPY_NOTIFY response */ diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c index e8ac3f615f93..08be0a0cce24 100644 --- a/fs/nfs/nfs4xdr.c +++ b/fs/nfs/nfs4xdr.c @@ -7702,6 +7702,7 @@ const struct rpc_procinfo nfs4_procedures[] = { PROC42(CLONE, enc_clone, dec_clone), PROC42(COPY, enc_copy, dec_copy), PROC42(OFFLOAD_CANCEL, enc_offload_cancel, dec_offload_cancel), + PROC42(OFFLOAD_STATUS, enc_offload_status, dec_offload_status), PROC42(COPY_NOTIFY, enc_copy_notify, dec_copy_notify), PROC(LOOKUPP, enc_lookupp, dec_lookupp), PROC42(LAYOUTERROR, enc_layouterror, dec_layouterror), diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h index 8d7430d9f218..5de96243a252 100644 --- a/include/linux/nfs4.h +++ b/include/linux/nfs4.h @@ -695,6 +695,7 @@ enum { NFSPROC4_CLNT_LISTXATTRS, NFSPROC4_CLNT_REMOVEXATTR, NFSPROC4_CLNT_READ_PLUS, + NFSPROC4_CLNT_OFFLOAD_STATUS, }; /* nfs41 types */ diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h index 559273a0f16d..9ac6c7a26b44 100644 --- a/include/linux/nfs_xdr.h +++ b/include/linux/nfs_xdr.h @@ -1520,8 +1520,9 @@ struct nfs42_offload_status_args { struct nfs42_offload_status_res { struct nfs4_sequence_res osr_seq_res; - uint64_t osr_count; - int osr_status; + u64 osr_count; + int complete_count; + u32 osr_complete; }; struct nfs42_copy_notify_args { From patchwork Sat Feb 1 00:34:45 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13955979 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 89FCE35953 for ; Sat, 1 Feb 2025 00:34:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370095; cv=none; b=Q+iNfsGBKSSt4spOAMM16ysmNBU5TlIA3VK7biJBXJwISqZOACdO7O+mn17hRg5/a06FxsOio8BwopHU6g6PORZ+BjMskUspfTIW9KWAU8zEDYmVzeDgxSO+V8l+kARgMaDXI6Jz8uXs80WG6Krht7GUSHZ5r8KYNKvlLR53WxQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370095; c=relaxed/simple; bh=MHGuVLz9VxHkBAxBM7GbE5N2RvoQrav56x72QdK5EbU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=JYu62F0k7WDrFIshhwPVSBteEaNxQog5YcrqYYum3Tb63sjrZAWhSN8XLKEO5/fBodOZR5yk9Yo1XaFK158/6dmbcgOofHqVJaeKWfWvSDbMrDzpQliKX1M/5IJD8mhkn+Inwi6Oer3yUEPZ7mJeAUEY7EIOhleV0pIzp4987LY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=eKQCmomx; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="eKQCmomx" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 53EFFC4CED1; Sat, 1 Feb 2025 00:34:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1738370095; bh=MHGuVLz9VxHkBAxBM7GbE5N2RvoQrav56x72QdK5EbU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=eKQCmomxmv/Ht+s01CtlaHTgfTIyAzNvIzgzyflHY16F06ASWjk3frVW2PzkFCz// 29bpCWQQCniMbfII5HRnQvT4jAmIA614+7JzoSRC35Z395+HFxCMkj/I5736Tl26nx tCaI1L5tDTCL0tQxZK0Y26GwFuXagkVCD9cSnc5EB6jnXg/gGqUlcY1hVFni+x6rZk aPqzupUEc5qaTllNYYQqoII5MxfFDvk8et94lVw2OQbuk2UmfY5PXLvClWIOO0N/+X LEwqWKac8EEd9rjMbGOfmgsrASyAiEV99seQ8EssA40WkHYmLAOaUQRXzfYPuyP/5i zGKnnsQJ0K96A== From: cel@kernel.org To: Trond Myklebust , Anna Schumaker Cc: , Chuck Lever , Jeff Layton , Benjamin Coddington , Olga Kornievskaia Subject: [PATCH v4 5/7] NFS: Implement NFSv4.2's OFFLOAD_STATUS operation Date: Fri, 31 Jan 2025 19:34:45 -0500 Message-ID: <20250201003447.54614-6-cel@kernel.org> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20250201003447.54614-1-cel@kernel.org> References: <20250201003447.54614-1-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Chuck Lever Enable the Linux NFS client to observe the progress of an offloaded asynchronous COPY operation. This new operation will be put to use in a subsequent patch. Reviewed-by: Jeff Layton Reviewed-by: Benjamin Coddington Reviewed-by: Olga Kornievskaia Tested-by: Olga Kornievskaia Signed-off-by: Chuck Lever --- fs/nfs/nfs42proc.c | 105 ++++++++++++++++++++++++++++++++++++++ fs/nfs/nfs4proc.c | 3 +- include/linux/nfs_fs_sb.h | 1 + 3 files changed, 108 insertions(+), 1 deletion(-) diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c index 9d716907cf30..c560801aae96 100644 --- a/fs/nfs/nfs42proc.c +++ b/fs/nfs/nfs42proc.c @@ -21,6 +21,8 @@ #define NFSDBG_FACILITY NFSDBG_PROC static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std); +static int nfs42_proc_offload_status(struct file *file, nfs4_stateid *stateid, + u64 *copied); static void nfs42_set_netaddr(struct file *filep, struct nfs42_netaddr *naddr) { @@ -582,6 +584,109 @@ static int nfs42_do_offload_cancel_async(struct file *dst, return status; } +static int +_nfs42_proc_offload_status(struct nfs_server *server, struct file *file, + struct nfs42_offload_data *data) +{ + struct nfs_open_context *ctx = nfs_file_open_context(file); + struct rpc_message msg = { + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_STATUS], + .rpc_argp = &data->args, + .rpc_resp = &data->res, + .rpc_cred = ctx->cred, + }; + int status; + + status = nfs4_call_sync(server->client, server, &msg, + &data->args.osa_seq_args, + &data->res.osr_seq_res, 1); + switch (status) { + case 0: + break; + + case -NFS4ERR_ADMIN_REVOKED: + case -NFS4ERR_BAD_STATEID: + case -NFS4ERR_OLD_STATEID: + /* + * Server does not recognize the COPY stateid. CB_OFFLOAD + * could have purged it, or server might have rebooted. + * Since COPY stateids don't have an associated inode, + * avoid triggering state recovery. + */ + status = -EBADF; + break; + case -NFS4ERR_NOTSUPP: + case -ENOTSUPP: + case -EOPNOTSUPP: + server->caps &= ~NFS_CAP_OFFLOAD_STATUS; + status = -EOPNOTSUPP; + break; + } + + return status; +} + +/** + * nfs42_proc_offload_status - Poll completion status of an async copy operation + * @dst: handle of file being copied into + * @stateid: copy stateid (from async COPY result) + * @copied: OUT: number of bytes copied so far + * + * Return values: + * %0: Server returned an NFS4_OK completion status + * %-EINPROGRESS: Server returned no completion status + * %-EREMOTEIO: Server returned an error completion status + * %-EBADF: Server did not recognize the copy stateid + * %-EOPNOTSUPP: Server does not support OFFLOAD_STATUS + * %-ERESTARTSYS: Wait interrupted by signal + * + * Other negative errnos indicate the client could not complete the + * request. + */ +static int __maybe_unused +nfs42_proc_offload_status(struct file *dst, nfs4_stateid *stateid, u64 *copied) +{ + struct inode *inode = file_inode(dst); + struct nfs_server *server = NFS_SERVER(inode); + struct nfs4_exception exception = { + .inode = inode, + }; + struct nfs42_offload_data *data; + int status; + + *copied = 0; + + if (!(server->caps & NFS_CAP_OFFLOAD_STATUS)) + return -EOPNOTSUPP; + + data = kzalloc(sizeof(*data), GFP_KERNEL); + if (!data) + return -ENOMEM; + data->seq_server = server; + data->args.osa_src_fh = NFS_FH(inode); + memcpy(&data->args.osa_stateid, stateid, + sizeof(data->args.osa_stateid)); + exception.stateid = &data->args.osa_stateid; + do { + status = _nfs42_proc_offload_status(server, dst, data); + if (status == -EOPNOTSUPP) + goto out; + status = nfs4_handle_exception(server, status, &exception); + } while (exception.retry); + if (status) + goto out; + + *copied = data->res.osr_count; + if (!data->res.complete_count) + status = -EINPROGRESS; + else if (data->res.osr_complete != NFS_OK) + status = -EREMOTEIO; + +out: + kfree(data); + return status; +} + static int _nfs42_proc_copy_notify(struct file *src, struct file *dst, struct nfs42_copy_notify_args *args, struct nfs42_copy_notify_res *res) diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c index 405f17e6e0b4..973b8d8fa98b 100644 --- a/fs/nfs/nfs4proc.c +++ b/fs/nfs/nfs4proc.c @@ -10769,7 +10769,8 @@ static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = { | NFS_CAP_CLONE | NFS_CAP_LAYOUTERROR | NFS_CAP_READ_PLUS - | NFS_CAP_MOVEABLE, + | NFS_CAP_MOVEABLE + | NFS_CAP_OFFLOAD_STATUS, .init_client = nfs41_init_client, .shutdown_client = nfs41_shutdown_client, .match_stateid = nfs41_match_stateid, diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h index b804346a9741..946ca1c28773 100644 --- a/include/linux/nfs_fs_sb.h +++ b/include/linux/nfs_fs_sb.h @@ -290,6 +290,7 @@ struct nfs_server { #define NFS_CAP_CASE_INSENSITIVE (1U << 6) #define NFS_CAP_CASE_PRESERVING (1U << 7) #define NFS_CAP_REBOOT_LAYOUTRETURN (1U << 8) +#define NFS_CAP_OFFLOAD_STATUS (1U << 9) #define NFS_CAP_OPEN_XOR (1U << 12) #define NFS_CAP_DELEGTIME (1U << 13) #define NFS_CAP_POSIX_LOCK (1U << 14) From patchwork Sat Feb 1 00:34:46 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13955980 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1889335964 for ; Sat, 1 Feb 2025 00:34:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370096; cv=none; b=L+xZyK1CwsQ+ifCazGkzJGwRSBvtZUWCLj76EgsToMO0H+OLr4SfUmjXKWrRiPTKRQXJCkfglFYLqVaSLXsqUvTAQ4qa3mQNurF0YEMmL74PmXS3Gvvvalbp3zA8IE1XjxS4+ndXKi4V7nbfmUyvHEw+z5Y86uvwcHO8tCw0xQY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370096; c=relaxed/simple; bh=t5NWF/sD9H5YoFVzqWylKFiG+MF1UKbZq35GsDK/08w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=E1eeBLbrwLZ3JPIk7P4nez7qMQRZ7WuoWTcQmk+MJwR1yqBG8WGyN0gF2qQp4TUZDWKq1iS/obsqjxruLrFg124jTmyEx1HYqMEiXxa2GWuccu978ouSUgIUEnD/odovpxV97f+UxjxUYktfFLl+RKNUAq2DlOW4d/uaRLVEj6I= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Xlgqbn2L; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Xlgqbn2L" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 491E2C4CEE1; Sat, 1 Feb 2025 00:34:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1738370096; bh=t5NWF/sD9H5YoFVzqWylKFiG+MF1UKbZq35GsDK/08w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Xlgqbn2L/8CA922DP0MWF/Xzn/cbwRl3njxOCUo6LLTDl5ouxpl1DXl/iHL4azjID 6eRqXa9+xRCuGZlSbx4iNHF1D4+H3TRbFWeCsxyODEmC3+ClEmKgT6G1przFhrGkic /YkAD9ls1U8ZIY8eWgRW2Vtb5A4h+5f6MRj3dmrUBrjfitf1z1/zBrInM9GSWTKZZZ laCiVmy0xS9KuGRnf2q54F3wUTubgSsWrpPMWMFqLeKZ3VhvErJuPGBG1Gkbk49p5p XYSWGWKWB2lIAdHKKCUqCsG1yEJcHcCr58rRhQnM/FiNv/Uc7FpnDDnkj1zQMYPMlf yT37R7hsH3nIw== From: cel@kernel.org To: Trond Myklebust , Anna Schumaker Cc: , Chuck Lever , Olga Kornievskaia , Jeff Layton , Benjamin Coddington Subject: [PATCH v4 6/7] NFS: Use NFSv4.2's OFFLOAD_STATUS operation Date: Fri, 31 Jan 2025 19:34:46 -0500 Message-ID: <20250201003447.54614-7-cel@kernel.org> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20250201003447.54614-1-cel@kernel.org> References: <20250201003447.54614-1-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Chuck Lever We've found that there are cases where a transport disconnection results in the loss of callback RPCs. NFS servers typically do not retransmit callback operations after a disconnect. This can be a problem for the Linux NFS client's current implementation of asynchronous COPY, which waits indefinitely for a CB_OFFLOAD callback. If a transport disconnect occurs while an async COPY is running, there's a good chance the client will never get the completing CB_OFFLOAD. Fix this by implementing the OFFLOAD_STATUS operation so that the Linux NFS client can probe the NFS server if it doesn't see a CB_OFFLOAD in a reasonable amount of time. This patch implements a simplistic check. As future work, the client might also be able to detect whether there is no forward progress on the request asynchronous COPY operation, and CANCEL it. Suggested-by: Olga Kornievskaia Link: https://bugzilla.kernel.org/show_bug.cgi?id=218735 Reviewed-by: Jeff Layton Reviewed-by: Benjamin Coddington Reviewed-by: Olga Kornievskaia Tested-by: Olga Kornievskaia Signed-off-by: Chuck Lever --- fs/nfs/nfs42proc.c | 73 +++++++++++++++++++++++++++++++++++++++------- 1 file changed, 62 insertions(+), 11 deletions(-) diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c index c560801aae96..f56558c58fe9 100644 --- a/fs/nfs/nfs42proc.c +++ b/fs/nfs/nfs42proc.c @@ -175,6 +175,20 @@ int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len) return err; } +static void nfs4_copy_dequeue_callback(struct nfs_server *dst_server, + struct nfs_server *src_server, + struct nfs4_copy_state *copy) +{ + spin_lock(&dst_server->nfs_client->cl_lock); + list_del_init(©->copies); + spin_unlock(&dst_server->nfs_client->cl_lock); + if (dst_server != src_server) { + spin_lock(&src_server->nfs_client->cl_lock); + list_del_init(©->src_copies); + spin_unlock(&src_server->nfs_client->cl_lock); + } +} + static int handle_async_copy(struct nfs42_copy_res *res, struct nfs_server *dst_server, struct nfs_server *src_server, @@ -184,9 +198,13 @@ static int handle_async_copy(struct nfs42_copy_res *res, bool *restart) { struct nfs4_copy_state *copy, *tmp_copy = NULL, *iter; - int status = NFS4_OK; struct nfs_open_context *dst_ctx = nfs_file_open_context(dst); struct nfs_open_context *src_ctx = nfs_file_open_context(src); + struct nfs_client *clp = dst_server->nfs_client; + unsigned long timeout = clp->cl_lease_time >> 1; + int status = NFS4_OK; + bool retry = false; + u64 copied; copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_KERNEL); if (!copy) @@ -224,15 +242,12 @@ static int handle_async_copy(struct nfs42_copy_res *res, spin_unlock(&src_server->nfs_client->cl_lock); } - status = wait_for_completion_interruptible(©->completion); - spin_lock(&dst_server->nfs_client->cl_lock); - list_del_init(©->copies); - spin_unlock(&dst_server->nfs_client->cl_lock); - if (dst_server != src_server) { - spin_lock(&src_server->nfs_client->cl_lock); - list_del_init(©->src_copies); - spin_unlock(&src_server->nfs_client->cl_lock); - } +wait: + status = wait_for_completion_interruptible_timeout(©->completion, + timeout); + if (!status) + goto timeout; + nfs4_copy_dequeue_callback(dst_server, src_server, copy); if (status == -ERESTARTSYS) { goto out_cancel; } else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) { @@ -242,6 +257,7 @@ static int handle_async_copy(struct nfs42_copy_res *res, } out: res->write_res.count = copy->count; + /* Copy out the updated write verifier provided by CB_OFFLOAD. */ memcpy(&res->write_res.verifier, ©->verf, sizeof(copy->verf)); status = -copy->error; @@ -253,6 +269,41 @@ static int handle_async_copy(struct nfs42_copy_res *res, if (!nfs42_files_from_same_server(src, dst)) nfs42_do_offload_cancel_async(src, src_stateid); goto out_free; +timeout: + if (retry) { + res->write_res.count = 0; + status = -EOPNOTSUPP; /* Fall back to READ/WRITE copy. */ + goto out_free; + } + status = nfs42_proc_offload_status(dst, ©->stateid, &copied); + if (status == -EINPROGRESS) + goto wait; + nfs4_copy_dequeue_callback(dst_server, src_server, copy); + switch (status) { + case 0: + /* The server recognized the copy stateid. Don't overwrite + * the verifier returned in the COPY result. */ + res->write_res.count = copied; + break; + case -EREMOTEIO: + /* COPY operation failed on the server, though it could + * have made some progress. */ + res->write_res.count = copied; + status = -EOPNOTSUPP; /* Fall back to READ/WRITE copy. */ + break; + case -EBADF: + /* Server did not recognize the copy stateid, but the + * CB_OFFLOAD request could have been received while the + * client waited for OFFLOAD_STATUS reply. */ + retry = true; + goto wait; + case -EOPNOTSUPP: + /* RFC 7862 REQUIREs server to support OFFLOAD_STATUS when + * it has signed up for an async COPY, so server is not + * spec-compliant. Fall back to READ/WRITE copy. */ + res->write_res.count = 0; + } + goto out_free; } static int process_copy_commit(struct file *dst, loff_t pos_dst, @@ -643,7 +694,7 @@ _nfs42_proc_offload_status(struct nfs_server *server, struct file *file, * Other negative errnos indicate the client could not complete the * request. */ -static int __maybe_unused +static int nfs42_proc_offload_status(struct file *dst, nfs4_stateid *stateid, u64 *copied) { struct inode *inode = file_inode(dst); From patchwork Sat Feb 1 00:34:47 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13955981 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0EBC535964 for ; Sat, 1 Feb 2025 00:34:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370097; cv=none; b=n2BhW+AGAENzDAYGvXEBftr6N0RljE1bBh/gy6e672p0CmhGwMzcnjbvXiwQDU2DRIDwfvNoCrNkgxoVivVnASNh3JdwahDxUCy4jvnehC12xQ70DB3YVTo5wuk5S79ukFjjXauZC+br7xCr1hQT3jcYht6iOsihEr8MjmJjHdg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738370097; c=relaxed/simple; bh=zi3n9IrtQ0jF2YL/XzOjVVOehRfF8DoajD1KCU6lpLU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=naa9zdYCaE/VK09yYNjKkAYv9m46eJNgoaVUI2lGO4d79r83/yutlD5+qxzk6uzxvQ9iUchnkayMAXwhI+BtbB5g5A80Kq6t/cmB4Aa5F3gu1LlW/fzHd422UxM75P6lSfYICoumr5ZCVDP332DMJ5rfXODmb6jxku+7hQHTmaQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=RkN6vi/2; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="RkN6vi/2" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 347AEC4CED1; Sat, 1 Feb 2025 00:34:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1738370096; bh=zi3n9IrtQ0jF2YL/XzOjVVOehRfF8DoajD1KCU6lpLU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=RkN6vi/2cwiApemItbeaKY7A4VI3r7RGYX/HQwGZ7wGHeA0i87dhEtZLEiyOGUEuZ AlrZtS5iurJFx/thVtS8hk6huMCIXJXPaoNPzK1wbqySZTXecp4NFZ46OGyddSU+/l r0zi/bgUS37Mv97nmPoUA967kwj9xjqb0SNtcpGHg11qwkkbgY1XvidAvRWUcBg8ZW QcCSE1qltXPvhmR0ehGpJpS64ioUEH8TTtZcvzolD9CGb8uifMopi4Qowco1Ptdu6x 5TJRViuq1UhSOr6gSlNGeQy16gjE0wfcAplKKySMA8Wy1YXwmtNCX4SJEMZ9oslS3O 3kzAbNnGe//rQ== From: cel@kernel.org To: Trond Myklebust , Anna Schumaker Cc: , Chuck Lever , Jeff Layton , Benjamin Coddington , Olga Kornievskaia Subject: [PATCH v4 7/7] NFS: Refactor trace_nfs4_offload_cancel Date: Fri, 31 Jan 2025 19:34:47 -0500 Message-ID: <20250201003447.54614-8-cel@kernel.org> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20250201003447.54614-1-cel@kernel.org> References: <20250201003447.54614-1-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 From: Chuck Lever Add a trace_nfs4_offload_status trace point that looks just like trace_nfs4_offload_cancel. Promote that event to an event class to avoid duplicating code. An alternative approach would be to expand trace_nfs4_offload_status to report more of the actual OFFLOAD_STATUS result. Reviewed-by: Jeff Layton Reviewed-by: Benjamin Coddington Reviewed-by: Olga Kornievskaia Tested-by: Olga Kornievskaia Signed-off-by: Chuck Lever --- fs/nfs/nfs42proc.c | 1 + fs/nfs/nfs4trace.h | 11 ++++++++++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c index f56558c58fe9..2c7f5cf6a46f 100644 --- a/fs/nfs/nfs42proc.c +++ b/fs/nfs/nfs42proc.c @@ -651,6 +651,7 @@ _nfs42_proc_offload_status(struct nfs_server *server, struct file *file, status = nfs4_call_sync(server->client, server, &msg, &data->args.osa_seq_args, &data->res.osr_seq_res, 1); + trace_nfs4_offload_status(&data->args, status); switch (status) { case 0: break; diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h index 22c973316f0b..bc67fe6801b1 100644 --- a/fs/nfs/nfs4trace.h +++ b/fs/nfs/nfs4trace.h @@ -2608,7 +2608,7 @@ TRACE_EVENT(nfs4_copy_notify, ) ); -TRACE_EVENT(nfs4_offload_cancel, +DECLARE_EVENT_CLASS(nfs4_offload_class, TP_PROTO( const struct nfs42_offload_status_args *args, int error @@ -2640,6 +2640,15 @@ TRACE_EVENT(nfs4_offload_cancel, __entry->stateid_seq, __entry->stateid_hash ) ); +#define DEFINE_NFS4_OFFLOAD_EVENT(name) \ + DEFINE_EVENT(nfs4_offload_class, name, \ + TP_PROTO( \ + const struct nfs42_offload_status_args *args, \ + int error \ + ), \ + TP_ARGS(args, error)) +DEFINE_NFS4_OFFLOAD_EVENT(nfs4_offload_cancel); +DEFINE_NFS4_OFFLOAD_EVENT(nfs4_offload_status); DECLARE_EVENT_CLASS(nfs4_xattr_event, TP_PROTO(