rxrpc: Miscellaneous fixes
Subsystems (5)
David Howells
maintainerv2 cover rxrpc: Miscellaneous fixes
Here are some fixes for rxrpc:
(1) Fix the calling of IP routing code with IRQs disabled.
(2) Fix a recvmsg/recvmsg race when the first completes a call.
(3) Fix a race between notification, recvmsg and sendmsg releasing a call.
(4) Fix abort of abort.
(5) Fix call-level aborts that should be connection-level aborts.
David
The patches can be found here also:
http://git.kernel.org/cgit/linux/kernel/git/dhowells/linux-fs.git/log/?h=rxrpc-fixes
Changes
=======
ver #2)
- Moved a trace note from patch 5 to patch 3 where it is used.
David Howells (5):
rxrpc: Fix irq-disabled in local_bh_enable()
rxrpc: Fix recv-recv race of completed call
rxrpc: Fix notification vs call-release vs recvmsg
rxrpc: Fix transmission of an abort in response to an abort
rxrpc: Fix to use conn aborts for conn-wide failures
include/trace/events/rxrpc.h | 6 +++++- net/rxrpc/ar-internal.h | 4 ++++ net/rxrpc/call_accept.c | 14 ++++++++------ net/rxrpc/call_object.c | 28 ++++++++++++---------------- net/rxrpc/io_thread.c | 14 ++++++++++++++ net/rxrpc/output.c | 22 +++++++++++++--------- net/rxrpc/peer_object.c | 6 ++---- net/rxrpc/recvmsg.c | 23 +++++++++++++++++++++-- net/rxrpc/security.c | 8 ++++---- 9 files changed, 83 insertions(+), 42 deletions(-)
David Howells
maintainerPATCH v2 1/5 rxrpc: Fix irq-disabled in local_bh_enable()
The rxrpc_assess_MTU_size() function calls down into the IP layer to find out the MTU size for a route. When accepting an incoming call, this is called from rxrpc_new_incoming_call() which holds interrupts disabled across the code that calls down to it. Unfortunately, the IP layer uses local_bh_enable() which, config dependent, throws a warning if IRQs are enabled:
WARNING: CPU: 1 PID: 5544 at kernel/softirq.c:387 __local_bh_enable_ip+0x43/0xd0 ... RIP: 0010:__local_bh_enable_ip+0x43/0xd0 ... Call Trace: <TASK> rt_cache_route+0x7e/0xa0 rt_set_nexthop.isra.0+0x3b3/0x3f0 __mkroute_output+0x43a/0x460 ip_route_output_key_hash+0xf7/0x140 ip_route_output_flow+0x1b/0x90 rxrpc_assess_MTU_size.isra.0+0x2a0/0x590 rxrpc_new_incoming_peer+0x46/0x120 rxrpc_alloc_incoming_call+0x1b1/0x400 rxrpc_new_incoming_call+0x1da/0x5e0 rxrpc_input_packet+0x827/0x900 rxrpc_io_thread+0x403/0xb60 kthread+0x2f7/0x310 ret_from_fork+0x2a/0x230 ret_from_fork_asm+0x1a/0x30 ... hardirqs last enabled at (23): _raw_spin_unlock_irq+0x24/0x50 hardirqs last disabled at (24): _raw_read_lock_irq+0x17/0x70 softirqs last enabled at (0): copy_process+0xc61/0x2730 softirqs last disabled at (25): rt_add_uncached_list+0x3c/0x90
Fix this by moving the call to rxrpc_assess_MTU_size() out of rxrpc_init_peer() and further up the stack where it can be done without interrupts disabled.
It shouldn't be a problem for rxrpc_new_incoming_call() to do it after the locks are dropped as pmtud is going to be performed by the I/O thread - and we're in the I/O thread at this point.
--- net/rxrpc/ar-internal.h | 1 + net/rxrpc/call_accept.c | 1 + net/rxrpc/peer_object.c | 6 ++---- 3 files changed, 4 insertions(+), 4 deletions(-)
net/rxrpc/ar-internal.h +1 -0
@@ -1383,6 +1383,7 @@ struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *, const struct sockaddr_rxrpc *);struct rxrpc_peer *rxrpc_lookup_peer (struct rxrpc_local *local,struct sockaddr_rxrpc *srx,gfp_t gfp); +void rxrpc_assess_MTU_size (struct rxrpc_local *local,struct rxrpc_peer *peer);struct rxrpc_peer *rxrpc_alloc_peer (struct rxrpc_local *,gfp_t ,enum rxrpc_peer_trace );void rxrpc_new_incoming_peer (struct rxrpc_local *local,struct rxrpc_peer *peer);
net/rxrpc/call_accept.c +1 -0
@@ -406,6 +406,7 @@ bool rxrpc_new_incoming_call(struct rxrpc_local *local,spin_unlock (&rx->incoming_lock);read_unlock_irq (&local->services_lock); +rxrpc_assess_MTU_size (local, call->peer);if (hlist_unhashed (&call->error_link)) {spin_lock_irq (&call->peer->lock);
net/rxrpc/peer_object.c +2 -4
@@ -149,8 +149,7 @@ struct rxrpc_peer *rxrpc_lookup_peer_rcu(struct rxrpc_local *local,* assess the MTU size for the network interface through which this peer is * reached */ -static void rxrpc_assess_MTU_size (struct rxrpc_local *local, -struct rxrpc_peer *peer) +void rxrpc_assess_MTU_size (struct rxrpc_local *local,struct rxrpc_peer *peer) {struct net *net = local->net;struct dst_entry *dst;
@@ -277,8 +276,6 @@ static void rxrpc_init_peer(struct rxrpc_local *local, struct rxrpc_peer *peer, peer->hdrsize +=sizeof (struct rxrpc_wire_header ); peer->max_data = peer->if_mtu - peer->hdrsize; - -rxrpc_assess_MTU_size (local, peer); }/*
@@ -297,6 +294,7 @@ static struct rxrpc_peer *rxrpc_create_peer(struct rxrpc_local *local,if (peer) {memcpy (&peer->srx, srx,sizeof (*srx));rxrpc_init_peer (local, peer, hash_key); +rxrpc_assess_MTU_size (local, peer); }_leave (" = %p" , peer);
David Howells
maintainerPATCH v2 2/5 rxrpc: Fix recv-recv race of completed call
In reply to David HowellsIf a call receives an event (such as incoming data), the call gets placed on the socket's queue and a thread in recvmsg can be awakened to go and process it. Once the thread has picked up the call off of the queue, further events will cause it to be requeued, and once the socket lock is dropped (recvmsg uses call->user_mutex to allow the socket to be used in parallel), a second thread can come in and its recvmsg can pop the call off the socket queue again.
In such a case, the first thread will be receiving stuff from the call and the second thread will be blocked on call->user_mutex. The first thread can, at this point, process both the event that it picked call for and the event that the second thread picked the call for and may see the call terminate - in which case the call will be "released", decoupling the call from the user call ID assigned to it (RXRPC_USER_CALL_ID in the control message).
The first thread will return okay, but then the second thread will wake up holding the user_mutex and, if it sees that the call has been released by the first thread, it will BUG thusly:
kernel BUG at net/rxrpc/recvmsg.c:474!
Fix this by just dequeuing the call and ignoring it if it is seen to be already released. We can't tell userspace about it anyway as the user call ID has become stale.
--- include/trace/events/rxrpc.h | 3 +++ net/rxrpc/call_accept.c | 1 + net/rxrpc/recvmsg.c | 19 +++++++++++++++++-- 3 files changed, 21 insertions(+), 2 deletions(-)
include/trace/events/rxrpc.h +3 -0
@@ -330,12 +330,15 @@ EM(rxrpc_call_put_userid, "PUT user-id ") \ EM(rxrpc_call_see_accept, "SEE accept ") \ EM(rxrpc_call_see_activate_client, "SEE act-clnt") \ + EM(rxrpc_call_see_already_released, "SEE alrdy-rl") \ EM(rxrpc_call_see_connect_failed, "SEE con-fail") \ EM(rxrpc_call_see_connected, "SEE connect ") \ EM(rxrpc_call_see_conn_abort, "SEE conn-abt") \ + EM(rxrpc_call_see_discard, "SEE discard ") \ EM(rxrpc_call_see_disconnected, "SEE disconn ") \ EM(rxrpc_call_see_distribute_error, "SEE dist-err") \ EM(rxrpc_call_see_input, "SEE input ") \ + EM(rxrpc_call_see_recvmsg, "SEE recvmsg ") \ EM(rxrpc_call_see_release, "SEE release ") \ EM(rxrpc_call_see_userid_exists, "SEE u-exists") \EM (rxrpc_call_see_waiting_call,"SEE q-conn " ) \
net/rxrpc/call_accept.c +1 -0
@@ -219,6 +219,7 @@ void rxrpc_discard_prealloc(struct rxrpc_sock *rx) tail = b->call_backlog_tail;while (CIRC_CNT (head, tail, size) >0 ) {struct rxrpc_call *call = b->call_backlog[tail]; +rxrpc_see_call (call, rxrpc_call_see_discard);rcu_assign_pointer (call->socket, rx);if (rx->app_ops && rx->app_ops->discard_new_call) {
net/rxrpc/recvmsg.c +17 -2
@@ -447,6 +447,16 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, goto try_again; } +rxrpc_see_call (call, rxrpc_call_see_recvmsg); +if (test_bit (RXRPC_CALL_RELEASED , &call->flags)) { +rxrpc_see_call (call, rxrpc_call_see_already_released); +list_del_init (&call->recvmsg_link); +spin_unlock_irq (&rx->recvmsg_lock); +release_sock (&rx->sk); +trace_rxrpc_recvmsg (call->debug_id, rxrpc_recvmsg_unqueue,0 ); +rxrpc_put_call (call, rxrpc_call_put_recvmsg); + goto try_again; + }if (!(flags &MSG_PEEK ))list_del_init (&call->recvmsg_link);else
@@ -470,8 +480,13 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,release_sock (&rx->sk); -if (test_bit (RXRPC_CALL_RELEASED , &call->flags)) -BUG (); +if (test_bit (RXRPC_CALL_RELEASED , &call->flags)) { +rxrpc_see_call (call, rxrpc_call_see_already_released); +mutex_unlock (&call->user_mutex); +if (!(flags &MSG_PEEK )) +rxrpc_put_call (call, rxrpc_call_put_recvmsg); + goto try_again; + } ret =rxrpc_recvmsg_user_id (call, msg, flags);if (ret <0 )
David Howells
maintainerPATCH v2 3/5 rxrpc: Fix notification vs call-release vs recvmsg
In reply to David HowellsWhen a call is released, rxrpc takes the spinlock and removes it from ->recvmsg_q in an effort to prevent racing recvmsg() invocations from seeing the same call. Now, rxrpc_recvmsg() only takes the spinlock when actually removing a call from the queue; it doesn't, however, take it in the lead up to that when it checks to see if the queue is empty. It *does* hold the socket lock, which prevents a recvmsg/recvmsg race - but this doesn't prevent sendmsg from ending the call because sendmsg() drops the socket lock and relies on the call->user_mutex.
Fix this by firstly removing the bit in rxrpc_release_call() that dequeues the released call and, instead, rely on recvmsg() to simply discard released calls (done in a preceding fix).
Secondly, rxrpc_notify_socket() is abandoned if the call is already marked as released rather than trying to be clever by setting both pointers in call->recvmsg_link to NULL to trick list_empty(). This isn't perfect and can still race, resulting in a released call on the queue, but recvmsg() will now clean that up.
---
Notes:
Changes
=======
ver #2)
- Moved in missing trace note declaration from later patchinclude/trace/events/rxrpc.h | 3 ++- net/rxrpc/call_object.c | 28 ++++++++++++---------------- net/rxrpc/recvmsg.c | 4 ++++ 3 files changed, 18 insertions(+), 17 deletions(-)
include/trace/events/rxrpc.h +2 -1
@@ -322,10 +322,10 @@ EM(rxrpc_call_put_kernel, "PUT kernel ") \ EM(rxrpc_call_put_poke, "PUT poke ") \ EM(rxrpc_call_put_recvmsg, "PUT recvmsg ") \ + EM(rxrpc_call_put_release_recvmsg_q, "PUT rls-rcmq") \ EM(rxrpc_call_put_release_sock, "PUT rls-sock") \ EM(rxrpc_call_put_release_sock_tba, "PUT rls-sk-a") \ EM(rxrpc_call_put_sendmsg, "PUT sendmsg ") \ - EM(rxrpc_call_put_unnotify, "PUT unnotify") \ EM(rxrpc_call_put_userid_exists, "PUT u-exists") \ EM(rxrpc_call_put_userid, "PUT user-id ") \EM (rxrpc_call_see_accept,"SEE accept " ) \
@@ -338,6 +338,7 @@ EM(rxrpc_call_see_disconnected, "SEE disconn ") \ EM(rxrpc_call_see_distribute_error, "SEE dist-err") \ EM(rxrpc_call_see_input, "SEE input ") \ + EM(rxrpc_call_see_notify_released, "SEE nfy-rlsd") \ EM(rxrpc_call_see_recvmsg, "SEE recvmsg ") \ EM(rxrpc_call_see_release, "SEE release ") \EM (rxrpc_call_see_userid_exists,"SEE u-exists" ) \
net/rxrpc/call_object.c +12 -16
@@ -561,7 +561,7 @@ static void rxrpc_cleanup_rx_buffers(struct rxrpc_call *call)void rxrpc_release_call (struct rxrpc_sock *rx,struct rxrpc_call *call) {struct rxrpc_connection *conn = call->conn; -bool put = false, putu = false; +bool putu = false;_enter ("{%d,%d}" , call->debug_id,refcount_read (&call->ref));
@@ -573,23 +573,13 @@ void rxrpc_release_call(struct rxrpc_sock *rx, struct rxrpc_call *call)rxrpc_put_call_slot (call); -/* Make sure we don't get any more notifications */ +/* Note that at this point, the call may still be on or may have been +* added back on to the socket receive queue. recvmsg() must discard +* released calls. The CALL_RELEASED flag should prevent further +* notifications. +*/ spin_lock_irq (&rx->recvmsg_lock); - -if (!list_empty (&call->recvmsg_link)) { -_debug ("unlinking once-pending call %p { e=%lx f=%lx }" , - call, call->events, call->flags); -list_del (&call->recvmsg_link); - put = true; - } - -/* list_empty() must return false in rxrpc_notify_socket() */ - call->recvmsg_link.next =NULL ; - call->recvmsg_link.prev =NULL ; -spin_unlock_irq (&rx->recvmsg_lock); -if (put) -rxrpc_put_call (call, rxrpc_call_put_unnotify);write_lock (&rx->call_lock);
@@ -638,6 +628,12 @@ void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx)rxrpc_put_call (call, rxrpc_call_put_release_sock); } +while ((call =list_first_entry_or_null (&rx->recvmsg_q, + struct rxrpc_call, recvmsg_link))) { +list_del_init (&call->recvmsg_link); +rxrpc_put_call (call, rxrpc_call_put_release_recvmsg_q); + } +_leave ("" ); }
net/rxrpc/recvmsg.c +4 -0
@@ -29,6 +29,10 @@ void rxrpc_notify_socket(struct rxrpc_call *call)if (!list_empty (&call->recvmsg_link))return ; +if (test_bit (RXRPC_CALL_RELEASED , &call->flags)) { +rxrpc_see_call (call, rxrpc_call_see_notify_released); +return ; + }rcu_read_lock ();
David Howells
maintainerPATCH v2 4/5 rxrpc: Fix transmission of an abort in response to an abort
In reply to David HowellsUnder some circumstances, such as when a server socket is closing, ABORT packets will be generated in response to incoming packets. Unfortunately, this also may include generating aborts in response to incoming aborts - which may cause a cycle. It appears this may be made possible by giving the client a multicast address.
Fix this such that rxrpc_reject_packet() will refuse to generate aborts in response to aborts.
--- net/rxrpc/output.c | 3 +++ 1 file changed, 3 insertions(+)
net/rxrpc/output.c +3 -0
@@ -814,6 +814,9 @@ void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb)__be32 code;int ret, ioc; +if (sp->hdr.type ==RXRPC_PACKET_TYPE_ABORT ) +return ;/* Never abort an abort. */ +rxrpc_see_skb (skb, rxrpc_skb_see_reject); iov[0 ].iov_base = &whdr;
David Howells
maintainerPATCH v2 5/5 rxrpc: Fix to use conn aborts for conn-wide failures
In reply to David HowellsFix rxrpc to use connection-level aborts for things that affect the whole connection, such as the service ID not matching a local service.
---
Notes:
Changes
=======
ver #2)
- Moved trace note declaration out to earlier patch that uses itnet/rxrpc/ar-internal.h | 3 +++ net/rxrpc/call_accept.c | 12 ++++++------ net/rxrpc/io_thread.c | 14 ++++++++++++++ net/rxrpc/output.c | 19 ++++++++++--------- net/rxrpc/security.c | 8 ++++---- 5 files changed, 37 insertions(+), 19 deletions(-)
net/rxrpc/ar-internal.h +3 -0
@@ -44,6 +44,7 @@ enum rxrpc_skb_mark {RXRPC_SKB_MARK_SERVICE_CONN_SECURED ,/* Service connection response has been verified */ RXRPC_SKB_MARK_REJECT_BUSY ,/* Reject with BUSY */ RXRPC_SKB_MARK_REJECT_ABORT ,/* Reject with ABORT (code in skb->priority) */ + RXRPC_SKB_MARK_REJECT_CONN_ABORT, /* Reject with connection ABORT (code in skb->priority) */ };/*
@@ -1253,6 +1254,8 @@ int rxrpc_encap_rcv(struct sock *, struct sk_buff *);void rxrpc_error_report (struct sock *);bool rxrpc_direct_abort (struct sk_buff *skb,enum rxrpc_abort_reason why,s32 abort_code,int err); +bool rxrpc_direct_conn_abort (struct sk_buff *skb,enum rxrpc_abort_reason why, +s32 abort_code,int err);int rxrpc_io_thread (void *data);void rxrpc_post_response (struct rxrpc_connection *conn,struct sk_buff *skb);static inline void rxrpc_wake_up_io_thread (struct rxrpc_local *local)
net/rxrpc/call_accept.c +6 -6
@@ -374,8 +374,8 @@ bool rxrpc_new_incoming_call(struct rxrpc_local *local,spin_lock (&rx->incoming_lock);if (rx->sk.sk_state ==RXRPC_SERVER_LISTEN_DISABLED || rx->sk.sk_state ==RXRPC_CLOSE ) { -rxrpc_direct_abort (skb, rxrpc_abort_shut_down, -RX_INVALID_OPERATION , -ESHUTDOWN ); +rxrpc_direct_conn_abort (skb, rxrpc_abort_shut_down, +RX_INVALID_OPERATION , -ESHUTDOWN ); goto no_call; }
@@ -422,12 +422,12 @@ bool rxrpc_new_incoming_call(struct rxrpc_local *local, unsupported_service:read_unlock_irq (&local->services_lock); -return rxrpc_direct_abort (skb, rxrpc_abort_service_not_offered, -RX_INVALID_OPERATION , -EOPNOTSUPP ); +return rxrpc_direct_conn_abort (skb, rxrpc_abort_service_not_offered, +RX_INVALID_OPERATION , -EOPNOTSUPP ); unsupported_security:read_unlock_irq (&local->services_lock); -return rxrpc_direct_abort (skb, rxrpc_abort_service_not_offered, -RX_INVALID_OPERATION , -EKEYREJECTED ); +return rxrpc_direct_conn_abort (skb, rxrpc_abort_service_not_offered, +RX_INVALID_OPERATION , -EKEYREJECTED ); no_call:spin_unlock (&rx->incoming_lock);read_unlock_irq (&local->services_lock);
net/rxrpc/io_thread.c +14 -0
@@ -97,6 +97,20 @@ bool rxrpc_direct_abort(struct sk_buff *skb, enum rxrpc_abort_reason why,return false; } +/* +* Directly produce a connection abort from a packet. +*/ +bool rxrpc_direct_conn_abort (struct sk_buff *skb,enum rxrpc_abort_reason why, +s32 abort_code,int err) +{ +struct rxrpc_skb_priv *sp =rxrpc_skb (skb); + +trace_rxrpc_abort (0 , why, sp->hdr.cid,0 , sp->hdr.seq, abort_code, err); + skb->mark =RXRPC_SKB_MARK_REJECT_CONN_ABORT ; + skb->priority = abort_code; +return false; +} +static bool rxrpc_bad_message (struct sk_buff *skb,enum rxrpc_abort_reason why) {return rxrpc_direct_abort (skb, why,RX_PROTOCOL_ERROR , -EBADMSG );
net/rxrpc/output.c +10 -9
@@ -829,7 +829,13 @@ void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb) msg.msg_controllen =0 ; msg.msg_flags =0 ; -memset (&whdr,0 ,sizeof (whdr)); + whdr = (struct rxrpc_wire_header ) { + .epoch =htonl (sp->hdr.epoch), + .cid =htonl (sp->hdr.cid), + .callNumber =htonl (sp->hdr.callNumber), + .serviceId =htons (sp->hdr.serviceId), + .flags = ~sp->hdr.flags &RXRPC_CLIENT_INITIATED , + };switch (skb->mark) {case RXRPC_SKB_MARK_REJECT_BUSY :
@@ -837,6 +843,9 @@ void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb) size =sizeof (whdr); ioc =1 ;break ; +case RXRPC_SKB_MARK_REJECT_CONN_ABORT : + whdr.callNumber =0 ; + fallthrough;case RXRPC_SKB_MARK_REJECT_ABORT : whdr.type =RXRPC_PACKET_TYPE_ABORT ; code =htonl (skb->priority);
@@ -850,14 +859,6 @@ void rxrpc_reject_packet(struct rxrpc_local *local, struct sk_buff *skb)if (rxrpc_extract_addr_from_skb (&srx, skb) ==0 ) { msg.msg_namelen = srx.transport_len; - whdr.epoch =htonl (sp->hdr.epoch); - whdr.cid =htonl (sp->hdr.cid); - whdr.callNumber =htonl (sp->hdr.callNumber); - whdr.serviceId =htons (sp->hdr.serviceId); - whdr.flags = sp->hdr.flags; - whdr.flags ^=RXRPC_CLIENT_INITIATED ; - whdr.flags &=RXRPC_CLIENT_INITIATED ; -iov_iter_kvec (&msg.msg_iter,WRITE , iov, ioc, size); ret =do_udp_sendmsg (local->socket, &msg, size);if (ret <0 )
net/rxrpc/security.c +4 -4
@@ -140,15 +140,15 @@ const struct rxrpc_security *rxrpc_get_incoming_security(struct rxrpc_sock *rx, sec =rxrpc_security_lookup (sp->hdr.securityIndex);if (!sec) { -rxrpc_direct_abort (skb, rxrpc_abort_unsupported_security, -RX_INVALID_OPERATION , -EKEYREJECTED ); +rxrpc_direct_conn_abort (skb, rxrpc_abort_unsupported_security, +RX_INVALID_OPERATION , -EKEYREJECTED );return NULL ; }if (sp->hdr.securityIndex !=RXRPC_SECURITY_NONE && !rx->securities) { -rxrpc_direct_abort (skb, rxrpc_abort_no_service_key, - sec->no_key_abort, -EKEYREJECTED ); +rxrpc_direct_conn_abort (skb, rxrpc_abort_no_service_key, + sec->no_key_abort, -EKEYREJECTED );return NULL ; }
This series was applied to netdev/net.git (main) by Jakub Kicinski <[email protected]>:
Hello:
This series was applied to netdev/net.git (main)
by Jakub Kicinski <[email protected]>:
Quoted 9 lines · On Thu, 17 Jul 2025 08:43:40 +0100 you wrote:
Here are some fixes for rxrpc:
(1) Fix the calling of IP routing code with IRQs disabled.
(2) Fix a recvmsg/recvmsg race when the first completes a call.
(3) Fix a race between notification, recvmsg and sendmsg releasing a call.
[...]
Here is the summary with links:
- [net,v2,1/5] rxrpc: Fix irq-disabled in local_bh_enable()
https://git.kernel.org/netdev/net/c/e4d2878369d5 - [net,v2,2/5] rxrpc: Fix recv-recv race of completed call https://git.kernel.org/netdev/net/c/962fb1f651c2 - [net,v2,3/5] rxrpc: Fix notification vs call-release vs recvmsg https://git.kernel.org/netdev/net/c/2fd895842d49 - [net,v2,4/5] rxrpc: Fix transmission of an abort in response to an abort https://git.kernel.org/netdev/net/c/e9c0b96ec0a3 - [net,v2,5/5] rxrpc: Fix to use conn aborts for conn-wide failures https://git.kernel.org/netdev/net/c/f0295678ad30
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html