Skip to contentSkip to conversation

rxrpc: Miscellaneous fixes

PATCH In review David Howells 2 participants 10 messages Jun 16 – Jun 18

Subsystems (5)
lore
Share & tools
lore

David Howells

author maintainer
#0 lore raw

cover rxrpc: Miscellaneous fixes

Here are some miscellaneous AF_RXRPC fixes for more stuff found by Sashiko[1]:

(1) Reject ACKALL packets for calls not in Tx or immediate post-Tx state.

(2) Fix connection leak from AF_RXRPC recvmsg userspace OOB handling.

(3) Fix double unlock in AF_RXRPC recvmsg userspace OOB handling.

(4) Fix AFS preallocate charge to flush the waitqueue after unlistening the socket so that any charging thread that does manage to get started will be waited for before socket destruction.

(5) Fix AFS OOB notify handling to cancel in-progress OOB notification handling and then to flush the workqueue it's on.

David

The patches can be found here also:

http://git.kernel.org/cgit/linux/kernel/git/dhowells/linux-fs.git/log/?h=rxrpc-fixes

[1] https://sashiko.dev/#/patchset/20260609140911.838677-1-dhowells%40redhat.com

David Howells (4):
rxrpc: Fix leak of connection from OOB challenge
rxrpc: Fix double unlock in rxrpc_recvmsg()
afs: Fix further netns teardown to cancel the preallocation charger
afs: Fix uncancelled rxrpc OOB message handler

Wyatt Feng (1):
rxrpc: input: reject ACKALL outside transmit phase

 fs/afs/cm_security.c |  3 ++-
 fs/afs/rxrpc.c       |  5 ++++-
 net/rxrpc/input.c    | 16 +++++++++++++++-
 net/rxrpc/oob.c      |  5 +++++
 net/rxrpc/recvmsg.c  |  2 +-
 5 files changed, 27 insertions(+), 4 deletions(-)
author maintainer
#1 lore raw

PATCH 1/5 rxrpc: input: reject ACKALL outside transmit phase

From: Wyatt Feng <[email protected]>

rxrpc_input_ackall() accepts ACKALL packets without checking whether the call is in a state that can legitimately have outstanding transmit buffers. A forged ACKALL can therefore reach a new service call in RXRPC_CALL_SERVER_RECV_REQUEST before any reply packets have been queued.

In that state call->tx_top is zero and call->tx_queue is NULL, so rxrpc_rotate_tx_window() dereferences a NULL txqueue and triggers a null-pointer dereference.

Fix rxrpc_input_ackall() to mirror the transmit-state gating already used for normal ACK processing, and ignore ACKALL when there is no outstanding transmit window to rotate.

Fixes b341a0263b1b ("rxrpc: Implement progressive transmission queue struct")
Assisted-by Codex:GPT-5.4
cc Marc Dionne <[email protected]>
---
 net/rxrpc/input.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)
net/rxrpc/input.c +15 -1
index ce761466b02d..37881dffa898 100644
@@ -1214,8 +1214,22 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb)
 static void rxrpc_input_ackall(struct rxrpc_call *call, struct sk_buff *skb)
 {
 	struct rxrpc_ack_summary summary = { 0 };
+	rxrpc_seq_t top = READ_ONCE(call->tx_top);
+
+	switch (__rxrpc_call_state(call)) {
+	case RXRPC_CALL_CLIENT_SEND_REQUEST:
+	case RXRPC_CALL_CLIENT_AWAIT_REPLY:
+	case RXRPC_CALL_SERVER_SEND_REPLY:
+	case RXRPC_CALL_SERVER_AWAIT_ACK:
+		break;
+	default:
+		return;
+	}
+
+	if (call->tx_bottom == top)
+		return;
 
-	if (rxrpc_rotate_tx_window(call, call->tx_top, &summary))
+	if (rxrpc_rotate_tx_window(call, top, &summary))
 		rxrpc_end_tx_phase(call, false, rxrpc_eproto_unexpected_ackall);
 }
 
reviewer
#2 lore raw

Re: [PATCH net 1/5] rxrpc: input: reject ACKALL outside transmit phase

This is an AI-generated review of your patch. The human sending this email has considered the AI review valid, or at least plausible. Full review at: https://sashiko.dev
---
rxrpc: input: reject ACKALL outside transmit phase

rxrpc_input_ackall() accepts ACKALL packets without checking whether the call is in a state that can legitimately have outstanding transmit buffers. A forged ACKALL can reach a new service call and trigger a null pointer dereference.

