net: avoid theoretical races with ref drain
Subsystems (2)
Jakub Kicinski
maintainerPATCH 1/1 net: avoid theoretical races with ref drain
Technically, it's illegal to take a ref on a netdev just because we have a pointer on which we already hold a ref, with no other protection. This is because our simple per-cpu refcount implementation cannot atomically read the count.
Let's make sure we cancel outstanding work and never queue more work for a device we know is dead. This way taking a ref on a dev we know is on the netdev_work_list is always going to be safe.
Jiangshan Yi reports that the issues is caught by ref tracker infra leading to a warning:
WARNING: lib/ref_tracker.c:322 at ref_tracker_free WARNING: lib/ref_tracker.c:246 at ref_tracker_dir_exit
--- net/core/dev.h | 1 + net/core/dev.c | 1 + net/core/netdev_work.c | 16 ++++++++++++++++ 3 files changed, 18 insertions(+)
net/core/dev.h +1 -0
@@ -179,6 +179,7 @@ enum netdev_work_core {void __netdev_work_core_sched (struct net_device *dev,unsigned long event);unsigned long __netdev_work_core_cancel (struct net_device *dev,unsigned long mask); +void netdev_work_cancel_all (struct net_device *dev); void __dev_notify_flags(struct net_device *dev, unsigned int old_flags, unsigned int gchanges, u32 portid,
net/core/dev.c +1 -0
@@ -12478,6 +12478,7 @@ void unregister_netdevice_many_notify(struct list_head *head,dev_tcx_uninstall (dev);dev_xdp_uninstall (dev);dev_memory_provider_uninstall (dev); +netdev_work_cancel_all (dev);netdev_unlock_ops (dev);bpf_dev_bound_netdev_unregister (dev);
net/core/netdev_work.c +16 -0
@@ -31,6 +31,10 @@ static void netdev_work_enqueue(struct net_device *dev, unsigned long events,return ;spin_lock_bh (&netdev_work_lock); +if (!dev_isalive (dev)) { +spin_unlock_bh (&netdev_work_lock); +return ; + }if (list_empty (&dev->work_node)) {list_add_tail (&dev->work_node, &netdev_work_list);netdev_hold (dev, &dev->work_tracker,GFP_ATOMIC );
@@ -61,6 +65,18 @@ netdev_work_dequeue(struct net_device *dev, unsigned long *pending,return events; } +void netdev_work_cancel_all (struct net_device *dev) +{ +spin_lock_bh (&netdev_work_lock); + dev->work_pending =0 ; + dev->work_core_pending =0 ; +if (!list_empty (&dev->work_node)) { +list_del_init (&dev->work_node); +netdev_put (dev, &dev->work_tracker); + } +spin_unlock_bh (&netdev_work_lock); +} +void netdev_work_sched (struct net_device *dev,unsigned long events) {netdev_work_enqueue (dev, events,0 );
Signature · 1 line
2.55.0
This patch was applied to netdev/net.git (main) by Jakub Kicinski <[email protected]>:
Hello:
This patch was applied to netdev/net.git (main)
by Jakub Kicinski <[email protected]>:
Quoted 10 lines · On Wed, 5 Aug 2026 19:28:21 -0700 you wrote:
Technically, it's illegal to take a ref on a netdev just because we have a pointer on which we already hold a ref, with no other protection. This is because our simple per-cpu refcount implementation cannot atomically read the count.
Let's make sure we cancel outstanding work and never queue more work for a device we know is dead. This way taking a ref on a dev we know is on the
netdev_work_listis always going to be safe.[...]
Here is the summary with links:
- [net] net: avoid theoretical races with ref drain
https://git.kernel.org/netdev/net/c/d31c14e56a4f
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html