Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/export.h>#include <linux/list.h>#include <linux/netdevice.h>#include <linux/rtnetlink.h>#include <linux/spinlock.h>#include <linux/workqueue.h>#include <net/netdev_lock.h>
#include "dev.h"
static void netdev_work_proc(struct work_struct *work);
/* @netdev_work_lock protects: * - @netdev_work_list * - within the list entries (struct net_device fields): * - work_node * - work_tracker * - work_pending * - work_core_pending */static LIST_HEAD(netdev_work_list);static DEFINE_SPINLOCK(netdev_work_lock);static DECLARE_WORK(netdev_work, netdev_work_proc);
static void netdev_work_enqueue(struct net_device *dev, unsigned long events, unsigned long core){ if (!events && !core) 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); } dev->work_pending |= events; dev->work_core_pending |= core; spin_unlock_bh(&netdev_work_lock);
schedule_work(&netdev_work);}
static unsigned longnetdev_work_dequeue(struct net_device *dev, unsigned long *pending, unsigned long mask){ unsigned long events;
spin_lock_bh(&netdev_work_lock); events = *pending & mask; *pending &= ~events; if (!list_empty(&dev->work_node) && !dev->work_pending && !dev->work_core_pending) { list_del_init(&dev->work_node); netdev_put(dev, &dev->work_tracker); } spin_unlock_bh(&netdev_work_lock);
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);}EXPORT_SYMBOL(netdev_work_sched);
/** * netdev_work_cancel() - cancel selected work for a netdev * @dev: net_device * @mask: events to cancel * * Clear @mask from the device's work pending mask. If no work is left pending * the device is dequeued and its ndo_work won't be called. * * No expectations on locking, but also no guarantees provided. If the caller * wants to touch @dev afterwards (e.g. call the work that got canceled) * they have to ensure @dev does not get freed. * * Returns: the subset of @mask that was actually pending, so the caller can run * those events inline. */unsigned long netdev_work_cancel(struct net_device *dev, unsigned long mask){ return netdev_work_dequeue(dev, &dev->work_pending, mask);}EXPORT_SYMBOL(netdev_work_cancel);
void __netdev_work_core_sched(struct net_device *dev, unsigned long events){ netdev_work_enqueue(dev, 0, events);}
unsigned long__netdev_work_core_cancel(struct net_device *dev, unsigned long mask){ return netdev_work_dequeue(dev, &dev->work_core_pending, mask);}
static void netdev_work_run(struct net_device *dev, unsigned long events, unsigned long core){ if (!netif_device_present(dev)) return;
if (core & NETDEV_WORK_RX_MODE) netif_rx_mode_run(dev); if (events && dev->netdev_ops->ndo_work) dev->netdev_ops->ndo_work(dev, events);}
static void netdev_work_proc(struct work_struct *work){ rtnl_lock();
while (true) { unsigned long events = 0, core = 0; netdevice_tracker tracker; struct net_device *dev;
spin_lock_bh(&netdev_work_lock); if (list_empty(&netdev_work_list)) { spin_unlock_bh(&netdev_work_lock); break; } dev = list_first_entry(&netdev_work_list, struct net_device, work_node); /* Take a temporary reference so @dev can't be freed while we * drop the lock to grab its ops lock; the work reference is * only released once we claim the work below. * The re-locking dance is to ensure that ops lock is enough * to ensure canceling work is not racy with dequeue. */ netdev_hold(dev, &tracker, GFP_ATOMIC); spin_unlock_bh(&netdev_work_lock);
netdev_lock_ops(dev); spin_lock_bh(&netdev_work_lock); if (!list_empty(&dev->work_node)) { list_del_init(&dev->work_node); core = dev->work_core_pending; dev->work_core_pending = 0; events = dev->work_pending; dev->work_pending = 0; /* We took another ref above */ netdev_put(dev, &dev->work_tracker);
if (!dev_isalive(dev)) core = events = 0; } spin_unlock_bh(&netdev_work_lock);
netdev_work_run(dev, events, core); netdev_unlock_ops(dev);
netdev_put(dev, &tracker); }
rtnl_unlock();}