Quoted 4 lines
net/rxrpc/input.c +0 -0
index ce761466b02d6..37881dffa898b 100644

[ ... ]

Quoted 11 lines
net/rxrpc/input.c +7 -0
@@ -1214,8 +1214,22 @@ static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb)
 static void rxrpc_input_ackall(struct rxrpc_call *call, struct sk_buff *skb)
 {
 	struct rxrpc_ack_summary summary = { 0 };
+	rxrpc_seq_t top = READ_ONCE(call->tx_top);
+
+	switch (__rxrpc_call_state(call)) {
+	case RXRPC_CALL_CLIENT_SEND_REQUEST:
+	case RXRPC_CALL_CLIENT_AWAIT_REPLY:
+	case RXRPC_CALL_SERVER_SEND_REPLY:
+	case RXRPC_CALL_SERVER_AWAIT_ACK:

net/rxrpc/input.c static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb) · line 1232

Quoted 10 lines
net/rxrpc/input.c +8 -1
+		break;
+	default:
+		return;
+	}
+
+	if (call->tx_bottom == top)
+		return;
 
-	if (rxrpc_rotate_tx_window(call, call->tx_top, &summary))
+	if (rxrpc_rotate_tx_window(call, top, &summary))

[Severity: High]
This isn't a bug introduced by this patch, but it appears the fix might be incomplete. The patch prevents a NULL pointer dereference in rxrpc_input_ackall() by checking if call->tx_bottom == top before calling rxrpc_rotate_tx_window().

However, does the same vulnerability remain in rxrpc_receiving_reply()?

If a client in the RXRPC_CALL_CLIENT_SEND_REQUEST state receives a forged or early DATA packet (acting as a reply) before it has queued any transmit data, call->tx_top and call->tx_bottom will both be 0, and call->tx_queue will be NULL.

rxrpc_receiving_reply() will then unconditionally call:

    if (!rxrpc_rotate_tx_window(call, top, &summary)) {

Because rxrpc_rotate_tx_window() uses a do { ... } while (before_eq(seq, to)) loop, it executes exactly once for seq = 1 and to = 0, which dereferences the NULL tq:

    if (tq->bufs[ix]->flags & RXRPC_LAST_PACKET) {

Should the empty window check be placed at the top of rxrpc_rotate_tx_window() instead, or mirrored in rxrpc_receiving_reply() to protect against early replies?

Quoted 2 lines
net/rxrpc/input.c +0 -0
 		rxrpc_end_tx_phase(call, false, rxrpc_eproto_unexpected_ackall);
 }
author maintainer
#3 lore raw

PATCH 2/5 rxrpc: Fix leak of connection from OOB challenge

In reply to David Howells

Fix leak of connection object from OOB challenge queue when response is provided by userspace.

Fixes 5800b1cf3fd8 ("rxrpc: Allow CHALLENGEs to the passed to the app for a RESPONSE")
cc Marc Dionne <[email protected]>
cc Eric Dumazet <[email protected]>
cc "David S. Miller" <[email protected]>
cc Jakub Kicinski <[email protected]>
cc Paolo Abeni <[email protected]>
cc Simon Horman <[email protected]>
---
 net/rxrpc/oob.c | 5 +++++
 1 file changed, 5 insertions(+)
net/rxrpc/oob.c +5 -0
index 05ca9c1faa57..3318c8bd82ad 100644
@@ -210,6 +210,11 @@ static int rxrpc_respond_to_oob(struct rxrpc_sock *rx,
 		break;
 	}
 
+	switch (skb->mark) {
+	case RXRPC_OOB_CHALLENGE:
+		rxrpc_put_connection(sp->chall.conn, rxrpc_conn_put_oob);
+		break;
+	}
 	rxrpc_free_skb(skb, rxrpc_skb_put_oob);
 	return ret;
 }
author maintainer
#4 lore raw

PATCH 3/5 rxrpc: Fix double unlock in rxrpc_recvmsg()

In reply to David Howells

Fix a double unlock in rxrpc_recvmsg() when dealing with OOB messages.

Fixes 5800b1cf3fd8 ("rxrpc: Allow CHALLENGEs to the passed to the app for a RESPONSE")
cc Marc Dionne <[email protected]>
cc Eric Dumazet <[email protected]>
cc "David S. Miller" <[email protected]>
cc Jakub Kicinski <[email protected]>
cc Paolo Abeni <[email protected]>
cc Simon Horman <[email protected]>
---
 net/rxrpc/recvmsg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
