1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// 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 (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 long
netdev_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_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();
}
|
