From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 50411489865; Mon, 31 Aug 2026 16:15:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192940; cv=none; b=J730QCp1NbU3ZL1QJTfVWdzXni7HRY4dSSmHj9Njn466pBnWIiCIbwgfKFZty/+3nlmsi78egeke9rjhYNWDikQ31Zu7z/IAwfooOr9tu03huZhPQDCzGRkk5LOIAz3WaYoqNWA/FaI3FLcUYnbHRyX8FXEtH0NexhEHlLhY3Lw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192940; c=relaxed/simple; bh=tRmgxww+rxzTihIU6XxzVA4+qqOxvEdXskaEQAJ+8Pg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=RpAWeDQH8NAAzOAnLexr/8SJHZGEmMZDjr4cnklgYJQ/7gHL+H/dHF7U7E8pcrdWi/iuShVA/3uDKmsaJvImhFEd9zyzzcneDuL7lf5a+EI3nIH4NL4l7nflDJYvxs7sYLC+gJtCGXdtsHEa6L481zwymJBdsIRf5w0zB9hRdEI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KWAaBgUy; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="KWAaBgUy" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 84AAF1F00A3D; Mon, 31 Aug 2026 16:15:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192939; bh=pL3XeMVN1EzXKRu842hzSRvAUH5WEX0PtRHjn0sU1pg=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=KWAaBgUypGx7j3uz1itdeRGAX8KWjAANJDtY0bgMSfOzSC/bpYjn5LcrP6NLiLWOe 3IFsS9jdKgF9Nb3gktAQMRcR+rZz1idOrj/nnWVAHYTPyX1XQPBR2Pl4eGjOerIHF2 7jfqejlBrkcRmLzXpqYkqtjO5viRvY11G3Y9ie/OCuxquinVi6t6TshHav3md6mRGy gf+fNxx06Ks8zbpYblzdQJkz98DJyT/b7jSCxBV9Ohbiyl8ncWrhCTVkVEPHDekS81 tTQkYKRZtbDg9bi6sPh5yISMi/D1Z+oE3drbwsQvAKUk4h+T9n/iTfmW2Y8qMN0NlI QhyoBy4zsWqLA== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:43 -0400 Subject: [PATCH v4 01/14] NFSD: cap the number of listeners accepted in listener_set Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-1-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2930; i=jlayton@kernel.org; h=from:subject:message-id; bh=tRmgxww+rxzTihIU6XxzVA4+qqOxvEdXskaEQAJ+8Pg=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaidH81ifZX4VooVLB9lzrNEQDOkWlPY6Mnvf dxXhKlCfOyJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWonQAKCRAADmhBGVaC FYr4D/wL2PRYGe/CPx0uDFZZE7W86rR5IynluV7OKy8ORRWFsH/dlOw3zbAaI73ENHqCWWoEFlr kQUo0JvjRd65Sb+5SqByQ0IdKdFjH/fmSLD36aXhDBTiiTV3atITlAXs+mfyjPmfI1YzzoKmHWm 9OBYlEMzzZa8y9qmrRrFux6LYncp/7UVgujzAyHgx4aCzIeo8R50ua3sZn6ADJ6eTXwfvJEpQht ycss2sKaU71hh4gH9uDSus3LWJKCRQorYpPbgryBRDZxV4+R1mUZ4guYHKxwjE6V1EZEihgxvV8 oJwSHtAPX0JJyNd8AIAD+EmVdtukIH6IArXme3+GNIRNNxVQl5xzZncCijGOnDL5qnVrAjk2phO bsE1LHHFk7ltzSsPR7hLoZu1S5odhEcktsuITaMJVBt+eGBiFwrq90Kd9LkuMyTH6SATuoXlNZe ndlZbQ9LdAenb024ApTmQrg1BLUO93bFj6RnUVNQy9bwSCjuEIirWqgleW8c7DMq0eMbqX36WMn /xN2xHhWovpypfssaaGEyHdA6m12a8uqO64AVtLwlAsrohJKJF/+Mw4/cszYXM/lCqOk3v2pD59 NNC7rajcAUL/VN3o5w08w0Ebo1tH4v9zMuJLA7GYC974tf3DDYooMd3WaoRHj88tomd2sa6kfc6 Dp708ZSSNuQebCA== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 nfsd_nl_listener_set_doit() matches each requested listener against the existing set. The nested loop that does this is O(N * M), where N is the requested count and M is the existing count. The loop runs under sv_lock with bottom halves disabled. A userland request with a very large listener list can therefore spin in atomic context for a long time. Reject a request that carries more than NFSD_NL_LISTENER_MAX (1024) entries. The check goes in nfsd_nl_validate_listeners(), before the code takes any lock. The limit is far above any realistic configuration. This patch does not cap M. Only the message size bounded N; real sockets bound M. A listener_set result set is the requested set, so that path also holds M at the cap, but __write_ports_addxprt() adds two listeners per call and removes none, so repeated calls can push M past it. The worst case under sv_lock is therefore 1024 * M, plus 1024 nla_parse_nested() calls. Both interfaces require CAP_NET_ADMIN. Fixes: 16a471177496 ("NFSD: add listener-{set,get} netlink command") Assisted-by: LLM Signed-off-by: Jeff Layton --- fs/nfsd/nfsctl.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index 5331b89c4281..b6f4d66f612a 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -1995,21 +1995,22 @@ int nfsd_nl_version_get_doit(struct sk_buff *skb, s= truct genl_info *info) return err; } =20 +/* Upper bound on the number of listeners a single request may carry. */ +#define NFSD_NL_LISTENER_MAX 1024 + /** * nfsd_nl_validate_listeners - sanity-check the listener list from userla= nd * @info: netlink metadata and command arguments * - * Walk every NFSD_A_SERVER_SOCK_ADDR attribute and confirm that each entry - * is well-formed: it parses against the policy, carries both an address a= nd - * a transport name, and the address is long enough for its family. Doing - * this up front lets the callers below assume every entry is valid and - * guarantees we make no changes when the request is malformed. + * Walk every NFSD_A_SERVER_SOCK_ADDR attribute and confirm that the list = is + * not oversized and that each entry is well-formed. * * Return: 0 if every entry is valid, or a negative errno otherwise. */ static int nfsd_nl_validate_listeners(struct genl_info *info) { const struct nlattr *attr; + unsigned int count =3D 0; int rem; =20 nlmsg_for_each_attr_type(attr, NFSD_A_SERVER_SOCK_ADDR, info->nlhdr, @@ -2018,6 +2019,11 @@ static int nfsd_nl_validate_listeners(struct genl_in= fo *info) struct sockaddr *sa; int err; =20 + if (++count > NFSD_NL_LISTENER_MAX) { + NL_SET_ERR_MSG(info->extack, "too many listeners"); + return -E2BIG; + } + err =3D nla_parse_nested(tb, NFSD_A_SOCK_MAX, attr, nfsd_sock_nl_policy, info->extack); if (err < 0) --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 262474B7177; Mon, 31 Aug 2026 16:15:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192942; cv=none; b=ImQaBcJsyO/qAVN5REYHqmmuC/pUDE3lsLQ4NuGK1Rn7eH/Ax3N90Jw2YfstLfCc0UI//dPosQJNnmnPovuwkiVEAKVTBO5TL910joKWAR4jF/H1iLHzgwbSKpzeBlpW5Woi4e3V5CUQVkBRCmOzU2pxEjDrUpST+YITi/+LAww= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192942; c=relaxed/simple; bh=aJetiop332TzGMjtNxCwp2osCzOlN1SMdSvmKASa+aI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=gYddHJBtUrr9PAOIxw3g8ule7j+rGH2bnp7+GE4/HmPP6coBfUPCZjdOSKyDLcLFJ3gy+6P38pm/5jGyTklbjZhTlka/4K7D7euc0LKsgRj7AvQld7beCFtXVDxE91GbChVuVAEkFjEzQHkakr0+rVu9ciFEaoVqJNFvDv+7J30= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=FwQ+4nFJ; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="FwQ+4nFJ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 362721F000E9; Mon, 31 Aug 2026 16:15:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192940; bh=f7DIO5UFdyzmop+0FickQyJR+upbMPxvd7WYzoH5UvM=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=FwQ+4nFJK0h5kunzgMnrcBnBiqAr6MOP/9hUW+bcXgJBCV24tIb4CQeDfQfA3p+Jt KrnST0je5exX4TOiFMOe5KH85e93G6kLQb+ipfVBDqGl16pNbQjDIBiB+WyZpwQtyy V2d4jD9SQfxoSqBsAABI1pRG7WkVOVp1IGiPsGnCL+BczPmjcdjeobUBP1mSfzFbL+ 0pNdUCDXtcHEKxFnma4d+3BmLaVsqYBufUuUH8cDJ9GAZoBBFsAgYj0kyzuMN0rH7N 6YFN8PJlSWhXpT1/gPg90r1dKun6qFDuGHIfzYKcNZWgaHa7oxWJKKZPoFpLDra9jD uqx02RkF90gPQ== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:44 -0400 Subject: [PATCH v4 02/14] NFSD: validate transport name in listener_set before serv creation Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-2-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2761; i=jlayton@kernel.org; h=from:subject:message-id; bh=aJetiop332TzGMjtNxCwp2osCzOlN1SMdSvmKASa+aI=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaieu4cKgNR2R4sHpDTZQOh+fGvc/LUHCNfaV QewspRHcwKJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWongAKCRAADmhBGVaC FbXTEACJ8pliZonrFmmFGrBtUJcbeSwXJdZqUXYt9OnDRD0f/qmCKZzFhmDhSR+uRcG1YUYKX80 QdXi50z268uEENITujKzaozoov/Y6GakWiu14KjnAy/hjZmA4BFyc/7JmkCYEy4rmtao7yI5JBc ZdpGxDxKh3vi3JSDwi7V67GYtqVuhjVNPyDLKBJprCA0L3dlAnliR+AxSa4IPn9/OKtLGMl4rXI D21uBNjQQBF4k0E5aA05ccM/bLHXB/0I7qGOKgBFx+DDfQubH+xlX34GwKtAoD9SaPmwhCE/80K 3hrTEIzgyB0BoDqVnSsfRi/PYMzsbgxUoWmQR79MV96Afqz8XRamCqjQ/oP9/IqEywlD78VXwS/ KBpTLJ0kZPFynzvCDa8u2a2J0hMAWBScxFoG97lVVX5G22UmmPGxN7qJKrrU0mUUohd6fjVDvcn 1HzXCKl4hzTAcSNbttAfdL6lhRAzeMYRuJcia3DQqwb4XYD/DpNj9OMzSwrWsm2WFA4kpaPLR9D eKqw/bGbtUfsgTpwStclaQl2qRuDVx9fStEaQBuWs/y+40oV0vMNHNm8LXLZ7q3w5xU30fwkg2i B8u3ztcq+4jB/GJSDJfIXBIAlNTVAY8j/NqKWlLazuWC4SM0qVg8/rFNHBZsJzosljDvhJ/cgmt lX5Zg9OET5Ut25w== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 nfsd_nl_listener_set_doit() holds nfsd_mutex for the whole listener teardown and rebuild. The code checks NFSD_A_SOCK_TRANSPORT_NAME for presence only, and not for content. An arbitrary name therefore reaches svc_xprt_create_from_sa(). There, a name that matches no registered class calls request_module("svc%s", name). That call is a TASK_KILLABLE usermode helper upcall, and it runs under nfsd_mutex. Check the name against the classes that NFSD can create: tcp, udp and rdma. The check goes in nfsd_nl_validate_listeners(), which runs before the code takes nfsd_mutex. The rejection names the offending attribute through extack, since -EPROTONOSUPPORT on its own does not say which entry carried the bad name. This narrows the upcall. It does not remove it. NFSD accepts "rdma" without a condition, so on a kernel that does not build svcrdma the name still reaches request_module("svcrdma") under nfsd_mutex. That is necessary for the modular case, where the autoload is legitimate. Fixes: 16a471177496 ("NFSD: add listener-{set,get} netlink command") Assisted-by: LLM Link: https://syzkaller.appspot.com/bug?extid=3Dc7eae0eb80858a2dba0f Signed-off-by: Jeff Layton --- fs/nfsd/nfsctl.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index b6f4d66f612a..d8135f38e69f 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -1995,6 +1995,23 @@ int nfsd_nl_version_get_doit(struct sk_buff *skb, st= ruct genl_info *info) return err; } =20 +/* + * Transport classes NFSD knows how to instantiate. Vetting the name here + * keeps a bogus string from reaching svc_xprt_create_from_sa(), where an + * unknown name triggers a request_module("svc%s", name) upcall under + * nfsd_mutex. + */ +static bool nfsd_nl_transport_supported(const char *name) +{ + static const char * const supported[] =3D { "tcp", "udp", "rdma" }; + int i; + + for (i =3D 0; i < ARRAY_SIZE(supported); i++) + if (!strcmp(name, supported[i])) + return true; + return false; +} + /* Upper bound on the number of listeners a single request may carry. */ #define NFSD_NL_LISTENER_MAX 1024 =20 @@ -2032,6 +2049,13 @@ static int nfsd_nl_validate_listeners(struct genl_in= fo *info) if (!tb[NFSD_A_SOCK_ADDR] || !tb[NFSD_A_SOCK_TRANSPORT_NAME]) return -EINVAL; =20 + if (!nfsd_nl_transport_supported(nla_data(tb[NFSD_A_SOCK_TRANSPORT_NAME]= ))) { + NL_SET_ERR_MSG_ATTR(info->extack, + tb[NFSD_A_SOCK_TRANSPORT_NAME], + "unsupported transport name"); + return -EPROTONOSUPPORT; + } + sa =3D nla_data(tb[NFSD_A_SOCK_ADDR]); if (nla_len(tb[NFSD_A_SOCK_ADDR]) < sizeof(sa->sa_family)) return -EINVAL; --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 CBE054BAA07; Mon, 31 Aug 2026 16:15:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192943; cv=none; b=d4UpyCVRicYNw79/v+TDdX1fRVTVxCNNTv4yMT2fKPR5C4PDS7zTK5fVx0FFXzjk1arJChgQNQugLtvnZCnQik9s+vwDYvmc3hy2Sc0RjSREcmnUvWj2RCINS2bWjyhZoR0+q6p/W+jsZiMcX0D6DOIJ32rWQyrxZzZNdYAQMqY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192943; c=relaxed/simple; bh=0/b63pHsH99q59pHXxgWpdCiis0fT0wFTjXendozs0s=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=pnYxNMC+cGPoBmtBZnbIl5SS74RX9/6auTVy/ohi7BAfFwksnYTSPGmP6GCzQsnMcPsEROvHCNfvX7VlCRDkKFYm6jU9uRprr4pdvUxHb6EWV2tlp6IfVgfKLsjYJJ04loqju7xf6+ykGEvG+gilqvZ8RYqbOoa/jc1HkkcBJPs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=kH880J8Y; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="kH880J8Y" Received: by smtp.kernel.org (Postfix) with ESMTPSA id DA7301F00A3D; Mon, 31 Aug 2026 16:15:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192942; bh=yBYuY0qF5cKQRzExECF4YXQMQy4ClFSSmJFRGPrU+CQ=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=kH880J8YfqTiHkCpfXySCRxWeIscyFxHnLCcqnJodHw4LXNx41/m7pGE4+uePht7m uo7yy+27TgcWhvdaHC2QJMv8Tqhp5igKNWZYB2owkcna4+YozbLwzUgTpejxT0FLH/ yIXSH8vu3GVMtPXJcvtXW1VQqdaO5uCSwLldQSFvF6xrnMjMT+dErggM97BT8CaahQ wjkC/fii0CIGPSxP0QPMcBr495IMYi3hjz97X9tbNBbAiq3JehG+tIB+gIKbNoJxnd EozBM9tVtWflufqZbQbF9p7ELxpr9CqHjbAs9dwUzz8KQkVeoQKzUiGh5ZIGOpOoR1 G7RmkfEUS8c3w== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:45 -0400 Subject: [PATCH v4 03/14] SUNRPC: keep the first error in svc_register() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-3-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=1206; i=jlayton@kernel.org; h=from:subject:message-id; bh=0/b63pHsH99q59pHXxgWpdCiis0fT0wFTjXendozs0s=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaifr4kI+z+Z/m0ZQ3U+vttDEKp4mDsd6valh Vcm0XymZYWJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWonwAKCRAADmhBGVaC FcJ1EAC2sYxpKivKMWjoAawHsfvUYbvw2PgdZ6oFidkbs81ICYPVn06JC7hb/Q5dlt2VQE+GlzL 5hooFA4p5mzLGxhEbD9UB8XZh/EuZC4PR/zH45xgqBTq03qVitYOZDsEiRyuGklcGOMe53FlqeR 9UVzpbLi8j3fXWNyr3Wsg/Hm+jp06HokierApoQGbg4h2YkczQ0M4kPIkM9IbaUKzDS7tLZIcjC i79joYCzf13Qt7WuQ67gnSI2AlhuqviCqEwrYKonkMu6OXQtmTdlX5VUMsxnC6DGq28KHMIHVtv acLzLPSjn/FtT2rVOafKGdFAcPVWQWYclChivIo8fyQsaOQCZQVKvqBzgHJkN/rT6IfDWat+fjd nb56YQJUaceyPbk5/vYJZ7319QtdMCjSdp3PTpk7vixv2WXFAJLU8N++JuPmN95xWKnFAhEtS+3 CBhsFIGMUsSCholUw14YRYuylYnK/9BWfQnLt//+YKtca85+BfA4AGMLOKfXDPS7yDB9WhfrGnS bJAMNjqmwldVxchQlcaNHK5nQh79ADKdrRq1jrGPGduOLVAQsEr+zA2i0Phsn+wRrJqWX5MbPeo m5CJfjY+KzLStMtb2VM2J+cZc2kX28jHBJz+RBC/TD+xWgpqO3eBXarwgMRXDptDT+a2o9L02uE kB338AJUGggFHHA== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 svc_register() assigns every pg_rpcbind_set() result to the same "error" variable and returns the last one, so a later result erases an earlier failure. Keep the first error instead of the last. Fixes: 642ee6b209c2 ("SUNRPC: Allow further customisation of RPC program re= gistration") Assisted-by: LLM Signed-off-by: Jeff Layton --- net/sunrpc/svc.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c index 8297bad2b177..4f402bbf97ba 100644 --- a/net/sunrpc/svc.c +++ b/net/sunrpc/svc.c @@ -1208,13 +1208,16 @@ int svc_register(const struct svc_serv *serv, struc= t net *net, struct svc_program *progp =3D &serv->sv_programs[p]; =20 for (i =3D 0; i < progp->pg_nvers; i++) { + int ret; =20 - error =3D progp->pg_rpcbind_set(net, progp, i, + ret =3D progp->pg_rpcbind_set(net, progp, i, family, proto, port); - if (error < 0) { + if (ret < 0) { printk(KERN_WARNING "svc: failed to register " "%sv%u RPC service (errno %d).\n", - progp->pg_name, i, -error); + progp->pg_name, i, -ret); + if (!error) + error =3D ret; break; } } --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 6A4DA4BB5C2; Mon, 31 Aug 2026 16:15:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192945; cv=none; b=gjPiYZUjnxLvqRQA1Ofd/Cw6Olh51uGc25ggJAyGEVbc9YgjBX02Rx5Cd2XzQHMiV+NuR/kCsOdrYeOoZPUNQB/jgcOr6JuX6JZKXTFT8/bggjFIqBuK5W/Dn4S6nw7ZaM0WGIL2NXaVO5g5cZ8q0+9i+0U5Qslb9mgk0M2rNdE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192945; c=relaxed/simple; bh=hTif5dKJuoIIsVz4dAaSFnhZxibEnCpGcJ3SqDcakyA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=bl9tnNBPTtodJKUGWkp14afGmcXyo+3QouCK/oirbLWXSkl4u3U5beQ7pQg7x1Zuk6bVc3HmVgWGk6bLeJ2DCMuGVvrJjl5TFGT2RWb7uX6kPDOJ3a5qaODHjdbvAHVMnZrn6AzUL4EoVMmZyQd1K+Aw/JvXczx/qzFgRdcOVrk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=lWxGpM+O; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="lWxGpM+O" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8AD091F000E9; Mon, 31 Aug 2026 16:15:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192944; bh=NJ+06JLg+zozGY40HFLsiWKPGrZUTJWkSToQO3R8seU=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=lWxGpM+OSQiOyed5qV50908uwxeN8bO3Cz82h9WJDL6LZBI5OU7LX6z7D8Fe7Gv54 CBccJpjMxI1+H9p9eb6cq2w47BG/dhsvNePIOQWMtp2ZG98bvKT5TuoYEUOPoVmGFw cYU5OO23kOxOPiIg0Yy9yEqUvYjKIXRFaBvwtLncSkST/U9dfqzdbdBCeXggJRsNKF NC5sUALgAzbulD4vbF58avEVPrgtdtyAGQd5Ph/1f5iI9UXDb8/zZcDlSs94B+yQ62 Jzj0H/rDqxD/PmpkyvFGPbPoLQD/+W9mSX9Fkh/buQC2zP0jmhJcOtJMx5xwlVE1xS sRiDnlPvYHgJw== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:46 -0400 Subject: [PATCH v4 04/14] SUNRPC: bound the local rpcbind client timeout to 1s Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-4-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2890; i=jlayton@kernel.org; h=from:subject:message-id; bh=hTif5dKJuoIIsVz4dAaSFnhZxibEnCpGcJ3SqDcakyA=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaifMXRaNzkhd/Bgc9UiPKoHi0PvpmcUdbHcZ 6ah2mwnmsiJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWonwAKCRAADmhBGVaC FVmpD/9heFfZiHYMVpqxb80QNV96cKFlZzEycfxDrNQTTw1I8GyZoIaaBg7KncWsOvDkMSAjnfq rvbsNSlyIiEMPxkWh13XzlK5PPlWjtMVQt7qvVyveQ2fwskM6adY07hJk7GkVP/bR3Ihrh9mdoM WjUlufUaeE1R2HOcCuY/xNUKD2vHSO/y0SXY7+dyCQACvOESDBm99juhni9Vz2m8aMp08VinOWY vKgBM54AmQpZS1LzYf7hV5Z3dxbzLZ1sp2DUIvueR2w3d3j3L2rgRPkwKzuasOKrNqNzDWkFlEl dMzcluM9Yy9Xv6J57/5mYKsg2v2z1en6weGLq5D9h2tilVrJ42HP2D8IjMED2/b9XBJei5qBYvL jK05VTv33T81Kq/87Xk6y4DlLqrM/OWf3L5JUTVs8arB95xNKYZriVMCP6B+pzkCEyNIdXgv0ID 6Rv0E78jhXJD2AUrHkVumqy/J3aYQpnQzJTurOcpgTFVhfH9D26eW1FaZ5WyPWqvSQ6vAWd5gdJ 3CuKrpfsAf7w92qT0cJ0naGWmIeP88UBLXd42QsNto4vJUf/YwbY3Nls7eibCllUUEJpHfzeMOR SxxIj8RlNxOz921j+zQqD7NogydoKAHW1Y+e8tY8LbmF67fGtZkQI8zyFaSX88oK0+Kg83g0SvV j/VOmwZYDkyNLfQ== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 The kernel's local rpcbind client uses the transport defaults: a 10s major timeout for AF_LOCAL, and 60s for the loopback TCP fallback. xprt_calc_majortimeo() returns to_initval when to_increment is 0. Those calls are synchronous, and they run under nfsd_mutex. One operation makes several of them. rpcb_create_local() tries up to three client creations, and svc_register() sends one call for each program and version. A local rpcbind that accepts the connection but never replies stalls every one of these calls. The accumulated hold is long enough to trip the hung-task watchdog on other NFSD netlink operations. The holder itself waits killably and escapes the watchdog: INFO: task hung in nfsd_nl_cache_flush_doit The local rpcbind is on loopback or on an AF_LOCAL socket, and it answers in microseconds. Bound its client to one attempt of 1s. This shortens the stall. It does not remove the stall, and it is not free. Registration stays synchronous and stays fatal. An rpcb_create_local() failure aborts nfsd_create_serv() through svc_bind(), and an svc_register() failure makes svc_setup_socket() fail. An rpcbind that is merely slow to be scheduled can therefore now fail server startup, where it succeeded before. The real fix is to make the registration asynchronous. Assisted-by: LLM Link: https://syzkaller.appspot.com/bug?extid=3Dc7eae0eb80858a2dba0f Signed-off-by: Jeff Layton --- net/sunrpc/rpcb_clnt.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c index 6aa372188c86..0aa376b82a52 100644 --- a/net/sunrpc/rpcb_clnt.c +++ b/net/sunrpc/rpcb_clnt.c @@ -221,6 +221,16 @@ static void rpcb_set_local(struct net *net, struct rpc= _clnt *clnt, # define SUN_LEN(ptr) (offsetof(struct sockaddr_un, sun_path) \ + 1 + strlen((ptr)->sun_path + 1)) =20 +/* + * The kernel's rpcbind client talks only to the local rpcbind, over loopb= ack + * or a local AF_LOCAL socket, where a healthy rpcbind answers in microsec= onds. + */ +static const struct rpc_timeout rpcb_local_timeout =3D { + .to_initval =3D 1 * HZ, + .to_maxval =3D 1 * HZ, + .to_retries =3D 0, +}; + /* * Returns zero on success, otherwise a negative errno value * is returned. @@ -238,6 +248,7 @@ static int rpcb_create_af_local(struct net *net, .version =3D RPCBVERS_2, .authflavor =3D RPC_AUTH_NULL, .cred =3D current_cred(), + .timeout =3D &rpcb_local_timeout, /* * We turn off the idle timeout to prevent the kernel * from automatically disconnecting the socket. @@ -312,6 +323,7 @@ static int rpcb_create_local_net(struct net *net) .version =3D RPCBVERS_2, .authflavor =3D RPC_AUTH_UNIX, .cred =3D current_cred(), + .timeout =3D &rpcb_local_timeout, .flags =3D RPC_CLNT_CREATE_NOPING, }; struct rpc_clnt *clnt, *clnt4; --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 EFED44BB7F9; Mon, 31 Aug 2026 16:15:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192947; cv=none; b=ZClByg5lxR9j3yEWKP2z2Wf6CR4RvFXNcyKd3/zwYL+yGPWIIgpwmSYb2l5zEaXPGAhX7twPjvTwKAmd18zmmOn39ojsXN7GPOPBzWYjPVCrdikDY8/5+6TsoepjhN9X7FHikn+OzzCAraAsifzBVM16kD9WWMVXZDvivrSuvn0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192947; c=relaxed/simple; bh=V+wvIGsJlzSDNv4WKj3Vpj9Bw7A+dysnBkXbj7sTYeg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=FEbYHIbO/2mZ7JZdOX65gRyG+LD3XJVsQ4EiwnWtiPD8PWnfIO+yDWvLxB+4hfeODDPpern57Nbmdy+wKSTR1QXh0rZwVfkr8nteZew10aizhGqNcXscSLVUjh733BOEWAV0DBpAoCtGcMaJR11hIIHpdXU7nLTgm3B4jjoCpUM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=dPAWNcLE; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="dPAWNcLE" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3B6271F00A3D; Mon, 31 Aug 2026 16:15:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192945; bh=dtpz+uXivVuZd9+O4vrtoCG96NBwe0+gdme3nSBwjT8=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=dPAWNcLEB/2zs6KOKGIayZpyi94BLmAbozxgk/s2zHn7vVdauOopb8TVi8f7XX7oP I+9tu5AqI4guY9ixPAwO2up49m2qSt5qK/z/7PxcF243XSteyle5BNR34Mrp9JvzQR WFop7qRxn6fSWhIElwEOCdK3outHvSZjaOS79z6Sclk2l2R/c5X0+IpD1I36tn2N1a Pry8z/9cMvR8D0VO581kd/qH2Pt8u1v7lvgUv6xfSKlAawa0HGp9M4js3d+LBfYveM MD0b9tiDgxt0UL/V5V2vs1X7Sd2pXcIgLComY4q6YXQbWglAU9P/JBOKb32SSmx5VA 2JvhTQi724kWQ== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:47 -0400 Subject: [PATCH v4 05/14] NFSD: report listener creation failures through extack Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-5-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2186; i=jlayton@kernel.org; h=from:subject:message-id; bh=V+wvIGsJlzSDNv4WKj3Vpj9Bw7A+dysnBkXbj7sTYeg=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaigtuikwgoHPp+2GT66KQKU9fhVZvx1/L5Y1 YJW0W58GnGJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWooAAKCRAADmhBGVaC FVdtD/4ukyznGIh5HgV7bqjYhpKnTMbvuqwvxMVTF8H77aMg0hP/yLExQ059nT/400lCFC9AT+0 Dwe+Eva195NN4e8xdH1IhWAMO7Rpa+2EAp0S8OV7M6mIsDTpZloLxgw9LzOhZ2CILBdnMufadUP 9Kq/LRDHmmHGO4ZfJkd7DQGVv2cp0N+p5bEQWpteHvyBpPpeFdtMHx9YwpndzPf4tVT4Vfd+d9u KwHs8PFVuHst82vJpDmFgnEb2gYp/mEGqi13ckCjQRb54XXwNwBHXDJANq5tvwCkjRBa7SJ3rDJ ntYNABLDT/xRcSl1Bn5Y/FaifmMvvS2TrBNX6vCWWV9yA4VqBhkcXCbfK/ZPbGx6I5uOyoypfp9 0aobZEbOCYxR+HL0I5zU4PeWVb1VQ2EF00aLCzAdzInMLpXK5amo9XkLbZC58FcDYhnd/B0SSgd T+bGcpbcNnuKR6VR6x3hAF5glrjM7AYTvm7Lpil0XrYCMDfN4DdZo1gxZiUaPQ//7vq+FRrirnW gX7zrBpywI/UwmW0D3GlA0r+njO+B3e7q5ObwLaYWg967GNZ4W1CGRUyz6i8ZSbDKnp0c3R355A uh1nBmo1zvdXBXPHmPan5XSDUT6pRx+YRsCJUUwdQ8kQdukRUla8JSEA26MmEvM+hRsrzGPTDMG PDO2B4/2/pZ3LSw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 nfsd_nl_listener_set_doit() returns the raw errno from svc_xprt_create_from_sa() and sets no extack. A failed LISTENER_SET therefore tells userland only "Address already in use", or whatever else the transport returned. It never tells userland which entry failed. Record the attribute and the transport name of the entry whose errno the call returns, and report both after the loop. NL_SET_BAD_ATTR() names the entry, which the message alone cannot do: a request can carry several entries with the same transport name. The rejections in nfsd_nl_validate_listeners() other than -E2BIG and the unsupported transport name still carry no extack. This patch does not change them. Assisted-by: LLM Signed-off-by: Jeff Layton --- fs/nfsd/nfsctl.c | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index d8135f38e69f..6cbdcee4b733 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -2089,7 +2089,9 @@ static int nfsd_nl_validate_listeners(struct genl_inf= o *info) int nfsd_nl_listener_set_doit(struct sk_buff *skb, struct genl_info *info) { struct net *net =3D genl_info_net(info); + const struct nlattr *bad_attr =3D NULL; struct svc_xprt *xprt, *tmp; + const char *bad_xprt =3D NULL; const struct nlattr *attr; struct svc_serv *serv; LIST_HEAD(permsocks); @@ -2208,8 +2210,22 @@ int nfsd_nl_listener_set_doit(struct sk_buff *skb, s= truct genl_info *info) ret =3D svc_xprt_create_from_sa(serv, xcl_name, net, sa, 0, current_cred()); /* always save the latest error */ - if (ret < 0) + if (ret < 0) { + bad_attr =3D attr; + bad_xprt =3D xcl_name; err =3D ret; + } + } + + /* + * The ack carries the errno of the last entry that failed. Point at + * that entry as well, since several entries can share a transport + * name and the errno alone cannot tell them apart. + */ + if (err) { + NL_SET_BAD_ATTR(info->extack, bad_attr); + NL_SET_ERR_MSG_FMT(info->extack, "cannot create %s listener", + bad_xprt); } =20 if (!serv->sv_nrthreads && list_empty(&nn->nfsd_serv->sv_permsocks)) --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 CF9A34BD117; Mon, 31 Aug 2026 16:15:47 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192949; cv=none; b=HwpZK8u8brvgW0EDI2JUe66+BMlYWebXdc0Qjp2lc5MLesP3v9mill1SoYJY78u9CKwq2/vEUgYLg/n4cWgtenfoHTArYCEI5zambOjvx9es5owmwAPRdjokr9L1YTy1WfbHG3AwVN1N3i561+/HrCAuRdKE+pmFAVvtdXOgu/k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192949; c=relaxed/simple; bh=o99W7qSRRJ+Y/tsip/S0lSm28nLHZLRmUmnaqw+MiHQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=h8r1bQ5aow/O+xoCO7ACL84nChRQp5vjp4FUoldUp3CMdJpEqwGalN7BQMFo8S1rTIumR6xJ9/xESXvjY2V6r8docod6V31dgIy7H7qBmFlFEFB3He7tkjw7fM0s1Bk0RoLzkc8HV6jQYgLOdC2NJh8qoTvNUFAoEJVEry+kIMo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=bY4ta6af; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="bY4ta6af" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E06CF1F000E9; Mon, 31 Aug 2026 16:15:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192947; bh=WlCLzkBgAhOYn2skq/4EcohabDdslPnnLRHwRDovpHs=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=bY4ta6afoiMZJt88wkRhqrt6a7ucewawJrqM/85+LLGuIXtxdF9FVBZuA+R4kc566 WGDk1sa+UTbiErkNUMZ3WchDm+sFLivmlIKt52Xa5FYhQTNIAhQ2Tf59OA6e+sdeIC 7CcWqxG/+CRdY0D6RifepOKcb8GB9VtUm9+1mJ4XRP4f+jU5RUjAO96m11ypnqbEFB 7WVTZsuAWBtE3X1emFxUkgrohRWDNrheFpK4Kjfe39NoBNdazYY8sTyAaikturWuuc 5KxO57VLmdUpH2zwlZSI4tjkyNR73wAij+6BG1gN+u6yER83kPup7qtSDePwjWX/+I OhBqXcaGzLRBg== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:48 -0400 Subject: [PATCH v4 06/14] SUNRPC: report local rpcbind calls that get no answer Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-6-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=8066; i=jlayton@kernel.org; h=from:subject:message-id; bh=o99W7qSRRJ+Y/tsip/S0lSm28nLHZLRmUmnaqw+MiHQ=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaihYeB4bGwAOJ1LJcPkQPww/FxX4AhbKyhyl ueq0R0ZRr2JAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWooQAKCRAADmhBGVaC Fa4WD/9swYrd6fEZc+rVaRDuLnUvO7QsaDg+Q5jVKDX3DxdqIwOtD1+GH4NW9X/FfYNCzsBDXax tEIrbmQ97Ppq9KVSVtBI4L3SbqirWWh9+Y64W2iLfy9n6I6FA8dWF5AjJ48mFQHXIboHxHjINCi en6f1wn71CpyhDCSzupxgF37IJ5/qpkal9pObKVkfCMQs6TRupByVXH6N2d3ENtEjowGvW3TSwW GKyUYdPY2gHPb3ktfxLNIe/aDvO/nAr7ol6xl5eeIG4FL/UnIGsdleORsWPecTFV8NFeMxW8fY2 ZfYonPpcCCSFOzRKNhzsyLNcU2p+6kTKANXw0xR50TwJ7TSRusm2P5lkrahRJQ+5BjWncSfEeBE kB3r4BqedfGzmXmyvDNpxXzNzfaBlotkJ0ibj/VOn9Zjn2Mryd7Pnw3NZqwzKzouRMTLecQ/76j RltnNDnu9XxavHnegPu5JP+3PSHaUOlZhWjeyM7ATyDL/IMbgPzY0Mb52MhY7QRB1/vfwBgd7oT 3ZwbAGiuvwWvtma1Pvj/iC+Pzto3GJREM/aR2zW+z5jo9Sa/adPLoCo/bm9bzhG8wbMXCEmiSgz CJN9OOVVBtd7VBI7v99tD//zSJPQBIx4DVGxZhCGEyNX+qOtoQCeLPK5CnVdSB4/dlYd0K/G/9N 86pTtTmdjwWSDqQ== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 A caller that creates many listeners in one operation calls svc_register() once for each of them. Every call waits for the local rpcbind on its own, so a rpcbind that never answers costs the caller one timeout per listener. The caller has no way to learn that the first call already failed. Split rpcb_register_call() failures by whether rpcbind answered: - answered: a FALSE reply, or an RPC-level rejection that rpc_decode_header() derives from the reply. -EACCES (FALSE reply or AUTH_ERROR), -EPROTONOSUPPORT, -EPFNOSUPPORT, -EOPNOTSUPP. - never sent: -ENOMEM, -EMSGSIZE, -ERESTARTSYS. - no answer: everything else, i.e. transport errors. Any no-answer error gets represented by -EIO, which is already what the RPC layer reports for most of it: rpc_check_timeout() returns -EIO for a soft timeout without RPC_TASK_TIMEOUT, and call_status() documents -EIO as "shutdown or soft timeout". Keep a count of the number of rpcbind failures in the serv. Later patches will use that to watch for hard rpcbind failures, and alter their behavior accordingly. Assisted-by: LLM Signed-off-by: Jeff Layton --- include/linux/sunrpc/clnt.h | 3 ++- include/linux/sunrpc/svc.h | 7 +++++-- net/sunrpc/rpcb_clnt.c | 21 ++++++++++++++++++--- net/sunrpc/svc.c | 42 +++++++++++++++++++++++++++++++++++++++++- 4 files changed, 66 insertions(+), 7 deletions(-) diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h index 3c2b8c355ab3..30344c0d6a9d 100644 --- a/include/linux/sunrpc/clnt.h +++ b/include/linux/sunrpc/clnt.h @@ -199,7 +199,8 @@ struct rpc_xprt *rpc_task_get_xprt(struct rpc_clnt *cln= t, =20 int rpcb_create_local(struct net *); void rpcb_put_local(struct net *); -int rpcb_register(struct net *, u32, u32, int, unsigned short); +int rpcb_register(struct net *net, u32 prog, u32 vers, int prot, + unsigned short port); int rpcb_v4_register(struct net *net, const u32 program, const u32 version, const struct sockaddr *address, diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h index 2db1b9ec5658..5fa9417e034d 100644 --- a/include/linux/sunrpc/svc.h +++ b/include/linux/sunrpc/svc.h @@ -78,6 +78,7 @@ struct svc_serv { unsigned int sv_max_payload; /* datagram payload size */ unsigned int sv_max_mesg; /* max_payload + 1 page for overheads */ unsigned int sv_xdrsize; /* XDR buffer size */ + atomic_t sv_rpcb_failures; /* unanswered rpcbind calls */ struct list_head sv_permsocks; /* all permanent sockets */ struct list_head sv_tempsocks; /* all temporary sockets */ int sv_tmpcnt; /* count of temporary "valid" sockets */ @@ -451,6 +452,7 @@ int sunrpc_set_pool_mode(const char *val); int sunrpc_get_pool_mode(char *val, size_t size); void svc_rpcb_cleanup(struct svc_serv *serv, struct net *net); int svc_bind(struct svc_serv *serv, struct net *net); +unsigned int svc_rpcb_failure_count(struct svc_serv *serv); struct svc_serv *svc_create(struct svc_program *, unsigned int, int (*threadfn)(void *data)); bool svc_rqst_replace_page(struct svc_rqst *rqstp, @@ -471,8 +473,9 @@ unsigned int svc_serv_maxthreads(const struct svc_se= rv *serv); int svc_pool_stats_open(struct svc_info *si, struct file *file); void svc_process(struct svc_rqst *rqstp); void svc_process_bc(struct rpc_rqst *req, struct svc_rqst *rqstp); -int svc_register(const struct svc_serv *, struct net *, const int, - const unsigned short, const unsigned short); +int svc_register(struct svc_serv *serv, struct net *net, + const int family, const unsigned short proto, + const unsigned short port); =20 void svc_wake_up(struct svc_serv *); void svc_reserve(struct svc_rqst *rqstp, int space); diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c index 0aa376b82a52..50169ee12bd8 100644 --- a/net/sunrpc/rpcb_clnt.c +++ b/net/sunrpc/rpcb_clnt.c @@ -412,7 +412,8 @@ static struct rpc_clnt *rpcb_create(struct net *net, co= nst char *nodename, return rpc_create(&args); } =20 -static int rpcb_register_call(struct sunrpc_net *sn, struct rpc_clnt *clnt= , struct rpc_message *msg, bool is_set) +static int rpcb_register_call(struct sunrpc_net *sn, struct rpc_clnt *clnt, + struct rpc_message *msg, bool is_set) { int flags =3D RPC_TASK_NOCONNECT; int error, result =3D 0; @@ -422,8 +423,22 @@ static int rpcb_register_call(struct sunrpc_net *sn, s= truct rpc_clnt *clnt, stru msg->rpc_resp =3D &result; =20 error =3D rpc_call_sync(clnt, msg, flags); - if (error < 0) - return error; + if (error < 0) { + switch (error) { + /* rpcbind answered; the reply itself carries the error */ + case -EPROTONOSUPPORT: + case -EPFNOSUPPORT: + case -EOPNOTSUPP: + case -EACCES: + /* the call never made it onto the wire */ + case -ENOMEM: + case -EMSGSIZE: + case -ERESTARTSYS: + return error; + } + /* anything else, we assume that rpcbind isn't functional */ + return -EIO; + } =20 if (!result) return -EACCES; diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c index 4f402bbf97ba..ca6f90653327 100644 --- a/net/sunrpc/svc.c +++ b/net/sunrpc/svc.c @@ -1179,10 +1179,40 @@ int svc_generic_rpcbind_set(struct net *net, error =3D svc_rpcbind_set_version(net, progp, version, family, proto, port); =20 + /* -EIO means no answer, not a refusal, so vs_rpcb_optnl must keep it. */ + if (error =3D=3D -EIO) + return error; + return (vers->vs_rpcb_optnl) ? 0 : error; } EXPORT_SYMBOL_GPL(svc_generic_rpcbind_set); =20 +/** + * svc_rpcb_failure_count - local rpcbind calls for @serv that got no answ= er + * @serv: RPC service to query + * + * svc_register() adds one for each of its calls that got no answer. A rep= ly + * that refuses one entry does not count, because rpcbind answered and the + * next entry may still succeed. + * + * The count is kept per serv rather than per net. The local rpcbind client + * is per-net and lockd shares it, but a count that another service can mo= ve + * says nothing about this serv's own calls. + * + * This is for callers that cannot see the svc_register() return, because a + * transport class sits in between. Such a caller reads the count before it + * starts and compares as it goes, so there is no state to reset between + * operations. The count never resets, and callers must not attach meaning + * to the value itself. + * + * Return: the number of unanswered calls since this serv was created. + */ +unsigned int svc_rpcb_failure_count(struct svc_serv *serv) +{ + return atomic_read(&serv->sv_rpcb_failures); +} +EXPORT_SYMBOL_GPL(svc_rpcb_failure_count); + /** * svc_register - register an RPC service with the local portmapper * @serv: svc_serv struct for the service to register @@ -1193,10 +1223,11 @@ EXPORT_SYMBOL_GPL(svc_generic_rpcbind_set); * * Service is registered for any address in the passed-in protocol family */ -int svc_register(const struct svc_serv *serv, struct net *net, +int svc_register(struct svc_serv *serv, struct net *net, const int family, const unsigned short proto, const unsigned short port) { + bool noanswer =3D false; unsigned int p, i; int error =3D 0; =20 @@ -1208,10 +1239,16 @@ int svc_register(const struct svc_serv *serv, struc= t net *net, struct svc_program *progp =3D &serv->sv_programs[p]; =20 for (i =3D 0; i < progp->pg_nvers; i++) { + const struct svc_version *vers =3D progp->pg_vers[i]; int ret; =20 ret =3D progp->pg_rpcbind_set(net, progp, i, family, proto, port); + if (ret =3D=3D -EIO) { + noanswer =3D true; + if (vers && vers->vs_rpcb_optnl) + ret =3D 0; + } if (ret < 0) { printk(KERN_WARNING "svc: failed to register " "%sv%u RPC service (errno %d).\n", @@ -1223,6 +1260,9 @@ int svc_register(const struct svc_serv *serv, struct = net *net, } } =20 + if (noanswer) + atomic_inc(&serv->sv_rpcb_failures); + return error; } =20 --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 64C1E4CC269; Mon, 31 Aug 2026 16:15:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192950; cv=none; b=ZSnWQL7bKqH/yjyquUczYtd7QcFwe65oGoaLDgGBdFszqLdcYZHXx0AELYdHjKO8HRgMriGRdu3hpC0yhQJNvIsek6LQ64hwJfkHbah0wcuQ9rXMaQvHKV+thyDxMmbbL9XvigCinMWtiSsYyYR3eHsCK8pxIe8TqYovMjDADJA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192950; c=relaxed/simple; bh=8BqEPxMa2y9rgo4Ng7eAaQpEsvFB9iEfXzOAyL/uhig=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Sh/838wXV/CYyOugesxihuaJFpO4TE/tYWCbWVJR/Ysq0gwcYRjAQWXOdJ3QCuAkPQ8bXoDeQlXhpKytg+pSUpsDxPzqVYZISXopQVfKJWCw3MNCYsdh7dVPkUO6JJ/gNN5S06FQOOFp1jO0X7Kg1ZAczg3LijTHSAfiMbMavGo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=LSAdOfd4; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="LSAdOfd4" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 919631F00A3F; Mon, 31 Aug 2026 16:15:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192949; bh=ifq9Lngr/8+mD4QMqfJpZRugAPFghjpAp6yjOdVsVA0=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=LSAdOfd4hUN8xnnN/MBA0LCDhRfwJOUJW8hC+glODpH5HKd6SyQtMfIUzyLDD7xbG FQUVPnKqeWJtwIYEnngVbU7KVlERXcysIlu35LVg2VrJ4ig1sJYFNH5GPCi1RMAgiv 5mClqKBP99/lhWDfPD+nzcax1RTHtI7Oj6UpuuZ4Gy+sRgkgw6fkkGgCFq8ernzJnS 8vj8H/qZ8PcNwer0qte60GgzpitI3RchOSSUEZ92npqpX9JFBy69nZe2vhXjvpHYx+ WPkp3X2m00JRCUlmsavbAbyzgerX/fmYpt9SGyFtIoZrjiFBANC8s/LP+wzkFVWxFY cnLhuhNgIfmag== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:49 -0400 Subject: [PATCH v4 07/14] SUNRPC: stop svc_register() once rpcbind stops answering Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-7-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=931; i=jlayton@kernel.org; h=from:subject:message-id; bh=8BqEPxMa2y9rgo4Ng7eAaQpEsvFB9iEfXzOAyL/uhig=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaiiWxMMgCV7IlQMOBuB3P0Db+l/hnVE7SU75 0xNu8+sN6CJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWoogAKCRAADmhBGVaC FXQ7EACwuSNXhbor7Pmvw7kc3yzB8T2qBADcLXIdHGNrr45LHlSxnrV94O6R8HyTvKa8Zfkn7Fh 9pZ9AcR+NiZUEyRsjzvFTMtDpOJofkc3BE0KF+Uzn+hWGciNxpN7Cw2RXhAiKGg6QuMtwyMx/Sa Yheo+/eRCURqi12JmGNVR2K37UUOgT5LjOLeIrM0VmuGe3XpE/IXxKeHaqaxK/yq2RVLnlkrJX2 WLUALmYoB8/myMKE0YUipkMBrGZ397AtNYB97nUzwxX39T/J+kapJ/iYRW2RVW/7qy1Qvs2MF55 qNmHBPV8ZVMWCUz/3yiQPU/PzlvKsk+1VJaQ9mgJKa7UxfFrBgzt7ybCsv8XADtyLciGJDRd59m RweNDLcEp7FozGfWe8adgLlJ9NWdpkgXnrXkbTbm6WHFWHZ5l0Gna0zqMgYsaxuxHz7H1NRP3E+ R0j7cTBeoC8OE80FioSTtLOeGuwKqG0FwLeMR2tNwo9XH5QpQN9HZ+O3b0YEIG4HpwJoJEu+K8K 39Gvojr7PI/LABeP7vKm1eVyjS2kbS8EBSbBUiQeIJwbQXSmbJSUU4H+YBNx12V4m93vfHn5Btt 1gfWkdHzSTvm2I6N7jDxCR9i1obHkbt40Lulv7QEykkyERtWZt4J6TPKwuCCKNOGYAyghci+Vm2 c9bJN0S5yRkf6sQ== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 svc_register() walks every program and every version. The break on error leaves the version loop only, so a program whose call to the local rpcbind timed out is followed by the next program timing out in the same way. With the 1s bound on the local rpcbind client, an nfsd serv pays 2s for that, once for nfsd and once for nfsacl. Stop the program loop too, but only when the call got no answer. Assisted-by: LLM Signed-off-by: Jeff Layton --- net/sunrpc/svc.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c index ca6f90653327..24fd18bb8770 100644 --- a/net/sunrpc/svc.c +++ b/net/sunrpc/svc.c @@ -1258,6 +1258,10 @@ int svc_register(struct svc_serv *serv, struct net *= net, break; } } + + /* Give up on trying to register anything if it didn't respond */ + if (noanswer) + break; } =20 if (noanswer) --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 1F0C152ED47; Mon, 31 Aug 2026 16:15:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192952; cv=none; b=M/Ttggxsjk2GP42fHGUb+EoQ3uZojxjQBA4be6XTyHp1RgazgfSkXJy8nSF85FcDIVjzVh4PXw77lV+SVxQQ3OPvWBLADw10KsAq5IYbZAoETY+O6m120uLPcnTITKAduz7H+MkNoPfCXqTIArbhIrw4gS3qkW2CZ23W+u9/IUo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192952; c=relaxed/simple; bh=Vw2juZXxW1XGzKvHC8nm1c9dSoC5XkIh5qWoA10eTLw=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=M2Z7R3S92dTIXMr/WJnyuaNTtATOM2TY82l6SBw2SpYokxyhcfOXn4M+Xdi7MDDNXz6EfIYYaV2kPDsK0ZsVHUTttIEbl9eA78fgOlzQpzr1zQ6GaL6252+9k3IjjEUSX3fdZG0BTp+/vh4qtRDjIEUUQnwangEIpIo0JecAThU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=nYwnXvDe; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="nYwnXvDe" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 42C7D1F00A3E; Mon, 31 Aug 2026 16:15:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192950; bh=RdNHHoYSmK/P1zLPHbwRiPWF9TcaXaL7Lr+awobKfL8=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=nYwnXvDegk+uG59BVwZEAYSPfhyGUgpMb5M6L5MYqncBgAPhtW8YdPtBxgJbeTRdd ZAlmMB+HFDcFFqnmYu5g/LYgySUA84i1QZDMv/534IAwA+FXMujyews/pTWB8Y63+/ GJe/ctNb7N4881hThOLo/0NYLsoZWtUOb+Rke93LMkaWSadhSAkUtO194i8Auad2pi KLAk7JU7BiL1c6EIoBOdbVwvhnPGoGRH7Np0RmGP5eyZqaMwHntWCqPI+9V/eCWyp8 9aoWBlHvNHexwRe1KpfcCaXpfzvyQyNiRfXH92EsIQSlgX1Toe+hBwa117En6Y3Khc HDFjp0L3WpAtw== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:50 -0400 Subject: [PATCH v4 08/14] SUNRPC: stop the svc_unregister() sweep once rpcbind stops answering Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-8-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=1958; i=jlayton@kernel.org; h=from:subject:message-id; bh=Vw2juZXxW1XGzKvHC8nm1c9dSoC5XkIh5qWoA10eTLw=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaiiaOjU+QLp3yCH/2ydQJVR8F50jJqzsUlBU qfgLe3MpTGJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWoogAKCRAADmhBGVaC FRN3EACxNoqfr1IHfCblEgeUtzryynMs/16Jgn/qXZI8yd8nft3EXvRJ+vF6frw80WpNYU6v29I P1Vyd4N1ouVl3b9T6I6gNx1QaFIX7Tu/d2I/fx+N2rryOQjYRuDGjQAF8SJU26uO4zKb82nIXTf szDHAlYQCdQQbL2oBnPB7FtUdhRAAfq/Hq6q17747S+3slrMgxdlvg5nzk3BJMet6NrSqhoAuOt 5tmJXSH+4L4BEZv8diVdd2qXtPr0KG50DmrJraeTxMjMcNoiAyJhLl22P0p3KEekk7oRg9VSyAt uVf1sB10RoafwRG9zxlNKlmm+PP7YZEB+n1PdP1J1GYGWUkdWAZaPWzFWNng+Cpb0DIvamAUQSW EZ0GbwKxgG1W5eMU/6d/yOxseDiDlsEoES66XtO04cZXglsHNXtm8kHjATpl68ZbcDGymU6cot7 LmMfZyreDrm/riG68Xs6bIOuRABUUN4VCJovdkHQDE2fTS6400mn8+UNFxJ8A97C0fWjBTCIKa9 dQ21wNB6l+/2zhq0Zu5szzQY495ECYCUj3R47QkXfzuSAOKlb5ZNWw4TaSvMapmNdUjPIk1rs78 XwC54Mv1rADS7p9ipAnPEIE60zgrKxti+6ffoF+3UK/EHAcsjyTRHzNm+E3uG1R4t+BI54AlKNy s8Y++tyOHZRlHww== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 svc_unregister() clears the rpcbind entry for every non-hidden program and version. svc_rpcb_setup() runs it to drop stale entries when a serv binds, and svc_rpcb_cleanup() runs it when one goes away. An nfsd serv with v3 and v4 enabled sweeps four or five entries, so a local rpcbind that never replies costs that many timeouts, twice per NFSD_CMD_LISTENER_SET, all under nfsd_mutex. Give up after the first call that gets no answer. Assisted-by: LLM Signed-off-by: Jeff Layton --- net/sunrpc/svc.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c index 24fd18bb8770..c00ae00b6a12 100644 --- a/net/sunrpc/svc.c +++ b/net/sunrpc/svc.c @@ -1277,8 +1277,8 @@ int svc_register(struct svc_serv *serv, struct net *n= et, * any "inet6" entries anyway. So a PMAP_UNSET should be sufficient * in this case to clear all existing entries for [program, version]. */ -static void __svc_unregister(struct net *net, const u32 program, const u32= version, - const char *progname) +static int __svc_unregister(struct net *net, const u32 program, const u32 = version, + const char *progname) { int error; =20 @@ -1292,6 +1292,7 @@ static void __svc_unregister(struct net *net, const u= 32 program, const u32 versi error =3D rpcb_register(net, program, version, 0, 0); =20 trace_svc_unregister(progname, version, error); + return error; } =20 /* @@ -1318,10 +1319,13 @@ static void svc_unregister(const struct svc_serv *s= erv, struct net *net) continue; if (progp->pg_vers[i]->vs_hidden) continue; - __svc_unregister(net, progp->pg_prog, i, progp->pg_name); + if (__svc_unregister(net, progp->pg_prog, i, + progp->pg_name) =3D=3D -EIO) + goto out; } } =20 +out: rcu_read_lock(); sighand =3D rcu_dereference(current->sighand); spin_lock_irqsave(&sighand->siglock, flags); --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 7AAA0550DA4; Mon, 31 Aug 2026 16:15:52 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192954; cv=none; b=bTCFckRzpqnBgqyRw0oROgsupeXW5o2ohaA86PWoEuqjieuESn1AA47mqFhQWiegzhoClu7ZODcRqO5aKzenZJSJDKnXX2beUAPbzxFUKgRDFSqxE8tNtRjid8XcioMDe4RcNBravm2Gh6hzdS0W+1qTVIfuPLw9sI9hBy80AwY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192954; c=relaxed/simple; bh=FKA2BkMlz5ELGl32gDJPPbAwvFf5JVXLuMfqgnUQM9U=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Xsi+h/0K9SSq9hbdJndmIzktt5BDfMY79epp9uysl10O6bbQfMU6nHd8tcLySkAmiXlMpU2ENaeAGFNvVW3p2I9e2OJxmHDswI4XMx0xab1zt+fj6NQ8BM+atBSnyym7/Rpzeg7UBJ6bg8HVgNPAjEa3Pu9ibDaehcEyoxWfzLM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=biNYiHdb; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="biNYiHdb" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E64FF1F000E9; Mon, 31 Aug 2026 16:15:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192952; bh=ockaZEjuUu+8Z8u8Q0PDF9tkO0ak/zH6aUQtKJaJl5Q=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=biNYiHdbdgMbhjVFrV1bJnvmPqnUXYQWX0oJ+16SWn4zHA/7w6x8oZsmH6FyBgjbI 0sxlVy2lhG+1U4DHHo6BPCUnq60PdsM74iySwbWnurS/NA+6lYi3W8iFLmbBxhrixO VSKVO56HPuqatyKCbuu5NaSr4wgspf4JsgsDTwTbRl456YTOYw5nJmjOqaM6CL1y2E eLL/nmTMNAdlJ0vUUc+JGAAxKxp15Im9TSW4FHgMr+YGIc4P0eKzXVGShZdW5/3BaX 5V4N2Kj97gli6A6NuqbB2JqBNoPeLG1T8FZEFYuhikjctZ7sAXla0MJNb9ND11vkFj 4r7JDmq9+tI+A== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:51 -0400 Subject: [PATCH v4 09/14] SUNRPC: stop unregistering listeners once rpcbind stops answering Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-9-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2044; i=jlayton@kernel.org; h=from:subject:message-id; bh=FKA2BkMlz5ELGl32gDJPPbAwvFf5JVXLuMfqgnUQM9U=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaijZKWaoLymbn17HCs3riwAw/Q5gs0L7Ow8t KSwKt1m/vKJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWoowAKCRAADmhBGVaC FUnID/9Oj3VQce6hrCQ3f+X7W92g9fuGHVHJ+qqG/6ndJv7AxTGQuJWPTRC3cdb0ZZB+6INe9NF ri0vt1PvUq5tWeyOvCaA1FfTrtrXucS8IJi4lzSIv9WuCHiZI4csXP6gxKuqsIcWMuCzqm474ks RQmS+Uq2gqR0Zy7p4M6Ay7+5ifddBCrPkyukqo8k3HWivnDDNF+NZMsVK4T+mfZ+abnc6yPBuBf y4Qg1hwgKStZLUMUkdAJrM8hkazQ3eL+AceKbyEcvy1zy1z59Tn1Iucbv4tqmR14bCKQDC9HKfv gq00oMGdooA4+SzNhiOAZe+NjHxnSrYk82YHh8D3S3kAzS6ArKlGyVdZS0VY/am54isLuyZJcMM ai4Na5K6qOutMJgfsZv/pELzKdVzc5IXoqhXXiuesDQto/SOXHzExf+/Ih+Zs/tdXf9zRIVN9tN N1S4Nps6P3qodgjlxrqApX174OoBKZM59UUZpI/yH/giod585mEsl5Y/SIm1lcSVUQkSEd/GPYg Yd9x2iid16Sl0iWm5/xuDLmuZyqeQjqkghI5ID1ZGHSemWAtugqUufqL4mzPseLDx2573TIaV2r /7d0fKJBhFhgVTl/eJ4QtJB7VoGTB36jjxras7pwS1LZjcVjJ4PmaRmezslKCMGEkEf0RaW++CX UDh8MvnEn9Oa2Bw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 svc_delete_xprt() unregisters each listener it destroys. One NFSD_CMD_LISTENER_SET that removes listeners therefore pays one local rpcbind timeout for each of them, under nfsd_mutex, on top of the one the create loop already bounds. One failure is enough to know that the rest of the teardown will not fare better. When the call gets no answer, clear XPT_RPCB_UNREG on every remaining transport in the same net. Assisted-by: LLM Signed-off-by: Jeff Layton --- net/sunrpc/svc_xprt.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c index 40040af588fb..7e471c92f23a 100644 --- a/net/sunrpc/svc_xprt.c +++ b/net/sunrpc/svc_xprt.c @@ -1101,6 +1101,22 @@ static void call_xpt_users(struct svc_xprt *xprt) spin_unlock(&xprt->xpt_lock); } =20 +/* + * If rpcbind stops answering, every listener still to be destroyed would + * only wait out the same timeout again. Drop the flag on all of the + * remaining listeners. + */ +static void svc_xprt_clear_rpcb_unreg(struct svc_serv *serv, struct net *n= et) +{ + struct svc_xprt *xprt; + + spin_lock_bh(&serv->sv_lock); + list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) + if (xprt->xpt_net =3D=3D net) + clear_bit(XPT_RPCB_UNREG, &xprt->xpt_flags); + spin_unlock_bh(&serv->sv_lock); +} + /* * Remove a dead transport */ @@ -1115,11 +1131,15 @@ static void svc_delete_xprt(struct svc_xprt *xprt) struct svc_sock *svsk =3D container_of(xprt, struct svc_sock, sk_xprt); struct socket *sock =3D svsk->sk_sock; + unsigned int failures =3D svc_rpcb_failure_count(serv); =20 if (svc_register(serv, xprt->xpt_net, sock->sk->sk_family, sock->sk->sk_protocol, 0) < 0) pr_warn("failed to unregister %s with rpcbind\n", xprt->xpt_class->xcl_name); + + if (svc_rpcb_failure_count(serv) !=3D failures) + svc_xprt_clear_rpcb_unreg(serv, xprt->xpt_net); } =20 if (test_and_set_bit(XPT_DEAD, &xprt->xpt_flags)) --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 7F578550DDA; Mon, 31 Aug 2026 16:15:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192955; cv=none; b=N0CunRwxNOrwEmsA62/llvwy2ksxeeiocmQ1vXso8BHhZUrUWEbfRb6HNTgqc/5x5oD2ikhXzNLoS5I3Mp2K4Q6/JmUDRV2oDs4HdGIXEhddJHn5x2bz7ISiMmzxQgjc8Ajp//1b5mj1rg+wLY/y9cg/5OXXUA8lepClfzhoAlc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192955; c=relaxed/simple; bh=SM2OWu0XleC4V96J3z4sUV5Kxnkpd0r1e2rH1vibgkM=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=NGxJaR0IEiifa4JZEy2ZMDdJtU5njNpE2EiQBkYzL6g1Zk2sjFiUVtk45gd4w4khBIWDrg3kF5muHIAefwoBaQCOZQprmOuvicehjkPbY5or6T4J7aA53relNf3XsVewUmA1NlJiN/+PiguHrUVgoAwgPGBMAqTApHF15cExLUk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=fwgWil/u; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="fwgWil/u" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 974FE1F00A3E; Mon, 31 Aug 2026 16:15:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192954; bh=l3TJj1IX1HGJ6W0nzGDz0cyAW5MqVKBuV0o+O9iQ0hc=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=fwgWil/uXxR+/S3jSu34sjWlYb0l5BDlEOdaz3YoyscRflcvp9titEx9DOR7grorE xSl4A+AS5KTFndvkdewux7XWcS2IWKsRdlnKsTzAZvuCBEQf9VBjpzRD4FkFI3FMD0 ghb7yWZ5E9Iooju6dOkzu4pVFZ5Pu1/s76TmgzyahfeZSmcO65qL13oKgf0KkjYY49 kKh3rVOb2eKXsMo07Deb0uC8/TQMPx2uXcNekK+Y+tNtuL+fV6AooJYsS+pjwoIo4Y I3UBCekY32qwYmNqxqjD7YLGk92q2FAZTHyCkiFXV8r8Ed1wW7lKwaeJY9Xvqe9fRE u49Z8tXfViB4w== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:52 -0400 Subject: [PATCH v4 10/14] NFSD: stop registering with rpcbind after a failure in listener_set Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-10-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=3554; i=jlayton@kernel.org; h=from:subject:message-id; bh=SM2OWu0XleC4V96J3z4sUV5Kxnkpd0r1e2rH1vibgkM=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaik2cLP0QIoCX8xMhRugEP5bcqI8NQHwBqJD 2ifud/oaXGJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWopAAKCRAADmhBGVaC FbHqD/4n8xtKqxf+Jrm+xW5wAD4L8iZtiqwD6FUrIjN0Zo33HX8pI+kRYNQL0JNQM8NSP4yyhk+ soE/gRW72iqlRh2r1gw0kUkGQgWNA+jTe69QEgTnKV1yL3m9dGfCtnpRJa2FNsa9mx5KMzVz7jJ ZNB0otZlK2qZaiX1u4MWhqpq6qFSLaynws+IeNCRHW1m+LoU85olYwFedjfuSrJZniUDZOj0u1l iV/EQFjTpSTvq5toKQBX0QUMzLp1uN/eDnuhBJAyyAncsfOMg0OO9TsU0uoV/8oN7XmDp/qKK8S L/e2PZV2PYlGdsdl/7aR2C3MyxCM+a5WRuut6HDG3wymtiudusczR+5gRex7b4uD5LEYG+Rvr5l A/eqQKMWJi53Z+YPGhe2mLuCBZAWIGVhY05IF5DC3ZdXWe20J+zjf1lSCTRAUsVcR7iddUz4gOY NuNJx+gVDeiLE9EF0bhCXGnnyozmGDcmiq7ZoPkQYChsxgOQKGmnITjxoA1koQs2oNP1FU4pbQB LVyH/YoW70RvZSFWEv5dQUfcK97xSH6cWq7fG1wD727ao7DzoYO9s3jgyugrryTONnvzrT51RBX HmWdkUitjPnLB7KDQf5DZGpEHgipdFyZEeHKOvua62lsERmxVVNQOcF2zH0FUsouEVAJnW6V/ci iwdwC7tildwEhuQ== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 nfsd_nl_listener_set_doit() calls svc_xprt_create_from_sa() once for each requested listener and passes flags of 0, so every listener registers with rpcbind on its own. A rpcbind that accepts the connection and never replies therefore costs one timeout for each entry. With the cap of 1024 entries the request can hold nfsd_mutex for about 34 minutes, which is roughly 17 times the hung-task threshold. One failure is enough to know that the next call will not fare better. Read svc_rpcb_failure_count() before the create loop, and pass SVC_SOCK_ANONYMOUS for the rest of the request once the count moves. Fixes: 16a471177496 ("NFSD: add listener-{set,get} netlink command") Assisted-by: LLM Link: https://syzkaller.appspot.com/bug?extid=3Dc7eae0eb80858a2dba0f Suggested-by: Olga Kornievskaia Signed-off-by: Jeff Layton --- fs/nfsd/nfsctl.c | 33 +++++++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-) diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index 6cbdcee4b733..2256c53277b8 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -2092,7 +2092,9 @@ int nfsd_nl_listener_set_doit(struct sk_buff *skb, st= ruct genl_info *info) const struct nlattr *bad_attr =3D NULL; struct svc_xprt *xprt, *tmp; const char *bad_xprt =3D NULL; + unsigned int rpcb_failures; const struct nlattr *attr; + bool skipped_rpcb =3D false; struct svc_serv *serv; LIST_HEAD(permsocks); struct nfsd_net *nn; @@ -2182,13 +2184,15 @@ int nfsd_nl_listener_set_doit(struct sk_buff *skb, = struct genl_info *info) if (delete) svc_xprt_destroy_all(serv, net, false); =20 + rpcb_failures =3D svc_rpcb_failure_count(serv); + /* walk list of addrs again, open any that still don't exist */ nlmsg_for_each_attr_type(attr, NFSD_A_SERVER_SOCK_ADDR, info->nlhdr, GENL_HDRLEN, rem) { struct nlattr *tb[NFSD_A_SOCK_MAX + 1]; const char *xcl_name; struct sockaddr *sa; - int ret; + int flags, ret; =20 /* validated up front in nfsd_nl_validate_listeners() */ if (nla_parse_nested(tb, NFSD_A_SOCK_MAX, attr, @@ -2207,8 +2211,20 @@ int nfsd_nl_listener_set_doit(struct sk_buff *skb, s= truct genl_info *info) continue; } =20 - ret =3D svc_xprt_create_from_sa(serv, xcl_name, net, sa, 0, + flags =3D skipped_rpcb ? SVC_SOCK_ANONYMOUS : 0; + ret =3D svc_xprt_create_from_sa(serv, xcl_name, net, sa, flags, current_cred()); + + if (!skipped_rpcb && + svc_rpcb_failure_count(serv) !=3D rpcb_failures) { + skipped_rpcb =3D true; + if (ret < 0) + ret =3D svc_xprt_create_from_sa(serv, xcl_name, + net, sa, + SVC_SOCK_ANONYMOUS, + current_cred()); + } + /* always save the latest error */ if (ret < 0) { bad_attr =3D attr; @@ -2224,8 +2240,17 @@ int nfsd_nl_listener_set_doit(struct sk_buff *skb, s= truct genl_info *info) */ if (err) { NL_SET_BAD_ATTR(info->extack, bad_attr); - NL_SET_ERR_MSG_FMT(info->extack, "cannot create %s listener", - bad_xprt); + if (skipped_rpcb) + NL_SET_ERR_MSG_FMT(info->extack, + "cannot create %s listener; rpcbind did not answer", + bad_xprt); + else + NL_SET_ERR_MSG_FMT(info->extack, + "cannot create %s listener", + bad_xprt); + } else if (skipped_rpcb) { + NL_SET_ERR_MSG(info->extack, + "rpcbind did not answer, some listeners are not registered"); } =20 if (!serv->sv_nrthreads && list_empty(&nn->nfsd_serv->sv_permsocks)) --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 D219A551995; Mon, 31 Aug 2026 16:15:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192957; cv=none; b=EHfLmD9caZJwqw58Mjd+goAsTuW76Z82rdYm8QBJVRd7s/n/iy5lA3zJ/4oDIIYe/hehDx1JDpI///6v3kUb/4fR1/m5dZepnSYgCyRHAOQXtxV8YJDPQoOVnTutTbqLOUBjbuHg3UQuASqfMlf/q4rEBjIMZKgyFol8JvO2OQY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192957; c=relaxed/simple; bh=qKb2bweuqy9GehslCZtN22n6bjX8AkfXkJJ9gCHcsS8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=thnl0X+CfO0KZGUVZqurB1xOpYZKM+fGlrF9CybUgbXdcd9zc47zOdEsUfR13uerlB1qUV7j2BW0OaRJg+w6twZsUhI7NDrx11cLgffGKwEiVNz9qWFPQMSzzVmhYWg/fSdYwGwP3zlAugf7km5f9WnPQDtHnhlMwuKo1UEZiv0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=TEceLQR8; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="TEceLQR8" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 493161F000E9; Mon, 31 Aug 2026 16:15:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192955; bh=Ww9aE1CgZAnMjvFIp83svlEAgt5oJyxEdaaWiGYit60=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=TEceLQR81OWVT38JuxxYlL5sDNp14UZKh4LZI6C8cmTtq6FpNPHh3kh6YTWnGevVW a7eAUdEqHhLcx8yZbexOfc9lOZEVbbx6aBynvxAApC1ssg5rl38ZO7WzjWlvZQrw+b TZeRV8inchWSjtreS/6j4U+JrsuTw7ok+7dSKVjFCJTji69GiUHn7jP8eRjFiAOk4T QGvcIpKQGWaWJ5TzKcdBMHjLSsv42OBvKN63FfFig9LsCLg8CSCOXWdmO2Yf4cGWJ9 isXNFtD8h5SMU58iKZXCtq6p6Mu2vlASKCmM6aK329EfUu2vv1CXjR0t3AdLvgWRcR ya0bk6apdZZuA== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:53 -0400 Subject: [PATCH v4 11/14] selftests/nfsd: exercise listener_set request validation Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-11-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=19166; i=jlayton@kernel.org; h=from:subject:message-id; bh=qKb2bweuqy9GehslCZtN22n6bjX8AkfXkJJ9gCHcsS8=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaikY7NfdxLTdClAGfstCqosT/OcdqstrLAXk k36oMAE0SuJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWopAAKCRAADmhBGVaC FQBQD/4kPrLwSU89GObFOK8/QdNOU3vIEvfMUrC/sOCROobfysrbkdMV1rNz8l0UwaAHFGK86VZ 5dJ0/TOd81XnYSkWGM1VOrn8YZnFtIH81T73sO4IeeGBp31sX6IAF6yZqFQEZOg4RkngNRXseUu mYzviZfpxlFn/hAxxZckkycooWbLjSghivB+15JWh+Cm4R/pO5rqrNzb5+kBJQfcd88+Z+tkuSp 0CY7gpHeCNEWKyDLnBfTrBnPPjij4VVx/UPHBX4eaWY3oif9+yGM2jtytXiUnl6P9V7ZYsMt2jt t6sORsOvwu7L+Oq0y1DKJdekXbmHSwNhDdFLC600+hK1THx+mv6woSE0LdVLKMcuex/I1Y3/mB/ C2UwwtnxI0zSW5G/PlfuTuepCzplTBaUFLyPm3uCbMQp9pnXyrkyrQfL5ayqFXFiX9h7gKlP8LG Jbnosk30+xeZM1qn+xneLMf46auKR1YoJZXtnH0IitaFZ9B9OFYKN1PIYfNk9UupJ51DXuBPXRf pwqOzXAHxzTkcBpeQx2nQwsnH1qk65AWCnK/w1d3GaelLj0o8/ZzfknLdgzl+CjafwrzMmpB5UY gnSZ/Jl+RwooR/vjfhbYXSg/ZudB2u1bNDqkkxTlPEo/68yRQsB4hq2GAVDd54cWKS8Dv0uSADl EeopfehoZ6fWuog== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 Add regression tests for the NFSD_CMD_LISTENER_SET checks that nfsd_nl_validate_listeners() runs before the code takes nfsd_mutex. The tests cover a bad transport name, an absent transport name, a missing address, a truncated or unsupported sockaddr, a bad address family, a malformed entry behind a well-formed one, and more than NFSD_NL_LISTENER_MAX entries. One more test sends a LISTENER_GET to an empty netns. None of these requests reach nfsd_create_serv(), so nothing here creates a serv or registers with rpcbind. The tests that do need a serv come next, with a stub. The tests use kselftest_harness.h, so each test runs in its own net and mount namespace. /run is masked there. unix_find_bsd() resolves by inode and takes no struct net, so a connect to "/var/run/rpcbind.sock" from this netns would otherwise reach the rpcbind on the host. svc_rpcb_setup() opens with a call to svc_unregister(), which would then clear the host's nfsd registrations. The config fragment must therefore cover the fixture as well as nfsd: NAMESPACES and NET_NS for the unshare(), SHMEM and TMPFS for the mask, and UNIX for the AF_LOCAL rpcbind client. Without them, every test skips. Add the new directory to the NFSD MAINTAINERS entry, which does not cover tools/testing/selftests/ today. Assisted-by: LLM Signed-off-by: Jeff Layton --- MAINTAINERS | 1 + tools/testing/selftests/Makefile | 1 + tools/testing/selftests/nfsd/.gitignore | 1 + tools/testing/selftests/nfsd/Makefile | 6 + tools/testing/selftests/nfsd/config | 8 + .../testing/selftests/nfsd/nfsd_netlink_listener.c | 488 +++++++++++++++++= ++++ tools/testing/selftests/nfsd/settings | 1 + 7 files changed, 506 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index be63cb3844db..9d97df56cad6 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -14163,6 +14163,7 @@ F: include/uapi/linux/nfsd/ F: include/uapi/linux/sunrpc/ F: net/sunrpc/ F: tools/net/sunrpc/ +F: tools/testing/selftests/nfsd/ =20 KERNEL NFSD BLOCK and SCSI LAYOUT DRIVER R: Christoph Hellwig diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Mak= efile index c62642302c84..edaf3c932011 100644 --- a/tools/testing/selftests/Makefile +++ b/tools/testing/selftests/Makefile @@ -89,6 +89,7 @@ TARGETS +=3D net/packetdrill TARGETS +=3D net/ppp TARGETS +=3D net/rds TARGETS +=3D net/tcp_ao +TARGETS +=3D nfsd TARGETS +=3D nolibc TARGETS +=3D pci_endpoint TARGETS +=3D pcie_bwctrl diff --git a/tools/testing/selftests/nfsd/.gitignore b/tools/testing/selfte= sts/nfsd/.gitignore new file mode 100644 index 000000000000..19e6dec04d8e --- /dev/null +++ b/tools/testing/selftests/nfsd/.gitignore @@ -0,0 +1 @@ +nfsd_netlink_listener diff --git a/tools/testing/selftests/nfsd/Makefile b/tools/testing/selftest= s/nfsd/Makefile new file mode 100644 index 000000000000..15ac65549d25 --- /dev/null +++ b/tools/testing/selftests/nfsd/Makefile @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0 +CFLAGS +=3D $(KHDR_INCLUDES) -Wall + +TEST_GEN_PROGS :=3D nfsd_netlink_listener + +include ../lib.mk diff --git a/tools/testing/selftests/nfsd/config b/tools/testing/selftests/= nfsd/config new file mode 100644 index 000000000000..ab84523fbedf --- /dev/null +++ b/tools/testing/selftests/nfsd/config @@ -0,0 +1,8 @@ +CONFIG_NAMESPACES=3Dy +CONFIG_NET_NS=3Dy +CONFIG_SHMEM=3Dy +CONFIG_TMPFS=3Dy +CONFIG_UNIX=3Dy +CONFIG_IPV6=3Dy +CONFIG_NFSD=3Dy +CONFIG_NFSD_V4=3Dy diff --git a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c b/tools/t= esting/selftests/nfsd/nfsd_netlink_listener.c new file mode 100644 index 000000000000..ae28c224255f --- /dev/null +++ b/tools/testing/selftests/nfsd/nfsd_netlink_listener.c @@ -0,0 +1,488 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Regression tests for the NFSD generic-netlink listener interface + * (NFSD_CMD_LISTENER_SET / NFSD_CMD_LISTENER_GET). + * + * These cover the request validation that nfsd_nl_validate_listeners() do= es + * before nfsd_mutex is taken: bad or absent transport name, missing addre= ss, + * truncated or unsupported sockaddr, oversized list. None of them reach + * nfsd_create_serv(), so nothing here creates a serv or talks to rpcbind. + * + * Each test runs in its own private net + mount namespace (unshare in + * FIXTURE_SETUP). /run is masked there: a pathname AF_LOCAL connect is not + * scoped by the network namespace, since unix_find_bsd() resolves by inode + * and takes no struct net, so the kernel's rpcbind client would otherwise= be + * able to reach the rpcbind running on the host. + */ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../kselftest_harness.h" + +/* NFSD generic-netlink constants (from linux/nfsd_netlink.h). */ +#define NFSD_FAMILY_NAME "nfsd" +#define NFSD_CMD_LISTENER_SET 6 +#define NFSD_CMD_LISTENER_GET 7 +#define NFSD_A_SERVER_SOCK_ADDR 1 /* per-listener nest */ +#define NFSD_A_SOCK_ADDR 1 /* inside the nest */ +#define NFSD_A_SOCK_TRANSPORT_NAME 2 /* inside the nest */ + +#define NLA_ALIGN4(len) (((len) + 3) & ~3) +#define TEST_PORT 20049 +#define MAX_LISTENERS 8 +#define RECV_TIMEO_SEC 30 + +static int nfsd_family; /* set per-test in FIXTURE_SETUP */ + +static void die(const char *msg) +{ + perror(msg); + exit(1); +} + +/* ------------------- minimal generic-netlink plumbing ------------------= - */ + +static int genl_open(void) +{ + struct sockaddr_nl sa =3D { .nl_family =3D AF_NETLINK }; + struct timeval tv =3D { .tv_sec =3D RECV_TIMEO_SEC }; + int fd =3D socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); + + if (fd < 0) + die("socket(NETLINK_GENERIC)"); + if (bind(fd, (void *)&sa, sizeof(sa)) < 0) + die("bind(netlink)"); + setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + return fd; +} + +/* Append an attribute at @off; return the new (aligned) offset. */ +static int put_attr(char *buf, int off, uint16_t type, + const void *data, int len) +{ + struct nlattr *na =3D (void *)(buf + off); + + na->nla_type =3D type; + na->nla_len =3D NLA_HDRLEN + len; + if (len) + memcpy(buf + off + NLA_HDRLEN, data, len); + return off + NLA_ALIGN4(NLA_HDRLEN + len); +} + +/* Build a genl message header into @buf; return the offset past it. */ +static int genl_hdr(char *buf, uint16_t type, uint16_t flags, uint8_t cmd) +{ + struct nlmsghdr *nlh =3D (void *)buf; + struct genlmsghdr *gnl =3D (void *)(buf + NLMSG_HDRLEN); + + memset(buf, 0, NLMSG_HDRLEN + GENL_HDRLEN); + nlh->nlmsg_type =3D type; + nlh->nlmsg_flags =3D flags; + nlh->nlmsg_seq =3D 1; + gnl->cmd =3D cmd; + gnl->version =3D 1; + return NLMSG_HDRLEN + GENL_HDRLEN; +} + +/* Send an nfsd command with an ACK; return the ACK errno (<=3D 0). */ +static int genl_request(uint8_t cmd, const char *attrs, int attrs_len) +{ + char buf[1 << 20], rbuf[4096]; + struct nlmsghdr *nlh =3D (void *)buf; + int fd =3D genl_open(); + int off, n, ret; + + off =3D genl_hdr(buf, nfsd_family, NLM_F_REQUEST | NLM_F_ACK, cmd); + if (attrs_len) { + memcpy(buf + off, attrs, attrs_len); + off +=3D attrs_len; + } + nlh->nlmsg_len =3D off; + + if (send(fd, buf, off, 0) < 0) + die("send(genl)"); + + n =3D recv(fd, rbuf, sizeof(rbuf), 0); + if (n < 0) + ret =3D (errno =3D=3D EAGAIN || errno =3D=3D EWOULDBLOCK) ? -ETIMEDOUT := -errno; + else if (((struct nlmsghdr *)rbuf)->nlmsg_type =3D=3D NLMSG_ERROR) + ret =3D ((struct nlmsgerr *)NLMSG_DATA(rbuf))->error; + else + ret =3D 0; + close(fd); + return ret; +} + +/* Send a command and return the full reply message; -errno on failure. */ +static int genl_request_reply(uint8_t cmd, char *rbuf, size_t rlen) +{ + char buf[256]; + struct nlmsghdr *nlh =3D (void *)buf; + int fd =3D genl_open(); + int off, n, ret; + + off =3D genl_hdr(buf, nfsd_family, NLM_F_REQUEST, cmd); + nlh->nlmsg_len =3D off; + + if (send(fd, buf, off, 0) < 0) + die("send(genl reply)"); + + n =3D recv(fd, rbuf, rlen, 0); + if (n < 0) + ret =3D (errno =3D=3D EAGAIN || errno =3D=3D EWOULDBLOCK) ? -ETIMEDOUT := -errno; + else if (((struct nlmsghdr *)rbuf)->nlmsg_type =3D=3D NLMSG_ERROR) + ret =3D ((struct nlmsgerr *)NLMSG_DATA(rbuf))->error; + else + ret =3D n; + close(fd); + return ret; +} + +/* Resolve the "nfsd" genl family id; -1 if not registered. */ +static int genl_resolve_nfsd(void) +{ + char buf[1024], rbuf[4096]; + struct nlmsghdr *nlh =3D (void *)buf; + struct nlmsghdr *rh =3D (void *)rbuf; + struct nlattr *na; + int fd, off, left, id =3D -1; + + fd =3D genl_open(); + off =3D genl_hdr(buf, GENL_ID_CTRL, NLM_F_REQUEST, CTRL_CMD_GETFAMILY); + off =3D put_attr(buf, off, CTRL_ATTR_FAMILY_NAME, + NFSD_FAMILY_NAME, sizeof(NFSD_FAMILY_NAME)); + nlh->nlmsg_len =3D off; + + if (send(fd, buf, off, 0) < 0) + die("send(GETFAMILY)"); + if (recv(fd, rbuf, sizeof(rbuf), 0) < 0) + die("recv(GETFAMILY)"); + close(fd); + + if (rh->nlmsg_type =3D=3D NLMSG_ERROR) + return -1; + + na =3D (void *)((char *)NLMSG_DATA(rh) + GENL_HDRLEN); + left =3D rh->nlmsg_len - NLMSG_HDRLEN - GENL_HDRLEN; + while (left >=3D (int)NLA_HDRLEN) { + if (na->nla_type =3D=3D CTRL_ATTR_FAMILY_ID) { + id =3D *(uint16_t *)((char *)na + NLA_HDRLEN); + break; + } + left -=3D NLA_ALIGN4(na->nla_len); + na =3D (void *)((char *)na + NLA_ALIGN4(na->nla_len)); + } + return id; +} + +/* ------------------- listener request builders ------------------- */ + +/* Fine-grained control for negative tests: any field can be omitted/malfo= rmed. */ +struct raw_listener { + const char *xprt; /* NULL -> omit NFSD_A_SOCK_TRANSPORT_NAME */ + int emit_addr; /* 0 -> omit NFSD_A_SOCK_ADDR */ + const void *addr; + int addr_len; /* bytes to emit for NFSD_A_SOCK_ADDR */ +}; + +static int put_raw_listener(char *buf, int off, const struct raw_listener = *r) +{ + struct nlattr *nest =3D (void *)(buf + off); + int inner =3D off + NLA_HDRLEN; + + if (r->emit_addr) + inner =3D put_attr(buf, inner, NFSD_A_SOCK_ADDR, r->addr, r->addr_len); + if (r->xprt) + inner =3D put_attr(buf, inner, NFSD_A_SOCK_TRANSPORT_NAME, + r->xprt, strlen(r->xprt) + 1); + nest->nla_type =3D NFSD_A_SERVER_SOCK_ADDR | NLA_F_NESTED; + nest->nla_len =3D inner - off; + return off + NLA_ALIGN4(nest->nla_len); +} + +/* Well-formed loopback listener for @family (AF_INET or AF_INET6). */ +static int put_listener_af(char *buf, int off, const char *xprt, int famil= y, + uint16_t port) +{ + struct sockaddr_storage ss =3D {0}; + struct raw_listener r =3D { .xprt =3D xprt, .emit_addr =3D 1, .addr =3D &= ss }; + + if (family =3D=3D AF_INET6) { + struct sockaddr_in6 *s6 =3D (void *)&ss; + + s6->sin6_family =3D AF_INET6; + s6->sin6_port =3D htons(port); + s6->sin6_addr =3D in6addr_loopback; + r.addr_len =3D sizeof(*s6); + } else { + struct sockaddr_in *s4 =3D (void *)&ss; + + s4->sin_family =3D AF_INET; + s4->sin_port =3D htons(port); + s4->sin_addr.s_addr =3D htonl(INADDR_LOOPBACK); + r.addr_len =3D sizeof(*s4); + } + return put_raw_listener(buf, off, &r); +} + +static int put_listener(char *buf, int off, const char *xprt, uint16_t por= t) +{ + return put_listener_af(buf, off, xprt, AF_INET, port); +} + +/* ------------------- LISTENER_GET parsing ------------------- */ + +struct listener_ent { + char xprt[16]; + int family; + uint16_t port; + struct in_addr a4; + struct in6_addr a6; +}; + +static int parse_listener_get(const char *rbuf, int len, + struct listener_ent *out, int max) +{ + const struct nlmsghdr *nlh =3D (const void *)rbuf; + const struct nlattr *na; + int left, count =3D 0; + + (void)len; + na =3D (const void *)(rbuf + NLMSG_HDRLEN + GENL_HDRLEN); + left =3D nlh->nlmsg_len - NLMSG_HDRLEN - GENL_HDRLEN; + + while (left >=3D (int)NLA_HDRLEN) { + int alen =3D na->nla_len; + + if ((na->nla_type & NLA_TYPE_MASK) =3D=3D NFSD_A_SERVER_SOCK_ADDR && + count < max) { + const struct nlattr *in =3D (const void *)((char *)na + NLA_HDRLEN); + int ileft =3D alen - NLA_HDRLEN; + struct listener_ent *e =3D &out[count]; + + memset(e, 0, sizeof(*e)); + while (ileft >=3D (int)NLA_HDRLEN) { + const void *d =3D (const char *)in + NLA_HDRLEN; + int t =3D in->nla_type & NLA_TYPE_MASK; + + if (t =3D=3D NFSD_A_SOCK_TRANSPORT_NAME) { + strncpy(e->xprt, d, sizeof(e->xprt) - 1); + } else if (t =3D=3D NFSD_A_SOCK_ADDR) { + const struct sockaddr_storage *ss =3D d; + + e->family =3D ss->ss_family; + if (ss->ss_family =3D=3D AF_INET) { + const struct sockaddr_in *s =3D d; + + e->a4 =3D s->sin_addr; + e->port =3D ntohs(s->sin_port); + } else if (ss->ss_family =3D=3D AF_INET6) { + const struct sockaddr_in6 *s =3D d; + + e->a6 =3D s->sin6_addr; + e->port =3D ntohs(s->sin6_port); + } + } + ileft -=3D NLA_ALIGN4(in->nla_len); + in =3D (const void *)((char *)in + NLA_ALIGN4(in->nla_len)); + } + count++; + } + left -=3D NLA_ALIGN4(alen); + na =3D (const void *)((char *)na + NLA_ALIGN4(alen)); + } + return count; +} + +/* ------------------- convenience wrappers ------------------- */ + +static int listener_set(const char *attrs, int len) +{ + return genl_request(NFSD_CMD_LISTENER_SET, attrs, len); +} + +/* Fetch the current listeners; returns count (>=3D0) or -errno. */ +static int listener_get(struct listener_ent *out, int max) +{ + char rbuf[8192]; + int n =3D genl_request_reply(NFSD_CMD_LISTENER_GET, rbuf, sizeof(rbuf)); + + if (n < 0) + return n; + return parse_listener_get(rbuf, n, out, max); +} + +/* --------------------------- fixture --------------------------- */ + +FIXTURE(nfsd_listener) { + int placeholder; +}; + +FIXTURE_SETUP(nfsd_listener) +{ + struct ifreq ifr =3D {0}; + struct stat st; + int s; + + if (geteuid() !=3D 0) + SKIP(return, "must be run as root"); + if (unshare(CLONE_NEWNET | CLONE_NEWNS) < 0) + SKIP(return, "unshare(NEWNET|NEWNS): %s", strerror(errno)); + if (mount("", "/", NULL, MS_REC | MS_PRIVATE, NULL) < 0) + SKIP(return, "mount(/ private): %s", strerror(errno)); + + /* + * Keep the kernel's rpcbind client inside this namespace. The + * abstract socket it tries first is per-netns, but the + * "/var/run/rpcbind.sock" fallback is not, so hide the path. + */ + if (mount("tmpfs", "/run", "tmpfs", 0, NULL) < 0) + SKIP(return, "mount(tmpfs on /run): %s", strerror(errno)); + if (lstat("/var/run", &st) =3D=3D 0 && S_ISDIR(st.st_mode) && + mount("tmpfs", "/var/run", "tmpfs", 0, NULL) < 0) + SKIP(return, "mount(tmpfs on /var/run): %s", strerror(errno)); + + /* Bring loopback up so listener binds (127.0.0.1 / ::1) work. */ + s =3D socket(AF_INET, SOCK_DGRAM, 0); + ASSERT_GE(s, 0); + strcpy(ifr.ifr_name, "lo"); + ASSERT_EQ(0, ioctl(s, SIOCGIFFLAGS, &ifr)); + ifr.ifr_flags |=3D IFF_UP | IFF_RUNNING; + ASSERT_EQ(0, ioctl(s, SIOCSIFFLAGS, &ifr)); + close(s); + + nfsd_family =3D genl_resolve_nfsd(); + if (nfsd_family < 0) + SKIP(return, "nfsd genl family not found (modprobe nfsd?)"); +} + +FIXTURE_TEARDOWN(nfsd_listener) +{ +} + +/* =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D validat= ion / negative =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D */ + +TEST_F(nfsd_listener, val_too_many) +{ + static char attrs[1 << 20]; + int i, off =3D 0; + + for (i =3D 0; i < 1025; i++) /* > NFSD_NL_LISTENER_MAX (1024) */ + off =3D put_listener(attrs, off, "udp", TEST_PORT); + EXPECT_EQ(-E2BIG, listener_set(attrs, off)); +} + +TEST_F(nfsd_listener, val_missing_addr) +{ + char attrs[64]; + struct raw_listener r =3D { .xprt =3D "tcp", .emit_addr =3D 0 }; + int off =3D put_raw_listener(attrs, 0, &r); + + EXPECT_EQ(-EINVAL, listener_set(attrs, off)); +} + +TEST_F(nfsd_listener, val_missing_transport) +{ + struct sockaddr_in s4 =3D { .sin_family =3D AF_INET, .sin_port =3D htons(= TEST_PORT) }; + struct raw_listener r =3D { .xprt =3D NULL, .emit_addr =3D 1, + .addr =3D &s4, .addr_len =3D sizeof(s4) }; + char attrs[64]; + int off =3D put_raw_listener(attrs, 0, &r); + + EXPECT_EQ(-EINVAL, listener_set(attrs, off)); +} + +/* + * A name matching no transport class must be refused before nfsd_mutex is + * taken, so it never reaches svc_xprt_create_from_sa() and its + * request_module("svc%s", name) upcall. + */ +TEST_F(nfsd_listener, val_bad_transport) +{ + char attrs[64]; + int off =3D put_listener(attrs, 0, "bogus_xprt", TEST_PORT); + + EXPECT_EQ(-EPROTONOSUPPORT, listener_set(attrs, off)); +} + +TEST_F(nfsd_listener, val_addr_too_short) +{ + unsigned char tiny =3D 0; + struct raw_listener r =3D { .xprt =3D "tcp", .emit_addr =3D 1, + .addr =3D &tiny, .addr_len =3D 1 }; + char attrs[64]; + int off =3D put_raw_listener(attrs, 0, &r); + + EXPECT_EQ(-EINVAL, listener_set(attrs, off)); +} + +TEST_F(nfsd_listener, val_inet_short) +{ + struct sockaddr_in s4 =3D { .sin_family =3D AF_INET, .sin_port =3D htons(= TEST_PORT) }; + struct raw_listener r =3D { .xprt =3D "tcp", .emit_addr =3D 1, .addr =3D = &s4, + .addr_len =3D sizeof(sa_family_t) + 2 }; + char attrs[64]; + int off =3D put_raw_listener(attrs, 0, &r); + + EXPECT_EQ(-EINVAL, listener_set(attrs, off)); +} + +TEST_F(nfsd_listener, val_inet6_short) +{ + struct sockaddr_in6 s6 =3D { .sin6_family =3D AF_INET6, .sin6_port =3D ht= ons(TEST_PORT) }; + struct raw_listener r =3D { .xprt =3D "tcp", .emit_addr =3D 1, .addr =3D = &s6, + .addr_len =3D sizeof(struct sockaddr_in) }; + char attrs[64]; + int off =3D put_raw_listener(attrs, 0, &r); + + EXPECT_EQ(-EINVAL, listener_set(attrs, off)); +} + +TEST_F(nfsd_listener, val_bad_family) +{ + struct sockaddr_storage ss =3D { .ss_family =3D AF_UNIX }; + struct raw_listener r =3D { .xprt =3D "tcp", .emit_addr =3D 1, .addr =3D = &ss, + .addr_len =3D sizeof(struct sockaddr_in) }; + char attrs[64]; + int off =3D put_raw_listener(attrs, 0, &r); + + EXPECT_EQ(-EAFNOSUPPORT, listener_set(attrs, off)); +} + +TEST_F(nfsd_listener, val_second_entry_bad) +{ + struct sockaddr_storage ss =3D { .ss_family =3D AF_UNIX }; + struct raw_listener bad =3D { .xprt =3D "tcp", .emit_addr =3D 1, .addr = =3D &ss, + .addr_len =3D sizeof(struct sockaddr_in) }; + char attrs[128]; + int off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + + off =3D put_raw_listener(attrs, off, &bad); + /* The whole request is rejected during validation; nothing applied. */ + EXPECT_EQ(-EAFNOSUPPORT, listener_set(attrs, off)); +} + +/* LISTENER_GET with no serv in this netns returns an empty list. */ +TEST_F(nfsd_listener, func_get_empty) +{ + struct listener_ent got[MAX_LISTENERS]; + + EXPECT_EQ(0, listener_get(got, MAX_LISTENERS)); +} + +TEST_HARNESS_MAIN diff --git a/tools/testing/selftests/nfsd/settings b/tools/testing/selftest= s/nfsd/settings new file mode 100644 index 000000000000..6091b45d226b --- /dev/null +++ b/tools/testing/selftests/nfsd/settings @@ -0,0 +1 @@ +timeout=3D120 --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 959DE5519B9; Mon, 31 Aug 2026 16:15:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192959; cv=none; b=Q3b/OMA6PqC7+vXvFBzohpJl1BcvlOAF7sR5L1HVPQVnwDE/VcTQJ5cviWy6bbbEYHXwufa35GxNxxttxFetjqxeNIV0KYW/YrTxQNOAnBdbgZTi/uw2Qy4RQtSYX5IJV8hTcpe7PG8NA0eOk5Ldbu7X7G3gQ7vcMvsI3k8SYA8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192959; c=relaxed/simple; bh=th48vMrVvf58O7nk4N1WnDhM2y9ibVFDXAp4BTCNaHc=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=lN2pIoF1W0XL+Ov2xj7IEka1xprPcGNj9CudQ07g3YFzJ1WUdERv14u3icthOW45QUHf2goIFNbW8pzPLA8PSQxGNyFgSaY1Ya1sRPYEhthBZsVEik1F8M6EZ5qOKUwYMtTHXLTPTFfAMHhpc7Eznk+N1Z6Ijla3SEPtVotMPx0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Z9JZJSLj; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Z9JZJSLj" Received: by smtp.kernel.org (Postfix) with ESMTPSA id F009F1F00A3D; Mon, 31 Aug 2026 16:15:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192957; bh=0wHkz9gKCDlM8SccDujfwP2D/PQWOv/mcr4bCZIAihY=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=Z9JZJSLjStkkLcjn7Tu5vJ75wyXtaz2bWRkEAYQs6U6doI3vpP7yry9/RrQ97jlhr 05X+gMY3soj3dCW56NNetxYUP/NPyXjBhMOz+eMMgjrVqhwBlTgQEI5nh3HgHPv7mf hXRDQwTlnCLURMTMTlOQ07mrcYgYoxGtQMO+zMLBaIeVo3qK3TdRbnhWxJ7dtAyNkj So5M2l0KqcPsPMRBB5inX+GjYzc+oopbXvhIJy6Imf+qaCayWWfyNjcKJkmuYbmm3W hT12vTgm/fEGwaULx7I2340fPLLElxs3sJJrKk4kPkiM/MG4vg56AiVMSahWQBA0ff j8MjfyLWGAEfA== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:54 -0400 Subject: [PATCH v4 12/14] selftests/nfsd: add a per-netns rpcbind stub and the listener round-trips Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-12-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=30213; i=jlayton@kernel.org; h=from:subject:message-id; bh=th48vMrVvf58O7nk4N1WnDhM2y9ibVFDXAp4BTCNaHc=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlailVLT8xklkF8MTH5K/17mMmY4OHevDaiKHp wUu0TUXtuOJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWopQAKCRAADmhBGVaC FeQnEADH0anGgFIxEQOX4lrCU7R+TjChpWEYTLj8Y/n/eZiTW+rbxgHAJKn2h5BmVwSImFpj0CA MHkcVIKFfnM6HFaV85H3i4NspNsHSUCjaCOtmkjWwIJNWE3QJhpeteiQWGCuUIgITG9f9V0HDDU zasvRon1jS96C4ymQACgZoKphTeGCsE95DAvLTw0qlmc3WxbQhS2FJx7/9xsjxTxhAz3fzFWQsw 3qdfdaIPMscJLvd/ydoa58boMdbEuCg3sCFfhD8GazaCyUI5W00XEnkhcPNu9xxsjD8+18njJjR QJp/ZMfZYRl9skS+OV/ZYtH2qFcSaluEz1t3kPAcRi/8oOUAIc0y8P7/EqDQ8lNI7KqoqgG7yhs RpeMNo9rismsWCZ6oHuP/+DBngnNeZHZYbzV86Eadr+dTh6pPrwMChvHYSGo94a2N299ZUU/aX6 lBusIRYmcruu8gjrcfMoDRTCiDoV5HjwG+MUj5jIBameNATHZVap6/edGJQriMQ9HcL7QjpJ16u zRBODST5DIPH4aXi4tqgVFjEeTiE///CX/L2fE85IuO/o1lSrZyJ2phYI7TcI/N0SixTKxRIi8d DKRQ7CQq6BFpj22PrfOuJ1z0WzuiBoNn/I2uLnNdNBka91qgFSkSzKrkmijsLQjVxs6p0UYOaAQ f7j1uzAZx1kwRhw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 The creation of a listener registers with rpcbind. svc_xprt_create_from_sa() passes flags of 0, so pmap_register is true in svc_setup_socket(). A fresh netns has no rpcbind. Every registration therefore waits out the local rpcbind timeout, once for each program and version, and the registration failure then takes the listener down. The host's rpcbind is not an option either. svc_rpcb_setup() opens with a call to svc_unregister(), which would clear the host's nfsd entries. Serve rpcbind from inside the namespace instead. The abstract AF_LOCAL name that the kernel tries first is per-netns, because unix_find_abstract() takes a struct net. Bind "\0/run/rpcbind.sock" and fork a minimal responder: - the responder never decodes arguments. The NULL procedure gets an empty success, and SET and UNSET get TRUE. - the responder answers RPCBVERS_4 as well as RPCBVERS_2. A v4 refusal makes __svc_rpcb_register6() return -EAFNOSUPPORT, which would leave every IPv6 listener unregistered. - the responder counts accepted connections and received calls in a page that it shares with the test, and reads its mode from that page on every call. The mode lives there rather than in the child so that a test can change it with a serv already up: killing and restarting the stub would close the connection the kernel holds, and rpcb_register_call() issues UNSET over AF_LOCAL with RPC_TASK_NOCONNECT, so the next call would fail at once with -ENOTCONN instead of waiting out a timeout. - PR_SET_PDEATHSIG plus an explicit kill in FIXTURE_TEARDOWN make sure that no stub outlives its test. With the stub in place, add the tests that need a serv. These cover the create, add and remove paths and the LISTENER_GET round trips: tcp, udp, several listeners at once, an idempotent re-set, the removal of a subset, the destruction of a serv from an empty list, and IPv6. Two more tests cover the empty-list request and the -EBUSY refusal after THREADS_SET has started threads. The netlink socket asks for NETLINK_EXT_ACK, so that the tests can read the extack message. It also asks for NETLINK_CAP_ACK, so that the kernel does not echo the request back and the TLVs sit at a fixed offset. FIXTURE_TEARDOWN drops whatever a test left running. A listener holds a reference to the netns, and that netns outlives the test process. Threads pin the listeners. Anything left up therefore leaks the namespace. Several of these tests exist to catch a revert, not to describe the interface. The errno alone shows none of them: - val_reject_keeps_listeners. An unknown transport name ends in -EPROTONOSUPPORT either way, because svc_xprt_create_from_sa() returns that error too. The difference is the state that it leaves. Without the up-front check, nfsd_nl_listener_set_doit() has already destroyed the listeners that did not match by the time the name fails. - val_bad_transport. This test now also requires that the stub saw no traffic. A request that reaches svc_xprt_create_from_sa() has run nfsd_create_serv(). svc_bind() then pings rpcbind at client creation and sweeps stale entries with svc_unregister(). Silence at the stub is therefore what shows that the kernel refused the request up front. - val_second_entry_bad. This test now also sends a LISTENER_GET. svc_xprt_create_from_sa() also returns -EAFNOSUPPORT for the bad entry, and the doit keeps the listeners that it did create. The well-formed tcp entry ahead of it would otherwise still be up. - sem_register_refused. This test puts the stub in a mode that answers RPCBPROC_SET with FALSE. rpcb_register_call() turns that answer into -EACCES, svc_register() then fails, and svc_setup_socket() creates no listener. The bare errno does not show that, because a bind can return -EACCES too, so the test reads the listener set back and requires that it is empty. - sem_create_failure_extack. This test squats on the port first, so the listener cannot bind. The extack must then name the transport that failed. - func_empty_destroys. This test uses the connection count. LISTENER_GET replies empty both for a destroyed serv and for a live serv with no permsocks. But only nfsd_destroy_serv() reaches svc_xprt_destroy_all(..., unregister=3Dtrue) -> svc_rpcb_cleanup() -> rpcb_put_local(), which drops the last user and shuts the local client down. The next serv has to connect again. - sem_busy_on_change and sem_busy_on_remove read the listeners back, because -EBUSY says nothing about what the doit did before it returned. find_listener() matches the address as well as the transport, the family and the port. Every listener here is created on loopback, so a reply that names 0.0.0.0 has to fail. Assisted-by: LLM Signed-off-by: Jeff Layton --- .../testing/selftests/nfsd/nfsd_netlink_listener.c | 637 +++++++++++++++++= +++- 1 file changed, 627 insertions(+), 10 deletions(-) diff --git a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c b/tools/t= esting/selftests/nfsd/nfsd_netlink_listener.c index ae28c224255f..99c320e2f7c2 100644 --- a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c +++ b/tools/testing/selftests/nfsd/nfsd_netlink_listener.c @@ -3,30 +3,41 @@ * Regression tests for the NFSD generic-netlink listener interface * (NFSD_CMD_LISTENER_SET / NFSD_CMD_LISTENER_GET). * - * These cover the request validation that nfsd_nl_validate_listeners() do= es - * before nfsd_mutex is taken: bad or absent transport name, missing addre= ss, - * truncated or unsupported sockaddr, oversized list. None of them reach - * nfsd_create_serv(), so nothing here creates a serv or talks to rpcbind. + * Three groups: + * validation - malformed/abusive LISTENER_SET requests are rejected by + * nfsd_nl_validate_listeners(), before nfsd_mutex is take= n. + * functional - create/add/remove listeners and verify LISTENER_GET + * reflects the set (round-trip of transport + addr:port). + * semantics - once threads are running (THREADS_SET) a listener change + * is refused with -EBUSY. * * Each test runs in its own private net + mount namespace (unshare in * FIXTURE_SETUP). /run is masked there: a pathname AF_LOCAL connect is not * scoped by the network namespace, since unix_find_bsd() resolves by inode * and takes no struct net, so the kernel's rpcbind client would otherwise= be - * able to reach the rpcbind running on the host. + * able to reach the rpcbind running on the host. Anything that creates a + * serv is served by the per-netns rpcbind stub below instead. */ #define _GNU_SOURCE #include +#include #include +#include +#include #include #include #include #include #include +#include #include +#include #include #include #include #include +#include +#include #include #include #include @@ -36,8 +47,10 @@ =20 /* NFSD generic-netlink constants (from linux/nfsd_netlink.h). */ #define NFSD_FAMILY_NAME "nfsd" +#define NFSD_CMD_THREADS_SET 2 #define NFSD_CMD_LISTENER_SET 6 #define NFSD_CMD_LISTENER_GET 7 +#define NFSD_A_SERVER_THREADS 1 #define NFSD_A_SERVER_SOCK_ADDR 1 /* per-listener nest */ #define NFSD_A_SOCK_ADDR 1 /* inside the nest */ #define NFSD_A_SOCK_TRANSPORT_NAME 2 /* inside the nest */ @@ -47,7 +60,10 @@ #define MAX_LISTENERS 8 #define RECV_TIMEO_SEC 30 =20 -static int nfsd_family; /* set per-test in FIXTURE_SETUP */ +static int nfsd_family =3D -1; /* set per-test in FIXTURE_SETUP */ + +/* Extack message from the last genl_request(); empty if there was none. */ +static char last_extack[128]; =20 static void die(const char *msg) { @@ -62,15 +78,50 @@ static int genl_open(void) struct sockaddr_nl sa =3D { .nl_family =3D AF_NETLINK }; struct timeval tv =3D { .tv_sec =3D RECV_TIMEO_SEC }; int fd =3D socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); + int on =3D 1; =20 if (fd < 0) die("socket(NETLINK_GENERIC)"); if (bind(fd, (void *)&sa, sizeof(sa)) < 0) die("bind(netlink)"); setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + /* + * Ask for extack, and cap the ack so the request is not echoed back: + * the TLVs then always follow the fixed part of the error message. + */ + setsockopt(fd, SOL_NETLINK, NETLINK_EXT_ACK, &on, sizeof(on)); + setsockopt(fd, SOL_NETLINK, NETLINK_CAP_ACK, &on, sizeof(on)); return fd; } =20 +/* Stash the extack message of an ack, if it carries one. */ +static void parse_extack(const char *rbuf) +{ + const struct nlmsghdr *nlh =3D (const void *)rbuf; + const struct nlattr *na; + int off, left; + + last_extack[0] =3D '\0'; + if (nlh->nlmsg_type !=3D NLMSG_ERROR || + !(nlh->nlmsg_flags & NLM_F_ACK_TLVS)) + return; + + off =3D NLMSG_HDRLEN + NLMSG_ALIGN(sizeof(struct nlmsgerr)); + left =3D nlh->nlmsg_len - off; + na =3D (const void *)(rbuf + off); + + while (left >=3D (int)NLA_HDRLEN) { + if ((na->nla_type & NLA_TYPE_MASK) =3D=3D NLMSGERR_ATTR_MSG) { + strncpy(last_extack, (const char *)na + NLA_HDRLEN, + sizeof(last_extack) - 1); + last_extack[sizeof(last_extack) - 1] =3D '\0'; + return; + } + left -=3D NLA_ALIGN4(na->nla_len); + na =3D (const void *)((const char *)na + NLA_ALIGN4(na->nla_len)); + } +} + /* Append an attribute at @off; return the new (aligned) offset. */ static int put_attr(char *buf, int off, uint16_t type, const void *data, int len) @@ -117,13 +168,16 @@ static int genl_request(uint8_t cmd, const char *attr= s, int attrs_len) if (send(fd, buf, off, 0) < 0) die("send(genl)"); =20 + last_extack[0] =3D '\0'; n =3D recv(fd, rbuf, sizeof(rbuf), 0); - if (n < 0) + if (n < 0) { ret =3D (errno =3D=3D EAGAIN || errno =3D=3D EWOULDBLOCK) ? -ETIMEDOUT := -errno; - else if (((struct nlmsghdr *)rbuf)->nlmsg_type =3D=3D NLMSG_ERROR) + } else if (((struct nlmsghdr *)rbuf)->nlmsg_type =3D=3D NLMSG_ERROR) { ret =3D ((struct nlmsgerr *)NLMSG_DATA(rbuf))->error; - else + parse_extack(rbuf); + } else { ret =3D 0; + } close(fd); return ret; } @@ -327,10 +381,296 @@ static int listener_get(struct listener_ent *out, in= t max) return parse_listener_get(rbuf, n, out, max); } =20 +/* + * Every listener these tests create comes from put_listener_af(), so the + * address is always loopback. Match on it too: without that, a reply that + * gave the right transport and port on the wrong address (0.0.0.0, say) + * would pass. + */ +static struct listener_ent *find_listener(struct listener_ent *e, int n, + const char *xprt, int family, + uint16_t port) +{ + int i; + + for (i =3D 0; i < n; i++) { + if (e[i].family !=3D family || e[i].port !=3D port || + strcmp(e[i].xprt, xprt)) + continue; + if (family =3D=3D AF_INET6) { + if (memcmp(&e[i].a6, &in6addr_loopback, sizeof(e[i].a6))) + continue; + } else if (e[i].a4.s_addr !=3D htonl(INADDR_LOOPBACK)) { + continue; + } + return &e[i]; + } + return NULL; +} + +/* Start (@n > 0) or stop (@n =3D=3D 0) nfsd threads in this netns. */ +static int threads_set(int n) +{ + char attrs[64]; + uint32_t v =3D n; + int off =3D put_attr(attrs, 0, NFSD_A_SERVER_THREADS, &v, sizeof(v)); + + return genl_request(NFSD_CMD_THREADS_SET, attrs, off); +} + +/* ------------------- per-netns local rpcbind stub ------------------- */ + +/* + * Creating a listener registers with rpcbind: nfsd_nl_listener_set_doit() + * passes no SVC_SOCK_ANONYMOUS for the first entry of a request, so + * pmap_register is true in svc_setup_socket(). The fixture's server has v3 + * enabled, and nfsd_version3 does not set vs_rpcb_optnl, so a failure the= re + * comes back out of svc_register() and takes the listener down with it. + * With nothing listening, every attempt first waits out the local rpcbind + * timeout. The abstract AF_LOCAL name the kernel tries first is per-netns + * (unix_find_abstract() takes a struct net), so answer it here and stay o= ut + * of the host's rpcbind. + * + * Arguments are never decoded. The NULL procedure gets an empty success a= nd + * SET/UNSET get TRUE, for both RPCBVERS_2 and RPCBVERS_4. v4 has to be + * answered because __svc_rpcb_register6() turns a v4 refusal into + * -EAFNOSUPPORT, which would leave every IPv6 listener unregistered. + * + * In RPCB_STUB_REFUSE mode SET is answered FALSE instead, which + * rpcb_register_call() reports as -EACCES. UNSET is left alone: only + * svc_unregister() issues it, and it discards the result. + * + * The stub also keeps counters and the mode in a page shared with the tes= t, so + * a test can assert that the kernel never talked to rpcbind at all, or th= at it + * dropped the local rpcbind client and had to reconnect. + * + * The mode lives there rather than in the child so that a test can change= it + * with a serv already up. Killing and restarting the stub would close the + * connection the kernel holds, and rpcb_register_call() issues UNSET over + * AF_LOCAL with RPC_TASK_NOCONNECT, so the next call would fail at once w= ith + * -ENOTCONN instead of waiting out a timeout. + */ +#define RPCB_PROGRAM 100000 +#define RPCB_PROC_NULL 0 +#define RPCB_PROC_SET 1 +#define RPCB_PROC_UNSET 2 +#define RPCB_ABSTRACT_NAME "/run/rpcbind.sock" +#define RPCB_STUB_MAXCONN 4 + +enum { RPCB_STUB_ACCEPT, RPCB_STUB_REFUSE }; + +struct rpcb_stub_stats { + unsigned int conns; /* connections accepted */ + unsigned int calls; /* calls received */ + unsigned int mode; /* RPCB_STUB_*, read on every call */ +}; + +static volatile struct rpcb_stub_stats *rpcb_stats; /* MAP_SHARED */ + +static int rpcb_stats_alloc(void) +{ + void *p =3D mmap(NULL, sizeof(*rpcb_stats), PROT_READ | PROT_WRITE, + MAP_SHARED | MAP_ANONYMOUS, -1, 0); + + if (p =3D=3D MAP_FAILED) + return -1; + rpcb_stats =3D p; + return 0; +} + +/* + * The stub bumps these before it replies and the kernel waits for that re= ply, + * so whatever a netlink request provoked is visible once it returns. + */ +static int rpcb_calls(void) +{ + return rpcb_stats ? (int)rpcb_stats->calls : 0; +} + +static int rpcb_conns(void) +{ + return rpcb_stats ? (int)rpcb_stats->conns : 0; +} + +/* Takes effect on the stub's next call; the caller has not sent one yet. = */ +static void rpcb_stub_set_mode(int mode) +{ + rpcb_stats->mode =3D mode; +} + +static int rpcb_stub_listen(void) +{ + struct sockaddr_un sun =3D { .sun_family =3D AF_UNIX }; + size_t nlen =3D strlen(RPCB_ABSTRACT_NAME); + socklen_t alen; + int fd; + + /* Abstract names are length-delimited, so the length must match. */ + memcpy(sun.sun_path + 1, RPCB_ABSTRACT_NAME, nlen); + alen =3D offsetof(struct sockaddr_un, sun_path) + 1 + nlen; + + fd =3D socket(AF_UNIX, SOCK_STREAM, 0); + if (fd < 0) + return -1; + if (bind(fd, (struct sockaddr *)&sun, alen) < 0 || + listen(fd, RPCB_STUB_MAXCONN) < 0) { + close(fd); + return -1; + } + return fd; +} + +static int rpcb_stub_read(int fd, void *buf, size_t len) +{ + size_t done =3D 0; + + while (done < len) { + ssize_t n =3D read(fd, (char *)buf + done, len - done); + + if (n <=3D 0) + return -1; + done +=3D n; + } + return 0; +} + +/* Handle one record-marked RPC call. Returns -1 when the peer is done. */ +static int rpcb_stub_call(int fd) +{ + unsigned int len, nrep =3D 6, mode =3D rpcb_stats->mode; + uint32_t mark, call[6], rep[7]; + size_t replen; + + if (rpcb_stub_read(fd, &mark, sizeof(mark))) + return -1; + len =3D ntohl(mark) & 0x7fffffff; + if (len < sizeof(call) || len > 4096) + return -1; + if (rpcb_stub_read(fd, call, sizeof(call))) + return -1; + + /* xid, msg_type, rpcvers, prog, vers, proc; the rest is discarded */ + for (len -=3D sizeof(call); len; ) { + char sink[256]; + unsigned int n =3D len > sizeof(sink) ? sizeof(sink) : len; + + if (rpcb_stub_read(fd, sink, n)) + return -1; + len -=3D n; + } + + if (rpcb_stats) + rpcb_stats->calls++; + + rep[0] =3D call[0]; /* xid */ + rep[1] =3D htonl(1); /* REPLY */ + rep[2] =3D htonl(0); /* MSG_ACCEPTED */ + rep[3] =3D htonl(0); /* verifier flavor AUTH_NULL */ + rep[4] =3D htonl(0); /* verifier length */ + rep[5] =3D htonl(0); /* SUCCESS */ + + if (ntohl(call[3]) !=3D RPCB_PROGRAM) { + rep[5] =3D htonl(1); /* PROG_UNAVAIL */ + } else { + switch (ntohl(call[5])) { + case RPCB_PROC_NULL: + break; + case RPCB_PROC_SET: + rep[6] =3D htonl(mode =3D=3D RPCB_STUB_REFUSE ? 0 : 1); + nrep =3D 7; + break; + case RPCB_PROC_UNSET: + rep[6] =3D htonl(1); /* TRUE */ + nrep =3D 7; + break; + default: + rep[5] =3D htonl(3); /* PROC_UNAVAIL */ + } + } + + replen =3D nrep * sizeof(rep[0]); + mark =3D htonl(0x80000000 | replen); + if (write(fd, &mark, sizeof(mark)) !=3D (ssize_t)sizeof(mark) || + write(fd, rep, replen) !=3D (ssize_t)replen) + return -1; + return 0; +} + +static void rpcb_stub_serve(int lfd) +{ + struct pollfd pfd[1 + RPCB_STUB_MAXCONN]; + nfds_t n =3D 1, i; + + pfd[0].fd =3D lfd; + + for (;;) { + /* stop polling the listener when full, or poll() spins */ + pfd[0].events =3D n < 1 + RPCB_STUB_MAXCONN ? POLLIN : 0; + + if (poll(pfd, n, -1) < 0) + return; + + if (pfd[0].revents & POLLIN) { + int c =3D accept(lfd, NULL, NULL); + + if (c >=3D 0) { + pfd[n].fd =3D c; + pfd[n].events =3D POLLIN; + /* + * poll() ran with the old n, so it did not + * write this revents. The loop below reads it. + */ + pfd[n].revents =3D 0; + n++; + if (rpcb_stats) + rpcb_stats->conns++; + } + } + + for (i =3D 1; i < n; i++) { + if (!(pfd[i].revents & (POLLIN | POLLHUP | POLLERR))) + continue; + if (rpcb_stub_call(pfd[i].fd)) { + close(pfd[i].fd); + pfd[i] =3D pfd[--n]; + } + } + } +} + +/* Returns the stub's pid, or -1. The socket is listening before we fork. = */ +static pid_t rpcb_stub_start(int mode) +{ + int lfd =3D rpcb_stub_listen(); + pid_t pid; + + if (lfd < 0) + return -1; + + rpcb_stats->mode =3D mode; + + pid =3D fork(); + if (pid < 0) { + close(lfd); + return -1; + } + if (pid =3D=3D 0) { + signal(SIGPIPE, SIG_IGN); + prctl(PR_SET_PDEATHSIG, SIGKILL); + if (getppid() =3D=3D 1) /* raced with parent exit */ + _exit(0); + rpcb_stub_serve(lfd); + _exit(0); + } + + close(lfd); + return pid; +} + /* --------------------------- fixture --------------------------- */ =20 FIXTURE(nfsd_listener) { - int placeholder; + pid_t rpcbd; }; =20 FIXTURE_SETUP(nfsd_listener) @@ -369,14 +709,43 @@ FIXTURE_SETUP(nfsd_listener) nfsd_family =3D genl_resolve_nfsd(); if (nfsd_family < 0) SKIP(return, "nfsd genl family not found (modprobe nfsd?)"); + + if (rpcb_stats_alloc() < 0) + SKIP(return, "mmap(rpcbind stub counters): %s", strerror(errno)); + + self->rpcbd =3D rpcb_stub_start(RPCB_STUB_ACCEPT); + if (self->rpcbd < 0) + SKIP(return, "cannot start the rpcbind stub: %s", + strerror(errno)); } =20 FIXTURE_TEARDOWN(nfsd_listener) { + /* + * A listener holds a reference to this netns, which outlives the test + * process, so anything still up leaks it. Threads pin the listeners in + * turn; dropping them destroys the serv and everything under it. + */ + if (nfsd_family >=3D 0 && listener_set(NULL, 0) =3D=3D -EBUSY) + threads_set(0); + + if (self->rpcbd > 0) { + kill(self->rpcbd, SIGKILL); + waitpid(self->rpcbd, NULL, 0); + } + if (rpcb_stats) { + munmap((void *)rpcb_stats, sizeof(*rpcb_stats)); + rpcb_stats =3D NULL; + } } =20 /* =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D validat= ion / negative =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D */ =20 +TEST_F(nfsd_listener, val_empty_list_ok) +{ + EXPECT_EQ(0, listener_set(NULL, 0)); +} + TEST_F(nfsd_listener, val_too_many) { static char attrs[1 << 20]; @@ -411,13 +780,21 @@ TEST_F(nfsd_listener, val_missing_transport) * A name matching no transport class must be refused before nfsd_mutex is * taken, so it never reaches svc_xprt_create_from_sa() and its * request_module("svc%s", name) upcall. + * + * The errno cannot show that -- svc_xprt_create_from_sa() returns + * -EPROTONOSUPPORT for an unknown name too. The rpcbind traffic can: + * getting that far means nfsd_create_serv() ran, and svc_bind() pings + * rpcbind at client creation and then sweeps stale entries with + * svc_unregister(). A silent stub is the proof nothing was created. */ TEST_F(nfsd_listener, val_bad_transport) { char attrs[64]; int off =3D put_listener(attrs, 0, "bogus_xprt", TEST_PORT); =20 + ASSERT_EQ(0, rpcb_calls()); EXPECT_EQ(-EPROTONOSUPPORT, listener_set(attrs, off)); + EXPECT_EQ(0, rpcb_calls()); } =20 TEST_F(nfsd_listener, val_addr_too_short) @@ -469,14 +846,49 @@ TEST_F(nfsd_listener, val_second_entry_bad) struct sockaddr_storage ss =3D { .ss_family =3D AF_UNIX }; struct raw_listener bad =3D { .xprt =3D "tcp", .emit_addr =3D 1, .addr = =3D &ss, .addr_len =3D sizeof(struct sockaddr_in) }; + struct listener_ent got[MAX_LISTENERS]; char attrs[128]; int off =3D put_listener(attrs, 0, "tcp", TEST_PORT); =20 off =3D put_raw_listener(attrs, off, &bad); /* The whole request is rejected during validation; nothing applied. */ EXPECT_EQ(-EAFNOSUPPORT, listener_set(attrs, off)); + /* + * Again the errno alone does not say so: svc_xprt_create_from_sa() + * also returns -EAFNOSUPPORT, and the doit keeps the listeners it did + * manage to create, so the well-formed tcp entry ahead of the bad one + * would still be up. + */ + EXPECT_EQ(0, listener_get(got, MAX_LISTENERS)); +} + +/* + * A rejected request must leave the listeners that are already up alone. + * The errno alone does not show that: svc_xprt_create_from_sa() returns + * -EPROTONOSUPPORT for an unknown name too. What differs is how far the + * request gets -- without the check in nfsd_nl_validate_listeners(), + * nfsd_nl_listener_set_doit() has already moved the unmatched tcp listener + * off sv_permsocks and run svc_xprt_destroy_all() on it by the time the + * name fails. + */ +TEST_F(nfsd_listener, val_reject_keeps_listeners) +{ + struct listener_ent got[MAX_LISTENERS]; + char good[64], bad[64]; + int og =3D put_listener(good, 0, "tcp", TEST_PORT); + int ob =3D put_listener(bad, 0, "bogus_xprt", TEST_PORT); + + ASSERT_EQ(0, listener_set(good, og)); + ASSERT_EQ(1, listener_get(got, MAX_LISTENERS)); + + EXPECT_EQ(-EPROTONOSUPPORT, listener_set(bad, ob)); + + ASSERT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "tcp", AF_INET, TEST_PORT)); } =20 +/* =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D functio= nal / round-trip =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D */ + /* LISTENER_GET with no serv in this netns returns an empty list. */ TEST_F(nfsd_listener, func_get_empty) { @@ -485,4 +897,209 @@ TEST_F(nfsd_listener, func_get_empty) EXPECT_EQ(0, listener_get(got, MAX_LISTENERS)); } =20 +TEST_F(nfsd_listener, func_create_tcp) +{ + struct listener_ent got[MAX_LISTENERS]; + char attrs[64]; + int off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + + ASSERT_EQ(0, listener_set(attrs, off)); + EXPECT_STREQ("", last_extack); /* nothing to warn about */ + ASSERT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "tcp", AF_INET, TEST_PORT)); +} + +TEST_F(nfsd_listener, func_create_udp) +{ + struct listener_ent got[MAX_LISTENERS]; + char attrs[64]; + int off =3D put_listener(attrs, 0, "udp", TEST_PORT); + + ASSERT_EQ(0, listener_set(attrs, off)); + ASSERT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "udp", AF_INET, TEST_PORT)); +} + +TEST_F(nfsd_listener, func_create_multi) +{ + struct listener_ent got[MAX_LISTENERS]; + char attrs[128]; + int off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + + off =3D put_listener(attrs, off, "udp", TEST_PORT); + ASSERT_EQ(0, listener_set(attrs, off)); + ASSERT_EQ(2, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 2, "tcp", AF_INET, TEST_PORT)); + EXPECT_NE(NULL, find_listener(got, 2, "udp", AF_INET, TEST_PORT)); +} + +TEST_F(nfsd_listener, func_idempotent) +{ + struct listener_ent got[MAX_LISTENERS]; + char attrs[64]; + int off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + + ASSERT_EQ(0, listener_set(attrs, off)); + EXPECT_EQ(0, listener_set(attrs, off)); /* re-set same list */ + ASSERT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "tcp", AF_INET, TEST_PORT)); +} + +TEST_F(nfsd_listener, func_add) +{ + struct listener_ent got[MAX_LISTENERS]; + char one[64], two[128]; + int o1 =3D put_listener(one, 0, "tcp", TEST_PORT); + int o2 =3D put_listener(two, 0, "tcp", TEST_PORT); + + o2 =3D put_listener(two, o2, "udp", TEST_PORT); + ASSERT_EQ(0, listener_set(one, o1)); + ASSERT_EQ(0, listener_set(two, o2)); /* add udp, keep tcp */ + ASSERT_EQ(2, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 2, "tcp", AF_INET, TEST_PORT)); + EXPECT_NE(NULL, find_listener(got, 2, "udp", AF_INET, TEST_PORT)); +} + +TEST_F(nfsd_listener, func_remove_subset) +{ + struct listener_ent got[MAX_LISTENERS]; + char both[128], one[64]; + int ob =3D put_listener(both, 0, "tcp", TEST_PORT); + int oo =3D put_listener(one, 0, "tcp", TEST_PORT); + + ob =3D put_listener(both, ob, "udp", TEST_PORT); + ASSERT_EQ(0, listener_set(both, ob)); + ASSERT_EQ(0, listener_set(one, oo)); /* drop udp */ + ASSERT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "tcp", AF_INET, TEST_PORT)); +} + +/* + * LISTENER_GET cannot tell a destroyed serv from a live one with no + * permsocks: nfsd_nl_listener_get_doit() replies empty either way. The + * rpcbind client can. nfsd_destroy_serv() is the only path that reaches + * svc_xprt_destroy_all(..., unregister=3Dtrue) -> svc_rpcb_cleanup() -> + * rpcb_put_local(), which drops the last user and shuts the local client + * down; the next serv then has to connect again. Leaving the serv in place + * would keep the first connection and the stub would see just the one. + */ +TEST_F(nfsd_listener, func_empty_destroys) +{ + struct listener_ent got[MAX_LISTENERS]; + char attrs[64]; + int off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + int conns; + + ASSERT_EQ(0, listener_set(attrs, off)); + conns =3D rpcb_conns(); + ASSERT_GT(conns, 0); + + EXPECT_EQ(0, listener_set(NULL, 0)); /* empty -> destroy serv */ + EXPECT_EQ(0, listener_get(got, MAX_LISTENERS)); + + ASSERT_EQ(0, listener_set(attrs, off)); + EXPECT_GT(rpcb_conns(), conns); +} + +TEST_F(nfsd_listener, func_ipv6) +{ + struct listener_ent got[MAX_LISTENERS]; + char attrs[64]; + int off, s; + + s =3D socket(AF_INET6, SOCK_STREAM, 0); + if (s < 0) + SKIP(return, "IPv6 unavailable: %s", strerror(errno)); + close(s); + + off =3D put_listener_af(attrs, 0, "tcp", AF_INET6, TEST_PORT); + ASSERT_EQ(0, listener_set(attrs, off)); + ASSERT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "tcp", AF_INET6, TEST_PORT)); +} + +/* =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D rpcbind= registration =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D */ + +/* + * A rpcbind that refuses the registration takes the listener down with it. + * svc_register() fails, so svc_setup_socket() fails, so no listener is + * created. -EACCES alone does not show that, since a bind can return it + * too, so read the listener set back as well. + */ +TEST_F(nfsd_listener, sem_register_refused) +{ + struct listener_ent got[MAX_LISTENERS]; + char attrs[64]; + int off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + + rpcb_stub_set_mode(RPCB_STUB_REFUSE); + + EXPECT_EQ(-EACCES, listener_set(attrs, off)); + EXPECT_STRNE("", last_extack); + EXPECT_EQ(0, listener_get(got, MAX_LISTENERS)); +} + +/* + * A listener that cannot be created reports which one it was: the errno + * alone does not name the entry in a multi-listener request. + */ +TEST_F(nfsd_listener, sem_create_failure_extack) +{ + struct sockaddr_in s4 =3D { .sin_family =3D AF_INET, + .sin_port =3D htons(TEST_PORT), + .sin_addr.s_addr =3D htonl(INADDR_LOOPBACK) }; + struct listener_ent got[MAX_LISTENERS]; + char attrs[64]; + int off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + int s; + + /* squat on the port so the listener cannot bind */ + s =3D socket(AF_INET, SOCK_STREAM, 0); + ASSERT_GE(s, 0); + ASSERT_EQ(0, bind(s, (struct sockaddr *)&s4, sizeof(s4))); + + EXPECT_EQ(-EADDRINUSE, listener_set(attrs, off)); + EXPECT_STRNE("", last_extack); + EXPECT_EQ(0, listener_get(got, MAX_LISTENERS)); + close(s); +} + +/* =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D threads= / -EBUSY semantics =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D */ + +TEST_F(nfsd_listener, sem_busy_on_change) +{ + struct listener_ent got[MAX_LISTENERS]; + char one[64], two[128]; + int o1 =3D put_listener(one, 0, "tcp", TEST_PORT); + int o2 =3D put_listener(two, 0, "tcp", TEST_PORT); + + o2 =3D put_listener(two, o2, "udp", TEST_PORT); + ASSERT_EQ(0, listener_set(one, o1)); + ASSERT_EQ(0, threads_set(1)); /* threads now running */ + EXPECT_EQ(-EBUSY, listener_set(two, o2)); /* add refused */ + + /* refused means refused: the udp listener must not have been added */ + EXPECT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "tcp", AF_INET, TEST_PORT)); + + threads_set(0); /* stop before netns exit */ +} + +TEST_F(nfsd_listener, sem_busy_on_remove) +{ + struct listener_ent got[MAX_LISTENERS]; + char one[64]; + int o1 =3D put_listener(one, 0, "tcp", TEST_PORT); + + ASSERT_EQ(0, listener_set(one, o1)); + ASSERT_EQ(0, threads_set(1)); + EXPECT_EQ(-EBUSY, listener_set(NULL, 0)); /* remove refused */ + + /* the doit moves the permsocks to a temp list before it can fail */ + EXPECT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "tcp", AF_INET, TEST_PORT)); + + threads_set(0); +} + TEST_HARNESS_MAIN --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 8CF1755293A; Mon, 31 Aug 2026 16:15:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192961; cv=none; b=rLP7qzSqtlLS7MRuUC8vyh/3BCCBrW+SAx4Oh8enJtwnotXvh6lw3GxsRJzZ3aGGLMsJc0tBp3CgE6adtdkJhoSCHTUgXyC4Reavk4u9YokAYDM0CHI1f87uQvCRTVdLWSK6XKmyz5kIvUlOzGOi3kj5pR3qLxVauLOi1jbgRms= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192961; c=relaxed/simple; bh=MIR3rubKscsZidNahSMzjgOnE9yq2FwNrVqOoqV3JX4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=RcAtRh0GeXQ6PFsUUM4iVl96+XhGUUUklsffn4QGp9ccixwCam3b3t9/Ah6ob75d3bouOfkMbbctElf7loZJfKiyHrQiVsZ9DKgsiOLzlur7f72znP9Nf0fMf5gONl5tD9TO56p5WgDbDlIMUAgskdY/crgk8KJuzEk+oVYgiL0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=dpnIYOV0; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="dpnIYOV0" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B433B1F00ACA; Mon, 31 Aug 2026 16:15:57 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192959; bh=wRFZHmFVeVOFufoeeCToiP5M0y58uqHGKptV/fgLHx8=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=dpnIYOV0Q1vXeA8sT+01jCcXKCZvEkGuWasKwDiSd/ERQqczgMkVOv5PefBKMVXRJ uzhEF4GZPh8o9X/HQFbPGSbJ4qBuUfIFqg5zWS4kYB372SKFDWIKBWcd+Xq1mdFpK7 wKIJ/U2BF95iiiSu+iNJfFCscF7K34iWMLbwcmFGwIPjZ2/GxD6FsoW0YOxdPtpuBg 6kiXiHe6TwiYH64/bqJEalxGOsjMIaijB2RwZqwEOUPrzZpGMaXzn66bt0Zn8Aif7Z 7oNqWSbDUHBV0Ow06u9tUDPfFFwhkMGkC1aMPLPTlvYLMr/ymTpdk33srDxHxfpx8f edAe1B13GVVZg== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:55 -0400 Subject: [PATCH v4 13/14] selftests/nfsd: check that listener_set asks rpcbind once Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-13-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=11536; i=jlayton@kernel.org; h=from:subject:message-id; bh=MIR3rubKscsZidNahSMzjgOnE9yq2FwNrVqOoqV3JX4=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaimPv0CC3EMUOStBlENkbtRmxz9SUh7ZPOxq 3iPvyxUeYSJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWopgAKCRAADmhBGVaC FbuMD/42Boiv0vnUwyxKa0AyX7C7EUxNVdOr4zDixlb4zb96CJmU1a8wmMPEdqdp7xjtTyZoQd9 49/kFmTI02PsYkSmFKNsqAvrw5X7oUZU5RO8r+CotvSqc0Na9qddx3MicdN5vrtTwHw2Us2wsA7 P4uJF68pcXqoSYb90grMwbyOeN7CIKXoI+igqzohLZAScUuzZX9MGaSm87QyH5e4BEZHKtUkaoI 1iTPND/q5jZdfMJE+YzHdXxlAUQMd8TGRkV8WmZZWMgHMzDPFLo6D0p1ik6nGE/ngfo4hLdZ3JF adCelI1LZkYdNtB4vlwBvMgl6V3dCgyHKhEaVSqCvKOHPGogSOxL86pctVZ3hR8AGaUFC5bOzk7 5PUyRCOBIPybaIYXEWJFLYQgKwKpaO1W/tb5f4ZYuMPegl2KclVhyQA58G66OUUGPuI0uyeRWqp NuqJScobOEolUd9BT3OgCl4yAy6YVDVr7XVcR0yxlHXWP7bMr5Liyp0l3Y+J7boMyk+7oigSlNk nE8M8mSoCcP4xFzXDzemzVELP/FoqM8WQ+TMGyVsude8y/qa0PQvZswCOb0HC7r/FoMKdgJ53rk cnAAhE2IZzQKMN22H3+ruZ4T51HL9SMN83ROsf3Rz/v/yS+XnvdOnF7l12ExKit3qB2MD4xvMV/ Rfnh+yyXrFZrDCw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 Cover the change that stops a listener_set request from registering after rpcbind stops answering. RPCB_STUB_SILENT is new. It reads a call and writes nothing back, so the kernel waits out its own timeout. RPCB_STUB_REFUSE cannot serve here: a refusal is an answer, and the count ignores it on purpose. Every procedure but the NULL one is silenced, so an unregistration goes unanswered as well. The NULL one has to be answered: rpcb_create_af_local() builds its client without RPC_CLNT_CREATE_NOPING, so rpc_create() pings at creation. Silencing that ping too would fail the AF_LOCAL client, send rpcb_create_local() on to the loopback client of rpcb_create_local_net(), and leave the stub seeing one call per request no matter how many listeners it carried. - rpcb_stop_after_failure. Ask for one listener, then for three, and compare what the stub saw. Three entries must not cost three times as much. - rpcb_silent_set_complete. The entry that finds rpcbind silent is the one that pays the timeout, and with v3 enabled it is the only entry whose listener would be lost. Require that a three-entry request brings up all three, succeeds, and warns. - rpcb_v4_only_bounded. The case that needs the count rather than a failed listener. version_set_only() makes the server v4-only, so vs_rpcb_optnl discards every error and every listener comes up. Require that the listeners are present, that the ack warns about them, and that three entries do not cost three round trips. - rpcb_retry_next_request. The stop lasts for one request. After the stub starts to answer, the next request must reach rpcbind again. The counts these tests compare include the unregistrations that the teardown between the two measurements issues. The preceding patches bound that direction too, so the sweeps stay at one timeout rather than one per program and version. version_set_only() is new. NFSD_CMD_VERSION_SET clears every version before it reads the request, so one nest leaves the server v4-only. It returns -EBUSY once a serv exists, so the test calls it first. Assisted-by: LLM Signed-off-by: Jeff Layton --- .../testing/selftests/nfsd/nfsd_netlink_listener.c | 188 +++++++++++++++++= +++- 1 file changed, 186 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c b/tools/t= esting/selftests/nfsd/nfsd_netlink_listener.c index 99c320e2f7c2..511d20566ff3 100644 --- a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c +++ b/tools/testing/selftests/nfsd/nfsd_netlink_listener.c @@ -48,12 +48,17 @@ /* NFSD generic-netlink constants (from linux/nfsd_netlink.h). */ #define NFSD_FAMILY_NAME "nfsd" #define NFSD_CMD_THREADS_SET 2 +#define NFSD_CMD_VERSION_SET 4 #define NFSD_CMD_LISTENER_SET 6 #define NFSD_CMD_LISTENER_GET 7 #define NFSD_A_SERVER_THREADS 1 #define NFSD_A_SERVER_SOCK_ADDR 1 /* per-listener nest */ #define NFSD_A_SOCK_ADDR 1 /* inside the nest */ #define NFSD_A_SOCK_TRANSPORT_NAME 2 /* inside the nest */ +#define NFSD_A_SERVER_PROTO_VERSION 1 /* per-version nest */ +#define NFSD_A_VERSION_MAJOR 1 /* inside the version nest */ +#define NFSD_A_VERSION_MINOR 2 /* inside the version nest */ +#define NFSD_A_VERSION_ENABLED 3 /* inside the version nest */ =20 #define NLA_ALIGN4(len) (((len) + 3) & ~3) #define TEST_PORT 20049 @@ -370,6 +375,28 @@ static int listener_set(const char *attrs, int len) return genl_request(NFSD_CMD_LISTENER_SET, attrs, len); } =20 +/* + * Enable exactly one NFS version in this netns. NFSD_CMD_VERSION_SET clea= rs + * every version first, so one nest is enough to leave the server v4-only. + * It refuses once a serv exists, so call it before any listener. + */ +static int version_set_only(uint32_t major, uint32_t minor) +{ + char attrs[64]; + struct nlattr *nest =3D (void *)attrs; + int inner =3D NLA_HDRLEN; + + inner =3D put_attr(attrs, inner, NFSD_A_VERSION_MAJOR, + &major, sizeof(major)); + inner =3D put_attr(attrs, inner, NFSD_A_VERSION_MINOR, + &minor, sizeof(minor)); + inner =3D put_attr(attrs, inner, NFSD_A_VERSION_ENABLED, NULL, 0); + nest->nla_type =3D NFSD_A_SERVER_PROTO_VERSION | NLA_F_NESTED; + nest->nla_len =3D inner; + + return genl_request(NFSD_CMD_VERSION_SET, attrs, NLA_ALIGN4(inner)); +} + /* Fetch the current listeners; returns count (>=3D0) or -errno. */ static int listener_get(struct listener_ent *out, int max) { @@ -440,6 +467,14 @@ static int threads_set(int n) * rpcb_register_call() reports as -EACCES. UNSET is left alone: only * svc_unregister() issues it, and it discards the result. * + * In RPCB_STUB_SILENT mode a SET or an UNSET is read and nothing is writt= en + * back, so the kernel waits out its own timeout. That is the only mode th= at + * makes rpcb_register_call() report a call that got no answer, which is w= hat + * the per-net failure count records. The NULL procedure is still answered: + * rpcb_create_af_local() builds its client without RPC_CLNT_CREATE_NOPING= , so + * rpc_create() pings, and a ping that goes unanswered drops the kernel on= to + * the loopback rpcb_create_local_net() client, which never reaches this s= tub. + * * The stub also keeps counters and the mode in a page shared with the tes= t, so * a test can assert that the kernel never talked to rpcbind at all, or th= at it * dropped the local rpcbind client and had to reconnect. @@ -457,7 +492,7 @@ static int threads_set(int n) #define RPCB_ABSTRACT_NAME "/run/rpcbind.sock" #define RPCB_STUB_MAXCONN 4 =20 -enum { RPCB_STUB_ACCEPT, RPCB_STUB_REFUSE }; +enum { RPCB_STUB_ACCEPT, RPCB_STUB_REFUSE, RPCB_STUB_SILENT }; =20 struct rpcb_stub_stats { unsigned int conns; /* connections accepted */ @@ -572,7 +607,9 @@ static int rpcb_stub_call(int fd) if (ntohl(call[3]) !=3D RPCB_PROGRAM) { rep[5] =3D htonl(1); /* PROG_UNAVAIL */ } else { - switch (ntohl(call[5])) { + unsigned int proc =3D ntohl(call[5]); + + switch (proc) { case RPCB_PROC_NULL: break; case RPCB_PROC_SET: @@ -586,6 +623,15 @@ static int rpcb_stub_call(int fd) default: rep[5] =3D htonl(3); /* PROC_UNAVAIL */ } + + /* + * Answer nothing, so the caller waits out its timeout. The + * NULL procedure is answered even here: the kernel pings at + * client creation, and a ping with no answer takes it off + * this socket entirely. + */ + if (mode =3D=3D RPCB_STUB_SILENT && proc !=3D RPCB_PROC_NULL) + return 0; } =20 replen =3D nrep * sizeof(rep[0]); @@ -1064,6 +1110,144 @@ TEST_F(nfsd_listener, sem_create_failure_extack) close(s); } =20 +/* =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D one rpcbind attempt for each reque= st =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D */ + +/* + * Every listener used to register on its own, so a rpcbind that never + * answers cost one timeout for each entry. Ask for one listener, then for + * three, and compare what the stub saw. Three entries must not cost three + * times as much. + * + * The stub has to stay silent rather than refuse. A refusal is an answer, + * and rpcbind refuses one entry at a time, so the count ignores it. + */ +TEST_F(nfsd_listener, rpcb_stop_after_failure) +{ + int before, one, three, off; + char attrs[192]; + + rpcb_stub_set_mode(RPCB_STUB_SILENT); + + before =3D rpcb_calls(); + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + listener_set(attrs, off); + one =3D rpcb_calls() - before; + ASSERT_GT(one, 0); + + ASSERT_EQ(0, listener_set(attrs, 0)); + + before =3D rpcb_calls(); + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 1); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 2); + listener_set(attrs, off); + three =3D rpcb_calls() - before; + + /* the second and third entries must not reach rpcbind at all */ + EXPECT_LE(three, one); +} + +/* + * The entry that finds rpcbind silent is the one that pays for the + * discovery, and v3 has no vs_rpcb_optnl to discard the error, so it is t= he + * only entry whose listener would be lost. Nothing distinguishes it from = the + * rest of the request, and a retry of the same request would fail the same + * entry again, so the set would stay short for as long as rpcbind was qui= et. + * + * Ask for three listeners against a silent stub and require the whole set, + * a success, and a warning that says why. + */ +TEST_F(nfsd_listener, rpcb_silent_set_complete) +{ + struct listener_ent got[MAX_LISTENERS]; + char attrs[192]; + int off; + + rpcb_stub_set_mode(RPCB_STUB_SILENT); + + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 1); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 2); + EXPECT_EQ(0, listener_set(attrs, off)); + + /* the first entry is not the odd one out */ + EXPECT_EQ(3, listener_get(got, MAX_LISTENERS)); + /* no errno reports this, so the ack has to */ + EXPECT_STRNE("", last_extack); +} + +/* + * The case that needs the count rather than a failed listener. NFSv4 sets + * vs_rpcb_optnl, so svc_generic_rpcbind_set() discards the error, every + * listener comes up, and nothing reports a failure. Without the fix each + * entry still waits for rpcbind on its own. + * + * Make the server v4-only, answer no SET, and require three things: the + * listeners come up, the ack warns that they are not registered, and the + * stub does not see one round trip for each entry. + */ +TEST_F(nfsd_listener, rpcb_v4_only_bounded) +{ + struct listener_ent got[MAX_LISTENERS]; + int before, one, three, off; + char attrs[192]; + + /* refuses once a serv exists, so this has to come first */ + ASSERT_EQ(0, version_set_only(4, 1)); + rpcb_stub_set_mode(RPCB_STUB_SILENT); + + before =3D rpcb_calls(); + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + ASSERT_EQ(0, listener_set(attrs, off)); + one =3D rpcb_calls() - before; + ASSERT_GT(one, 0); + + /* start over, so the second measurement also builds a serv */ + ASSERT_EQ(0, listener_set(attrs, 0)); + + before =3D rpcb_calls(); + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 1); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 2); + ASSERT_EQ(0, listener_set(attrs, off)); + three =3D rpcb_calls() - before; + + /* the listeners are up even though rpcbind never answered */ + EXPECT_EQ(3, listener_get(got, MAX_LISTENERS)); + /* and the ack says they are unregistered, since no errno can */ + EXPECT_STRNE("", last_extack); + EXPECT_LE(three, one); +} + +/* + * The stop applies to one request only. After rpcbind starts answering, + * the next request must register without any other step. + */ +TEST_F(nfsd_listener, rpcb_retry_next_request) +{ + int before, after, off; + char attrs[192]; + + rpcb_stub_set_mode(RPCB_STUB_SILENT); + + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 1); + listener_set(attrs, off); + ASSERT_EQ(0, listener_set(attrs, 0)); + + /* rpcbind recovers */ + rpcb_stub_set_mode(RPCB_STUB_ACCEPT); + + before =3D rpcb_calls(); + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + EXPECT_EQ(0, listener_set(attrs, off)); + after =3D rpcb_calls(); + + /* a fresh request starts from a fresh reading and tries again */ + EXPECT_GT(after, before); + EXPECT_STREQ("", last_extack); +} + /* =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D threads= / -EBUSY semantics =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D */ =20 TEST_F(nfsd_listener, sem_busy_on_change) --=20 2.55.0 From nobody Sat Sep 26 14:38:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 07DA34C6800; Mon, 31 Aug 2026 16:16:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192962; cv=none; b=ELfYXqWL+7N2st1RX4edVEsRG5Txe7LGAJMM5SV228Booxm9zslFeGDxheqKZuqqXCbfGavO8b8lRJToliRm0MTurc2dI75AOYISOs8f9TzRh+1Q6LNhkZJh1YwFw4YZzSYufKvuPMzE3AzOfIh4dj0SXh8prUjgE/RYOLNph5o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788192962; c=relaxed/simple; bh=grf6clZnkQGXGoZ9rkU2+lKlywCVByX9ysCCD0mMuIg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=VE48ZOLBalA2zv1IE/kYCQDLxwY/9HLoiS6RLZNOlkro2mlbTmZ58VGAhFL5MJ/9+tx4N/GteMjfrdQtRiEZIDQpo961xiaHD7kQmQDQYNVqHd5znUOBtnMnxbvGqv1b6SqiJfoJEPwf+//taWHlko2LA6XZ2REIEX4n02Z0LYk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ApfWe4ym; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ApfWe4ym" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 659FF1F000E9; Mon, 31 Aug 2026 16:15:59 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788192960; bh=+xLJWmj9sHbeFwxKybs/pfRQuWXRiA1jYXOW+vEeb5Y=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=ApfWe4ymY781tQiaMrPed108X/TAPsyAkvY0XOMuHRFtmdeVp64MIYpMpJFpgBeMY 2xPsAY7anNBPLRL9R5sHH60QSrIj5EPajY+Di8Z79VkxRLnruPqFKfQ6LggDkXChzw gMCuJjtQhpmbgK923DrYgR0bO8O51YtlSyxSLxYU85D9GUlvKWsllH0FuOQdbULkPf 3ojmuQ7MUl42F70MqPJ8wny7qSCM9fsphYNOpw0JiMT2mKm1o2r6nM0poL1TyRwL4L QQjCZBjxGOUbfUwhtg/V4E5Ka3MnTQUh8Lc68KXPxKHomkJcUvlbtVdYpFiWgkNPz0 UxpT8JEFzTuXA== From: Jeff Layton Date: Mon, 31 Aug 2026 12:14:56 -0400 Subject: [PATCH v4 14/14] selftests/nfsd: check that listener removal asks rpcbind once Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260831-nfsd-nl-hang-v4-14-0f4e89139409@kernel.org> References: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> In-Reply-To: <20260831-nfsd-nl-hang-v4-0-0f4e89139409@kernel.org> To: Chuck Lever , NeilBrown , Olga Kornievskaia , Dai Ngo , Tom Talpey , Trond Myklebust , Anna Schumaker , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan Cc: Slawomir Stepien , linux-nfs@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Trond Myklebust , linux-kselftest@vger.kernel.org, Jeff Layton X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2494; i=jlayton@kernel.org; h=from:subject:message-id; bh=grf6clZnkQGXGoZ9rkU2+lKlywCVByX9ysCCD0mMuIg=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqlaintFaR6Lo01AKYk0WWEnnoyjEQ5mFScTL6H xT48VXWKleJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCapWopwAKCRAADmhBGVaC FclCEACCXT51cYbhdaIr2T+leg20uyxRaHUQlcjWkUWlVHkSihZKT89lWeUDfWJW8Tk3/RyL08c 8iUwUyDsVLbDJPBMpRzMSVn0h+/FlX6D9HCU61XcCNZB+yyELum7RnJavcxB7xUVhhACKsd3uqm TjAML8Y9RSgFGaIwi9AuzoSOz2zFWYTLGMPgW8k6UYhQpRUICd7++etlsKm21RIuXzMcGW8tU+f AihS93zV2uE7qU6M+4zMPGbUP6D7dxZLiI7g21izRuGXoLqX8+2y2aGWtKlUNtxWLoQnSywQ0f3 5kX+0iVZLY3ThqEA8n20ZQ7xmeQ1QdPt5V3Y7CIi6R7jA/2oAzcIxcUfHpCsvkcNNelT6bEpo6M pFBdd0/c3uDvyWokbaRsptI4c2KfnEa1r2qDwZGR27B3hsyD1TE8460K1sS8Lo9IF91Zp4a7Daa QDmhjEwzrPxddxXl7NRfmGM4gil7Rg/vqZfoFX2aR/gfZrpaUIg9Ie7QAkYcJlZylTBXDb+6die YZDeLlwmUInrQ+cRTH6TNg7nrM/OzwutD7UDqKa0X8g3uz4PCA5LYVYVhR8GEgHP9lIEmgGcyEB PA6vlPvBfkF/QITwwZcKgiQhkeMJHfq47cEzfXdFBdLtJXe6VcSc5zeF7lfeTynZxkQv44gn99d 4fZrKTyvYE0RsqA== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 Cover the teardown side of the same rule. Remove one listener, then three, with the stub silent, and compare what it saw. Three removals must not cost three timeouts. Both measurements also pay the svc_unregister() sweep that nfsd_destroy_serv() runs once the last listener is gone, so that cancels out of the comparison. The listeners are registered with the stub answering, so each one has an entry to remove. Assisted-by: LLM Signed-off-by: Jeff Layton --- .../testing/selftests/nfsd/nfsd_netlink_listener.c | 39 ++++++++++++++++++= ++++ 1 file changed, 39 insertions(+) diff --git a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c b/tools/t= esting/selftests/nfsd/nfsd_netlink_listener.c index 511d20566ff3..89d1da825b95 100644 --- a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c +++ b/tools/testing/selftests/nfsd/nfsd_netlink_listener.c @@ -1248,6 +1248,45 @@ TEST_F(nfsd_listener, rpcb_retry_next_request) EXPECT_STREQ("", last_extack); } =20 +/* + * The same rule on the way out. Removing a listener unregisters it, so a + * rpcbind that stops answering used to cost one timeout for each listener + * removed. Register one listener while the stub answers, silence the stub, + * remove it and count; then do the same with three. + * + * Both measurements also pay the svc_unregister() sweep that + * nfsd_destroy_serv() runs once the last listener is gone, so that cancels + * out of the comparison. + */ +TEST_F(nfsd_listener, rpcb_unreg_stop_after_failure) +{ + int before, one, three, off; + char attrs[192]; + + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + ASSERT_EQ(0, listener_set(attrs, off)); + + rpcb_stub_set_mode(RPCB_STUB_SILENT); + before =3D rpcb_calls(); + ASSERT_EQ(0, listener_set(NULL, 0)); + one =3D rpcb_calls() - before; + ASSERT_GT(one, 0); + + rpcb_stub_set_mode(RPCB_STUB_ACCEPT); + off =3D put_listener(attrs, 0, "tcp", TEST_PORT); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 1); + off =3D put_listener(attrs, off, "tcp", TEST_PORT + 2); + ASSERT_EQ(0, listener_set(attrs, off)); + + rpcb_stub_set_mode(RPCB_STUB_SILENT); + before =3D rpcb_calls(); + ASSERT_EQ(0, listener_set(NULL, 0)); + three =3D rpcb_calls() - before; + + /* the second and third removals must not reach rpcbind at all */ + EXPECT_LE(three, one); +} + /* =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D threads= / -EBUSY semantics =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D */ =20 TEST_F(nfsd_listener, sem_busy_on_change) --=20 2.55.0