* [PATCH net-next v4 0/4] net: make moving a device to another netns cheaper
@ 2026-11-18 2:28 Qiliang Yuan
2026-11-18 2:28 ` [PATCH net-next v4 1/4] ipv4: draw rt_genid from a sequence shared by all netns Qiliang Yuan
` (3 more replies)
0 siblings, 4 replies; 11+ messages in thread
From: Qiliang Yuan @ 2026-11-18 2:28 UTC (permalink / raw)
To: David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, David Ahern, Ido Schimmel, Nikolay Aleksandrov
Cc: Kuniyuki Iwashima, netdev, linux-kernel, Qiliang Yuan
Moving a device to another netns waits in rcu_barrier() with RTNL held.
Container and sandbox managers move one end of a veth pair for every
new network namespace, so this barrier limits how fast such namespaces
can be created on the whole system, to about 70 per second with 4
CPUs online however many threads create them.
The barrier was added for NETDEV_UNREGISTER_FINAL, which is long gone,
but it still keeps cached IPv4 routes through the moved device from
being accepted in the old netns, and it lets the RCU callbacks of the
nexthops removed with the device release their IPv6 route exceptions
before the move. Routes through nexthop objects are not fully covered by
it: their cached dst entries are released by an RCU callback queued from
another RCU callback, so a socket in the old netns can still send
through a device that now belongs to another netns whenever the route
generation numbers of the two netns happen to match.
Patches 1 and 2 draw the IPv4 rt_genid and the IPv6 fib6_sernum bumps
from sequences shared by all netns, so a cached route no longer matches
another netns. Patch 3 releases the cached routes of a nexthop when it
is removed from a group, instead of leaving its IPv6 exceptions valid
until it is freed. With these, nothing relies on the barrier, and patch
4 removes it.
Without patch 3, removing the barrier lets a socket keep sending through
a moved device that carries no IPv6 address and is a member of a nexthop
group, until its exceptions are released. Datagrams a socket in netns A
sent through such a device after it moved to netns B, 10 trials,
median and range, with patches 1, 2 and 4 before and 1-4 after:
before (datagrams) after (datagrams) change
per trial 1044 (444-7789) 0 -100%
Creating 400 netns, each with a veth pair whose host end is moved back
to the initial netns, a tap device, addresses and routes, in a guest
with 4 CPUs online, median of 5 runs:
before (netns/s) after (netns/s) change
1 thread 30 32 +6.7%
4 threads 40 48 +20%
16 threads 69 110 +59%
Signed-off-by: Qiliang Yuan <qiliang.yuan@linux.dev>
---
V3 -> V4:
- 2/4: reject the initial fib6_sernum in rt6_is_valid(), which a route
can record while fib6_add() has published it but not bumped the sernum
yet (Sashiko review)
- 3/4: release the per-cpu routes and exceptions of the removed IPv6
nexthop instead of bumping the IPv6 sernum once per group, and flush
the IPv4 route cache at most once; this also drops the forward
declaration (Jakub Kicinski, Sashiko review)
- 3/4: with the exceptions released when the nexthop leaves the group,
4/4 no longer lets nexthop_free_rcu() remove them after the old netns
freed its rt6_stats (Sashiko review on 4/4)
- Drop the Fixes and Reviewed-by tags (Jakub Kicinski)
- Rebase onto net-next and remeasure in a 32 vCPU guest with 4 CPUs
online, so the netns creation rates differ from v3
V2 -> V3:
- Add patch 3: flush the cached routes of a group when one of its
nexthops is removed. Without it, patch 4 lets a socket keep sending
through a moved device that has no IPv6 address (Sashiko review)
- 1/4, 2/4: say that cached routes carry values drawn from the sequence
because inserting a route bumps it, not because NETDEV_UP does, and
that this holds until the sequence wraps (Sashiko review)
- 1/4, 2/4: add Kuniyuki's Reviewed-by, the code changes only in comments
- 4/4: commit message only, keep Eric's and Kuniyuki's Reviewed-by
- Rebase onto net-next and remeasure in another guest, where the barrier
costs about 4 ms per move instead of about 10 ms, so the gains are
smaller than in v2
- Send from my linux.dev address
V1 -> V2:
- 2/3: keep the initial fib6_sernum of each netns and never hand it out
from the shared sequence, instead of drawing a value at netns creation
(Eric Dumazet); 1/3: do the same for rt_genid
- 2/3: note that fib6_sernum is no longer monotonic per netns (Eric
Dumazet); 1/3: likewise for rt_genid
- Drop Kuniyuki's Reviewed-by from 1/3 and 2/3, which changed
- Rebase onto net-next and remeasure
v3: https://lore.kernel.org/r/20261109-bug-net-netns-move-rcu-barrier-v3-0-6084b02610b3@linux.dev
v2: https://lore.kernel.org/r/20261019-bug-net-netns-move-rcu-barrier-v2-0-b6eb7780c492@gmail.com
v1: https://lore.kernel.org/r/20261016-bug-net-netns-move-rcu-barrier-v1-0-4157d798658f@gmail.com
---
Qiliang Yuan (4):
ipv4: draw rt_genid from a sequence shared by all netns
ipv6: take fib6_sernum from a sequence shared by all netns
nexthop: release cached routes when a nexthop leaves a group
net: remove rcu_barrier() from __dev_change_net_namespace()
include/net/net_namespace.h | 5 +----
net/core/dev.c | 1 -
net/ipv4/nexthop.c | 15 +++++++++++++++
net/ipv4/route.c | 21 +++++++++++++++++++++
net/ipv6/ip6_fib.c | 16 +++++++++++++---
net/ipv6/route.c | 6 +++++-
6 files changed, 55 insertions(+), 9 deletions(-)
---
base-commit: c432f1c3b529be7fdaa5c08feeeb640b6e144745
change-id: 20261016-bug-net-netns-move-rcu-barrier-d998c6395830
Best regards,
--
Qiliang Yuan <qiliang.yuan@linux.dev>
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v4 1/4] ipv4: draw rt_genid from a sequence shared by all netns
2026-11-18 2:28 [PATCH net-next v4 0/4] net: make moving a device to another netns cheaper Qiliang Yuan
@ 2026-11-18 2:28 ` Qiliang Yuan
2026-11-22 3:14 ` netdev-bot+sashiko
2026-11-18 2:28 ` [PATCH net-next v4 2/4] ipv6: take fib6_sernum " Qiliang Yuan
` (2 subsequent siblings)
3 siblings, 1 reply; 11+ messages in thread
From: Qiliang Yuan @ 2026-11-18 2:28 UTC (permalink / raw)
To: David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, David Ahern, Ido Schimmel, Nikolay Aleksandrov
Cc: Kuniyuki Iwashima, netdev, linux-kernel, Qiliang Yuan
An IPv4 route records the rt_genid of the netns it was created in, and
rt_is_expired() compares it with the rt_genid of the netns its device
belongs to when the route is checked. Every netns starts its rt_genid
at 0 and increments it on each cache flush, so different netns often
hold the same value.
When a device moves to another netns, routes cached through it remain
usable until dst_dev_put() points them to blackhole_netdev. For a route
using a nexthop object this happens in nexthop_free_rcu(), which
free_fib_info_rcu() queues from inside an RCU callback, so the
rcu_barrier() in __dev_change_net_namespace() does not wait for it. If
the rt_genid of the new netns matches the cached one in that window,
ipv4_dst_check() accepts the route and a socket in the old netns keeps
sending through a device that now belongs to another netns.
Take every rt_genid bump from one sequence shared by all netns, which
never hands out 0, the value every netns starts with. Inserting a route
bumps rt_genid, so the routes a netns caches carry values drawn from the
sequence, which no other netns holds until it wraps after 2^32 bumps. A
moved device sends again only once it is up in its new netns, and
NETDEV_UP flushes the route cache there, so that netns no longer holds 0
either.
Concurrent bumps of one netns can leave the older of two values, so
rt_genid is no longer monotonic per netns. It is only compared for
equality, so this costs at most an extra route lookup.
A connected UDP socket in netns A caches a route through a nexthop
object on a veth. The veth is moved to netns B and brought up with one
RTM_NEWLINK, then the socket sends 200000 datagrams. B's rt_genid is
bumped 0 to 20 times before the move, 63 trials:
before after change
trials sending after move (count) 1 0 -100%
datagrams sent after move (count) 661 0 -100%
Signed-off-by: Qiliang Yuan <qiliang.yuan@linux.dev>
---
include/net/net_namespace.h | 5 +----
net/ipv4/route.c | 21 +++++++++++++++++++++
2 files changed, 22 insertions(+), 4 deletions(-)
diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h
index 4a4d72080acdc..11133ba130480 100644
--- a/include/net/net_namespace.h
+++ b/include/net/net_namespace.h
@@ -558,10 +558,7 @@ static inline int rt_genid_ipv6(const struct net *net)
}
#endif
-static inline void rt_genid_bump_ipv4(struct net *net)
-{
- atomic_inc(&net->ipv4.rt_genid);
-}
+void rt_genid_bump_ipv4(struct net *net);
extern void (*__fib6_flush_trees)(struct net *net);
static inline void rt_genid_bump_ipv6(struct net *net)
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index b9f5397336d34..294c9c278c403 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -393,6 +393,27 @@ static inline int ip_rt_proc_init(void)
}
#endif /* CONFIG_PROC_FS */
+/*
+ * Draw rt_genid bumps from one sequence shared by all netns. A route keeps
+ * the genid of the netns it was created in, and is checked against the netns
+ * its device is in now, so distinct values make that check fail once the
+ * device has moved. Every netns starts at 0, which the sequence never hands
+ * out, and inserting a route bumps the genid, so cached routes carry values
+ * drawn from the sequence.
+ */
+static atomic_t rt_genid_seq;
+
+void rt_genid_bump_ipv4(struct net *net)
+{
+ int genid;
+
+ do {
+ genid = atomic_inc_return(&rt_genid_seq);
+ } while (!genid);
+ atomic_set(&net->ipv4.rt_genid, genid);
+}
+EXPORT_SYMBOL_GPL(rt_genid_bump_ipv4);
+
static inline bool rt_is_expired(const struct rtable *rth)
{
bool res;
--
2.43.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v4 2/4] ipv6: take fib6_sernum from a sequence shared by all netns
2026-11-18 2:28 [PATCH net-next v4 0/4] net: make moving a device to another netns cheaper Qiliang Yuan
2026-11-18 2:28 ` [PATCH net-next v4 1/4] ipv4: draw rt_genid from a sequence shared by all netns Qiliang Yuan
@ 2026-11-18 2:28 ` Qiliang Yuan
2026-11-20 17:52 ` Ralf Lici
2026-11-22 3:14 ` netdev-bot+sashiko
2026-11-18 2:28 ` [PATCH net-next v4 3/4] nexthop: release cached routes when a nexthop leaves a group Qiliang Yuan
2026-11-18 2:28 ` [PATCH net-next v4 4/4] net: remove rcu_barrier() from __dev_change_net_namespace() Qiliang Yuan
3 siblings, 2 replies; 11+ messages in thread
From: Qiliang Yuan @ 2026-11-18 2:28 UTC (permalink / raw)
To: David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, David Ahern, Ido Schimmel, Nikolay Aleksandrov
Cc: Kuniyuki Iwashima, netdev, linux-kernel, Qiliang Yuan
A per-cpu IPv6 route of a nexthop object records fib6_sernum of the
netns it was created in, and rt6_is_valid() compares it with fib6_sernum
of the netns its device belongs to when the route is checked. Every netns
starts its fib6_sernum at 1 and increments it on each tree change, so
different netns often hold the same value.
When a device moves to another netns, such a route remains usable until
nexthop_free_rcu() releases it, and fib6_info_destroy_rcu() queues that
callback from inside an RCU callback, after the device has moved. If the
fib6_sernum of the new netns matches the cached one in that window,
ip6_dst_check() accepts the route and a socket in the old netns keeps
sending through a device that now belongs to another netns.
Take every fib6_sernum bump from one sequence shared by all netns, which
only hands out values from 2 up, and have rt6_is_valid() reject 1, the
value every netns starts with: fib6_add() publishes a route before it
bumps fib6_sernum, so a route looked up in between can record 1. 0 still
means there is no sernum to check. Any other value a route records was
drawn from the sequence, which no other netns holds until it wraps after
2^31 bumps. fib6_new_sernum() callers only hold their own table's
tb6_lock, so two tables of one netns can store their values in either
order, and fib6_sernum is no longer monotonic per netns. It is only
compared for equality, so this costs at most an extra invalidation.
A connected UDP socket in netns A caches a route through an IPv6 nexthop
object on a veth. The veth is moved to netns B and brought up with one
RTM_NEWLINK, then the socket sends 200000 datagrams. A route is added to
and removed from B 0 to 20 times before the move, 63 trials:
before after change
trials sending after move (count) 2 0 -100%
datagrams sent after move (count) 4399 0 -100%
Signed-off-by: Qiliang Yuan <qiliang.yuan@linux.dev>
---
net/ipv6/ip6_fib.c | 16 +++++++++++++---
net/ipv6/route.c | 6 +++++-
2 files changed, 18 insertions(+), 4 deletions(-)
diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index e1d49897d6ab0..827051cbf7482 100644
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -123,13 +123,23 @@ static void fib6_walkers_skip_rt(struct net *net, struct fib6_info *rt)
fib6_walkers_replace_leaf(net, rt, next);
}
+/*
+ * Draw fib6_sernum bumps from one sequence shared by all netns, so that a
+ * route cached against one netns does not match the sernum of another one,
+ * e.g. after its device moved, until the sequence wraps. Every netns starts
+ * at 1 and the sequence only hands out values from 2 up: 0 means no sernum
+ * to check.
+ */
+static atomic_t fib6_sernum_seq = ATOMIC_INIT(1);
+
static int fib6_new_sernum(struct net *net)
{
- int new, old = atomic_read(&net->ipv6.fib6_sernum);
+ int new, old = atomic_read(&fib6_sernum_seq);
do {
- new = old < INT_MAX ? old + 1 : 1;
- } while (!atomic_try_cmpxchg(&net->ipv6.fib6_sernum, &old, new));
+ new = old < INT_MAX ? old + 1 : 2;
+ } while (!atomic_try_cmpxchg(&fib6_sernum_seq, &old, new));
+ atomic_set(&net->ipv6.fib6_sernum, new);
return new;
}
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 4a4c5ace63c54..6731665fbb16d 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -1466,7 +1466,11 @@ static struct rt6_info *ip6_rt_pcpu_alloc(const struct fib6_result *res)
static bool rt6_is_valid(const struct rt6_info *rt6)
{
- return rt6->sernum == rt_genid_ipv6(dev_net(rt6->dst.dev));
+ /* Reject the initial sernum, which every netns shares and which a
+ * route can record before its insertion bumps the sernum.
+ */
+ return rt6->sernum != 1 &&
+ rt6->sernum == rt_genid_ipv6(dev_net(rt6->dst.dev));
}
/* It should be called with rcu_read_lock() acquired */
--
2.43.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v4 3/4] nexthop: release cached routes when a nexthop leaves a group
2026-11-18 2:28 [PATCH net-next v4 0/4] net: make moving a device to another netns cheaper Qiliang Yuan
2026-11-18 2:28 ` [PATCH net-next v4 1/4] ipv4: draw rt_genid from a sequence shared by all netns Qiliang Yuan
2026-11-18 2:28 ` [PATCH net-next v4 2/4] ipv6: take fib6_sernum " Qiliang Yuan
@ 2026-11-18 2:28 ` Qiliang Yuan
2026-11-22 3:14 ` netdev-bot+sashiko
2026-11-18 2:28 ` [PATCH net-next v4 4/4] net: remove rcu_barrier() from __dev_change_net_namespace() Qiliang Yuan
3 siblings, 1 reply; 11+ messages in thread
From: Qiliang Yuan @ 2026-11-18 2:28 UTC (permalink / raw)
To: David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, David Ahern, Ido Schimmel, Nikolay Aleksandrov
Cc: Kuniyuki Iwashima, netdev, linux-kernel, Qiliang Yuan
When a nexthop is removed while other members keep its group alive, only
the group array changes: the routes through the group stay in the FIB,
and the dsts they cached through the removed nexthop are released when
that nexthop is freed, from an RCU callback.
Until then those dsts stay valid. IPv6 route exceptions, such as the
ones created on Packet Too Big, are checked against the cookie of their
FIB node, which does not change, so a socket keeps sending through the
removed nexthop. When the nexthop goes away with its device, removing
the device's IPv6 addresses usually flushes the routing tree first, but
not when the device carries no IPv6 address.
Once all readers see the new group arrays, release the per-cpu routes and
exceptions of a removed IPv6 nexthop, as replacing a group already does
for its old members, and flush the IPv4 route cache once if any of the
groups carries IPv4 routes. The routes using the nexthop directly are
already gone at that point.
A connected UDP socket in netns A sends to a route through group {nh 1,
nh 2}, on an IPv6 exception of nh 1 created by Packet Too Big, while nh 1
is deleted. Datagrams still sent through nh 1 after the new group is
published and before nh 1 is freed, 10 trials, median and range, the
ones left after the change being sent before the dsts are released:
before (datagrams) after (datagrams) change
per trial 1140 (367-3788) 1 (1-3) -99.9%
Signed-off-by: Qiliang Yuan <qiliang.yuan@linux.dev>
---
net/ipv4/nexthop.c | 15 +++++++++++++++
1 file changed, 15 insertions(+)
diff --git a/net/ipv4/nexthop.c b/net/ipv4/nexthop.c
index 42e55b5a755ee..3fccd4f2f916b 100644
--- a/net/ipv4/nexthop.c
+++ b/net/ipv4/nexthop.c
@@ -2116,6 +2116,7 @@ remove_nexthop_from_groups(struct net *net, struct nexthop *nh,
struct nh_grp_entry *nhge, *tmp;
LIST_HEAD(deferred_free);
bool need_flush = false;
+ struct nh_info *nhi;
/* If there is nothing to do, let's avoid the costly call to
* synchronize_net()
@@ -2130,6 +2131,20 @@ remove_nexthop_from_groups(struct net *net, struct nexthop *nh,
/* make sure all see the newly published array before releasing rtnl */
synchronize_net();
+ /* Routes through the groups can still hold dsts cached through @nh,
+ * which are only released when @nh is freed. Release them now that
+ * no reader can pick @nh from the old groups any more.
+ */
+ nhi = rtnl_dereference(nh->nh_info);
+ if (nhi->family == AF_INET6)
+ fib6_nh_release_dsts(&nhi->fib6_nh);
+ list_for_each_entry(nhge, &deferred_free, nh_list) {
+ if (!list_empty(&nhge->nh_parent->fi_list)) {
+ rt_cache_flush(net);
+ break;
+ }
+ }
+
/* Now safe to free percpu stats — all RCU readers have finished */
list_for_each_entry_safe(nhge, tmp, &deferred_free, nh_list) {
list_del(&nhge->nh_list);
--
2.43.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v4 4/4] net: remove rcu_barrier() from __dev_change_net_namespace()
2026-11-18 2:28 [PATCH net-next v4 0/4] net: make moving a device to another netns cheaper Qiliang Yuan
` (2 preceding siblings ...)
2026-11-18 2:28 ` [PATCH net-next v4 3/4] nexthop: release cached routes when a nexthop leaves a group Qiliang Yuan
@ 2026-11-18 2:28 ` Qiliang Yuan
2026-11-22 3:14 ` netdev-bot+sashiko
3 siblings, 1 reply; 11+ messages in thread
From: Qiliang Yuan @ 2026-11-18 2:28 UTC (permalink / raw)
To: David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, David Ahern, Ido Schimmel, Nikolay Aleksandrov
Cc: Kuniyuki Iwashima, netdev, linux-kernel, Qiliang Yuan
Commit 6549dd43c043 ("net: dev: fix the incorrect hold of net
namespace's lo device") added rcu_barrier() before
NETDEV_UNREGISTER_FINAL in dev_change_net_namespace(), so that dst
entries released by RCU callbacks were on the dst garbage list before
dst_ifdown() moved them to the loopback device of the old netns.
Commit 070f2d7e264a ("net: Drop NETDEV_UNREGISTER_FINAL") removed the
event but kept the barrier, and dead dst entries now point to
blackhole_netdev instead of a loopback device.
The barrier waits for the RCU callbacks pending on every CPU while RTNL
is held, which takes a full grace period on each netns move. Container
and sandbox managers move one end of a veth pair for every new network
namespace, so this limits how fast such namespaces can be created on the
whole system, regardless of how many threads create them.
Remove the barrier. The RCU callbacks queued by NETDEV_UNREGISTER
handlers free memory and drop device references, which the move does not
wait for. Routes cached through the moved device are rejected once its
netns changes: IPv4 and per-cpu IPv6 routes no longer match the rt_genid
or fib6_sernum of another netns, and the per-cpu routes and exceptions
of a nexthop that leaves a group were already released when it left.
Creating 400 netns, each with a veth pair whose host end is moved back
to the initial netns, a tap device, addresses and routes, in a guest
with 4 CPUs online, median of 5 runs:
before (netns/s) after (netns/s) change
1 thread 30 32 +6.7%
4 threads 40 48 +20%
16 threads 69 110 +59%
Signed-off-by: Qiliang Yuan <qiliang.yuan@linux.dev>
---
net/core/dev.c | 1 -
1 file changed, 1 deletion(-)
diff --git a/net/core/dev.c b/net/core/dev.c
index 3a520c798d4a8..8a899e10e91c6 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -13153,7 +13153,6 @@ int __dev_change_net_namespace(struct net_device *dev, struct net *net,
* the device is just moving and can keep their slaves up.
*/
call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
- rcu_barrier();
new_nsid = peernet2id_alloc(dev_net(dev), net, GFP_KERNEL);
--
2.43.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH net-next v4 2/4] ipv6: take fib6_sernum from a sequence shared by all netns
2026-11-18 2:28 ` [PATCH net-next v4 2/4] ipv6: take fib6_sernum " Qiliang Yuan
@ 2026-11-20 17:52 ` Ralf Lici
2026-11-20 23:13 ` Qiliang Yuan
2026-11-22 3:14 ` netdev-bot+sashiko
1 sibling, 1 reply; 11+ messages in thread
From: Ralf Lici @ 2026-11-20 17:52 UTC (permalink / raw)
To: qiliang.yuan
Cc: davem, dsahern, edumazet, horms, idosch, kuba, kuniyu,
linux-kernel, netdev, pabeni, razor
Hi Qiliang,
I stumbled upon this series while looking for what caused a conflict
patchwork reported on one of my series [1], which touches the same code.
On Tue, 17 Nov 2026 21:28:31 -0500, Qiliang Yuan wrote:
> 2^31 bumps. fib6_new_sernum() callers only hold their own table's
> tb6_lock, so two tables of one netns can store their values in either
> order, and fib6_sernum is no longer monotonic per netns. It is only
> compared for equality, so this costs at most an extra invalidation.
Eric raised this on v1 [2], and for the equality checks I agree: values
are not reused, so a stale value cannot match. What the atomic_set
changes is the ordering. It comes after the full barrier of the cmpxchg,
so nothing orders it before the node stamp in fib6_update_sernum: a
reader can sample the new fn_sernum while still reading the old
generation (this one is allowed on arm64). Nothing in the tree compares
the two today, but my series relies on that order, since it brackets the
lookup and cookie sampling with two reads of the generation.
The late store also loses the guarantee that a reader seeing a value
sees the routing changes published before it. With the per-netns
cmpxchg, each update reads from the previous one. Here, CPU0 can draw 2
and stall while CPU1 links a route, draws 3 and publishes it, and then
CPU0 stores 2. LKMM allows a reader that reads 2 to miss CPU1's route
(x86 and arm64 forbid it in practice), and a per-cpu dst of a nexthop
object allocated from that lookup records 2 and passes rt6_is_valid
until the next bump.
Drawing from the shared sequence but publishing with a cmpxchg on the
per-netns counter keeps both, at the cost of a wasted draw on
contention:
static int fib6_new_sernum(struct net *net)
{
int old = atomic_read(&net->ipv6.fib6_sernum);
int new;
do {
new = fib6_sernum_draw();
} while (!atomic_try_cmpxchg(&net->ipv6.fib6_sernum, &old, new));
return new;
}
where fib6_sernum_draw is your current loop on fib6_sernum_seq. I
checked both cases with LKMM litmus tests: they are reachable with
atomic_set and forbidden with the cmpxchg publish.
1/4 has the same pattern for rt_genid, and IPv4 bumps can run
concurrently too, since xfrm policy insertion does not hold RTNL.
[1] https://lore.kernel.org/netdev/cover.1795166508.git.ralf@mandelbit.com/
[2] https://lore.kernel.org/netdev/CAL4WiioL+wiv3jgqeT1qiZ2mGWQ+HV+mEQP2K0aFMCpjDvwYDg@mail.gmail.com/
--
Ralf Lici
Mandelbit Srl
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH net-next v4 2/4] ipv6: take fib6_sernum from a sequence shared by all netns
2026-11-20 17:52 ` Ralf Lici
@ 2026-11-20 23:13 ` Qiliang Yuan
0 siblings, 0 replies; 11+ messages in thread
From: Qiliang Yuan @ 2026-11-20 23:13 UTC (permalink / raw)
To: Ralf Lici
Cc: Qiliang Yuan, davem, dsahern, edumazet, horms, idosch, kuba,
kuniyu, linux-kernel, netdev, pabeni, razor
Hi Ralf,
On Fri, Nov 20, 2026 at 06:52:41PM +0100, Ralf Lici wrote:
> What the atomic_set
> changes is the ordering. It comes after the full barrier of the cmpxchg,
> so nothing orders it before the node stamp in fib6_update_sernum: a
> reader can sample the new fn_sernum while still reading the old
> generation (this one is allowed on arm64).
[...]
> The late store also loses the guarantee that a reader seeing a value
> sees the routing changes published before it.
[...]
> Drawing from the shared sequence but publishing with a cmpxchg on the
> per-netns counter keeps both, at the cost of a wasted draw on
> contention:
Thanks for the careful review. I wrote both cases as litmus tests and
herd7 agrees: the stale generation and the late store of a smaller
value are both reachable with atomic_set() and forbidden once the
value is published with atomic_try_cmpxchg() on the per-netns counter.
> 1/4 has the same pattern for rt_genid, and IPv4 bumps can run
> concurrently too, since xfrm policy insertion does not hold RTNL.
Right. I'll publish with a cmpxchg in both 1/4 and 2/4 in v5, as you
suggested, and Cc you on it.
Thanks,
Qiliang
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH net-next v4 1/4] ipv4: draw rt_genid from a sequence shared by all netns
2026-11-18 2:28 ` [PATCH net-next v4 1/4] ipv4: draw rt_genid from a sequence shared by all netns Qiliang Yuan
@ 2026-11-22 3:14 ` netdev-bot+sashiko
0 siblings, 0 replies; 11+ messages in thread
From: netdev-bot+sashiko @ 2026-11-22 3:14 UTC (permalink / raw)
To: qiliang.yuan
Cc: davem, edumazet, kuba, pabeni, horms, dsahern, idosch, razor,
kuniyu, netdev, linux-kernel
Thank you for your contribution! Sashiko AI review found 2 potential
issue(s) to consider.
Critical: 0 · High: 0 · Medium: 1 · Low: 1
If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).
- [Medium] The fix depends on one guarantee: no other netns holds a given
rt_genid value until the global 32-bit rt_genid_seq wraps.
- [Low] The commit fixes a cross-netns isolation bug that already exists
in the current tree but has no Fixes: tag and no Cc: stable.
--
ipv4: draw rt_genid from a sequence shared by all netns
This patch moves rt_genid_bump_ipv4() out of line and takes every IPv4
rt_genid value from one global atomic sequence shared by all netns. That
sequence never returns 0. The aim is to make sure a route cached in one
netns cannot match the rt_genid of the netns its device has moved to.
> When a device moves to another netns, routes cached through it remain
> usable until dst_dev_put() points them to blackhole_netdev. For a route
> using a nexthop object this happens in nexthop_free_rcu(), which
> free_fib_info_rcu() queues from inside an RCU callback, so the
> rcu_barrier() in __dev_change_net_namespace() does not wait for it. If
> the rt_genid of the new netns matches the cached one in that window,
> ipv4_dst_check() accepts the route and a socket in the old netns keeps
> sending through a device that now belongs to another netns.
[Severity: Low]
Should this carry a Fixes: tag and a Cc: stable?
The premise holds in the current tree. For a fib_info that uses a nexthop
object, free_fib_info_rcu() in net/ipv4/fib_semantics.c only drops the
nexthop reference:
if (fi->nh) {
nexthop_put(fi->nh);
} else {
The cached rtables are released later, through this chain:
nexthop_free_rcu()->nexthop_free_single()->fib_nh_release()
That runs from an RCU callback queued inside another RCU callback, so the
rcu_barrier() in __dev_change_net_namespace() does not wait for it.
The old rt_genid_bump_ipv4() was a plain atomic_inc() from 0 in every
netns, so this cross-netns leak is visible to users in released kernels.
It most likely dates from when nexthop object support was added to
fib_info.
Without a Fixes: tag, how can backporters tell which stable trees need
this?
[ ... ]
> diff --git a/net/ipv4/route.c b/net/ipv4/route.c
> index b9f5397336d34..294c9c278c403 100644
> --- a/net/ipv4/route.c
> +++ b/net/ipv4/route.c
> @@ -393,6 +393,27 @@ static inline int ip_rt_proc_init(void)
> }
> #endif /* CONFIG_PROC_FS */
>
> +/*
> + * Draw rt_genid bumps from one sequence shared by all netns. A route keeps
> + * the genid of the netns it was created in, and is checked against the netns
> + * its device is in now, so distinct values make that check fail once the
> + * device has moved. Every netns starts at 0, which the sequence never hands
> + * out, and inserting a route bumps the genid, so cached routes carry values
> + * drawn from the sequence.
> + */
> +static atomic_t rt_genid_seq;
> +
> +void rt_genid_bump_ipv4(struct net *net)
> +{
> + int genid;
> +
> + do {
> + genid = atomic_inc_return(&rt_genid_seq);
> + } while (!genid);
> + atomic_set(&net->ipv4.rt_genid, genid);
> +}
[Severity: Medium]
Can an unprivileged user force rt_genid_seq to wrap and bring back the
collision this patch is meant to close?
The fix assumes no other netns holds a given value until the 32-bit
sequence wraps. However, sysctl_route_net_init() deliberately keeps the
per-netns route flush sysctl for netns owned by non-init user namespaces:
/* Don't export non-whitelisted sysctls to unprivileged users */
if (net->user_ns != &init_user_ns) {
if (tbl[0].procname != ipv4_route_flush_procname)
table_size = 0;
}
Each write to that sysctl advances the global counter, with no rate limit:
ipv4_sysctl_rtcache_flush()->rt_cache_flush()->rt_genid_bump_ipv4()
Route add/delete loops and xfrm_policy_insert() also advance it. The
period is 2^32-1 nonzero values, so a few threads could cycle it in
anywhere from minutes to about an hour.
After a wrap, the NETDEV_UP rt_cache_flush() in the device's new netns B
can hand out the same value that a route cached in the old netns A
carries. rt_is_expired() only tests for equality:
res = rth->rt_genid != rt_genid_ipv4(dev_net_rcu(rth->dst.dev));
so ipv4_dst_check() would accept the stale route. A socket in A would
then send through a device that belongs to B until dst_dev_put() runs.
Lining up the exact count between the two draws without being able to
read the counter is uncertain. Still, the commit message's "no other
netns holds until it wraps after 2^32 bumps" seems to treat the wrap as
unreachable.
This matters more later in the series. "net: remove rcu_barrier() from
__dev_change_net_namespace()" removes the barrier, so rt_genid uniqueness
becomes the only guard for all IPv4 cached routes, not just nexthop
object routes, until the deferred dst_dev_put() runs.
Would comparing netns identity, or using a wider sequence, avoid relying
on a value that unprivileged users can cycle?
> +EXPORT_SYMBOL_GPL(rt_genid_bump_ipv4);
> +
> static inline bool rt_is_expired(const struct rtable *rth)
> {
> bool res;
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261117-bug-net-netns-move-rcu-barrier-v4-0-43e1ca0aac7f%40linux.dev
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH net-next v4 2/4] ipv6: take fib6_sernum from a sequence shared by all netns
2026-11-18 2:28 ` [PATCH net-next v4 2/4] ipv6: take fib6_sernum " Qiliang Yuan
2026-11-20 17:52 ` Ralf Lici
@ 2026-11-22 3:14 ` netdev-bot+sashiko
1 sibling, 0 replies; 11+ messages in thread
From: netdev-bot+sashiko @ 2026-11-22 3:14 UTC (permalink / raw)
To: qiliang.yuan
Cc: davem, edumazet, kuba, pabeni, horms, dsahern, idosch, razor,
kuniyu, netdev, linux-kernel
Thank you for your contribution! Sashiko AI review found more severe
issue(s) in other patches of this series. This mail is only an FYI, in case
you want to address the nit picks below when you respin.
Low priority / nit picks for your consideration:
- [Low] The commit fixes a bug that is real and visible to users, but it
carries no Fixes: tag and no Cc: stable.
--
ipv6: take fib6_sernum from a sequence shared by all netns
This patch makes fib6_new_sernum() take every fib6_sernum bump from one
sequence shared by all netns, starting at 2. A per-cpu nexthop route
cached in one netns then no longer matches the sernum of another netns
after its device moves. rt6_is_valid() also rejects 1, the initial value
that every netns starts with.
> When a device moves to another netns, such a route remains usable until
> nexthop_free_rcu() releases it, and fib6_info_destroy_rcu() queues that
> callback from inside an RCU callback, after the device has moved. If the
> fib6_sernum of the new netns matches the cached one in that window,
> ip6_dst_check() accepts the route and a socket in the old netns keeps
> sending through a device that now belongs to another netns.
[ ... ]
> Signed-off-by: Qiliang Yuan <qiliang.yuan@linux.dev>
[Severity: Low]
This fixes a netns isolation problem that users can hit, but the patch has
no Fixes: tag and no Cc: stable. Should it have them?
Two pieces of code came in with the same commit. One records the sernum in
ip6_rt_pcpu_alloc(). The other compares it across netns in rt6_is_valid():
net/ipv6/route.c:ip6_rt_pcpu_alloc() {
...
if (f6i->nh)
pcpu_rt->sernum = rt_genid_ipv6(dev_net(dev));
...
}
net/ipv6/route.c:rt6_is_valid() {
return rt6->sernum == rt_genid_ipv6(dev_net(rt6->dst.dev));
}
Going by git blame, both lines come from this commit:
Fixes: 8f34e53b60b3 ("ipv6: Use global sernum for dst validation with nexthop objects")
The commit message also never calls this a netns isolation problem: a
socket in netns A keeps sending through a device that netns B now owns.
Could the message say so explicitly, for stable and security triage?
The IPv4 companion patch in this series, "ipv4: draw rt_genid from a
sequence shared by all netns", seems to be missing the same tags.
The series also puts these fixes together with "net: remove rcu_barrier()
from __dev_change_net_namespace()", which looks like a net-next style
optimization. Would it make sense to split the fixes out and send them to
net, so they can be picked up for stable?
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261117-bug-net-netns-move-rcu-barrier-v4-0-43e1ca0aac7f%40linux.dev
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH net-next v4 3/4] nexthop: release cached routes when a nexthop leaves a group
2026-11-18 2:28 ` [PATCH net-next v4 3/4] nexthop: release cached routes when a nexthop leaves a group Qiliang Yuan
@ 2026-11-22 3:14 ` netdev-bot+sashiko
0 siblings, 0 replies; 11+ messages in thread
From: netdev-bot+sashiko @ 2026-11-22 3:14 UTC (permalink / raw)
To: qiliang.yuan
Cc: davem, edumazet, kuba, pabeni, horms, dsahern, idosch, razor,
kuniyu, netdev, linux-kernel
Thank you for your contribution! Sashiko AI review found 2 potential
issue(s) to consider.
Critical: 0 · High: 1 · Medium: 0 · Low: 1
If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).
- [High] nexthop: missing rt_genid_bump_ipv6() in
remove_nexthop_from_groups()
- [Low] The new block comment in remove_nexthop_from_groups()
(net/ipv4/nexthop.c) says "Routes through the groups can still hold…
--
nexthop: release cached routes when a nexthop leaves a group
When a nexthop is removed from a group that stays alive, this patch makes
remove_nexthop_from_groups() release the per-cpu routes and exceptions of
the removed nexthop once synchronize_net() returns, if it is IPv6. It also
flushes the IPv4 route cache once if any affected group carries IPv4
routes.
> diff --git a/net/ipv4/nexthop.c b/net/ipv4/nexthop.c
> index 42e55b5a755ee..3fccd4f2f916b 100644
> --- a/net/ipv4/nexthop.c
> +++ b/net/ipv4/nexthop.c
[ ... ]
> @@ -2130,6 +2131,20 @@ remove_nexthop_from_groups(struct net *net, struct nexthop *nh,
> /* make sure all see the newly published array before releasing rtnl */
> synchronize_net();
>
> + /* Routes through the groups can still hold dsts cached through @nh,
> + * which are only released when @nh is freed. Release them now that
> + * no reader can pick @nh from the old groups any more.
> + */
> + nhi = rtnl_dereference(nh->nh_info);
> + if (nhi->family == AF_INET6)
> + fib6_nh_release_dsts(&nhi->fib6_nh);
> + list_for_each_entry(nhge, &deferred_free, nh_list) {
> + if (!list_empty(&nhge->nh_parent->fi_list)) {
> + rt_cache_flush(net);
> + break;
> + }
> + }
[Severity: High]
Does this also need an IPv6 genid bump for the groups that carry IPv6
routes?
For a route through a group, ip6_rt_pcpu_alloc() records the current
rt_genid_ipv6() in pcpu_rt->sernum. ip6_dst_check() then takes the
early path for that route:
net/ipv6/route.c:ip6_dst_check() {
...
if (rt->sernum)
return rt6_is_valid(rt) ? dst : NULL;
...
}
rt6_is_valid() only compares rt->sernum against
rt_genid_ipv6(dev_net(rt->dst.dev)). It does not look at
dst->obsolete or rt->from.
fib6_nh_release_dsts() calls dst_dev_put() on each per-cpu route.
That marks the route DST_OBSOLETE_DEAD, points dst->output at
dst_discard_out and moves the device to blackhole_netdev. Nothing on
this path bumps the IPv6 genid, though. The group's routes stay in
the FIB, and __remove_nexthop_fib() only walks nh->f6i_list, not the
parent's.
In a non-initial netns, as in the test from the commit message,
moving the device to blackhole_netdev changes dev_net() to &init_net.
The sernum comparison then fails, more or less by accident.
In init_net, dev_net(blackhole_netdev) is still &init_net and the
genid has not moved. rt6_is_valid() keeps returning true for the dead
dst. Wouldn't a connected socket in init_net then keep that dst in
sk_dst_cache and silently discard everything it sends, instead of
failing over to the remaining members of the group?
The same missing bump would also seem to leave uncached routes
through @nh on rt6_uncached_list valid. Those routes are in neither
rt6i_pcpu nor the exception buckets that fib6_nh_release_dsts()
walks.
nh_rt_cache_flush() handles the replace case by checking f6i_list
under the lock first:
net/ipv4/nexthop.c:nh_rt_cache_flush() {
...
spin_lock_bh(&nh->lock);
have_f6i = !list_empty(&nh->f6i_list);
spin_unlock_bh(&nh->lock);
if (have_f6i)
rt_genid_bump_ipv6(net);
...
}
Should the loop over deferred_free also check
nhge->nh_parent->f6i_list under nh_parent->lock? It could then call
rt_genid_bump_ipv6(net) once, the same way it calls
rt_cache_flush(net) for fi_list.
[Severity: Low]
This isn't a bug, but is the comment accurate for the IPv4 case?
The comment says the dsts cached through @nh are released here. That holds
for IPv6, where fib6_nh_release_dsts() flushes the exceptions and drops the
per-cpu routes.
For IPv4, rt_cache_flush() only bumps the genid:
net/ipv4/route.c:rt_cache_flush() {
rt_genid_bump_ipv4(net);
}
That invalidates the cached rtables, but it does not release them. The
rtables in @nh's fib_nh_common (nhc_pcpu_rth_output and the fnhe
exceptions), and the device references they hold, are still dropped later
from the RCU callback, through nexthop_free_single()->fib_nh_release().
nh_rt_cache_flush() describes these as two separate things. One comment
says the dst entries "need to be regenerated" (the genid bump), and another
says "we have to release all old dsts" (IPv6 only).
Could the new comment draw the same distinction, so it doesn't suggest the
IPv4 dsts are freed at this point?
> +
> /* Now safe to free percpu stats — all RCU readers have finished */
> list_for_each_entry_safe(nhge, tmp, &deferred_free, nh_list) {
> list_del(&nhge->nh_list);
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261117-bug-net-netns-move-rcu-barrier-v4-0-43e1ca0aac7f%40linux.dev
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [PATCH net-next v4 4/4] net: remove rcu_barrier() from __dev_change_net_namespace()
2026-11-18 2:28 ` [PATCH net-next v4 4/4] net: remove rcu_barrier() from __dev_change_net_namespace() Qiliang Yuan
@ 2026-11-22 3:14 ` netdev-bot+sashiko
0 siblings, 0 replies; 11+ messages in thread
From: netdev-bot+sashiko @ 2026-11-22 3:14 UTC (permalink / raw)
To: qiliang.yuan
Cc: davem, edumazet, kuba, pabeni, horms, dsahern, idosch, razor,
kuniyu, netdev, linux-kernel
Thank you for your contribution! Sashiko AI review found 2 potential
issue(s) to consider.
Critical: 0 · High: 0 · Medium: 2 · Low: 0
If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).
- [Medium] net: race in __dev_change_net_namespace() leaves moved dev on
xfrm_dst
- [Medium] net: missing dst_dev_put() wait in
__dev_change_net_namespace()
--
> diff --git a/net/core/dev.c b/net/core/dev.c
> --- a/net/core/dev.c
> +++ b/net/core/dev.c
> @@ -13153,7 +13153,6 @@ int __dev_change_net_namespace(struct net_device *dev, struct net *net,
> * the device is just moving and can keep their slaves up.
> */
> call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
> - rcu_barrier();
>
> new_nsid = peernet2id_alloc(dev_net(dev), net, GFP_KERNEL);
>
>
[Severity: Medium]
The changelog says routes cached through the moved device are
rejected once the netns changes. That only covers users that go
through dst_check(). Is that enough here?
For routes without a nexthop object, dst_dev_put() on the per-cpu
and exception dsts only happens in two places: free_fib_info_rcu() ->
fib_nh_release(), and fib6_info_destroy_rcu() ->
fib6_nh_release() -> fib6_nh_release_dsts(). On NETDEV_UNREGISTER,
fib6_drop_pcpu_from() only clears ->from.
Without rcu_barrier(), __dev_change_net_namespace() can therefore
return while those dsts still have dst->output set to ip_output() /
ip6_output() and dst->dev_rcu pointing at dev.
A few users don't call dst_check():
A corked UDP, UDPv6 or RAW socket in the old netns keeps the dst from
ip_setup_cork() / ip6_setup_cork(). On uncork,
udp_push_pending_frames() -> ip_send_skb() -> dst_output() uses it
as is. If dev has already been brought up in its new netns, the
corked packet goes out there.
The following read dst_dev_rcu(__sk_dst_get(sk)) directly:
get_netdev_for_sock() in net/tls/tls_device.c,
net_devmem_get_sock_binding(), smc_clc_prfx_set(),
smc_clc_prfx_match(), smc_vlan_by_tcpsk() and
smc_pnet_find_roce_resource(). They would get the moved device
rather than blackhole_netdev, and attach offload state to a device
in another netns.
The window is small. The synchronize_net() at the end means the
grace period has elapsed and only callback invocation is pending.
But rcu_barrier() closed it completely before.
Could the changelog cover these users? If the barrier has to go,
would it be better to release the cached dsts of routes on dev
synchronously in the NETDEV_UNREGISTER handlers? Or is there a
reason these paths don't matter?
[Severity: Medium]
Does dropping the barrier open a window where an xfrm bundle gets
built on the moved device after the uncached list flush has run?
NETDEV_UNREGISTER queues free_fib_info_rcu() and
fib6_info_destroy_rcu(), and those are what call dst_dev_put() on
the per-cpu and exception routes. Until they run, dst_dev_rcu() on
such a route still returns dev. netif_is_alive(dev) also stays true,
because reg_state remains NETREG_REGISTERED across the move.
ip_route_output_flow() and ip6_dst_lookup_flow() take a reference on
the base route and drop rcu_read_lock() before calling
xfrm_lookup_route(). So the synchronize_net() earlier in
__dev_change_net_namespace() does not wait for them.
xfrm_policy_queue_process() also passes xfrm_dst_path(skb_dst(skb))
from the hold queue to xfrm_lookup() without a dst_check().
Suppose xfrm_bundle_create() or xfrm_create_dummy_bundle() runs
after NETDEV_UNREGISTER has done rt_flush_dev() and
rt6_uncached_list_flush_dev(), but before the RCU callbacks.
xfrm4_fill_dst() / xfrm6_fill_dst() then take a reference on dev.
Once NETDEV_REGISTER has run in the target netns, they also take a
reference on the inet6_dev that ipv6_add_dev() just allocated there.
The xdst is then added to rt_uncached_list / rt6_uncached_list with
no flush left to catch it. It keeps the moved device and the new
inet6_dev referenced, and traffic can leave through dev in its new
netns.
With rcu_barrier() in place, dst_dev_put() had already switched these
routes to blackhole_netdev before dev_net_set().
The rt_genid / fib6_sernum argument in the changelog relies on
dst_check(), which these xfrm paths don't seem to do. Did you look
at them? Is there something else that closes this window, or does
the move still need to wait for these callbacks in some form?
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261117-bug-net-netns-move-rcu-barrier-v4-0-43e1ca0aac7f%40linux.dev
^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2026-11-22 3:14 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-18 2:28 [PATCH net-next v4 0/4] net: make moving a device to another netns cheaper Qiliang Yuan
2026-11-18 2:28 ` [PATCH net-next v4 1/4] ipv4: draw rt_genid from a sequence shared by all netns Qiliang Yuan
2026-11-22 3:14 ` netdev-bot+sashiko
2026-11-18 2:28 ` [PATCH net-next v4 2/4] ipv6: take fib6_sernum " Qiliang Yuan
2026-11-20 17:52 ` Ralf Lici
2026-11-20 23:13 ` Qiliang Yuan
2026-11-22 3:14 ` netdev-bot+sashiko
2026-11-18 2:28 ` [PATCH net-next v4 3/4] nexthop: release cached routes when a nexthop leaves a group Qiliang Yuan
2026-11-22 3:14 ` netdev-bot+sashiko
2026-11-18 2:28 ` [PATCH net-next v4 4/4] net: remove rcu_barrier() from __dev_change_net_namespace() Qiliang Yuan
2026-11-22 3:14 ` netdev-bot+sashiko
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®