rq_lease_breaker has always been a NFSv4 specific layering violation in
svc_rqst. The reason it's there though is that we need a place that is
thread-local, and accessible from the svc_rqst pointer.

Add a new rq_private pointer to struct svc_rqst. This is intended for
use by the threads that are handling the service. sunrpc code doesn't
touch it.

In nfsd, define a new struct nfsd_thread_local_info. nfsd declares one
of these on the stack and puts a pointer to it in rq_private.

Add a new ntli_lease_breaker field to the new struct and convert all of
the places that access rq_lease_breaker to use the new field instead.

Signed-off-by: Jeff Layton <jlayton@kernel.org>
---
 fs/nfsd/nfs4proc.c         | 3 ++-
 fs/nfsd/nfs4state.c        | 9 ++++++---
 fs/nfsd/nfsd.h             | 4 ++++
 fs/nfsd/nfssvc.c           | 3 +++
 include/linux/sunrpc/svc.h | 5 ++++-
 5 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index d476d108f6e107ad5310e4ea504daabd750cf450..5c30ea99daad2825ba62fefc456a6d2cc41b6063 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -3038,6 +3038,7 @@ nfsd4_proc_compound(struct svc_rqst *rqstp)
 	struct svc_fh *current_fh = &cstate->current_fh;
 	struct svc_fh *save_fh = &cstate->save_fh;
 	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
+	struct nfsd_thread_local_info *ntli = rqstp->rq_private;
 	__be32		status;
 
 	resp->xdr = &rqstp->rq_res_stream;
@@ -3076,7 +3077,7 @@ nfsd4_proc_compound(struct svc_rqst *rqstp)
 	}
 	check_if_stalefh_allowed(args);
 
