tipc: syzbot related fixes
Subsystems (3)
v2 cover tipc: syzbot related fixes
First patch fixes a recent syzbot report.
Second patch is inspired by numerous syzbot soft lockup reports with RTNL pressure.
Eric Dumazet (2):
tipc: fix UAF in cleanup_bearer() due to premature dst_cache_destroy()
tipc: avoid busy looping in tipc_exit_net()
net/tipc/core.c | 4 ++-- net/tipc/udp_media.c | 19 ++++++++++++++----- 2 files changed, 16 insertions(+), 7 deletions(-)
Signature · 1 line
2.55.0.rc0.799.gd6f94ed593-goog
PATCH v2 1/2 tipc: fix UAF in cleanup_bearer() due to premature dst_cache_destroy()
TIPC UDP media bearer teardown calls dst_cache_destroy() on its replicast caches before calling synchronize_net() to wait for concurrent RCU readers (transmitters) to finish:
static void cleanup_bearer(struct work_struct *work) {
...
list_for_each_entry_safe(rcast, tmp, &ub->rcast.list, list) {
dst_cache_destroy(&rcast->dst_cache);
list_del_rcu(&rcast->list);
kfree_rcu(rcast, rcu);
}
...
dst_cache_destroy(&ub->rcast.dst_cache);
udp_tunnel_sock_release(ub->sk);
synchronize_net();...
}
This is highly buggy because dst_cache_destroy() immediately frees the per-CPU cache memory (free_percpu()) and releases the cached dst entries without any synchronization.
If a concurrent transmitter (e.g., tipc_udp_xmit()) is running on another CPU under RCU protection, it can call dst_cache_get() concurrently, leading to:
1. Use-After-Free on the per-CPU cache pointer itself (crash).
2. "rcuref - imbalanced put()" warning if it attempts to release a dst that was concurrently released by dst_cache_destroy().
Furthermore, calling kfree(ub) immediately after synchronize_net() without closing the socket first (or waiting after closing it) leaves a window where a concurrent receiver (tipc_udp_recv()) could start after synchronize_net(), access ub, and suffer a UAF when kfree(ub) runs.
To fix this, we must defer dst_cache_destroy() and kfree(ub) until after we have ensured that no more readers can see the bearer/socket and all existing readers have finished:
1. Defer rcast entry destruction (both dst_cache_destroy() and kfree()) to an RCU callback using call_rcu_hurry().
Using call_rcu_hurry() ensures the dst entries are released quickly.
2. Release the bearer socket using udp_tunnel_sock_release() (stops new receive readers).
3. Call synchronize_net() to wait for all outstanding RCU readers (both transmit and receive) to finish.
4. Now that it is safe, call dst_cache_destroy() on the main bearer cache, and free ub.
Note: 3) and 4) can be changed later in net-next to also use call_rcu_hurry() and get rid of the synchronize_net() latency.
---
v2: addressed Xin Long feedback
v1: https://lore.kernel.org/netdev/CANn89i+dkbrSAwvaWXW7yWMfcwUebuTBLG5T7AGZaZcpVYGyfQ@mail.gmail.com/T/#m7bbeedffe3bedb69e33236410e3833c7ce809850
net/tipc/udp_media.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
net/tipc/udp_media.c +11 -4
@@ -803,6 +803,14 @@ static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,return err; } +static void rcast_free_rcu (struct rcu_head *rcu) +{ + struct udp_replicast *rcast = container_of(rcu, struct udp_replicast, rcu); + +dst_cache_destroy (&rcast->dst_cache); +kfree (rcast); +} +/* cleanup_bearer - break the socket/bearer association */ static void cleanup_bearer (struct work_struct *work) {
@@ -811,18 +819,17 @@ static void cleanup_bearer(struct work_struct *work)struct tipc_net *tn;list_for_each_entry_safe (rcast, tmp, &ub->rcast.list, list) { -dst_cache_destroy (&rcast->dst_cache);list_del_rcu (&rcast->list); -kfree_rcu (rcast, rcu); +call_rcu_hurry (&rcast->rcu, rcast_free_rcu); } tn =tipc_net (sock_net (ub->sk)); -dst_cache_destroy (&ub->rcast.dst_cache);udp_tunnel_sock_release (ub->sk); -/* Note: could use a call_rcu() to avoid another synchronize_net() */ synchronize_net (); + +dst_cache_destroy (&ub->rcast.dst_cache);atomic_dec (&tn->wq_count);kfree (ub); }
Signature · 1 line
2.55.0.rc0.799.gd6f94ed593-goog
Tung Quang Nguyen
maintainerRE: [PATCH v2 net 1/2] tipc: fix UAF in cleanup_bearer() due to premature dst_cache_destroy()
Quoted 79 lines
Subject: [PATCH v2 net 1/2] tipc: fix UAF in
cleanup_bearer()due to prematuredst_cache_destroy()TIPC UDP media bearer teardown calls
dst_cache_destroy()on its replicast caches before callingsynchronize_net()to wait for concurrent RCU readers (transmitters) to finish:static void
cleanup_bearer(struct work_struct *work){ ...list_for_each_entry_safe(rcast, tmp, &ub->rcast.list, list) { dst_cache_destroy(&rcast->dst_cache); list_del_rcu(&rcast->list); kfree_rcu(rcast, rcu); } ... dst_cache_destroy(&ub->rcast.dst_cache); udp_tunnel_sock_release(ub->sk); synchronize_net();...
}This is highly buggy because
dst_cache_destroy()immediately frees the per- CPU cache memory (free_percpu()) and releases the cached dst entries without any synchronization.If a concurrent transmitter (e.g.,
tipc_udp_xmit()) is running on another CPU under RCU protection, it can calldst_cache_get()concurrently, leading to:
1. Use-After-Free on the per-CPU cache pointer itself (crash).
2. "rcuref - imbalancedput()" warning if it attempts to release a dst that was concurrently released bydst_cache_destroy().Furthermore, calling kfree(ub) immediately after
synchronize_net()without closing the socket first (or waiting after closing it) leaves a window where a concurrent receiver (tipc_udp_recv()) could start aftersynchronize_net(), access ub, and suffer a UAF when kfree(ub) runs.To fix this, we must defer
dst_cache_destroy()and kfree(ub) until after we have ensured that no more readers can see the bearer/socket and all existing readers have finished:1. Defer rcast entry destruction (both
dst_cache_destroy()andkfree()) to an RCU callback usingcall_rcu_hurry().
Usingcall_rcu_hurry()ensures the dst entries are released quickly.2. Release the bearer socket using
udp_tunnel_sock_release()(stops new receive readers).3. Call
synchronize_net()to wait for all outstanding RCU readers (both transmit and receive) to finish.4. Now that it is safe, call
dst_cache_destroy()on the main bearer cache, and free ub.Note: 3) and 4) can be changed later in net-next to also use
call_rcu_hurry()and get rid of thesynchronize_net()latency.Fixes e9c1a793210f ("tipc: add dst_cache support for udp media")Reported-by [email protected]Closes:
https://lore.kernel.org/netdev/6a396a66.52ae72c2.136ac7.0003.GAE@google.
com/T/#uSigned-off-by Eric Dumazet <[email protected]>Cc Xin Long <[email protected]>Cc Jon Maloy <[email protected]>---
v2: addressed Xin Long feedback
v1:
https://lore.kernel.org/netdev/CANn89i+dkbrSAwvaWXW7yWMfcwUebuTBLG
[email protected]/T/#m7bbeedffe3bedb69e33236410e3833c7ce809850net/tipc/udp_media.c| 15 +++++++++++----1 file changed, 11 insertions(+), 4 deletions(-)net/tipc/udp_media.c index renamed from net/tipc/udp_media.c +0
-0
988b8a7f953ad6da860e6190f1f244650f121dce..66f3cb87a0aaaac8f40e8f237ab9a44d539b1cd8100644
net/tipc/udp_media.c static int tipc_udp_enable(struct net *net, struct · line 809
Quoted 7 lines
net/tipc/udp_media.c +3
-0@@ -803,6 +803,14 @@ static int tipc_udp_enable(struct net *net, structtipc_bearer *b, return err; } +static void rcast_free_rcu (struct rcu_head *rcu) { + struct udp_replicast *rcast = container_of(rcu, struct udp_replicast, +rcu);
This line is long (over 80 columns). Please break it into 2 lines (refer to linux/Documentation/process/coding-style.rst).
Quoted 32 lines
net/tipc/udp_media.c +5
-0+ +dst_cache_destroy (&rcast->dst_cache); +kfree (rcast); +} + /* cleanup_bearer - break the socket/bearer association */ static void
cleanup_bearer(struct work_struct *work){ @@ -811,18 +819,17 @@ static voidcleanup_bearer(struct work_struct *work)struct tipc_net *tn; list_for_each_entry_safe(rcast, tmp, &ub->rcast.list, list) {net/tipc/udp_media.c +0
-1-dst_cache_destroy (&rcast->dst_cache);list_del_rcu(&rcast->list);net/tipc/udp_media.c +1
-1-kfree_rcu (rcast, rcu); +call_rcu_hurry (&rcast->rcu, rcast_free_rcu);} tn = tipc_net(sock_net(ub->sk));net/tipc/udp_media.c +0
-1-dst_cache_destroy (&ub->rcast.dst_cache);udp_tunnel_sock_release(ub->sk);net/tipc/udp_media.c +0
-1-/* Note: could use a call_rcu() to avoid another synchronize_net() */ synchronize_net();net/tipc/udp_media.c +2
-0+ +dst_cache_destroy (&ub->rcast.dst_cache);atomic_dec(&tn->wq_count); kfree(ub); }--
2.55.0.rc0.799.gd6f94ed593-goog
Re: [PATCH v2 net 1/2] tipc: fix UAF in cleanup_bearer() due to premature dst_cache_destroy()
Quoted 84 lines · Tung Quang Nguyen
Quoted 84 lines
Subject: [PATCH v2 net 1/2] tipc: fix UAF in
cleanup_bearer()due to prematuredst_cache_destroy()TIPC UDP media bearer teardown calls
dst_cache_destroy()on its replicast caches before callingsynchronize_net()to wait for concurrent RCU readers (transmitters) to finish:static void
cleanup_bearer(struct work_struct *work){ ...list_for_each_entry_safe(rcast, tmp, &ub->rcast.list, list) { dst_cache_destroy(&rcast->dst_cache); list_del_rcu(&rcast->list); kfree_rcu(rcast, rcu); } ... dst_cache_destroy(&ub->rcast.dst_cache); udp_tunnel_sock_release(ub->sk); synchronize_net();...
}This is highly buggy because
dst_cache_destroy()immediately frees the per- CPU cache memory (free_percpu()) and releases the cached dst entries without any synchronization.If a concurrent transmitter (e.g.,
tipc_udp_xmit()) is running on another CPU under RCU protection, it can calldst_cache_get()concurrently, leading to:
1. Use-After-Free on the per-CPU cache pointer itself (crash).
2. "rcuref - imbalancedput()" warning if it attempts to release a dst that was concurrently released bydst_cache_destroy().Furthermore, calling kfree(ub) immediately after
synchronize_net()without closing the socket first (or waiting after closing it) leaves a window where a concurrent receiver (tipc_udp_recv()) could start aftersynchronize_net(), access ub, and suffer a UAF when kfree(ub) runs.To fix this, we must defer
dst_cache_destroy()and kfree(ub) until after we have ensured that no more readers can see the bearer/socket and all existing readers have finished:1. Defer rcast entry destruction (both
dst_cache_destroy()andkfree()) to an RCU callback usingcall_rcu_hurry().
Usingcall_rcu_hurry()ensures the dst entries are released quickly.2. Release the bearer socket using
udp_tunnel_sock_release()(stops new receive readers).3. Call
synchronize_net()to wait for all outstanding RCU readers (both transmit and receive) to finish.4. Now that it is safe, call
dst_cache_destroy()on the main bearer cache, and free ub.Note: 3) and 4) can be changed later in net-next to also use
call_rcu_hurry()and get rid of thesynchronize_net()latency.Fixes e9c1a793210f ("tipc: add dst_cache support for udp media")Reported-by [email protected]Closes:
https://lore.kernel.org/netdev/6a396a66.52ae72c2.136ac7.0003.GAE@google.
com/T/#uSigned-off-by Eric Dumazet <[email protected]>Cc Xin Long <[email protected]>Cc Jon Maloy <[email protected]>---
v2: addressed Xin Long feedback
v1:
https://lore.kernel.org/netdev/CANn89i+dkbrSAwvaWXW7yWMfcwUebuTBLG
[email protected]/T/#m7bbeedffe3bedb69e33236410e3833c7ce809850net/tipc/udp_media.c| 15 +++++++++++----1 file changed, 11 insertions(+), 4 deletions(-)net/tipc/udp_media.c index renamed from net/tipc/udp_media.c +0
-0
988b8a7f953ad6da860e6190f1f244650f121dce..66f3cb87a0aaaac8f40e8f237ab9a44d539b1cd8100644net/tipc/udp_media.c +0
-0@@ -803,6 +803,14 @@ static int tipc_udp_enable(struct net *net, structtipc_bearer *b, return err; }
Quoted 5 lines
net/tipc/udp_media.c static int tipc_udp_enable(struct net *net, struct · line 809
Quoted 3 lines
net/tipc/udp_media.c +3
-0+static void rcast_free_rcu (struct rcu_head *rcu) { + struct udp_replicast *rcast = container_of(rcu, struct udp_replicast, +rcu);This line is long (over 80 columns). Please break it into 2 lines (refer to
linux/Documentation/process/coding-style.rst).
I prefer it this way.
BTW:
commit bdc48fa11e46f867ea4d75fa59ee87a7f48be144
Author: Joe Perches <[email protected]> Date: Fri May 29 16:12:21 2020 -0700
checkpatch/coding-style: deprecate 80-column warning
Yes, staying withing 80 columns is certainly still _preferred_. But it's not the hard limit that the checkpatch warnings imply, and other concerns can most certainly dominate.
Increase the default limit to 100 characters. Not because 100 characters is some hard limit either, but that's certainly a "what are you doing" kind of value and less likely to be about the occasional slightly longer lines.
Miscellanea:
- to avoid unnecessary whitespace changes in files, checkpatch will no longer emit a warning about line length when scanning files unless --strict is also used
- Add a bit to coding-style about alignment to open parenthesis
Re: [PATCH v2 net 1/2] tipc: fix UAF in cleanup_bearer() due to premature dst_cache_destroy()
In reply to Eric DumazetQuoted 6 lines
net/tipc/udp_media.c +0
-0@@ -803,6 +803,14 @@ static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,return err;
net/tipc/udp_media.c static int tipc_udp_enable(struct net *net, struct tipc_bearer *b, · line 813
Quoted 10 lines
net/tipc/udp_media.c +8
-0} +static void rcast_free_rcu (struct rcu_head *rcu) +{ + struct udp_replicast *rcast = container_of(rcu, struct udp_replicast, rcu); + +dst_cache_destroy (&rcast->dst_cache); +kfree (rcast); +} +
Since this adds a module-specific callback rcast_free_rcu registered with RCU via call_rcu_hurry(), is an rcu_barrier() needed in the TIPC module exit function?
If the module is unloaded, the RCU grace period might expire after the module memory is freed.
net/tipc/core.c:tipc_exit() {tipc_netlink_compat_stop();
...pr_info("Deactivated\n");
}
Could this result in a kernel panic when RCU attempts to execute the unloaded rcast_free_rcu function?
This sashiko report looks legit.
I think synchronize_net() doesn't guarantee rcast_free_rcu() to be done.
Re: [PATCH v2 net 1/2] tipc: fix UAF in cleanup_bearer() due to premature dst_cache_destroy()
Quoted 9 lines · Xin Long
Quoted 9 lines
net/tipc/udp_media.c +0
-0@@ -803,6 +803,14 @@ static int tipc_udp_enable(struct net *net, struct tipc_bearer *b,return err; }
Quoted 11 lines
net/tipc/udp_media.c static int tipc_udp_enable(struct net *net, struct tipc_bearer *b, · line 813
Quoted 8 lines
net/tipc/udp_media.c +8
-0+static void rcast_free_rcu (struct rcu_head *rcu) +{ + struct udp_replicast *rcast = container_of(rcu, struct udp_replicast, rcu); + +dst_cache_destroy (&rcast->dst_cache); +kfree (rcast); +} +Since this adds a module-specific callback
rcast_free_rcuregistered with RCU viacall_rcu_hurry(), is anrcu_barrier()needed in the TIPC module exit function?
There is one already, this was one of my feedback for this patch:
commit 1579342d71133da7f00daa02c75cebec7372097b
Author: Weiming Shi <[email protected]> Date: Wed Jun 17 21:57:45 2026 +0800
tipc: fix use-after-free of the discoverer in tipc_disc_rcv()
Quoted 13 lines
If the module is unloaded, the RCU grace period might expire after the module memory is freed.
net/tipc/core.c:tipc_exit() {tipc_netlink_compat_stop();
...pr_info("Deactivated\n");
}
Could this result in a kernel panic when RCU attempts to execute the unloadedrcast_free_rcufunction?This sashiko report looks legit.
I think
synchronize_net()doesn't guaranteercast_free_rcu()to be done.
PATCH v2 2/2 tipc: avoid busy looping in tipc_exit_net()
In reply to Eric DumazetBlamed commit introduced a busy-wait loop in tipc_exit_net() to wait for pending UDP bearer cleanup works to complete:
while (atomic_read(&tn->wq_count))
cond_resched();This loop can busy-wait for a long time if cond_resched() is a NOP. This typically happens if the netns exit is executed by a high priority task, or under kernels configured without preemption (CONFIG_PREEMPT_NONE). In such cases, it wastes CPU cycles and can lead to soft lockups.
Fix this by replacing the busy loop with wait_var_event(), allowing the thread to sleep properly until the work queue count reaches zero.
Accordingly, update cleanup_bearer() to use atomic_dec_and_test() and wake_up_var() to wake up the waiter when the count drops to zero.
This uses the global wait queue hash table, avoiding the need to bloat struct tipc_net with a wait_queue_head_t. The atomic_dec_and_test() provides the necessary memory barrier to ensure the wakeup is not missed.
--- net/tipc/core.c | 4 ++-- net/tipc/udp_media.c | 4 +++- 2 files changed, 5 insertions(+), 3 deletions(-)
net/tipc/core.c +2 -2
@@ -45,6 +45,7 @@#include "crypto.h" #include <linux/module.h> +#include <linux/wait_bit.h> /* configurable TIPC parameters */ unsigned int tipc_net_id__read_mostly ;
@@ -118,8 +119,7 @@ static void __net_exit tipc_exit_net(struct net *net)#ifdef CONFIG_TIPC_CRYPTO tipc_crypto_stop (&tipc_net (net)->crypto_tx);#endif -while (atomic_read (&tn->wq_count)) -cond_resched (); +wait_var_event (&tn->wq_count,atomic_read (&tn->wq_count) ==0 ); } static void __net_exit tipc_pernet_pre_exit(struct net *net)
net/tipc/udp_media.c +3 -1
@@ -40,6 +40,7 @@#include <linux/igmp.h> #include <linux/kernel.h> #include <linux/workqueue.h> +#include <linux/wait_bit.h> #include <linux/list.h> #include <net/sock.h> #include <net/ip.h>
@@ -830,7 +831,8 @@ static void cleanup_bearer(struct work_struct *work)synchronize_net ();dst_cache_destroy (&ub->rcast.dst_cache); -atomic_dec (&tn->wq_count); +if (atomic_dec_and_test (&tn->wq_count)) +wake_up_var (&tn->wq_count);kfree (ub); }
Signature · 1 line
2.55.0.rc0.799.gd6f94ed593-goog
Tung Quang Nguyen
maintainerRE: [PATCH v2 net 2/2] tipc: avoid busy looping in tipc_exit_net()
Quoted 49 lines
Subject: [PATCH v2 net 2/2] tipc: avoid busy looping in
tipc_exit_net()Blamed commit introduced a busy-wait loop in
tipc_exit_net()to wait for pending UDP bearer cleanup works to complete:while (atomic_read(&tn->wq_count)) cond_resched();This loop can busy-wait for a long time if
cond_resched()is a NOP. This typically happens if the netns exit is executed by a high priority task, or under kernels configured without preemption (CONFIG_PREEMPT_NONE). In such cases, it wastes CPU cycles and can lead to soft lockups.Fix this by replacing the busy loop with
wait_var_event(), allowing the thread to sleep properly until the work queue count reaches zero.Accordingly, update
cleanup_bearer()to useatomic_dec_and_test()andwake_up_var()to wake up the waiter when the count drops to zero.This uses the global wait queue hash table, avoiding the need to bloat struct
tipc_netwith await_queue_head_t. Theatomic_dec_and_test()provides the necessary memory barrier to ensure the wakeup is not missed.Fixes 04c26faa51d1 ("tipc: wait and exit until all work queues are done")Signed-off-by Eric Dumazet <[email protected]>Cc Xin Long <[email protected]>Cc Jon Maloy <[email protected]>---
net/tipc/core.c| 4 ++--net/tipc/udp_media.c| 4 +++-2 files changed, 5 insertions(+), 3 deletions(-)net/tipc/core.c index renamed from net/tipc/core.c +0
-0
1ddecea1df6e9100334c47a28ff6c065292fb9ad..315975c3be8186784e9c44c9ff69d62c17ffd4b9100644net/tipc/core.c +1
-0@@ -45,6 +45,7 @@#include "crypto.h" #include <linux/module.h> +#include <linux/wait_bit.h> /* configurable TIPC parameters */ unsigned int
tipc_net_id__read_mostly; @@ -118,8 +119,7 @@ static void__net_exittipc_exit_net(struct net *net)#ifdefCONFIG_TIPC_CRYPTOtipc_crypto_stop(&tipc_net(net)->crypto_tx);#endif
net/tipc/core.c static void __net_exit tipc_exit_net(struct net *net) · line 122
Quoted 3 lines
net/tipc/core.c +1
-2-while (atomic_read (&tn->wq_count)) -cond_resched (); +wait_var_event (&tn->wq_count,atomic_read (&tn->wq_count) ==0 );
It could be nicer if you change to this simple call:wait_var_event(&tn->wq_count, !atomic_read(&tn->wq_count));
Quoted 29 lines
}
static void
__net_exittipc_pernet_pre_exit(struct net *net)diff --gita/net/tipc/udp_media.cb/net/tipc/udp_media.cindex66f3cb87a0aaaac8f40e8f237ab9a44d539b1cd8..62ae7f5b58409c89798c915dee752ac42487581f100644net/tipc/udp_media.c +3
-2@@ -40,6 +40,7 @@#include <linux/igmp.h> #include <linux/kernel.h> #include <linux/workqueue.h> +#include <linux/wait_bit.h> #include <linux/list.h> #include <net/sock.h> #include <net/ip.h> @@ -830,7 +831,8 @@ static void cleanup_bearer(struct work_struct *work)synchronize_net ();dst_cache_destroy (&ub->rcast.dst_cache); -atomic_dec (&tn->wq_count); +if (atomic_dec_and_test (&tn->wq_count)) +wake_up_var (&tn->wq_count);kfree (ub); } --2.55.0.rc0.799.gd6f94ed593-goog
Re: [PATCH v2 net 2/2] tipc: avoid busy looping in tipc_exit_net()
Quoted 4 lines · Tung Quang Nguyen
It could be nicer if you change to this simple call:
wait_var_event(&tn->wq_count, !atomic_read(&tn->wq_count));
Given the amount of work we currently have with various AI reports, I will keep it this way to avoid unnecessary noise.
Thank you,
Quoted 10 lines · Eric Dumazet
First patch fixes a recent syzbot report.
Second patch is inspired by numerous syzbot soft lockup reports with RTNL pressure.
Eric Dumazet (2):
tipc: fix UAF incleanup_bearer()due to prematuredst_cache_destroy()
tipc: avoid busy looping intipc_exit_net()
Quoted 7 lines
net/tipc/core.c | 4 ++-- net/tipc/udp_media.c | 19 ++++++++++++++----- 2 files changed, 16 insertions(+), 7 deletions(-)--
2.55.0.rc0.799.gd6f94ed593-goog
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 10 lines · On Tue, 23 Jun 2026 17:30:28 +0000 you wrote:
First patch fixes a recent syzbot report.
Second patch is inspired by numerous syzbot soft lockup reports with RTNL pressure.
Eric Dumazet (2):
tipc: fix UAF incleanup_bearer()due to prematuredst_cache_destroy()
tipc: avoid busy looping intipc_exit_net()[...]
Here is the summary with links:
- [v2,net,1/2] tipc: fix UAF in cleanup_bearer() due to premature dst_cache_destroy()
https://git.kernel.org/netdev/net/c/7116764ca53f - [v2,net,2/2] tipc: avoid busy looping in tipc_exit_net() https://git.kernel.org/netdev/net/c/c1481c94e74c
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html