From nobody Tue Sep 29 08:25:36 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 B8E594322F3; Mon, 10 Aug 2026 17:39:03 +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=1786383544; cv=none; b=ZVlln33y5CqrD0mTaocewtAsEYUeEFKRgyYr62WASIYWfeScoDgWxdrCKSCFG/IKB6dBTtoieN4HLFuY4fexuRCWEEHLZlhInhIz+nlLrNcA7XimG0xDMbVMQ/x/epwJZh0iKEMSvm43g42ADHowZxbS/aPoo7vTXhE0GwdLjEs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786383544; c=relaxed/simple; bh=JnXgLEqpQix6o8S4i2Xd1C08UD/tmbEvIEjBhqLN7UY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ktHwceoym1703shmRhQEU2V78YPH4qqTOMzqHjAcvN3lOeTdF1Fn//ePbI9FDw0LMfMpL/xqOlSEDNy1l8yk+ERF/5E61B7aUHs3P5H+UaBen2Nlf9PXJhAq+16Q/JCjGJXLblXeRVIhnBUsF4Qxu9LgjO5KkwVX9R0LPoTf7J4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ObaKTsXG; 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="ObaKTsXG" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D847E1F00A3E; Mon, 10 Aug 2026 17:39:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786383543; bh=fBaZ7zzsi43W+QfWC/aOkPWJFwHYEdhrvpew+LuReqg=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=ObaKTsXGC5HowqLlspyN0qFH7fxEFMdmDiSra4m2KLxIoFMRp4GMs1XLnGAGRxozm G2LMUAA6faENb4txu4mBBapa0eLKQpQsdNiab2zgh0kIRAYxiiZXXh0pt+EolbZzGE Kb2epCkZUu/IqeLnXs28vlsI716K7KvcShjqXbVN56ud84JWxw00mYSUOEVa3DNM7Z Mnut1kugGCZGBmeXKbcwGmLWIKvbtAS1zwS7jpFLXZkHEsvsimGHp3QDqS8b+9fPaL XHSDJsdE2mpMe7aE8Ul991b35OMtaEUcumfH1ucynMhDKb7RXPxccKmc1DzFVf6t0o k0GVb5M1BFRww== From: Jeff Layton Date: Mon, 10 Aug 2026 13:38:48 -0400 Subject: [PATCH 1/7] 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: <20260810-nfsd-nl-hang-v1-1-2519fdd5bc1a@kernel.org> References: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@kernel.org> In-Reply-To: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@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 , "J. Bruce Fields" , Shuah Khan Cc: 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=2981; i=jlayton@kernel.org; h=from:subject:message-id; bh=JnXgLEqpQix6o8S4i2Xd1C08UD/tmbEvIEjBhqLN7UY=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqegyyl+EFz6cMWQ6YPJaxUnp9ejwtFVejKdM2H zdGYmT2nXWJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCanoMsgAKCRAADmhBGVaC FfEKD/9qoqIWXwgl8tUqWbxFXbth42miQsIhKLT7mjuRXiqFnmGsY9VHXdjF83u4UbbCTh1OV5Z cmtwQD5Lgv8EAC714A2DxgokvEm6ntIaZz3lgXMurNkANAnRydCOK+jj+uhTcYVC5qDnlKmW6NI sdISjdYLKDUKP/LuSt8JPdQCK8BZBjp8d3iA3p2rn5rTuJF0KiAANNqLVuArmmDSCfktbslI3SN t/PCeU0hkA7EW1dX2VRvzjvVty1UOYJTKpGh3V0JWditpaVodWrX8B/6A6NkHNtOUcGKgLejiFY eUMb09yCPXLhmRzm+wGWPi66Txe6EEY1sZvr+A1K5PkkFYCqqEDYsDs2vrL0Rba99IG18NT2kgl 4v1ubgR0WsBqEasUkqL2yqh7cywqmdYCYLJxxnMg9u/idkU7INflKFhTA1LWv5GSGPR+kE22HLx AKw3AqdRwm5KOBqUrWzf4WKXAZo470gaeIPKnsaGyvPK38M+Y79p+VfDfyQXA8Drq7PPa4PO31y 0yS1qOAi1Qj2E+olhROAV/fwC6wOTwkmnPVfEAfZnbz/zSSwd/dcuAxoLh84LO02KZoFVHJ/Gjt x5IYO4Eu/zdoQQBdomKhggI47h+Q/OSAhjmLwmbqRhMRLXCfXlXtuT3NgWI2hEEFC2xgNvnfzfv P9TWVi+FO894DWw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 nfsd_nl_listener_set_doit() holds nfsd_mutex across the whole listener teardown/rebuild. NFSD_A_SOCK_TRANSPORT_NAME is only checked for presence, not content, so an arbitrary name reaches svc_xprt_create_from_sa(), where a name matching no registered class triggers request_module("svc%s", name) -- a TASK_KILLABLE usermode-helper upcall run under nfsd_mutex. Vet the name against the classes NFSD can instantiate (tcp, udp, rdma) in nfsd_nl_validate_listeners(), which runs before nfsd_mutex is taken. This narrows the upcall rather than removing it. "rdma" is accepted unconditionally, so on a kernel where svcrdma is not built it still reaches request_module("svcrdma") under nfsd_mutex -- as it must for the modular case, where autoloading is legitimate. Link: https://syzkaller.appspot.com/bug?extid=3Dc7eae0eb80858a2dba0f Signed-off-by: Jeff Layton Assisted-by: LLM --- fs/nfsd/nfsctl.c | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index 4e5e083d8477..e5844d8454b8 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -1975,14 +1975,31 @@ int nfsd_nl_version_get_doit(struct sk_buff *skb, s= truct 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; +} + /** * 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 + * a supported transport name, and the address is long enough for its fami= ly. + * Doing this up front lets the callers below assume every entry is valid = and * guarantees we make no changes when the request is malformed. * * Return: 0 if every entry is valid, or a negative errno otherwise. @@ -2006,6 +2023,9 @@ static int nfsd_nl_validate_listeners(struct genl_inf= o *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]= ))) + 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 Tue Sep 29 08:25:36 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 63812432E70; Mon, 10 Aug 2026 17:39:05 +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=1786383546; cv=none; b=nEJgMzzZHZFv/mH1DWTVa7f+IWlceEZOkHbFBy6/1bLeQXaEQmiTA4KqF+0LkD3Iqd/9XrZe5ISSmSff7fm0OyJZ90oGzrJ/eYtQujwPxp4PQSWmYlE7FVtFGk/fw7RIzikFnObLeDa3/iJStaCHDQyvmu/gmnTiWJyC4pKz2W8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786383546; c=relaxed/simple; bh=wvCDV6FUUGUKLu+qd8tUSkHX6KpxGk5Xwj978KtfzJA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=HGTZjsOpqQGsWYnmzM6yWKlAc28mZ9g/d2zyiVOI1vOH/K8Nvs+jHXyDYLla86d4ULRHurhOHAs3PT9PVXezI/fu2pmEbXKq8jQw7+SnYnesnJODtGWCY3+aVxUxTuRv/KjbKloMMJ53LBmw+PT2PKkFstAARzXSY+SUlOzwfjQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=FjXzEOdJ; 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="FjXzEOdJ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 96CD61F00A3D; Mon, 10 Aug 2026 17:39:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786383545; bh=X1CGXomtQU4g6qOdGivQ1WvTQyymrShiwvPN5yiskEg=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=FjXzEOdJMtIq4cU8yX8LhNWXjIl6CYLc90IYhlcvb5o3hlFr3tYG3nGfEVeGvV6oV EqLwqCbLvMLiVfqB88NGbpWvxlgZO7K9wfkQbJDfcAF1N6881b/r6Ko+hYkmeImNF3 lzovQhKNVQGay99K6KPtO7RbKA6+qWtajosJFcrsFi6qkOI7FBLNdosh6LHyw8hAUs j07bQbAEtX+Sg2LuW8eo4jHLiChLmMQxbPlyFM0RtCqeBrOdT6ftE4YxE4Y8Qs6Ekx XyQNWc0iL4wPe3+0V5SBPUVEiQ/5fWj8m0geZpOIQb0G90dfa27JkHrYf2re06FgK5 BsY4DSWjpjJbg== From: Jeff Layton Date: Mon, 10 Aug 2026 13:38:49 -0400 Subject: [PATCH 2/7] 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: <20260810-nfsd-nl-hang-v1-2-2519fdd5bc1a@kernel.org> References: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@kernel.org> In-Reply-To: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@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 , "J. Bruce Fields" , Shuah Khan Cc: 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=2696; i=jlayton@kernel.org; h=from:subject:message-id; bh=wvCDV6FUUGUKLu+qd8tUSkHX6KpxGk5Xwj978KtfzJA=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqegyy+HMsMUh/WsODuvmO1Xu1PfDS0WptqlDkD Y/vWn+nNpeJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCanoMsgAKCRAADmhBGVaC Fd7xEAClWvltEm6zzGnaIxLS6go3jwsSmnOk+ADwAZAPh2DWuioWGsUfM6kiuA2KOLlvw6zxUa1 xOZdlzGZmRyVOWkAWvC2TXVVf08vLOVx0dxte/qhkCtByDgO9yHk6v/buJA7FLtdK4yMsYw1hGE fLaYTGG3tr2aiaYXPNQZ+2kqnCgCaAusitRK9ZB26Ple+yT4e2qS9Kn3fsGwr2U8x5PtCMO8Sge wjHatple8fbreMar6dTWr5B+mun6/uSpvYcQ6ClOE/LDyHcvq4UU0ZvcasYfmz5++FnymiE4BU1 uNRc1zulcRnA0mnbj/R6OoaWMjB1PTFH1XpL+xvm+uCIgsPJnLdNvIfywxEvH1i4PnKS2RlHAdZ EUfY3vNlRRt0w9nQb2q0ZTEU52JiVgdH9Y7UM6FSXVhnv+cv6yCEA314OOcOfqk6GDyox7JgsSw 5jJFETrGNe5BCRug5LwjXoBIEjS+nwtw4zdN0RDg3jG7jCTOZmZVj70FcBw2qnnGASlaVvyIVJr 4039kqnmgU+zoKeiGTiD5Jh+WgLFqPij+uIq5LXWtwW+VzUfE3gMGnmkl52PS+UA1q283pEdvTB WkWyUGzvU1Qsrca4dbCLK8y1ul4DU8J8S3bNmEEpLHe3bHfvqT9PnVHfhYruAnAiuUfX5byiM5x FeB+qQEdC+ALfpw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 nfsd_nl_listener_set_doit() matches each requested listener against the existing set in a nested loop that is O(N * M) in the requested (N) and existing (M) counts, run 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 requests carrying more than NFSD_NL_LISTENER_MAX (1024) entries in nfsd_nl_validate_listeners(), before any lock is taken. The limit is far above any realistic configuration. M is not capped here: write_ports() can add listeners too, via svc_addsock() and svc_xprt_create(). But each one costs a real socket, so M is bounded by resources, where N was bounded only by the message size. Capping N leaves ~1M iterations plus 1024 nla_parse_nested() calls under sv_lock as the worst case. Signed-off-by: Jeff Layton Assisted-by: LLM --- 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 e5844d8454b8..66931caaaaed 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -1992,21 +1992,22 @@ static bool nfsd_nl_transport_supported(const char = *name) return false; } =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 supported transport name, and the address is long enough for its fami= ly. - * 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, @@ -2015,6 +2016,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 Tue Sep 29 08:25:36 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 0371843304A; Mon, 10 Aug 2026 17:39:06 +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=1786383551; cv=none; b=F4WEiBLpdMxjMTXRaBTjLNMhj7ueds8CxzQqGNqcSWWN1mXrbgGSAvAGs+2uQ4swfa+7guvfVfd1afE33hNY69uDP8I0LnkTD3NudunnAv/Mb6BvJdfWIgRk7Dw+TYbMVrrAne0fecm4ki5Q4Ev3eDzH0wybiQqzihyLaMNIHsA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786383551; c=relaxed/simple; bh=gXSVpxD3LgPSvTeIjfOzxNTMA1HNxMCns5+Nkhcyrqw=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=bh9G6/aRPvJREka57RL4GDPaBsGFjQ3EIu+4KvtHygCA/dCPu3K+OgLTb4eholgz+PnlpwOICcoXiieUE5HSZCNFLipVWpoz6TND4vF7kgyDdDnZ7hag5oQwybmKF42Qu6T7+0MVejCdHIce+dx5UejTCgBjWsIOh9qTlgh2tmA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=TSkq0rfc; 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="TSkq0rfc" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4CAAD1F000E9; Mon, 10 Aug 2026 17:39:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786383546; bh=WrutuuH4P6LM2zJvGTkPDSVYBeFawd9DB0yEU/wEhHE=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=TSkq0rfcSjyJQeVaOaxefrxfANNhBVbKM1bFEpMonSaOR1K9qwMtteGOzQL37Iske hFQdX+n8x28y5AIL6NC/+dXKNis36lIs3ayfEW2bLGqvF2kIsnY8c1AA0bZNY/XOdZ 4N2TCajixYugF/KgtQ3988Ce1qnu3EXIghma/ltQlFjJBcu+DuZA6LpWpkJWkOYEPV X0f9JSCXcQWMLFSzkpB09BZ6OW+b2Lwp/Z9DXAP7QmTcYsfoG3myWAiqA4GIXjqCZE G75Iq1Dtl+Ht0r3FjLwikJ4f9ekFyUNjDDDQzt7GJta2EOvYInX2bZWX0wYCPKv24M iJrGXtOkIU91Q== From: Jeff Layton Date: Mon, 10 Aug 2026 13:38:50 -0400 Subject: [PATCH 3/7] 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: <20260810-nfsd-nl-hang-v1-3-2519fdd5bc1a@kernel.org> References: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@kernel.org> In-Reply-To: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@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 , "J. Bruce Fields" , Shuah Khan Cc: 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=2034; i=jlayton@kernel.org; h=from:subject:message-id; bh=gXSVpxD3LgPSvTeIjfOzxNTMA1HNxMCns5+Nkhcyrqw=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqegyyIH+S/UbKSf5YIGiLm+ULs36yE3KECl90m 8PcSWVK7BuJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCanoMsgAKCRAADmhBGVaC FSqtEACHP2HX/chR61oV8ojBqSvpesvf83raDfrb0LJCh8HwJt7z0h1EbDXbMhwBlaJvbGye1Oh n3YDFcFanTJQb4Q0I/zq0oY/iPPEPHj/jcCaJZyV0MHqk78nWGh6F2XB0Xmdjjtobf2BihV0/Bm Brz/HJYgJhRfa2Ik31m+/lh9rXXb6jS+IqNnahn3cVWKxQN2rXuApt3/vblWWQ+P7UAPxuX4Kkc cbsa+w+IRanYz+cdQiGc3tBAXCJy9Hjiwnpedl51AZAmN8HrfRun0yjdzhmqUlgpqeVj6azN2s1 e6A6wEHNvOZoLCJpCU/6rYBDlthuV8YLq10l2od4Xev+WWUmPY9NVf13NRFqe519k73NPUQUQ1+ kVJlNQ/0eXc9+978rF2Me56tOeY3MA5qeLfZFLFHCcfMI6BhCRz2zo2XlGgu179aL8dY9ajxTfQ jq4aF6aMXmXf5nA7Jo4CB3HHwGGi1HV7+hcG7/ePTwTlr6Ejsit6MpJkYzZMekxFs0IUfpRkn9G hVyz4YQ81QQ3z0OPxmI8V8x7vqGSA/HZi7sn2+cb7eg7uZ4bSoNpM7c7UUnKESsi4UxBjxUplkl 7JtQPxftk0liFoZxsJjf8ncpzB5O8PFkh902elCUuxwIGb6dtwGH7t3XsCu1/jg+DBjamrUeyLW sb+v1ygsM/EL18Q== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 svc_register() assigns each pg_rpcbind_set() result to the same "error" and returns the last one. The break only leaves the version loop, so any program after a failed one overwrites its error. Keep the first error instead of the last. This is a flag day for CONFIG_NFS_LOCALIO=3Dy, which converges on the CONFIG_NFS_LOCALIO=3Dn behaviour (the Kconfig default): - NFSv4 is unaffected: nfsd_version4 sets vs_rpcb_optnl, so svc_generic_rpcbind_set() returns 0 for it however __svc_register() went. - nfsd_version3 does not set it, and nfsd_net_init() enables every supported version, so a v3-enabled server with no reachable rpcbind now fails to bring up any listener. svc_bind() does not catch that earlier: rpcb_create_local() falls through to rpcb_create_local_net(), which passes RPC_CLNT_CREATE_NOPING and returns 0 with nothing listening. - A partial failure (nfsd registered, nfsacl not) tears the listener down but leaves the nfsd entry in rpcbind until the next svc_rpcb_setup() clears it. Fixes: 642ee6b209c2 ("SUNRPC: Allow further customisation of RPC program re= gistration") Signed-off-by: Jeff Layton Assisted-by: LLM --- 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 Tue Sep 29 08:25:36 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 CD69D432E65; Mon, 10 Aug 2026 17:39:08 +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=1786383551; cv=none; b=FWvKvcyq3SNDIJAFHqH1QwE6xw39iWk3gh7JOkixg5hEO/MvhiZKtA37fP0qdznmDffhp3ggrE/LTd8lNm1SjCZ7Ccb6ZS08i44y0PXjarrAGJHM9UB2Rm1sK2IblHNvvkFuEtBpI7xpZswy4LQsXzD+c85HD3qPb59mBD54IdQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786383551; c=relaxed/simple; bh=bU7TlyIjI/xXMBkA3z/pqZrvS0xFPRFOQxK9yoCYpTA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=q4XO1splvxxq0pkWdcF/3QG7/HOBVmuGRZ+rZbuJyJBeZsbniH4EWmsLxkCZa0iq5GSfdLHNYP+KaY3NVin5eieqKsRPL4++qFqtFaYahhjuhHTUTMKSFthT1+g/2PRm3zBZWBO5+3SPuibAL0AdbmNxaJGk7zVDuEXJ1HkgXXk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=NZtWlNmE; 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="NZtWlNmE" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 00BDD1F00A3D; Mon, 10 Aug 2026 17:39:06 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786383548; bh=nawCu433u2kLsu8sTCjfwWASNlocLJb+FFSqUBIHmJM=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=NZtWlNmEZ+fyTJgKHVfUBMd667HmERsd5C2ZeFg1iyWgYVJ/T729lbOIXAOzBGBim M/WbHvPYg0BBxP0ZAxqWAelsx9rTgZEq6PoTgc8g+muH7uPqW2gZUIJOwF07vku42X mjpG3MYGNpc1oNPWrijG019jdTofh9nFiCO+kkHQKw6BBGoQuupUd9S28lDNOYGGmR aLHEOj8ocUCHOqyjhvUU5GwxT1KFqZx/QVB1wyupQtUvHSD2YO+qILmLqQatGqwZjb 1dOPOHEqU3aoVhNqLxBeXpiwJkqoTFSChQ9KO1ZCCI2tHVTs94aL2VxLvPnE2EINgQ DQv0l3ndUrR1A== From: Jeff Layton Date: Mon, 10 Aug 2026 13:38:51 -0400 Subject: [PATCH 4/7] 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: <20260810-nfsd-nl-hang-v1-4-2519fdd5bc1a@kernel.org> References: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@kernel.org> In-Reply-To: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@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 , "J. Bruce Fields" , Shuah Khan Cc: 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=2805; i=jlayton@kernel.org; h=from:subject:message-id; bh=bU7TlyIjI/xXMBkA3z/pqZrvS0xFPRFOQxK9yoCYpTA=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqegyzAa1WVv1nHbnmBvVVGUYXv045yQN5mGhYx sK5Aqlv3SqJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCanoMswAKCRAADmhBGVaC FQbrD/9ObIiVjx4tMPALoeCzye/MmKTJB/LLsskFMCO8CLbwbhmCuVz9JdIi6Ph6Np/iy909Ts4 cpFVZuuN4p+x4M9qKd8JTUycUVBbzk0MrSGgAkPmR+6+Oyxx3n0t60OdTAmatmSah8S0Agfbh4J Sa9cr+1hE4lLIE4C1Tk9sLDZH4MOeNvL4xvhGCoCIEjL9et6gn/oXxFpkXSHesUpS2udAOwUqRa sQv5i87Rq3LJ0/jQZUR2HEgEDw196TwJaDxEO7EqIkXAcTAUy7dpVLcFuvUkGg+8FIhG7p88CHA ++vWwHhjfAUFf519AA37AOua0s/WVB/pu7bQK1Qa0tGFRMeHSLpiB7ZusObXncfA6bGyIw3Nq63 rlb0K3z3w7XFRYlRl7YD8/GxHEqOlXEKEDjBHmAZQtwcK1wbH2AzsCiJevP3q+6GVNhE3OVtC5G b14ONh7bmi003sMd0xyiMxD0+VmlKXdhnKV73V8JgD8zLIZVfsiUNDtKH2M8dPt26DbhYESRoDl 6jlVkRPxeQeLjLIQ36RDGywPye1OhlgZRu7ltzzSDyUQ53GTICZ2aku+GFEQ9EjVRc+7ou20W/C VzdZPNh8WN0Na4tuWFp8dovCadpvC1nw7VKn6egk7M08fKjyIo9JiWS54owL97XPW93mYuGO4aE gsiRJsbvPviSugA== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 The kernel's local rpcbind client runs on the transport defaults: a 10s major timeout for AF_LOCAL, 60s for the loopback TCP fallback (xprt_calc_majortimeo() returns to_initval when to_increment is 0). Those calls are synchronous and run under nfsd_mutex, several per operation: rpcb_create_local() attempts up to three client creations, and svc_register() issues one call per program and version. A local rpcbind that accepts the connection but never replies stalls each of them, and the accumulated hold is enough to trip the hung-task watchdog on other NFSD netlink ops (the holder waits killably and evades it): INFO: task hung in nfsd_nl_cache_flush_doit The local rpcbind lives on loopback or an AF_LOCAL socket and answers in microseconds, so bound its client to one attempt, 1s. This shortens the stall rather than removing it, and it is not free. Registration stays synchronous and stays fatal: rpcb_create_local() failure aborts nfsd_create_serv() via svc_bind(), and svc_register() failure makes svc_setup_socket() fail, so a rpcbind that is merely slow to be scheduled can now fail server startup where it previously succeeded. Making the registration asynchronous is the real fix. Link: https://syzkaller.appspot.com/bug?extid=3Dc7eae0eb80858a2dba0f Signed-off-by: Jeff Layton Assisted-by: LLM --- 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 Tue Sep 29 08:25:36 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 3EE6E432E70; Mon, 10 Aug 2026 17:39:10 +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=1786383554; cv=none; b=o8W8BTCOtrJ4lIzlChzg49/scspGbt7MJ1UeOLEA64XUjFY/gJRhx0LQBRAnAgmu2nvc9BrszRZCQ8FfwHOOpfKXTaKubZ3E8drgPujrq9r6ce7r5RhXzADBGA0BFKJmhJ3c87onyS32phUTg1Mcp68rmXPlhbLeAmxPPlZ0U5s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786383554; c=relaxed/simple; bh=X2Sy2wzTG7KljTPlPxvIGdh7rCdZk2v6GHezqhHS0VA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ltwGC151hf83xgAYaAzNumuc1xZOZpoHCd2+aTVFHw3l/NO84nLJEm5s0faNwTuodLbMugtl7PhOxvQm6lhWO8uRWXhx6ptKHZn92rycfI7gyzBTd+YTXKJ62/USG2g+hURyMU/qEmzRg41XzJgJi64XATdLAl0yJhulKCrm4o0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ELa+kdsI; 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="ELa+kdsI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A8CAF1F00ADE; Mon, 10 Aug 2026 17:39:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786383550; bh=mtAPr3+A6mSt3477rQKJMbZWgrnq/LtLzN3O0hTuQT4=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=ELa+kdsIqKMduIAXfe73Y6gvSZKxlYWlrctfwWNdwXvp9wigOFVS3rEpfMkKGSSDZ IDQjt299Bl6MoWgNJ41cxzcNBC+18+BMvEkoeElz5Ueeuqq1S4b/HTbWWR9B7iYqSM V1xAp+I90JC1boOkt74t0xzG3PWgZSIvyeL4yvjJ8aCgPsPNWqqctz7rTZ0VyPbSm0 +yevaDjhhg1WHRJviIOr365GGnkkwhxWtxm2ZJs0llfH39J9woD9kAvkF49KUCu4HT +0Tm8W/RGNgA+gqjmp72dwPcsfsPoyuZgHhXWT640t9TT7rugSerM+52ZCnEsAhJHG CFzMHd7LscicA== From: Jeff Layton Date: Mon, 10 Aug 2026 13:38:52 -0400 Subject: [PATCH 5/7] 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: <20260810-nfsd-nl-hang-v1-5-2519fdd5bc1a@kernel.org> References: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@kernel.org> In-Reply-To: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@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 , "J. Bruce Fields" , Shuah Khan Cc: 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=1503; i=jlayton@kernel.org; h=from:subject:message-id; bh=X2Sy2wzTG7KljTPlPxvIGdh7rCdZk2v6GHezqhHS0VA=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqegyzqumvQs27MKaGfgAfO6V+CGzVC/xVc60x6 f+jz1NQi8yJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCanoMswAKCRAADmhBGVaC FTEHEADIrk8U2pkJpzE9bpChnwglKteWOp+tzfmbY0vmdyuezTNTaZxSF4u5g4f/Bt36M8qfkLR kFNjqFD7lpMa89o9d92VgiA2S640wElYXaylqARqN+lFisV8lZfDcnqVp3Hj87ptnhf9VS6BWqa 9KHknLKm/SpF8brsx/wL9Px3JwIROJo/QiB/gqVqTyk7eWp1FnYKtVe3mrbDcj1in64YhFU+mlF qKDGiI8/qk2VtgwSIux481Qc7WVjV4VSLWY7k3BBjEI4i8pgqP1TYthCe/ICQkFUObZPHTGKCIv aKyhPUf9FNHMLMZGkb+Kz7R2sgchZ3j9rAQgVIjc26VBFjaMvqo8eHn/Q/7fsIXah/Lx0Jadln8 nVEB4/ApqCVX8l6w2jsHjDmmR58m+bcmaufVytzaliHURZht011fa94NApp0rOy0nbqnSr3/hp1 DtOhv58xmmqFRGUw9s7sTa4B4v+OqkIZlDKki/2b7j5lv/plWgmJ7K+xJ2oDH94g4anQNzFFjmO Z6R2QuFXUV++vdIGYUXoLTdwESv8onNjF6eabeKHVek0qRiq4S2c7SU6KhMsroqe52iUJJZENif hT4T9lFkgNioDIYjpS19Kliwqs9IwJTAP6E1yQH1CYAHbp+9H8m5T6F0/hzXwWpj5zO+vc3tsMb Yc807Eq38Ra7+yA== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 nfsd_nl_listener_set_doit() hands back the raw errno from svc_xprt_create_from_sa() and sets no extack, so a failed LISTENER_SET tells userland only "Connection refused". The usual cause is svc_setup_socket() -> svc_register() failing because the local rpcbind is not reachable, which is not guessable from the errno alone -- and since "SUNRPC: keep the first error in svc_register()" that failure is fatal on CONFIG_NFS_LOCALIO=3Dy too. Name the transport and the error. The message tracks err, which keeps the last failure, so a multi-listener request reports the entry whose errno is returned. The rejections in nfsd_nl_validate_listeners() other than -E2BIG are still bare; those are left alone here. Signed-off-by: Jeff Layton Assisted-by: LLM --- fs/nfsd/nfsctl.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c index 66931caaaaed..a6ef85e6b419 100644 --- a/fs/nfsd/nfsctl.c +++ b/fs/nfsd/nfsctl.c @@ -2184,8 +2184,12 @@ 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) { + NL_SET_ERR_MSG_FMT(info->extack, + "cannot create %s listener: %d", + xcl_name, ret); err =3D ret; + } } =20 if (!serv->sv_nrthreads && list_empty(&nn->nfsd_serv->sv_permsocks)) --=20 2.55.0 From nobody Tue Sep 29 08:25:36 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 001D4433E89; Mon, 10 Aug 2026 17:39:11 +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=1786383563; cv=none; b=MjmJxgdeSeJNvcXbIz6dZKUzcho78AX0J0kW4gUiy412t3s+7VqlbUL+2UyFJ9OpnS8RI9HqTi+MKi1wV8g0PU65EAYZVPlMrfAHc5txHZWX2BH8OOeNMkzN+MUl/ujDITRbIiF2g3wkFec8CRIYHvFr4DOmg2WtUEGPBCnMM9Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786383563; c=relaxed/simple; bh=OL4dg/suKjkKoJBC6wXTDjwITGW/3JNAhtxddzSH180=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=qv66TpCrr8ZP3hY01fEazSBW/0P5EjyjxfGxTNei9Qd3a+lp8z6qXZXvgSK/HovVGMbn1XU3+wsFeWGprbNyJFAoNoEfGP8/R0rh5cwOJZgMUnGzhzzip/jWgtc/YVlWKFP1DVSyLRxrX7i6R30eF9KA3MyJ6USUkLxZl/ElnP4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=aGj++8ny; 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="aGj++8ny" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5CFB31F00AC4; Mon, 10 Aug 2026 17:39:10 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786383551; bh=lqrq5wwTC5/J09LYCTcsE4eXPGtB6fXiyfPiysou/oA=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=aGj++8ny8yt6eQzc6CrcgMoSBjNgviH9QKvGu0/EcBh3biCnJVgQhE3GU6PwoBi9w zvczXwo+vyUazdUaXViAywtDo7FpshrkeYkpcBPWF/QFsYImydOAnrrY4T/q7ianHR yFMwa9qNjBJdAOm4u4pLgI/INMAtnZNgrgwX9VZx+zXzvCIT58cn20QPWOxQgA/Kvl XuTRkQ7lmHipqeiJm1Q/lu6VokPxs1bAmpdRLM12TFRtY6lHpEi0NFgJgSQzf3sl40 OyEH5uParN/sf0XLBMMxj9NmLGXB9ihheVNReV8FoC2G7IvgijHlQUTF+Zwfre3Xrj Fjd266nePDsMA== From: Jeff Layton Date: Mon, 10 Aug 2026 13:38:53 -0400 Subject: [PATCH 6/7] 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: <20260810-nfsd-nl-hang-v1-6-2519fdd5bc1a@kernel.org> References: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@kernel.org> In-Reply-To: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@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 , "J. Bruce Fields" , Shuah Khan Cc: 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=18242; i=jlayton@kernel.org; h=from:subject:message-id; bh=OL4dg/suKjkKoJBC6wXTDjwITGW/3JNAhtxddzSH180=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqegyzzwp9u+RO9vcsurYq+Y1qWRG7SvzuOjh/x 6GEiNmFlCWJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCanoMswAKCRAADmhBGVaC FUVmEACfAGIJ2E1ULMD095keNhHA2VLmD8Mq3ARprhcz7cpFPyaj4LbXdiv0F5n9r6sW6DrZfJj sUKr+2K3jQjYXamorlaSIo7P/eXIabFPRtKrJVB19trKnqYdrsFwSFrbOfpnMIdkpGIHLyAgMqW 6X4NMJ5z7Rup1f8b7DPzWxviL3hdkAU4Pz+0d5uus5Cf0/JfatxEjF9GXUE55FPZHXW46rfceMz Pbdku2ZNCiArlWfL9zdUQmEwj4rZTf/yJuS13TNd6nqkdUT2FGNB5D/yhATZJB5rFiVlgLRuqqq shcmSVZDnRDwAGbZaOVAAW57096E2BwHQkquHSkS+djF99wKpfqBh3eQTuUPwTRRUetJhnOFmq4 LXBOea2zQOkRn4ulA4S6kLbkgSnlxLQO96jKVylWXZnSo0UtKu6RzkOvQwQD0WKchydbYMCIs9Q tPNEuCw5EATOfyuKHM0RiDWFDUiVwzf9OBzFmwD5xRhu/asF2GPK2hpatmpO6pCb9SjtdomJg8I wHtzELnPwXV/EoiBrFgasRSQ4dHhbJj0IMfxNOepd52V3T13cYIQ+qERNbw+ERYM4GvTN9ZUeH7 MJAksqu1k4Zo26AI9PdVBZo8lr7EVfZxgIbQmJgLL/rUPHxqKFidrUO8jfrXRpkPEiXnWFH0Xss xsXRy8N1/JPZU0g== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 Regression tests for the NFSD_CMD_LISTENER_SET checks that nfsd_nl_validate_listeners() runs before nfsd_mutex is taken: bad or absent transport name, missing address, truncated or unsupported sockaddr, bad address family, a malformed entry behind a well-formed one, and more than NFSD_NL_LISTENER_MAX entries. Plus a LISTENER_GET against an empty netns. None of these reach nfsd_create_serv(), so nothing here creates a serv or registers with rpcbind. Tests that do need one come next, with a stub. Uses kselftest_harness.h so each test runs in its own net+mount namespace. /run is masked there: unix_find_bsd() resolves by inode and takes no struct net, so a "/var/run/rpcbind.sock" connect from this netns would otherwise reach the rpcbind on the host -- and svc_rpcb_setup() opens by calling svc_unregister(), which would clear the host's nfsd registrations. Signed-off-by: Jeff Layton Assisted-by: LLM --- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/nfsd/.gitignore | 1 + tools/testing/selftests/nfsd/Makefile | 6 + tools/testing/selftests/nfsd/config | 4 + .../testing/selftests/nfsd/nfsd_netlink_listener.c | 488 +++++++++++++++++= ++++ tools/testing/selftests/nfsd/settings | 1 + 6 files changed, 501 insertions(+) diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Mak= efile index 8d4db2241cc2..5d615301d368 100644 --- a/tools/testing/selftests/Makefile +++ b/tools/testing/selftests/Makefile @@ -85,6 +85,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..e6945ff9551c --- /dev/null +++ b/tools/testing/selftests/nfsd/config @@ -0,0 +1,4 @@ +CONFIG_NET_NS=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 Tue Sep 29 08:25:36 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 ABCCE4322F4; Mon, 10 Aug 2026 17:39:13 +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=1786383555; cv=none; b=oUTlGwCFchiIin54C7txGGeXv9myx363MlENvLGAfTvEeyA7DgnF8150WxTzycPVdOk4/IKuzInXM1QdCdZEKwxmnc5vv6LZgQ01UoHdYfq+Oc8eKU0TiDS5GariBgF9mpXfa1p8olO0JC1HNM6xyK6OBNtcDd1/E57RgkisZKg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786383555; c=relaxed/simple; bh=R3woNQi9oGCf9GbRzPNsOP1NNIFGpQMUcmCS3wj4UXQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=k1Cy1Qit2AZg3gebREni9GmNTHOtTDHZP5fhCb3GJRz3uGREAqxBHiAOeeO5O+ouhlaqJPj9qoMPhhYBQzXQERKUrd3Inn5PjVrQwxpfm94pAaezP3GH4HMpr2IBZSl5G/mWGKHJ2Y8KIPtsEo/hKiKckuligja7xAVVktyZLkQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CbxefDuL; 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="CbxefDuL" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2250E1F00A3A; Mon, 10 Aug 2026 17:39:12 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1786383553; bh=UaWwWq3StU66+Eg/0V1UlDxQAXL7Uw/wC8/hFceq28o=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=CbxefDuLsOaoHRZjqe2VRmVramqwanUFnB1thzaSGyzT1Mfsr1MZ4qjJWPyWfbIMq kxlTs0oSwL49jqVd4XVzdl73y7PED1Ioifmmn8tbgIAQFS370UjdZUZsnreLtXc4RJ v6eW1k+296ehacd+1KBRYDOaFtvn0+RiPHQtBspNJUAlgUlK3U8i0nc7b9zEYvLJkv Jaad6RQtMGu71Oq3aPklDMqNywjLzazWCUpOzgELMZLvHBk0RZLN4qbP3HnL0ZMERy SHOFq0y4NPuKbZ49UAHJI93Zni/m7j8lh8Nnr4mZaosRsWwqA5+5keredXfOgdHjpa zRlciNFAtCmQw== From: Jeff Layton Date: Mon, 10 Aug 2026 13:38:54 -0400 Subject: [PATCH 7/7] 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: <20260810-nfsd-nl-hang-v1-7-2519fdd5bc1a@kernel.org> References: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@kernel.org> In-Reply-To: <20260810-nfsd-nl-hang-v1-0-2519fdd5bc1a@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 , "J. Bruce Fields" , Shuah Khan Cc: 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=18843; i=jlayton@kernel.org; h=from:subject:message-id; bh=R3woNQi9oGCf9GbRzPNsOP1NNIFGpQMUcmCS3wj4UXQ=; b=owEBbQKS/ZANAwAKAQAOaEEZVoIVAcsmYgBqegyzwnfR8omsjDt2uMOIq5iiST8x6PYf8KRFF CbN1HkCAYqJAjMEAAEKAB0WIQRLwNeyRHGyoYTq9dMADmhBGVaCFQUCanoMswAKCRAADmhBGVaC FZzID/99Mt4cmw5GUOCDNAvGY1576EfcbTWBcOQVL93fh3NB35PBpN1S+AXBPRSIGP1QqWU+ov0 huxF1FCE4D5TY1NOYutd21wCLfQ13DH65eiizD0lHbI5GHGMVfIWXtedetiHItHtIPf9k5+++kL 1WkKnR+0C7K6+vJabhN0kxvavjpo4PYlS9N8GGs62xXe2y34qbl4/XAQsb+xK+VQmBf0/pbrt7F UfwKQnE54LWxBpvLHWhkphexI3xGajMtFCy/q98HMaA1LeBzoOs7VnoNcg1Bm5kPCE3IF6NDRMy sIN8YzBX2tK7eKH47N0BhqFFKnjF8v7lVASgpEc+4uGiIOGMGAwB4Ey1OUgmrRfqiJnesPDhhgE 7aC6/jK4p/nrBxOfMy/pFrAwUWbjrSPT9ST1/wPM2XMGK+udCPbXIxo7wMIOqvl+pV3spgPywzd dQ0nbsdBPLZ5HcWJT+rL+wsK8tv/feppDZMLHDRDe5Ci156r4o3mYpQQkcq/WV1dk7a7nXMJ/gf 1R608H1DdnKD9tzlIMfZHjJm2Znj2wJ5uC9R0gPbhjWl74feM7lBBDZphzB6V9NFBfgj2nM0qCF Pw+t9UdESb/Gx/Rv6s7ep7ZpQ4SZiYAhTYYcyfwMCpHbsz02t2gpvdxY94hlXxglALz3rDWwQpa SWhvAPrZOgdjyRw== X-Developer-Key: i=jlayton@kernel.org; a=openpgp; fpr=4BC0D7B24471B2A184EAF5D3000E684119568215 Creating a listener registers with rpcbind: svc_xprt_create_from_sa() passes flags of 0, so pmap_register is true in svc_setup_socket(), and nfsd_version3 is enabled by default and does not set vs_rpcb_optnl, so a registration failure aborts listener creation. A fresh netns has no rpcbind, and reaching the host's is not an option -- svc_rpcb_setup() opens by calling svc_unregister(), which would clear the host's nfsd entries. Serve it from within the namespace instead. The abstract AF_LOCAL name the kernel tries first is per-netns (unix_find_abstract() takes a struct net), so bind "\0/run/rpcbind.sock" and fork a minimal responder: - arguments are never decoded; the NULL procedure gets an empty success and SET/UNSET get TRUE - RPCBVERS_4 is answered as well as RPCBVERS_2, because __svc_rpcb_register6() turns a v4 refusal into -EAFNOSUPPORT and that would fail every IPv6 listener - PR_SET_PDEATHSIG plus an explicit kill in FIXTURE_TEARDOWN, so no stub outlives its test With that in place, add the tests that need a serv: create/add/remove and LISTENER_GET round-trips (tcp, udp, multi, idempotent re-set, subset removal, empty-list serv destroy, IPv6), the empty-list request, and the -EBUSY refusal once THREADS_SET has started threads. Two of the new tests exist to catch a revert rather than to describe the interface, since neither is visible in the errno alone: - val_reject_keeps_listeners. An unknown transport name ends in -EPROTONOSUPPORT either way, because svc_xprt_create_from_sa() returns that too. What differs is that 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. - sem_register_refused, which restarts the stub in a mode that answers RPCBPROC_SET with FALSE. rpcb_register_call() turns that into -EACCES, which must reach userland and leave no listener behind. On CONFIG_NFS_LOCALIO=3Dy it does not, unless svc_register() keeps the first error: nfslocalio is last in nfsd_programs and its NULL and vs_hidden versions both report success, overwriting the failure. Signed-off-by: Jeff Layton Assisted-by: LLM --- .../testing/selftests/nfsd/nfsd_netlink_listener.c | 444 +++++++++++++++++= +++- 1 file changed, 438 insertions(+), 6 deletions(-) diff --git a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c b/tools/t= esting/selftests/nfsd/nfsd_netlink_listener.c index ae28c224255f..3e3307680d7d 100644 --- a/tools/testing/selftests/nfsd/nfsd_netlink_listener.c +++ b/tools/testing/selftests/nfsd/nfsd_netlink_listener.c @@ -3,30 +3,40 @@ * 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 @@ -36,8 +46,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 */ @@ -327,10 +339,233 @@ static int listener_get(struct listener_ent *out, in= t max) return parse_listener_get(rbuf, n, out, max); } =20 +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=3D family && e[i].port =3D=3D port && + !strcmp(e[i].xprt, xprt)) + 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: svc_xprt_create_from_sa() + * passes flags of 0, so pmap_register is true in svc_setup_socket(), and + * nfsd_version3 is registerable by default and does not set vs_rpcb_optnl, + * so a registration failure aborts listener creation. The abstract AF_LOC= AL + * name the kernel tries first is per-netns (unix_find_abstract() takes a + * struct net), so answer it here and stay out 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 fail every IPv6 listener. + * + * 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. + */ +#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 }; + +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, int mode) +{ + uint32_t mark, call[6], rep[7]; + unsigned int len, nrep =3D 6; + 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; + } + + 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, int mode) +{ + 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; + n++; + } + } + + for (i =3D 1; i < n; i++) { + if (!(pfd[i].revents & (POLLIN | POLLHUP | POLLERR))) + continue; + if (rpcb_stub_call(pfd[i].fd, mode)) { + 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; + + 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, mode); + _exit(0); + } + + close(lfd); + return pid; +} + +/* + * Swap the stub for one in @mode. Safe before the first request: no serv + * exists yet, so the kernel has not connected and the abstract name is fr= ee + * again once the old stub has been reaped. + */ +static int rpcb_stub_restart(pid_t *pid, int mode) +{ + if (*pid > 0) { + kill(*pid, SIGKILL); + waitpid(*pid, NULL, 0); + } + *pid =3D rpcb_stub_start(mode); + return *pid > 0 ? 0 : -1; +} + /* --------------------------- fixture --------------------------- */ =20 FIXTURE(nfsd_listener) { - int placeholder; + pid_t rpcbd; }; =20 FIXTURE_SETUP(nfsd_listener) @@ -369,14 +604,28 @@ FIXTURE_SETUP(nfsd_listener) nfsd_family =3D genl_resolve_nfsd(); if (nfsd_family < 0) SKIP(return, "nfsd genl family not found (modprobe nfsd?)"); + + 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) { + if (self->rpcbd > 0) { + kill(self->rpcbd, SIGKILL); + waitpid(self->rpcbd, NULL, 0); + } } =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]; @@ -477,6 +726,33 @@ TEST_F(nfsd_listener, val_second_entry_bad) EXPECT_EQ(-EAFNOSUPPORT, listener_set(attrs, off)); } =20 +/* + * 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)); +} + +/* =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 +761,160 @@ 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)); + ASSERT_EQ(1, listener_get(got, MAX_LISTENERS)); + EXPECT_NE(NULL, find_listener(got, 1, "tcp", AF_INET, TEST_PORT)); + EXPECT_EQ(htonl(INADDR_LOOPBACK), got[0].a4.s_addr); +} + +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)); +} + +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); + + ASSERT_EQ(0, listener_set(attrs, off)); + EXPECT_EQ(0, listener_set(NULL, 0)); /* empty -> destroy serv */ + EXPECT_EQ(0, listener_get(got, MAX_LISTENERS)); +} + +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)); + EXPECT_EQ(0, memcmp(&got[0].a6, &in6addr_loopback, sizeof(in6addr_loopbac= k))); +} + +/* =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 must fail listener creation, + * whatever CONFIG_NFS_LOCALIO is set to. + * + * The error has to survive svc_register()'s walk over sv_programs to get + * here. With CONFIG_NFS_LOCALIO=3Dy the trailing nfslocalio program has o= nly + * a NULL and a vs_hidden version, and svc_generic_rpcbind_set() reports 0 + * for both, so an svc_register() that keeps the last result rather than t= he + * first hands back success and the listener comes up regardless. + */ +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); + + ASSERT_EQ(0, rpcb_stub_restart(&self->rpcbd, RPCB_STUB_REFUSE)); + + EXPECT_EQ(-EACCES, listener_set(attrs, off)); + EXPECT_EQ(0, listener_get(got, MAX_LISTENERS)); +} + +/* =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) +{ + 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 */ + threads_set(0); /* stop before netns exit */ +} + +TEST_F(nfsd_listener, sem_busy_on_remove) +{ + 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 */ + threads_set(0); +} + TEST_HARNESS_MAIN --=20 2.55.0