FAILED: patch "[PATCH] SUNRPC: Copy the deferred RPC Call from the head buffer" failed to apply to 5.10-stable tree
Subsystems (4)
[email protected]
maintainerThe patch below does not apply to the 5.10-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.10.y
git checkout FETCH_HEAD
git cherry-pick -x 2192a56b0686599358909c3e12e9a366f5b5d452
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026110458-walnut-distant-f403@gregkh' --subject-prefix 'PATCH 5.10.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 2192a56b0686599358909c3e12e9a366f5b5d452 Mon Sep 17 00:00:00 2001
From: Chuck Lever <[email protected]>
Date: Wed, 2 Sep 2026 09:31:01 -0400
Subject: [PATCH] SUNRPC: Copy the deferred RPC Call from the head buffer
svc_defer() snapshots the RPC Call for replay once a pending cache upcall resolves. It copies the Call starting (rq_arg.len - head[0].iov_len) bytes before head[0].iov_base, a back-up that once covered a transport header. No transport has had one since commit 983084b2672c ("SUNRPC: Remove svc_rqst::rq_xprt_hlen"), so the two lengths are meant to be equal.
An RPCSEC_GSS Call breaks that assumption. Unwrapping the integrity service truncates rq_arg.len by the length of the trailing checksum, and unwrapping the privacy service leaves rq_arg.len short by an amount the client sets with trailing bytes after the wrap token. Neither adjusts head[0].iov_len. Both lengths are size_t, so the subtraction underflows and the copy starts past head[0].iov_base. Every deferred integrity Call replays a shifted snapshot.
A deferred replay skips GSS verification, so a shifted snapshot runs as an authenticated Call. With the privacy service the offset is client-chosen. A forged Call placed in that window, naming another user's GSS context handle, runs under that identity.
Copy the Call from head[0].iov_base. Refuse to defer a Call whose length runs past the head buffer, so the copy cannot read out of bounds.
net/sunrpc/svc_xprt.c +7 -15
@@ -1299,13 +1299,8 @@ static void svc_revisit(struct cache_deferred_req *dreq, int too_many) }/* -* Save the request off for later processing. The request buffer looks -* like this: -* -* <xprt-header><rpc-header><rpc-pagelist><rpc-tail> -* -* This code can only handle requests that consist of an xprt-header -* and rpc-header. +* Save the request off for later processing. Only a Call that fits +* entirely in rq_arg.head[0] can be deferred. */ static struct cache_deferred_req *svc_defer (struct cache_req *req) {
@@ -1318,8 +1313,11 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) dr = rqstp->rq_deferred; rqstp->rq_deferred =NULL ; }else { -size_t skip;size_t size; + +if (rqstp->rq_arg.len > rqstp->rq_arg.head[0 ].iov_len) +return NULL ; +/* FIXME maybe discard if size too large */ size =sizeof (struct svc_deferred_req ) + rqstp->rq_arg.len; dr =kmalloc (size,GFP_KERNEL );
@@ -1333,9 +1331,7 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) dr->daddr = rqstp->rq_daddr; dr->argslen = rqstp->rq_arg.len >>2 ; -/* back up head to the start of the buffer and copy */ - skip = rqstp->rq_arg.len - rqstp->rq_arg.head[0 ].iov_len; -memcpy (dr->args, rqstp->rq_arg.head[0 ].iov_base - skip, +memcpy (dr->args, rqstp->rq_arg.head[0 ].iov_base, dr->argslen <<2 ); } dr->xprt_ctxt = rqstp->rq_xprt_ctxt;
@@ -1358,17 +1354,13 @@ static noinline int svc_deferred_recv(struct svc_rqst *rqstp)trace_svc_defer_recv (dr); -/* setup iov_base past transport header */ rqstp->rq_arg.head[0 ].iov_base = dr->args; -/* The iov_len does not include the transport header bytes */ rqstp->rq_arg.head[0 ].iov_len = dr->argslen <<2 ; rqstp->rq_arg.page_len =0 ; -/* The rq_arg.len includes the transport header bytes */ rqstp->rq_arg.len = dr->argslen <<2 ; rqstp->rq_prot = dr->prot;memcpy (&rqstp->rq_addr, &dr->addr, dr->addrlen); rqstp->rq_addrlen = dr->addrlen; -/* Save off transport header len in case we get deferred again */ rqstp->rq_daddr = dr->daddr; rqstp->rq_xprt_ctxt = dr->xprt_ctxt;
PATCH 1/1 SUNRPC: Copy the deferred RPC Call from the head buffer
From: Chuck Lever <[email protected]>
svc_defer() snapshots the RPC Call for replay once a pending cache upcall resolves. It copies the Call starting (rq_arg.len - head[0].iov_len) bytes before head[0].iov_base, a back-up that once covered a transport header. No transport has had one since commit 983084b2672c ("SUNRPC: Remove svc_rqst::rq_xprt_hlen"), so the two lengths are meant to be equal.
An RPCSEC_GSS Call breaks that assumption. Unwrapping the integrity service truncates rq_arg.len by the length of the trailing checksum, and unwrapping the privacy service leaves rq_arg.len short by an amount the client sets with trailing bytes after the wrap token. Neither adjusts head[0].iov_len. Both lengths are size_t, so the subtraction underflows and the copy starts past head[0].iov_base. Every deferred integrity Call replays a shifted snapshot.
A deferred replay skips GSS verification, so a shifted snapshot runs as an authenticated Call. With the privacy service the offset is client-chosen. A forged Call placed in that window, naming another user's GSS context handle, runs under that identity.
Copy the Call from head[0].iov_base. Refuse to defer a Call whose length runs past the head buffer, so the copy cannot read out of bounds.
--- net/sunrpc/svc_xprt.c | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-)
net/sunrpc/svc_xprt.c +7 -11
@@ -1181,13 +1181,8 @@ static void svc_revisit(struct cache_deferred_req *dreq, int too_many) }/* -* Save the request off for later processing. The request buffer looks -* like this: -* -* <xprt-header><rpc-header><rpc-pagelist><rpc-tail> -* -* This code can only handle requests that consist of an xprt-header -* and rpc-header. +* Save the request off for later processing. Only a Call that fits +* entirely in rq_arg.head[0] can be deferred. */ static struct cache_deferred_req *svc_defer (struct cache_req *req) {
@@ -1200,8 +1195,11 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) dr = rqstp->rq_deferred; rqstp->rq_deferred =NULL ; }else { -size_t skip;size_t size; + +if (rqstp->rq_arg.len > rqstp->rq_arg.head[0 ].iov_len) +return NULL ; +/* FIXME maybe discard if size too large */ size =sizeof (struct svc_deferred_req ) + rqstp->rq_arg.len; dr =kmalloc (size,GFP_KERNEL );
@@ -1216,9 +1214,7 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) dr->argslen = rqstp->rq_arg.len >>2 ; dr->xprt_hlen = rqstp->rq_xprt_hlen; -/* back up head to the start of the buffer and copy */ - skip = rqstp->rq_arg.len - rqstp->rq_arg.head[0 ].iov_len; -memcpy (dr->args, rqstp->rq_arg.head[0 ].iov_base - skip, +memcpy (dr->args, rqstp->rq_arg.head[0 ].iov_base, dr->argslen <<2 ); }trace_svc_defer (rqstp);
Signature · 1 line
2.50.1
PATCH v2 1/1 SUNRPC: Copy the deferred RPC Call from the head buffer
From: Chuck Lever <[email protected]>
commit 2192a56b0686599358909c3e12e9a366f5b5d452 upstream.
svc_defer() snapshots the RPC Call for replay once a pending cache upcall resolves. It copies the Call starting (rq_arg.len - head[0].iov_len) bytes before head[0].iov_base, a back-up that once covered a transport header. No transport has had one since commit 983084b2672c ("SUNRPC: Remove svc_rqst::rq_xprt_hlen"), so the two lengths are meant to be equal.
An RPCSEC_GSS Call breaks that assumption. Unwrapping the integrity service truncates rq_arg.len by the length of the trailing checksum, and unwrapping the privacy service leaves rq_arg.len short by an amount the client sets with trailing bytes after the wrap token. Neither adjusts head[0].iov_len. Both lengths are size_t, so the subtraction underflows and the copy starts past head[0].iov_base. Every deferred integrity Call replays a shifted snapshot.
A deferred replay skips GSS verification, so a shifted snapshot runs as an authenticated Call. With the privacy service the offset is client-chosen. A forged Call placed in that window, naming another user's GSS context handle, runs under that identity.
Copy the Call from head[0].iov_base. Refuse to defer a Call whose length runs past the head buffer, so the copy cannot read out of bounds.
[doebel: 5.10 lacks 983084b2672c; keep xprt_hlen and its comments in
svc_deferred_recv(). The removed skip is zero for all 5.10 transports.]
---
v2:
- Add the "commit <sha1> upstream." line.
- Document why the backport differs from upstream.
net/sunrpc/svc_xprt.c | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-)
net/sunrpc/svc_xprt.c +7 -11
@@ -1181,13 +1181,8 @@ static void svc_revisit(struct cache_deferred_req *dreq, int too_many) }/* -* Save the request off for later processing. The request buffer looks -* like this: -* -* <xprt-header><rpc-header><rpc-pagelist><rpc-tail> -* -* This code can only handle requests that consist of an xprt-header -* and rpc-header. +* Save the request off for later processing. Only a Call that fits +* entirely in rq_arg.head[0] can be deferred. */ static struct cache_deferred_req *svc_defer (struct cache_req *req) {
@@ -1200,8 +1195,11 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) dr = rqstp->rq_deferred; rqstp->rq_deferred =NULL ; }else { -size_t skip;size_t size; + +if (rqstp->rq_arg.len > rqstp->rq_arg.head[0 ].iov_len) +return NULL ; +/* FIXME maybe discard if size too large */ size =sizeof (struct svc_deferred_req ) + rqstp->rq_arg.len; dr =kmalloc (size,GFP_KERNEL );
@@ -1216,9 +1214,7 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) dr->argslen = rqstp->rq_arg.len >>2 ; dr->xprt_hlen = rqstp->rq_xprt_hlen; -/* back up head to the start of the buffer and copy */ - skip = rqstp->rq_arg.len - rqstp->rq_arg.head[0 ].iov_len; -memcpy (dr->args, rqstp->rq_arg.head[0 ].iov_base - skip, +memcpy (dr->args, rqstp->rq_arg.head[0 ].iov_base, dr->argslen <<2 ); }trace_svc_defer (rqstp);
Signature · 1 line
2.50.1
Sasha Levin
maintainerRe: [PATCH 5.10.y v2] SUNRPC: Copy the deferred RPC Call from the head buffer
Quoted 4 lines · Bjoern Doebel
[PATCH 5.10.y v2] SUNRPC: Copy the deferred RPC Call from the head buffer
svc_defer()snapshots the RPC Call for replay once a pending cache upcall resolves. It copies the Call starting (rq_arg.len - head[0].iov_len) bytes before head[0].iov_base, a back-up that once
On 5.10 the RPC header is already consumed from head[0] before svc_defer() runs, so the premise behind the new check in 2192a56b0686 ("SUNRPC: Copy the deferred RPC Call from the head buffer"), rq_arg.len == head[0].iov_len, doesn't hold. With it, nearly every request would be refused deferral.
Could you rework the 5.10 version so it doesn't change that behavior and send a v3?
Signature · 2 lines
Thanks, Sasha
PATCH v3 1/1 SUNRPC: Copy the deferred RPC Call from the head buffer
From: Chuck Lever <[email protected]>
commit 2192a56b0686599358909c3e12e9a366f5b5d452 upstream.
svc_defer() snapshots the RPC Call for replay once a pending cache upcall resolves. It copies the Call starting (rq_arg.len - head[0].iov_len) bytes before head[0].iov_base, a back-up that once covered a transport header. No transport has had one since commit 983084b2672c ("SUNRPC: Remove svc_rqst::rq_xprt_hlen"), so the two lengths are meant to be equal.
An RPCSEC_GSS Call breaks that assumption. Unwrapping the integrity service truncates rq_arg.len by the length of the trailing checksum, and unwrapping the privacy service leaves rq_arg.len short by an amount the client sets with trailing bytes after the wrap token. Neither adjusts head[0].iov_len. Both lengths are size_t, so the subtraction underflows and the copy starts past head[0].iov_base. Every deferred integrity Call replays a shifted snapshot.
A deferred replay skips GSS verification, so a shifted snapshot runs as an authenticated Call. With the privacy service the offset is client-chosen. A forged Call placed in that window, naming another user's GSS context handle, runs under that identity.
Copy the Call from head[0].iov_base. Refuse to defer a Call whose length runs past the head buffer, so the copy cannot read out of bounds.
[doebel: 5.10 backport. Here rq_arg.len > head[0].iov_len for every
Call at svc_defer() time, so the upstream guard and copy-from-iov_base cannot apply; keep the skip-based snapshot that svc_deferred_recv() expects (5.10 still has rq_xprt_hlen). Only gss_unwrap_kerberos_v2() breaks the len - iov_len invariant, by resetting buf->len; refuse to defer after a GSS integrity/privacy unwrap (rq_auth_slack != 0) or when len < head[0].iov_len.]
---
v3:
- Rework for 5.10's accounting per Sasha's feedback: keep the skip-based snapshot (5.10 still has rq_xprt_hlen and svc_deferred_recv() depends on it); refuse deferral only after a GSS integrity/privacy unwrap (rq_auth_slack != 0) or when len < head[0].iov_len, since gss_unwrap_kerberos_v2() resets buf->len and breaks the len - iov_len invariant.
v2:
- Add the "commit <sha1> upstream." line.
- Document why the backport differs from upstream.
net/sunrpc/svc_xprt.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
net/sunrpc/svc_xprt.c +14 -0
@@ -1202,6 +1202,20 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req) }else {size_t skip;size_t size; + +/* +* A GSS integrity/privacy unwrap can reset rq_arg.len so +* it no longer measures from the start of the receive +* buffer (see gss_unwrap_kerberos_v2()). In that state +* len - iov_len does not locate the buffer start, and a +* snapshot taken here would be replayed without GSS +* verification. Refuse to defer; the caller fails the +* request and the client retries. +*/ +if (rqstp->rq_auth_slack || + rqstp->rq_arg.len < rqstp->rq_arg.head[0 ].iov_len) +return NULL ; +/* FIXME maybe discard if size too large */ size =sizeof (struct svc_deferred_req ) + rqstp->rq_arg.len; dr =kmalloc (size,GFP_KERNEL );
Signature · 1 line
2.50.1
Re: [PATCH 5.10.y v3] SUNRPC: Copy the deferred RPC Call from the head buffer
Quoted 1 line · Bjoern Doebel
Subject: [PATCH 5.10.y v3] SUNRPC: Copy the deferred RPC Call from the head buffer
Queued for 5.10, thanks.
Signature · 2 lines
Thanks, Sasha
Re: [PATCH 5.10.y v2] SUNRPC: Copy the deferred RPC Call from the head buffer
In reply to Sasha LevinHi Sasha,
thanks for raising this. I sent a v3 earlier in this thread ([PATCH 5.10.y v3]) that reworks the backport instead of applying the upstream mechanics.
The short version: on 5.10, header parsing advances rq_arg.head[0] via svc_getnl() without updating xdr_buf::len, so rq_arg.len > head[0].iov_len for every Call at svc_defer() time. The upstream guard would refuse every deferral, and copying from head[0].iov_base would drop the headers svc_deferred_recv() expects. v3 therefore keeps the skip-based snapshot and refuses deferral only once a GSS integrity/privacy unwrap has run (rq_auth_slack != 0) or when len < head[0].iov_len, since gss_unwrap_kerberos_v2() resets buf->len.
The same rework applies to 5.15 and 6.1. The assumption upstream relies on only holds since header parsing moved to xdr_stream in v6.3 (163cdfca341b7, "SUNRPC: Decode most of RPC header with xdr_stream"); 5.15 and 6.1 still use svc_getnl(). I see the verbatim patch is already queued for both trees - it will refuse all deferrals there, just like my v2 would have on 5.10.
Want me to send v3-style backports for 5.15.y and 6.1.y?
Best regards,
Bjoern
Sasha Levin
maintainerRe: [PATCH 5.10.y v2] SUNRPC: Copy the deferred RPC Call from the head buffer
Quoted 5 lines · Bjoern Doebel
I see the verbatim patch is
already queued for both trees - it will refuse all deferrals there, just like my v2 would have on 5.10.Want me to send v3-style backports for 5.15.y and 6.1.y?
You are right. I dropped the verbatim copies of 2192a56b0686 ("SUNRPC: Copy the deferred RPC Call from the head buffer") from the 5.15 and 6.1 queues.
Yes please, send v3-style backports for 5.15.y and 6.1.y.
Signature · 2 lines
Thanks, Sasha