-	rqstp->rq_lease_breaker = (void **)&cstate->clp;
+	ntli->ntli_lease_breaker = &cstate->clp;
 
 	trace_nfsd_compound(rqstp, args->tag, args->taglen, args->client_opcnt);
 	while (!status && resp->opcnt < args->opcnt) {
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index af2b307ac78cf3733a173f9024aced87fe94603f..583c13b5aaf3cd12a87c7aae62fe6a8223368f55 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -5542,13 +5542,15 @@ nfsd_break_deleg_cb(struct file_lease *fl)
 static bool nfsd_breaker_owns_lease(struct file_lease *fl)
 {
 	struct nfs4_delegation *dl = fl->c.flc_owner;
+	struct nfsd_thread_local_info *ntli;
 	struct svc_rqst *rqst;
 	struct nfs4_client *clp;
 
 	rqst = nfsd_current_rqst();
 	if (!nfsd_v4client(rqst))
 		return false;
-	clp = *(rqst->rq_lease_breaker);
+	ntli = rqst->rq_private;
+	clp = *ntli->ntli_lease_breaker;
 	return dl->dl_stid.sc_client == clp;
 }
 
@@ -9360,13 +9362,14 @@ __be32
 nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct dentry *dentry,
 			     struct nfs4_delegation **pdp)
 {
-	__be32 status;
 	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
+	struct nfsd_thread_local_info *ntli = rqstp->rq_private;
 	struct file_lock_context *ctx;
 	struct nfs4_delegation *dp = NULL;
 	struct file_lease *fl;
 	struct nfs4_cb_fattr *ncf;
 	struct inode *inode = d_inode(dentry);
+	__be32 status;
 
 	ctx = locks_inode_context(inode);
 	if (!ctx)
@@ -9387,7 +9390,7 @@ nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct dentry *dentry,
 		break;
 	}
 	if (dp == NULL || dp == NON_NFSD_LEASE ||
-	    dp->dl_recall.cb_clp == *(rqstp->rq_lease_breaker)) {
+	    dp->dl_recall.cb_clp == *(ntli->ntli_lease_breaker)) {
 		spin_unlock(&ctx->flc_lock);
 		if (dp == NON_NFSD_LEASE) {
 			status = nfserrno(nfsd_open_break_lease(inode,
diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
index a01d709533585f09df1399b85eecc36ea7c466c5..938906c6d10cd65e7e3a1bc889b4fdcb56918f6f 100644
--- a/fs/nfsd/nfsd.h
+++ b/fs/nfsd/nfsd.h
@@ -82,6 +82,10 @@ extern atomic_t			nfsd_th_cnt;		/* number of available threads */
 
 extern const struct seq_operations nfs_exports_op;
 
+struct nfsd_thread_local_info {
+	struct nfs4_client	**ntli_lease_breaker;
+};
+
 /*
  * Common void argument and result helpers
  */
diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
index eee8c3f4a251a3fae6e41679de0ec34c76caf198..8ce366c9e49220e8baf475c2e5f3424fedc1cec1 100644
--- a/fs/nfsd/nfssvc.c
+++ b/fs/nfsd/nfssvc.c
@@ -900,6 +900,7 @@ nfsd(void *vrqstp)
 	struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
 	struct net *net = perm_sock->xpt_net;
 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+	struct nfsd_thread_local_info ntli = { };
 	bool have_mutex = false;
 
 	/* At this point, the thread shares current->fs
@@ -914,6 +915,8 @@ nfsd(void *vrqstp)
 
 	set_freezable();
 
+	rqstp->rq_private = &ntli;
+
 	/*
 	 * The main request loop
 	 */
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 4dc14c7a711b010473bf03fc401df0e66d9aa4bd..ab8237ba9596e9f31e2c42abedec435a23162b40 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -175,6 +175,9 @@ static inline unsigned long svc_serv_maxpages(const struct svc_serv *serv)
 /*
  * The context of a single thread, including the request currently being
  * processed.
+ *
+ * RPC programs are free to use rq_private to stash thread-local information.
+ * The sunrpc layer will not access it.
  */
 struct svc_rqst {
 	struct list_head	rq_all;		/* all threads list */
@@ -251,7 +254,7 @@ struct svc_rqst {
 	unsigned long		bc_to_initval;
 	unsigned int		bc_to_retries;
 	unsigned int		rq_status_counter; /* RPC processing counter */
-	void			**rq_lease_breaker; /* The v4 client breaking a lease */
+	void			*rq_private;	/* For use by the service thread */
 };
 
 /* bits for rq_flags */

-- 
2.52.0

On Tue, Jan 13, 2026, at 1:37 PM, Jeff Layton wrote:
> diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
> index eee8c3f4a251a3fae6e41679de0ec34c76caf198..8ce366c9e49220e8baf475c2e5f3424fedc1cec1 100644
> --- a/fs/nfsd/nfssvc.c
> +++ b/fs/nfsd/nfssvc.c
> @@ -900,6 +900,7 @@ nfsd(void *vrqstp)
> struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
> struct net *net = perm_sock->xpt_net;
> struct nfsd_net *nn = net_generic(net, nfsd_net_id);
> + struct nfsd_thread_local_info ntli = { };
> bool have_mutex = false;
>  
> /* At this point, the thread shares current->fs
> @@ -914,6 +915,8 @@ nfsd(void *vrqstp)
>  
> set_freezable();
>  
> + rqstp->rq_private = &ntli;
> +
> /*
> * The main request loop
> */

Thanks for tackling this one. Nits below...

This assumes sizeof(structure nfsd_thread_local_info) will always
be small enough that it is reasonable to keep on the stack. I
can't say that would be a good bet in the long run.

And we don't need the perfect reliability of not doing a dynamic
allocation here. If kmalloc(sizeof(struct nfsd_thread_local_info))
fails, the thread exits immediately, no harm.

Also, scatter-gather lists could not be stored directly in this
object because it is on the stack. If Ben wanted to stick a
32-byte buffer in struct nfsd_thread_local_info to be used with
the crypto API, it would have to be a pointer to it, not the
buffer itself.


Chuck Lever

On Tue, 2026-01-13 at 14:21 -0500, Chuck Lever wrote:
> 
> On Tue, Jan 13, 2026, at 1:37 PM, Jeff Layton wrote:
> > diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
> > index eee8c3f4a251a3fae6e41679de0ec34c76caf198..8ce366c9e49220e8baf475c2e5f3424fedc1cec1 100644
> > --- a/fs/nfsd/nfssvc.c
> > +++ b/fs/nfsd/nfssvc.c
> > @@ -900,6 +900,7 @@ nfsd(void *vrqstp)
> > struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
> > struct net *net = perm_sock->xpt_net;
> > struct nfsd_net *nn = net_generic(net, nfsd_net_id);
> > + struct nfsd_thread_local_info ntli = { };
> > bool have_mutex = false;
> >  
> > /* At this point, the thread shares current->fs
> > @@ -914,6 +915,8 @@ nfsd(void *vrqstp)
> >  
> > set_freezable();
> >  
> > + rqstp->rq_private = &ntli;
> > +
> > /*
> > * The main request loop
> > */
> 
> Thanks for tackling this one. Nits below...
> 
> This assumes sizeof(structure nfsd_thread_local_info) will always
> be small enough that it is reasonable to keep on the stack. I
> can't say that would be a good bet in the long run.
> 
> And we don't need the perfect reliability of not doing a dynamic
> allocation here. If kmalloc(sizeof(struct nfsd_thread_local_info))
> fails, the thread exits immediately, no harm.
> 

Not sure how much space Ben will need (if any).

We certainly could have nfsd allocate this separately. I didn't see the
point for something that is only a few bytes though.

> Also, scatter-gather lists could not be stored directly in this
> object because it is on the stack. If Ben wanted to stick a
> 32-byte buffer in struct nfsd_thread_local_info to be used with
> the crypto API, it would have to be a pointer to it, not the
> buffer itself.
> 

*nod*
-- 
Jeff Layton <jlayton@kernel.org>

On Tue, Jan 13, 2026, at 2:31 PM, Jeff Layton wrote:
> On Tue, 2026-01-13 at 14:21 -0500, Chuck Lever wrote:
>> 
>> On Tue, Jan 13, 2026, at 1:37 PM, Jeff Layton wrote:
>> > diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
>> > index eee8c3f4a251a3fae6e41679de0ec34c76caf198..8ce366c9e49220e8baf475c2e5f3424fedc1cec1 100644
>> > --- a/fs/nfsd/nfssvc.c
>> > +++ b/fs/nfsd/nfssvc.c
>> > @@ -900,6 +900,7 @@ nfsd(void *vrqstp)
>> > struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
>> > struct net *net = perm_sock->xpt_net;
>> > struct nfsd_net *nn = net_generic(net, nfsd_net_id);
>> > + struct nfsd_thread_local_info ntli = { };
>> > bool have_mutex = false;
>> >  
>> > /* At this point, the thread shares current->fs
>> > @@ -914,6 +915,8 @@ nfsd(void *vrqstp)
>> >  
>> > set_freezable();
>> >  
>> > + rqstp->rq_private = &ntli;
>> > +
>> > /*
>> > * The main request loop
>> > */
>> 
>> Thanks for tackling this one. Nits below...
>> 
>> This assumes sizeof(structure nfsd_thread_local_info) will always
>> be small enough that it is reasonable to keep on the stack. I
>> can't say that would be a good bet in the long run.
>> 
>> And we don't need the perfect reliability of not doing a dynamic
>> allocation here. If kmalloc(sizeof(struct nfsd_thread_local_info))
>> fails, the thread exits immediately, no harm.
>> 
>
> Not sure how much space Ben will need (if any).
>
> We certainly could have nfsd allocate this separately. I didn't see the
> point for something that is only a few bytes though.

If we are designing for today, another approach would be to set up
a BUILD_WARN_ON or other type of static build failure if this
structure grows larger than, say 256 bytes -- then add dynamic
allocation at that point.


>> Also, scatter-gather lists could not be stored directly in this
>> object because it is on the stack. If Ben wanted to stick a
>> 32-byte buffer in struct nfsd_thread_local_info to be used with
>> the crypto API, it would have to be a pointer to it, not the
>> buffer itself.
>> 
>
> *nod*
> -- 
> Jeff Layton <jlayton@kernel.org>

-- 
Chuck Lever

On Tue, 2026-01-13 at 14:41 -0500, Chuck Lever wrote:
> 
> On Tue, Jan 13, 2026, at 2:31 PM, Jeff Layton wrote:
> > On Tue, 2026-01-13 at 14:21 -0500, Chuck Lever wrote:
> > > 
> > > On Tue, Jan 13, 2026, at 1:37 PM, Jeff Layton wrote:
> > > > diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
> > > > index eee8c3f4a251a3fae6e41679de0ec34c76caf198..8ce366c9e49220e8baf475c2e5f3424fedc1cec1 100644
> > > > --- a/fs/nfsd/nfssvc.c
> > > > +++ b/fs/nfsd/nfssvc.c
> > > > @@ -900,6 +900,7 @@ nfsd(void *vrqstp)
> > > > struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
> > > > struct net *net = perm_sock->xpt_net;
> > > > struct nfsd_net *nn = net_generic(net, nfsd_net_id);
> > > > + struct nfsd_thread_local_info ntli = { };
> > > > bool have_mutex = false;
> > > >  
> > > > /* At this point, the thread shares current->fs
> > > > @@ -914,6 +915,8 @@ nfsd(void *vrqstp)
> > > >  
> > > > set_freezable();
> > > >  
> > > > + rqstp->rq_private = &ntli;
> > > > +
> > > > /*
> > > > * The main request loop
> > > > */
> > > 
> > > Thanks for tackling this one. Nits below...
> > > 
> > > This assumes sizeof(structure nfsd_thread_local_info) will always
> > > be small enough that it is reasonable to keep on the stack. I
> > > can't say that would be a good bet in the long run.
> > > 
> > > And we don't need the perfect reliability of not doing a dynamic
> > > allocation here. If kmalloc(sizeof(struct nfsd_thread_local_info))
> > > fails, the thread exits immediately, no harm.
> > > 
> > 
> > Not sure how much space Ben will need (if any).
> > 
> > We certainly could have nfsd allocate this separately. I didn't see the
> > point for something that is only a few bytes though.
> 
> If we are designing for today, another approach would be to set up
> a BUILD_WARN_ON or other type of static build failure if this
> structure grows larger than, say 256 bytes -- then add dynamic
> allocation at that point.
> 

I don't see us growing this to huge proportions. I think that's the
sort of thing we just have to watch out for as maintainers.

If you really insist on a BUILD_WARN_ON tripwire, I'll add one, but it
seems like overkill to me.
-- 
Jeff Layton <jlayton@kernel.org>

On Tue, Jan 13, 2026, at 3:12 PM, Jeff Layton wrote:
> On Tue, 2026-01-13 at 14:41 -0500, Chuck Lever wrote:
>> 
>> On Tue, Jan 13, 2026, at 2:31 PM, Jeff Layton wrote:
>> > On Tue, 2026-01-13 at 14:21 -0500, Chuck Lever wrote:
>> > > 
>> > > On Tue, Jan 13, 2026, at 1:37 PM, Jeff Layton wrote:
>> > > > diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
>> > > > index eee8c3f4a251a3fae6e41679de0ec34c76caf198..8ce366c9e49220e8baf475c2e5f3424fedc1cec1 100644
>> > > > --- a/fs/nfsd/nfssvc.c
>> > > > +++ b/fs/nfsd/nfssvc.c
>> > > > @@ -900,6 +900,7 @@ nfsd(void *vrqstp)
>> > > > struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
>> > > > struct net *net = perm_sock->xpt_net;
>> > > > struct nfsd_net *nn = net_generic(net, nfsd_net_id);
>> > > > + struct nfsd_thread_local_info ntli = { };
>> > > > bool have_mutex = false;
>> > > >  
>> > > > /* At this point, the thread shares current->fs
>> > > > @@ -914,6 +915,8 @@ nfsd(void *vrqstp)
>> > > >  
>> > > > set_freezable();
>> > > >  
>> > > > + rqstp->rq_private = &ntli;
>> > > > +
>> > > > /*
>> > > > * The main request loop
>> > > > */
>> > > 
>> > > Thanks for tackling this one. Nits below...
>> > > 
>> > > This assumes sizeof(structure nfsd_thread_local_info) will always
>> > > be small enough that it is reasonable to keep on the stack. I
>> > > can't say that would be a good bet in the long run.
>> > > 
>> > > And we don't need the perfect reliability of not doing a dynamic
>> > > allocation here. If kmalloc(sizeof(struct nfsd_thread_local_info))
>> > > fails, the thread exits immediately, no harm.
>> > > 
>> > 
>> > Not sure how much space Ben will need (if any).
>> > 
>> > We certainly could have nfsd allocate this separately. I didn't see the
>> > point for something that is only a few bytes though.
>> 
>> If we are designing for today, another approach would be to set up
>> a BUILD_WARN_ON or other type of static build failure if this
>> structure grows larger than, say 256 bytes -- then add dynamic
>> allocation at that point.
>> 
>
> I don't see us growing this to huge proportions. I think that's the
> sort of thing we just have to watch out for as maintainers.
>
> If you really insist on a BUILD_WARN_ON tripwire, I'll add one, but it
> seems like overkill to me.

I think a tripwire documents the assumption made here in a single
line... no different than a lockdep_assert.

More critically, though, maintainers tend to have a very short memory.
Not a trustworthy lot, really.

static_assert(sizeof(struct nfsd_thread_local_info) < 256);


-- 
Chuck Lever