net/rxrpc/recvmsg.c +1 -1
index 82614cbdb60f..39a03684432d 100644
@@ -471,7 +471,7 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 		release_sock(&rx->sk);
 		if (ret == -EAGAIN)
 			goto try_again;
-		goto error_no_call;
+		goto error_trace;
 	}
 
 	/* Find the next call and dequeue it if we're not just peeking.  If we
author maintainer
#5 lore raw

PATCH 4/5 afs: Fix further netns teardown to cancel the preallocation charger

In reply to David Howells

When an afs network namespace is torn down, it cancels and waits for the work item that keeps the preallocated rxrpc call/conn/peer queue charged before disabling incoming (i.e. listen 0), but there's a small window in which it can be requeued by an incoming call wending through the I/O thread.

Fix this by flushing the workqueue on which the charger runs after reducing the listen backlog to zero.

Fixes 47694fbc9d24 ("afs: Fix netns teardown to cancel the preallocation charger")
cc Li Daming <[email protected]>
cc Ren Wei <[email protected]>
cc Marc Dionne <[email protected]>
cc Jeffrey Altman <[email protected]>
cc Eric Dumazet <[email protected]>
cc "David S. Miller" <[email protected]>
cc Paolo Abeni <[email protected]>
cc Simon Horman <[email protected]>
---
 fs/afs/rxrpc.c | 1 +
 1 file changed, 1 insertion(+)
fs/afs/rxrpc.c +1 -0
index d5cfd24e815b..fd2d260fb25f 100644
@@ -130,6 +130,7 @@ void afs_close_socket(struct afs_net *net)
 	cancel_work_sync(&net->charge_preallocation_work);
 	kernel_listen(net->socket, 0);
 	flush_workqueue(afs_async_calls);
+	flush_workqueue(afs_wq);
 
 	if (net->spare_incoming_call) {
 		afs_put_call(net->spare_incoming_call);
reviewer
#6 lore raw

Re: [PATCH net 4/5] afs: Fix further netns teardown to cancel the preallocation charger

This is an AI-generated review of your patch. The human sending this email has considered the AI review valid, or at least plausible. Full review at: https://sashiko.dev
---
afs: Fix further netns teardown to cancel the preallocation charger

This commit modifies the afs network namespace teardown process to wait for the preallocation charger work item. It addresses a small window where the work item could be requeued after being cancelled by flushing the workqueue on which the charger runs.

fs/afs/rxrpc.c void afs_close_socket(struct afs_net *net) · line 133

Quoted 8 lines
fs/afs/rxrpc.c +1 -0
@@ -130,6 +130,7 @@ void afs_close_socket(struct afs_net *net)
 	cancel_work_sync(&net->charge_preallocation_work);
 	kernel_listen(net->socket, 0);
 	flush_workqueue(afs_async_calls);
+	flush_workqueue(afs_wq);

[Severity: High]
Will flushing the system-wide global workqueue here cause cross-namespace stalls during teardown?

It appears afs_wq is allocated once in afs_init() as a system-wide workqueue shared by all AFS network namespaces:

fs/afs/main.c:afs_init() {
    ...
    afs_wq = alloc_workqueue("afs", WQ_PERCPU, 0);
    ...
}

Other namespaces use afs_wq for operations like cell management, which can block for tens of seconds waiting for userspace DNS lookups via the request_key mechanism.

Since afs_close_socket() runs in the context of the global cleanup_net worker thread, does this stall the destruction of all network namespaces system-wide until unrelated AFS work across the entire system finishes?

Would it be safer to explicitly call cancel_work_sync(&net->charge_preallocation_work) a second time here instead of flushing the shared queue?

author maintainer
#7 lore raw

PATCH 5/5 afs: Fix uncancelled rxrpc OOB message handler

In reply to David Howells

Fix AFS to cancel its OOB message processing (typically to respond to security challenges). Also move OOB message processing to afs_wq so that it's also waited for and make the OOB handler just return if the net namespace is no longer live.

Fixes 5800b1cf3fd8 ("rxrpc: Allow CHALLENGEs to the passed to the app for a RESPONSE")
cc Li Daming <[email protected]>
cc Ren Wei <[email protected]>
cc Marc Dionne <[email protected]>
cc Jeffrey Altman <[email protected]>
cc Eric Dumazet <[email protected]>
cc "David S. Miller" <[email protected]>
cc Jakub Kicinski <[email protected]>
cc Paolo Abeni <[email protected]>
cc Simon Horman <[email protected]>
---
 fs/afs/cm_security.c | 3 ++-
 fs/afs/rxrpc.c       | 4 +++-
 2 files changed, 5 insertions(+), 2 deletions(-)
fs/afs/cm_security.c +2 -1
index edcbd249d202..103168c70dd4 100644
@@ -101,7 +101,8 @@ void afs_process_oob_queue(struct work_struct *work)
 	struct sk_buff *oob;
 	enum rxrpc_oob_type type;
 
-	while ((oob = rxrpc_kernel_dequeue_oob(net->socket, &type))) {
+	while (READ_ONCE(net->live) &&
+	       (oob = rxrpc_kernel_dequeue_oob(net->socket, &type))) {
 		switch (type) {
 		case RXRPC_OOB_CHALLENGE:
 			afs_respond_to_challenge(oob);
fs/afs/rxrpc.c +3 -1
index fd2d260fb25f..6241f9349f6b 100644
@@ -128,6 +128,7 @@ void afs_close_socket(struct afs_net *net)
 	_enter("");
 
 	cancel_work_sync(&net->charge_preallocation_work);
+	cancel_work_sync(&net->rx_oob_work);
 	kernel_listen(net->socket, 0);
 	flush_workqueue(afs_async_calls);
 	flush_workqueue(afs_wq);
@@ -985,5 +986,6 @@ static void afs_rx_notify_oob(struct sock *sk, struct sk_buff *oob)
 {
 	struct afs_net *net = sk->sk_user_data;
 
-	schedule_work(&net->rx_oob_work);
+	if (net->live)
+		queue_work(afs_wq, &net->rx_oob_work);
 }
reviewer
#8 lore raw

Re: [PATCH net 5/5] afs: Fix uncancelled rxrpc OOB message handler

This is an AI-generated review of your patch. The human sending this email has considered the AI review valid, or at least plausible. Full review at: https://sashiko.dev
---
afs: Fix uncancelled rxrpc OOB message handler

This commit cancels AFS OOB message processing during shutdown and moves it to afs_wq. It also prevents queuing if the net namespace is no longer live.

Quoted 4 lines
fs/afs/rxrpc.c +0 -0
index fd2d260fb25f9..6241f9349f6b6 100644

[ ... ]

fs/afs/rxrpc.c void afs_close_socket(struct afs_net *net) · line 134

Quoted 8 lines
fs/afs/rxrpc.c +1 -0
@@ -128,6 +128,7 @@ void afs_close_socket(struct afs_net *net)
 	_enter("");
 
 	cancel_work_sync(&net->charge_preallocation_work);
+	cancel_work_sync(&net->rx_oob_work);
 	kernel_listen(net->socket, 0);
 	flush_workqueue(afs_async_calls);
 	flush_workqueue(afs_wq);

[Severity: High]
This is a pre-existing issue, but does placing the cancellation and flush before kernel_sock_shutdown() leave a window open for the work to be queued afterwards?

If kernel_sock_shutdown() is what synchronously disables the notify_oob callback from firing, couldn't a delayed callback still queue work on afs_wq after we've already flushed it here?

[ ... ]

fs/afs/rxrpc.c static void afs_rx_notify_oob(struct sock *sk, struct sk_buff *oob) · line 991

Quoted 8 lines
fs/afs/rxrpc.c +2 -1
@@ -985,5 +986,6 @@ static void afs_rx_notify_oob(struct sock *sk, struct sk_buff *oob)
 {
 	struct afs_net *net = sk->sk_user_data;
 
-	schedule_work(&net->rx_oob_work);
+	if (net->live)
+		queue_work(afs_wq, &net->rx_oob_work);
 }

[Severity: High]
This is a pre-existing issue, but does this lockless check of net->live allow a race condition that leads to a use-after-free?

Consider this sequence:

CPU1 (teardown)
afs_net_exit()

    net->live = false;
    afs_close_socket()
        cancel_work_sync(&net->rx_oob_work);
        flush_workqueue(afs_wq);
        kernel_sock_shutdown()  // blocks waiting for recvmsg_lock

CPU2 (incoming OOB)
rxrpc_notify_socket_oob()

    spin_lock_irq(&rx->recvmsg_lock);
    afs_rx_notify_oob()
        // Reads net->live == true (stale read, or delayed execution)
        queue_work(afs_wq, &net->rx_oob_work);
    spin_unlock_irq(&rx->recvmsg_lock);

CPU1 then finishes kernel_sock_shutdown() and frees the net namespace, but afs_wq is never flushed again.

Would moving cancel_work_sync() and flush_workqueue() to the end of afs_close_socket(), after kernel_sock_shutdown() completes, prevent this race?