From patchwork Tue Jul 2 15:19:49 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13719917 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 6EB911BB6A9 for ; Tue, 2 Jul 2024 15:20:18 +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=1719933618; cv=none; b=q913xRpfxeB4LfHN9SluCh9z1bofuLhMcYN/nQ40uBDp/F6Qu/culIljySQAPd3REkJiythkmj8IJDhSwYgXbc+VKhvu9z3tegNl5tyD9BGF65uU2+/bZh3fFPJ9qtB/+AM50Xvr4jPDXpF0569vvPsoEbd+EiPXVuhhEgACpvM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1719933618; c=relaxed/simple; bh=zVSe19MLa1slkzxgl7ntV/Oi30w0dqs2gNOynpYLGnM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=RfhE9CyAS6DkJcsEkH0y/LJcIHKi6/bd/u/DzlZHRqh/+QHsoIBRKX84MkWLWuVQby2v5xoq41jL4Ogbu8CNZT3+kfcUbeoXX6PRCn5mYwRfwbHZz32/v6zeEAH77rFmmSNrju5wIY3oq6rAn4mGbuS4smQbdgVfEnkCwtbzSuU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ZbwrpHKL; 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="ZbwrpHKL" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9B48EC116B1; Tue, 2 Jul 2024 15:20:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1719933618; bh=zVSe19MLa1slkzxgl7ntV/Oi30w0dqs2gNOynpYLGnM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ZbwrpHKLKfGRaigXQxURHa/Ivacdnu2xuU/ix7KW5O7CE4PgHMPFN1AGna79jbWVU xLlDTNSMeovVhRW3tLrwdrtvWliRMPS94USIXF3t9QVDDhMnQf781i4OdJvJ5k2p5c d9N0glFv/6+ZnelC2pINHLCW5pLHdcoo+QZluzCcxTN5PueTRDddWvOEGIVK4+Yk2e 88iaiyWIx/gsGTFuYqeLVAMTp1wtBlUDkjwuoQvWhzqG4Dwum1MI5hRlHf1HN9GWXP y/UIYgSGTwyL5aTGIhBdEDec/vA9Hdi2mtlJkTXr669KCdqQYqKbA3SOmx5JVXD4tn Hrj0wjTXRd4Nw== From: cel@kernel.org To: Cc: Olga Kornievskaia , Dai Ngo , Chuck Lever Subject: [RFC PATCH 1/6] NFS: Fix typo in OFFLOAD_CANCEL comment Date: Tue, 2 Jul 2024 11:19:49 -0400 Message-ID: <20240702151947.549814-9-cel@kernel.org> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240702151947.549814-8-cel@kernel.org> References: <20240702151947.549814-8-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=546; i=chuck.lever@oracle.com; h=from:subject; bh=FouNxurNnc7KaV/m3hYXhCzOdaMvMV0gIbtNAiH2Mpg=; b=owEBbQKS/ZANAwAIATNqszNvZn+XAcsmYgBmhBqZr+dDyB/Pw/NdXpxgPhGvDjUZ3WU8CksI2 Vx/DVdRfKqJAjMEAAEIAB0WIQQosuWwEobfJDzyPv4zarMzb2Z/lwUCZoQamQAKCRAzarMzb2Z/ lx14D/0Yj8VlofOZmxh/FnomCnfHZvosNarfUn5K6riPiPvAY+Kb4um594Chv65G0LmNYxh0POJ v+uvG7veoR5UCaMoenmS+dbM+SQsOrxTMpmo4Qge8Ze3DrUo9HETGzPPBPNpFOIy2wqzGlhzFqj OBue9zTARnwcAf7NyoJZQcDMziUV9uRCYg0l34JilQg13m3DPWkzf70/V3cbi+iGmWTtEppCSjD UI3kU76Ravnoannw7sXAFo0vE//siHKqoc90Xra1qulBapsEeTtaNh4Q9oOOkO2MS+TAJxXim/k oaiHDuZgUw56yJdR/Ydgz5Kz2bDQ/jX9Jnmtd2+y3mmj1vxiS9wgmUjHIVVmo4II8yl9GEl/rYQ zRPXIWSAhQLL2pE9W7udvJ8l7L5yasxK65MBZumF30z56fU1y+8FSMooecqKCxBnwXo3JlQPwrR AxUEcuQINR8AFoaTi4xJyDM+Zv4AUBMS6wf1EM6J6f9AoHKU53ReWXbcsgMifpCF5MZBKwbWV5h 6sbJrRIu6or+LQtmZs9NYpK7qUiJ5eYXYAegp8sYvpsufYNZ7N/VCgSDtZrmHs11/WFYKNGUlXL Tb3RbFzl9xlXlQabeAKGqHQFlp9pM2vZOYPUEofu/yvERAFSC/WJ7+eN35naS0TSBv0x/Kdlyr7 IEt7QT/BIIuU6ag== X-Developer-Key: i=chuck.lever@oracle.com; a=openpgp; fpr=28B2E5B01286DF243CF23EFE336AB3336F667F97 From: Chuck Lever 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 Tue Jul 2 15:19:50 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13719918 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 7183F1BA868 for ; Tue, 2 Jul 2024 15:20:31 +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=1719933631; cv=none; b=FclnpS/tYlp8H9I5pi0E+xDay30s2ZYUS1oaOw352EyIJZXPLE6nY7lcIOOnaL9oySLJFgk+eV5ATst1xc0FpdBtwF/2oSbPZvp3ncqIp0AdaJsc21mG5o9ePOxKZrCFe3TF1HLx3INLLMoIPiyrpzyPxchcawQ9eZQTDd4+mzw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1719933631; c=relaxed/simple; bh=nU8PzLnCGdJoBzEmXv7G4/knHrqrabOg//s0tnmPTAc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=gZ1U5eApHlc47VfN43GCImzHFe3EfQ437noknBoPl7voP9HzGFhCGCdrYDA2+JT9PHv2/5W0w1HwYhk0JnM6yQzsZ+w5KqFwUtRDe5ATy5GqCv2bex45ZSWiwxffNK0bPGuT/2gyhVNIvZeNwjvQaSiO2u3drMPJjz3cJQ0iK5s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=pi06NEP3; 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="pi06NEP3" Received: by smtp.kernel.org (Postfix) with ESMTPSA id DB92AC116B1; Tue, 2 Jul 2024 15:20:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1719933631; bh=nU8PzLnCGdJoBzEmXv7G4/knHrqrabOg//s0tnmPTAc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=pi06NEP3IFQj/9j+n8lRZBG0KQli66OqgmJhjFVcdGw1mUZbgzIe9KHb4xRiGhL4/ ZkA8paOERW7MWWjkdRI/G8p8ywiwLJsqUKYD/zGuJ5+Y86rEoYOUxdc6LixivK+2Nd FYvJowuJsZWSoMGOYIKakLJEgSLEivWw6SlKyQKhoev6wEqHWtdPACoSNil4MFINif SSxt6Ybu+iEQQVORHqil/KBb2sBVVRoCdrsYh8luUa7MHYG/hVOfaWtugCZnCvxl5D iS+5teIMqopjYdkXW21DVXEN1+V7UmQqi3qrLGHFZ6W7B4zQSwrGtwenXQaGHpwS35 bv91TMMIMVaog== From: cel@kernel.org To: Cc: Olga Kornievskaia , Dai Ngo , Chuck Lever Subject: [RFC PATCH 2/6] NFS: Implement NFSv4.2's OFFLOAD_STATUS XDR Date: Tue, 2 Jul 2024 11:19:50 -0400 Message-ID: <20240702151947.549814-10-cel@kernel.org> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240702151947.549814-8-cel@kernel.org> References: <20240702151947.549814-8-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=5794; i=chuck.lever@oracle.com; h=from:subject; bh=mZSVZGictBIHGhxqPex3Koaq7nik6NWOJ22ujwpodEM=; b=owEBbQKS/ZANAwAIATNqszNvZn+XAcsmYgBmhBqZPeLDvC6Fp1+UQWwC8U7sj6BGwZSZkn2a9 Ulc7+3jKN2JAjMEAAEIAB0WIQQosuWwEobfJDzyPv4zarMzb2Z/lwUCZoQamQAKCRAzarMzb2Z/ lxrSD/0e3DgYqDIBivF9O4dG0hgFw1b+ETJ1cGbIr0ZARS3lT3fDYpHzHWsmYtSORv6nS9qS55T e9nsh32Q7qSE4LoaWWFkMbJkJVcaZ2PgPX0pe0v5xSLXYcMz077QXYpBj0D9C0xAW/1p0OO88Ch ygbmCp8g1xER62IZTi82CjZ9a90TjkVU+5x95DJzXte2K3wJz7OC4PzdeJ0MWSshclq/mVpyNfj eEyVW5ZQ7jtTPCNy3IroYnwC80+0+P+/iTYxj+J0gDh8FDDDhiT1RH1Vnj0A7PVGB8eoM9HuOFw W4ssNokjX7UxEEM6lNNhi988uFl2tzsdQDFBcOKqCuOTIi/kKTCs69D8k5T8Cjq/I0yotohJbRC qIvXwtv8nS94kiXy8s1W9LHcta9xijyRb46kMqf8mp9EO/Jv/5EWYxewCmCUl9Pi8PXKbKN9uqh o/prXtkkXU2RGmas98FDyZMpd9SqHTp2jccJsy9QJTrLnbXiJkc4L0JWru8cFnNL4CftDW0q0Hk oXTZ3bP4Iaco55//5ST3t9YucugHC0UN753OQ9AiLzfjIejFiQNvA6r/574/LyGrNHK83ENLyeY 7mGb7TNMBqxOc4Pn/qIrLPtaFmyohuGkCCd0lcV3CyHVyBe4zukRoRgCEi3dA0KLU2x3XDUsi9o j+LpbpMINjmPszA== X-Developer-Key: i=chuck.lever@oracle.com; a=openpgp; fpr=28B2E5B01286DF243CF23EFE336AB3336F667F97 From: Chuck Lever Add XDR encoding and decoding functions for the NFSv4.2 OFFLOAD_STATUS operation. 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..ad3d1293f917 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 1416099dfcd1..bcb7de1c1b44 100644 --- a/fs/nfs/nfs4xdr.c +++ b/fs/nfs/nfs4xdr.c @@ -7711,6 +7711,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 0d896ce296ce..66e9f2f11fa1 100644 --- a/include/linux/nfs4.h +++ b/include/linux/nfs4.h @@ -681,6 +681,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 d09b9773b20c..3372971360d8 100644 --- a/include/linux/nfs_xdr.h +++ b/include/linux/nfs_xdr.h @@ -1488,8 +1488,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[1]; }; struct nfs42_copy_notify_args { From patchwork Tue Jul 2 15:19:51 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13719919 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 269CE1AD9E7 for ; Tue, 2 Jul 2024 15:20:44 +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=1719933645; cv=none; b=qjYAcezqWrtplpmE85RyYf3/xNVHTeP7b5JEpEPQ1WfheqsMLHUrslZ1F+4Gz4CS6tSxkm41NfhSd5e3OuVLxYWx5FqDb85NdZLBUtRAIvFuNkk1520Ajy3juIJNbCBZUzijvjyOHj9ODXhv6hrcoEN5WS8OvuhGl8cpcoI1pAE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1719933645; c=relaxed/simple; bh=dEbGFFraBMJ1Q1c1EO1/MEet2T2kWfBE53dhkFfQ6YA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=muf9X/T46ukESoKZ+H426H9eEslD3vVCXDlpOOt2r6AdZeFKFT/xYRDjdQzPlZZ7uf1eNj0IBZFnR4Ybxl+RK0evoluuXPsZsER1FECi9hHutjaggqkcMHrl4UXpqrwrvh1vleG52hHRc+cExda9mAtXY7Fe9MHWNyffDZpDUvQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=QJr4rXZK; 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="QJr4rXZK" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 500C1C116B1; Tue, 2 Jul 2024 15:20:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1719933644; bh=dEbGFFraBMJ1Q1c1EO1/MEet2T2kWfBE53dhkFfQ6YA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=QJr4rXZKbl/n2390XtXenjBK/3N03ct+AuVDZtBZvX8UqALwjx+DryO7dCOhxgMpk qhBmSaE9uS65b9zulS53Ks/fZg5II6uqixGcAfC1Ry6lLWPqw1v+4EIjUVhWo878/P kb7DFY7y4xMkQ6xjkbKQP6ywsqEKEjIwx4mxTXOm6vljT0NGZKslB/tQaoZAA16m+x qgm9z4GWZyooxpQO4JrsWKXHu87+EtX6rVS+3GbnN9nFWVzkqykAU88WGDTfCiOC+0 Jt377qJdjaCQMGJrLxyqUE+VuFMrNHFjsRI4cCaTFKWZNIlj+hhN6UkosVvjLRAoz0 1cjiyxhVxN0Gg== From: cel@kernel.org To: Cc: Olga Kornievskaia , Dai Ngo , Chuck Lever Subject: [RFC PATCH 3/6] NFS: Rename struct nfs4_offloadcancel_data Date: Tue, 2 Jul 2024 11:19:51 -0400 Message-ID: <20240702151947.549814-11-cel@kernel.org> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240702151947.549814-8-cel@kernel.org> References: <20240702151947.549814-8-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=2778; i=chuck.lever@oracle.com; h=from:subject; bh=Q9fd4qf8bUFBPJTIx+vVQjzBA3hK+6DW5giz192Ag58=; b=owEBbQKS/ZANAwAIATNqszNvZn+XAcsmYgBmhBqZeKYhl3gM4YUaWsH4hA+is/QXhnQAXVGH0 NhwiiccycOJAjMEAAEIAB0WIQQosuWwEobfJDzyPv4zarMzb2Z/lwUCZoQamQAKCRAzarMzb2Z/ l5mYD/93gAnRFnj4UPJm/4i5ny6ktrrozt98UC0kP9XtT3jCgZvfblgOxBgMhpbT6q1YSf53THa yosk2w3Kjz/ixkRGBidj1Ngxqlk3X7wmHkcSn09wTJuW3WBaW7zRtUcDo3Cdm4hSc4pL29ZNfPH IecJ6FQIHpmvczlbFK8ckGWMaYct/8gJRcWdxFsjplSI6K0Yeeb54CRqxY9IloGE7L9HZ4XZXIX edqXhGpgwpXtknwb5nMXOvgOUnNbZcKmC/uuNJrngiGkvtTvfUFX//wLJ//Bi+mMYZlRu+rZLjg HdTDsa+zaEQeol8xe3Olt8qK7PavhJUasf2ity3H7inV2ek3Z+egUWEa9PgqpuJWDd+WvDInTE+ nGMG+U4Yok8aN0K1VV1QQH2q19iagV/llBOzSXz/oU4h/StuQcdsRRWCyBZxUAUGCk98gVOOErW gTDMt+Afa79UY2GzJ29CaHHsrAK/5vCNk7o5pBgGQD9eDwbZ4Tzq1HL1EWB0p99yF0Mb2GLtVoX W9xDjWiuVf0LQIk3XCCCKuBlQjnQ+4mjVXfZcnujdsiCBeL4oDqOPQ2xQd6RPFZDYRTE9qDko7p vwjsOFuKH0L4VaZ76yLk+0FoYhd/G+Kmy4LMa8qmpuefT4f426nxjw2VfRH+xrhtlLAxU1C6Hm3 7e5HaP6i/aUnscg== X-Developer-Key: i=chuck.lever@oracle.com; a=openpgp; fpr=28B2E5B01286DF243CF23EFE336AB3336F667F97 From: Chuck Lever Refactor: This struct can be used unchanged for the new OFFLOAD_STATUS implementation, so give it a more generic name. 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 28704f924612..869605a0a9d5 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 Tue Jul 2 15:19:52 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13719920 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 5F0AE1AD9E7 for ; Tue, 2 Jul 2024 15:20:58 +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=1719933658; cv=none; b=TblQui/Owt/7ayb8cuzFaKW228qyXUAylshGX9S0YHSFsUc8XcMXxfkroVP/gOpSfbhYpkPb6KMSZBccdNT/QbYIVbvKBZpiwf13TB0RDCfGE+TSkkOWhQn82d1KsFlgJFID9RDwxZlNGQqxoYVZf8M9RyGxeFEULTYgQ7yR2P0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1719933658; c=relaxed/simple; bh=2QfSfREv7XsLiYzVIDPiC88C7bCowAudVtuQMvAvPic=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=fu+a8zmW/eSQ0TnUrZTlEsfbdD42PFPSGJdRrX5UVb7g7/ZAtfxi6TRE9x2OiWS5NniruWL4pYArDncc4K/Dpy1YD0pI/4LB9QpXzq59Ex8F+2dQFxexhBNVBumPxxYmKy3KkYaUX83zV9MIc2EVdab6lUYui4GF5KsXExwFvaA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=jzpv2qsu; 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="jzpv2qsu" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 86AE8C4AF0C; Tue, 2 Jul 2024 15:20:57 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1719933658; bh=2QfSfREv7XsLiYzVIDPiC88C7bCowAudVtuQMvAvPic=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=jzpv2qsu5sTwriWMJvGzkOAdDiMb4aGIO5eDm3Bwj14GurHgGGDCn+OhvCR0vhLy5 RoOrJikWXyp8CSEXuF7anQhe+ggo5D1Dv/A0zniJHUUygoL+kB7S/xlm9ECm1b0F8T TAiXyHOTR+yKaKo8tQNIW80hiP4LfyFM6r56CJF0v/76kET81/hk7tvQzPjkM45AxM nDpG1Jq+5/YDmUnJSJ1YrZtl6suL1t/ZVKzn4XoGqFFdcKloRD3TEpRNN1OKebmQki bMZxXPBXkOaYJytosZD1pTq3Uvokm+YqDiq6ZAZan4TwA8XT+KlhP4yb5r1kdvz6WG yolLjzpSRleJQ== From: cel@kernel.org To: Cc: Olga Kornievskaia , Dai Ngo , Chuck Lever Subject: [RFC PATCH 4/6] NFS: Implement NFSv4.2's OFFLOAD_STATUS operation Date: Tue, 2 Jul 2024 11:19:52 -0400 Message-ID: <20240702151947.549814-12-cel@kernel.org> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240702151947.549814-8-cel@kernel.org> References: <20240702151947.549814-8-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=4802; i=chuck.lever@oracle.com; h=from:subject; bh=7xMXUEeia+4iJBPnT1BQ6xl/jRDx8k+7VEvXenSB2HI=; b=owEBbQKS/ZANAwAIATNqszNvZn+XAcsmYgBmhBqZQiItdu/AwuC4UP4QXECenZ3wn22XzaB3R LqhEtPtJ8OJAjMEAAEIAB0WIQQosuWwEobfJDzyPv4zarMzb2Z/lwUCZoQamQAKCRAzarMzb2Z/ l9C2D/9Vpt0FhWV+OSFXzftGRE5dkq8giU69P5fmcaUredNaW3ycYR+yFy/50qxzi4zxY7/Ni+E fVLbCm11hO2F/lNA+YdGyyFdA7zzfjSu+4gA5wNBedcpvXbX+3hyRLoxCgBf6STB1gaPjTho9s8 cPUF+lCHphalwGpiKv2KjVUafrIgXDdoIDF3Oz2a4HeYawrok5wD3DXSr2xxo+7McliDMkHhBYy hAEObfk4havibagkbcaiI5+i285XZjpeIa5MImW2rkvniyvLRyb08/DUXiOXxQchZC7V09kftLL o2aJSfrahTBo0jjrDZNulgz7creiEkL3MTr8CCL0Sfi9jIlVzvOYxaL71pKS7Ts3ql60LqEXMIU RuG548NOKyPOzNhzOsU6wFXMR2zgKCD8qqPDU3MOphGUpx6c9B7dWET5tnkO4fnSXoJ06Suc01m W3IhoYYIOQPv55uB201MaZl748SChcTFwjmBLXXJd5zt/865MOpa24EaFsTP3H4Ypuy9nAnB52a q3tBVWdutl6QZbbdZKwR0Wu4M2V6/2t/PF6qarHOBdAieX5kweHLRhPuCLjxWRUseUrN6NApOCI LyfAkT2zm9jOCToaWFwVu224SC2Y7e5Q3vKCntR9w3v9HN0aQvPhA7CT+gADi5RWw4IjFQ+Oz/B UvwRoHgPGoLcICQ== X-Developer-Key: i=chuck.lever@oracle.com; a=openpgp; fpr=28B2E5B01286DF243CF23EFE336AB3336F667F97 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. Signed-off-by: Chuck Lever --- fs/nfs/nfs42proc.c | 113 ++++++++++++++++++++++++++++++++++++++ include/linux/nfs_fs_sb.h | 1 + 2 files changed, 114 insertions(+) diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c index 869605a0a9d5..c55247da8e49 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,117 @@ static int nfs42_do_offload_cancel_async(struct file *dst, return status; } +static void nfs42_offload_status_done(struct rpc_task *task, void *calldata) +{ + struct nfs42_offload_data *data = calldata; + + if (!nfs4_sequence_done(task, &data->res.osr_seq_res)) + return; + + switch (task->tk_status) { + case 0: + return; + case -NFS4ERR_DELAY: + case -NFS4ERR_GRACE: + if (nfs4_async_handle_error(task, data->seq_server, + NULL, NULL) == -EAGAIN) + rpc_restart_call_prepare(task); + else + task->tk_status = -EIO; + break; + case -NFS4ERR_ADMIN_REVOKED: + case -NFS4ERR_BAD_STATEID: + case -NFS4ERR_OLD_STATEID: + task->tk_status = -EBADF; + break; + case -NFS4ERR_NOTSUPP: + case -ENOTSUPP: + case -EOPNOTSUPP: + data->seq_server->caps &= ~NFS_CAP_OFFLOAD_STATUS; + task->tk_status = -EOPNOTSUPP; + break; + default: + task->tk_status = -EIO; + } +} + +static const struct rpc_call_ops nfs42_offload_status_ops = { + .rpc_call_prepare = nfs42_offload_prepare, + .rpc_call_done = nfs42_offload_status_done, + .rpc_release = nfs42_offload_release +}; + +/* + * 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 + * + * Other negative errnos indicate the client could not complete the + * request. + */ +static int nfs42_proc_offload_status(struct file *file, nfs4_stateid *stateid, + u64 *copied) +{ + struct nfs_open_context *ctx = nfs_file_open_context(file); + struct nfs_server *server = NFS_SERVER(file_inode(file)); + struct nfs42_offload_data *data = NULL; + struct rpc_message msg = { + .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_STATUS], + .rpc_cred = ctx->cred, + }; + struct rpc_task_setup task_setup_data = { + .rpc_client = server->client, + .rpc_message = &msg, + .callback_ops = &nfs42_offload_status_ops, + .workqueue = nfsiod_workqueue, + .flags = RPC_TASK_ASYNC | RPC_TASK_SOFTCONN, + }; + struct rpc_task *task; + int status; + + if (!(server->caps & NFS_CAP_OFFLOAD_STATUS)) + return -EOPNOTSUPP; + + data = kzalloc(sizeof(struct nfs42_offload_data), GFP_KERNEL); + if (data == NULL) + return -ENOMEM; + + data->seq_server = server; + data->args.osa_src_fh = NFS_FH(file_inode(file)); + memcpy(&data->args.osa_stateid, stateid, + sizeof(data->args.osa_stateid)); + msg.rpc_argp = &data->args; + msg.rpc_resp = &data->res; + task_setup_data.callback_data = data; + nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res, + 1, 0); + task = rpc_run_task(&task_setup_data); + if (IS_ERR(task)) { + nfs42_offload_release(data); + return PTR_ERR(task); + } + status = rpc_wait_for_completion_task(task); + if (status) + goto out; + + *copied = data->res.osr_count; + if (!data->res.complete_count) { + status = -EINPROGRESS; + goto out; + } + if (data->res.osr_complete[0] != NFS_OK) { + status = -EREMOTEIO; + goto out; + } + +out: + rpc_put_task(task); + 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/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h index 92de074e63b9..0937e73c4767 100644 --- a/include/linux/nfs_fs_sb.h +++ b/include/linux/nfs_fs_sb.h @@ -278,6 +278,7 @@ struct nfs_server { #define NFS_CAP_LGOPEN (1U << 5) #define NFS_CAP_CASE_INSENSITIVE (1U << 6) #define NFS_CAP_CASE_PRESERVING (1U << 7) +#define NFS_CAP_OFFLOAD_STATUS (1U << 8) #define NFS_CAP_POSIX_LOCK (1U << 14) #define NFS_CAP_UIDGID_NOMAP (1U << 15) #define NFS_CAP_STATEID_NFSV41 (1U << 16) From patchwork Tue Jul 2 15:19:53 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13719921 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 58BD31AD9E7 for ; Tue, 2 Jul 2024 15:21:12 +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=1719933672; cv=none; b=mtbC207p51SzQdd0QzG+0ahEwMKFxh3pkIbCQz3ViA8i5XJOo7n7cDGuYVbQmyZ3tY2cn3Tmhf3tZpI5jexzoGXioIBctUewZYazWCG4R5vcHM4mvJJDjhJtLv+9bWWqnzMrYxkduLTuTxsWmkWT2JlcnkPhp50MpsfjNzLoPU0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1719933672; c=relaxed/simple; bh=vfqZ0xv+/IM20oUUxdM4iwZluQr6goFsE6boGZaic7w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=CzdKu+ifSua1LevrWetAcBxvC13wB1WJH1x2YOQsGPWhb17bM1zMZAB6JCqqzDEScQFgJ8+veVG+QU0p0t0rOBm3Q/H5OUWEatTYttZMH4RiyIbtk4DPkbWRWzZbx2h0Kh0VesDhe1sOZ3lCPv3qP98sUcHiOWmZdERFXzQboH8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=U2Dw+ULp; 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="U2Dw+ULp" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C8367C116B1; Tue, 2 Jul 2024 15:21:11 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1719933672; bh=vfqZ0xv+/IM20oUUxdM4iwZluQr6goFsE6boGZaic7w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=U2Dw+ULpnsmFECBTn8BFQWcisk3lNUiViTOCjuDalsH8/Z6tsPiqc7NHpIrPb8sRn W5m8LNdLXnwQ7ivQP8i4NchPb00NTXUDs9BvxN2eTRqqAf3YFjlXzJ/vqahppMUXom 87/b7/5kDqc/LPUu1CQUltXzPTNJ4P+cTNJlEOR7PhmwymxA0prv1bWy/+LT6rQMTU mak1Eqjo/iTeuYhgmt/JUbq310sT+8BH8T4WLPDhRUPaLirrLOKIuJUsRBx/UEGQKX as0DrawNHYTBpygd70Gz85+aQZeNN1FwQSVxX9hkmc7x6580Z2M1WZINAsAzW4RZMo 5YgfszfyrBFnA== From: cel@kernel.org To: Cc: Olga Kornievskaia , Dai Ngo , Chuck Lever Subject: [RFC PATCH 5/6] NFS: Use NFSv4.2's OFFLOAD_STATUS operation Date: Tue, 2 Jul 2024 11:19:53 -0400 Message-ID: <20240702151947.549814-13-cel@kernel.org> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240702151947.549814-8-cel@kernel.org> References: <20240702151947.549814-8-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=3808; i=chuck.lever@oracle.com; h=from:subject; bh=DWbh404bj8qe6AC5OIsvBQmjKXvF2TOOOWVemzfvpZM=; b=owEBbQKS/ZANAwAIATNqszNvZn+XAcsmYgBmhBqZG5wR6tFYGRTPhNo8K1/HIVc3XQezbLsuB c6Sze+jc/2JAjMEAAEIAB0WIQQosuWwEobfJDzyPv4zarMzb2Z/lwUCZoQamQAKCRAzarMzb2Z/ l0XHD/9Jn8QF7aWpwF9E2EokMuCtfm5iqfhPZkxVqtce59Q7gOyomrjOjzWpCJnQsAnf5IJK1MK ah93CLhr0yCPH/k6k9aU3dGHX9fjtIYtezOinZL0j1sxnAQLtXcO0/iABZ0ZMDxcjNUCdsrApwS eYW1an7Glpz/PxJk74bzwRQW8ziHJ8xL0grDK8UlmeG/z8U0267Qcywj/1ohjL2VXxuJSGskFRv g8y+lJpBA2ly3he3Y4UhUSln42Unsgd89MwLXRPSj3fSpQlQTNu8opco2I4nupbCt4P4bgSIsVs w3Dxj7etHzJ7DeEzmXtVbDKPAwrkj0cHcCUXyAokIAIZr8BsLhMp029x7MByUz1qdt4c/8KV1Jr NzrUkmc1ExNarCqYvEo3DHk4bEGly8SDmnhPNn44aZ+PtudnZOiXkbnNMTXikNhOCBxtdJqL3PX e7ki0TTM7EWuS2aDOdeDQ9JCTepd+p/oXJXlvKw55xRgYnetbznjEvTrotHJw3m7qR6RtyN/1+S Ur5ZSf2ciJ9xaREi6eODS5g1BwMTOhCwzNrMYvlb4huvt0JetsdSarLJ/WUqXB4tYpklkjDYF9w uFL4jMiD49zOaSFAXLaUkfHs7gR0xdCn6M43w3uygavvBXn96YZkVoTm+Vh/BrrW4U40hLZ7VaQ RijEmamDn0Oq06g== X-Developer-Key: i=chuck.lever@oracle.com; a=openpgp; fpr=28B2E5B01286DF243CF23EFE336AB3336F667F97 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 Signed-off-by: Chuck Lever --- fs/nfs/nfs42proc.c | 40 +++++++++++++++++++++++++++++++++------- 1 file changed, 33 insertions(+), 7 deletions(-) diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c index c55247da8e49..246534bfc946 100644 --- a/fs/nfs/nfs42proc.c +++ b/fs/nfs/nfs42proc.c @@ -175,6 +175,11 @@ int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len) return err; } +/* Wait this long before checking progress on a COPY operation */ +enum { + NFS42_COPY_TIMEOUT = 5 * HZ, +}; + static int handle_async_copy(struct nfs42_copy_res *res, struct nfs_server *dst_server, struct nfs_server *src_server, @@ -184,9 +189,10 @@ 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); + int status = NFS4_OK; + u64 copied; copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_KERNEL); if (!copy) @@ -224,7 +230,9 @@ static int handle_async_copy(struct nfs42_copy_res *res, spin_unlock(&src_server->nfs_client->cl_lock); } - status = wait_for_completion_interruptible(©->completion); +wait: + status = wait_for_completion_interruptible_timeout(©->completion, + NFS42_COPY_TIMEOUT); spin_lock(&dst_server->nfs_client->cl_lock); list_del_init(©->copies); spin_unlock(&dst_server->nfs_client->cl_lock); @@ -233,12 +241,17 @@ static int handle_async_copy(struct nfs42_copy_res *res, list_del_init(©->src_copies); spin_unlock(&src_server->nfs_client->cl_lock); } - if (status == -ERESTARTSYS) { - goto out_cancel; - } else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) { - status = -EAGAIN; - *restart = true; + switch (status) { + case 0: + goto timeout; + case -ERESTARTSYS: goto out_cancel; + default: + if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) { + status = -EAGAIN; + *restart = true; + goto out_cancel; + } } out: res->write_res.count = copy->count; @@ -253,6 +266,19 @@ 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: + status = nfs42_proc_offload_status(src, src_stateid, &copied); + switch (status) { + case 0: + case -EREMOTEIO: + res->write_res.count = copied; + memcpy(&res->write_res.verifier, ©->verf, sizeof(copy->verf)); + goto out_free; + case -EINPROGRESS: + case -EOPNOTSUPP: + goto wait; + } + goto out; } static int process_copy_commit(struct file *dst, loff_t pos_dst, From patchwork Tue Jul 2 15:19:54 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chuck Lever X-Patchwork-Id: 13719922 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 0863D1AD9E7 for ; Tue, 2 Jul 2024 15:21:27 +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=1719933687; cv=none; b=akq+8d89EdjdoCnHz3hqZrHgfFJlixTacnH5q45lCR/NkOdk6y8/ebRf6BnKH90W36WwiWUtBKrD9nOEJoYCuqArPN+hEFN7dx11bHEaZkUrulhqMRgxh8CTagx6f1+R9RrwTRoqGotVjfXasqiu31KOSlUjrI9jbxcipmS4UKA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1719933687; c=relaxed/simple; bh=3j84Ol5Z+vZEa5NDp1swZbhk0XVOhydkoB5Ca4fpm3c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Ij8tqILSpFAnpugQf7fLjyuLZfSRWvpbN0/qJyE2Ckv7wwbghR2oz/Fj8iOB/LyYLfMdqH9PhHI2t+J7mHb1d+bxK2YPeqnQLoAtl9wZNNCkmDdYwQ0I06ehHv42SNLV2/DxnjjM2QOP4vHUtcx6CZlVKg+LjcS+Wp7YrsHh534= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=mQSp1voT; 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="mQSp1voT" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 771D9C4AF0E; Tue, 2 Jul 2024 15:21:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1719933686; bh=3j84Ol5Z+vZEa5NDp1swZbhk0XVOhydkoB5Ca4fpm3c=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=mQSp1voTsKK9zzIQZwlPCwq2tC14lzxkbnixFKYwOe5rsrnsKVeBJ2VvskZ0ke/SN WNKsOHz+JPZ+epRa93iUUS3J81DQMv9/9f21Y094/o1vvOWxjv6GMxTIC1dVlxlHGW Qz6DKDdK3d7Idi4QcqSbbXiSwsQFlufjLuvpr3hUHPObT0UOCGk84zaVUXs+sS63dR 8aqlm6wS0UvwRxSPutIyZXjYO0t6cu1dnAj1W0lXOSp74zGiRMydMUBgdObGlxxKLF 3ZanpuZqkn8Ndi+mtvrpdlIAaKrqqz7J3Ws8TG33cbGnysQrchT17YHussMcZ9CUan EBxYcHEzTz9Tw== From: cel@kernel.org To: Cc: Olga Kornievskaia , Dai Ngo , Chuck Lever Subject: [RFC PATCH 6/6] NFS: Refactor trace_nfs4_offload_cancel Date: Tue, 2 Jul 2024 11:19:54 -0400 Message-ID: <20240702151947.549814-14-cel@kernel.org> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240702151947.549814-8-cel@kernel.org> References: <20240702151947.549814-8-cel@kernel.org> Precedence: bulk X-Mailing-List: linux-nfs@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=1772; i=chuck.lever@oracle.com; h=from:subject; bh=VX2jzkhgECcgrnCAm4M21TNA2oUc+Ss10cwUNaRthhk=; b=owEBbQKS/ZANAwAIATNqszNvZn+XAcsmYgBmhBqaDOqSFa/iy2qclDACO6H/0EhDBT9CW/Gc2 4HsEnpO8g2JAjMEAAEIAB0WIQQosuWwEobfJDzyPv4zarMzb2Z/lwUCZoQamgAKCRAzarMzb2Z/ l+ZmD/4kwqdIcxoLKSybxCrbK4Wfwe+ltTY+lvIXe7XjlQJABkejhGzI3u5/Rw81LTBQXWf2hbT fMsFsQt+jFgMDuEPFLzp6Az7iqTiwQkVSeRv9kVQtzV6IL0smca+lRB7k/uKxl2LduWtKQ/cmdL ypiNbuWeDa8lkAxZI3JH/KTk/dmhBoA3FE/WqaVO/Sk7U8wQzMCwAqkV0aD+5ADzXhk0Tud47Ed olS4FIyxJMVb5u6jSR8PqDABnNwwHUaZ0IOKi3aWt+EKAlh6M+G+LXD553xPPlSlPQBS+bMvtDf iXw4RJlrIhk0BdcF2wYhGPzbM7VpoGWqTcDV6S7/hhtwoLBfeoiTGG278SEjcUk6K1tvx/CVBn0 j2qCUjk0pvIceyZ1Tj6cuzGpJEP6bhcqazDWKQmGAJo8xzvXI27MabAcpRYbjRrxzyOl8CdQf7u bXfbS+N9063AEJOoFmU60wKSHTFQ0UFlRhrpZFSvZuKOvD+ScP8Z9778jUAqp+vKrPp8+Tc2hMY uotaS6zdS+S39gSutJaa82HDwuacYL+vZsWrKV+ZRozkejfCYJtZi8gIzm7XViYIWl0aEnJC0La SKttcuR2eVRHQ/uG88BbVc/6zwbTqfLWpUiG0nwUsEJkcOgrAi0GuAGQIrdRJRkA+oOlJ8IsscS qUzB1AG8DeY9c+A== X-Developer-Key: i=chuck.lever@oracle.com; a=openpgp; fpr=28B2E5B01286DF243CF23EFE336AB3336F667F97 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. Signed-off-by: Chuck Lever --- fs/nfs/nfs42proc.c | 2 ++ fs/nfs/nfs4trace.h | 11 ++++++++++- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c index 246534bfc946..fd4e66e9b43d 100644 --- a/fs/nfs/nfs42proc.c +++ b/fs/nfs/nfs42proc.c @@ -614,6 +614,8 @@ static void nfs42_offload_status_done(struct rpc_task *task, void *calldata) { struct nfs42_offload_data *data = calldata; + trace_nfs4_offload_status(&data->args, task->tk_status); + if (!nfs4_sequence_done(task, &data->res.osr_seq_res)) return; diff --git a/fs/nfs/nfs4trace.h b/fs/nfs/nfs4trace.h index 4de8780a7c48..885da7ef20a9 100644 --- a/fs/nfs/nfs4trace.h +++ b/fs/nfs/nfs4trace.h @@ -2520,7 +2520,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 @@ -2552,6 +2552,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(