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#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/netdevice.h>
33#include <linux/etherdevice.h>
34#include <linux/init.h>
35#include <linux/interrupt.h>
36#include <linux/moduleparam.h>
37#include <net/pkt_sched.h>
38#include <net/net_namespace.h>
39
40#define TX_Q_LIMIT 32
41struct ifb_private {
42 struct tasklet_struct ifb_tasklet;
43 int tasklet_pending;
44
45 struct u64_stats_sync rsync;
46 struct sk_buff_head rq;
47 u64 rx_packets;
48 u64 rx_bytes;
49
50 struct u64_stats_sync tsync;
51 struct sk_buff_head tq;
52 u64 tx_packets;
53 u64 tx_bytes;
54};
55
56static int numifbs = 2;
57
58static void ri_tasklet(unsigned long dev);
59static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev);
60static int ifb_open(struct net_device *dev);
61static int ifb_close(struct net_device *dev);
62
63static void ri_tasklet(unsigned long dev)
64{
65 struct net_device *_dev = (struct net_device *)dev;
66 struct ifb_private *dp = netdev_priv(_dev);
67 struct netdev_queue *txq;
68 struct sk_buff *skb;
69
70 txq = netdev_get_tx_queue(_dev, 0);
71 if ((skb = skb_peek(&dp->tq)) == NULL) {
72 if (__netif_tx_trylock(txq)) {
73 skb_queue_splice_tail_init(&dp->rq, &dp->tq);
74 __netif_tx_unlock(txq);
75 } else {
76
77 goto resched;
78 }
79 }
80
81 while ((skb = __skb_dequeue(&dp->tq)) != NULL) {
82 u32 from = G_TC_FROM(skb->tc_verd);
83
84 skb->tc_verd = 0;
85 skb->tc_verd = SET_TC_NCLS(skb->tc_verd);
86
87 u64_stats_update_begin(&dp->tsync);
88 dp->tx_packets++;
89 dp->tx_bytes += skb->len;
90 u64_stats_update_end(&dp->tsync);
91
92 rcu_read_lock();
93 skb->dev = dev_get_by_index_rcu(dev_net(_dev), skb->skb_iif);
94 if (!skb->dev) {
95 rcu_read_unlock();
96 dev_kfree_skb(skb);
97 _dev->stats.tx_dropped++;
98 if (skb_queue_len(&dp->tq) != 0)
99 goto resched;
100 break;
101 }
102 rcu_read_unlock();
103 skb->skb_iif = _dev->ifindex;
104
105 if (from & AT_EGRESS) {
106 dev_queue_xmit(skb);
107 } else if (from & AT_INGRESS) {
108 skb_pull(skb, skb->dev->hard_header_len);
109 netif_receive_skb(skb);
110 } else
111 BUG();
112 }
113
114 if (__netif_tx_trylock(txq)) {
115 if ((skb = skb_peek(&dp->rq)) == NULL) {
116 dp->tasklet_pending = 0;
117 if (netif_queue_stopped(_dev))
118 netif_wake_queue(_dev);
119 } else {
120 __netif_tx_unlock(txq);
121 goto resched;
122 }
123 __netif_tx_unlock(txq);
124 } else {
125resched:
126 dp->tasklet_pending = 1;
127 tasklet_schedule(&dp->ifb_tasklet);
128 }
129
130}
131
132static struct rtnl_link_stats64 *ifb_stats64(struct net_device *dev,
133 struct rtnl_link_stats64 *stats)
134{
135 struct ifb_private *dp = netdev_priv(dev);
136 unsigned int start;
137
138 do {
139 start = u64_stats_fetch_begin_irq(&dp->rsync);
140 stats->rx_packets = dp->rx_packets;
141 stats->rx_bytes = dp->rx_bytes;
142 } while (u64_stats_fetch_retry_irq(&dp->rsync, start));
143
144 do {
145 start = u64_stats_fetch_begin_irq(&dp->tsync);
146
147 stats->tx_packets = dp->tx_packets;
148 stats->tx_bytes = dp->tx_bytes;
149
150 } while (u64_stats_fetch_retry_irq(&dp->tsync, start));
151
152 stats->rx_dropped = dev->stats.rx_dropped;
153 stats->tx_dropped = dev->stats.tx_dropped;
154
155 return stats;
156}
157
158
159static const struct net_device_ops ifb_netdev_ops = {
160 .ndo_open = ifb_open,
161 .ndo_stop = ifb_close,
162 .ndo_get_stats64 = ifb_stats64,
163 .ndo_start_xmit = ifb_xmit,
164 .ndo_validate_addr = eth_validate_addr,
165};
166
167#define IFB_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | NETIF_F_FRAGLIST | \
168 NETIF_F_TSO_ECN | NETIF_F_TSO | NETIF_F_TSO6 | \
169 NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_CTAG_TX | \
170 NETIF_F_HW_VLAN_STAG_TX)
171
172static void ifb_setup(struct net_device *dev)
173{
174
175 dev->destructor = free_netdev;
176 dev->netdev_ops = &ifb_netdev_ops;
177
178
179 ether_setup(dev);
180 dev->tx_queue_len = TX_Q_LIMIT;
181
182 dev->features |= IFB_FEATURES;
183 dev->vlan_features |= IFB_FEATURES & ~(NETIF_F_HW_VLAN_CTAG_TX |
184 NETIF_F_HW_VLAN_STAG_TX);
185
186 dev->flags |= IFF_NOARP;
187 dev->flags &= ~IFF_MULTICAST;
188 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
189 netif_keep_dst(dev);
190 eth_hw_addr_random(dev);
191}
192
193static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev)
194{
195 struct ifb_private *dp = netdev_priv(dev);
196 u32 from = G_TC_FROM(skb->tc_verd);
197
198 u64_stats_update_begin(&dp->rsync);
199 dp->rx_packets++;
200 dp->rx_bytes += skb->len;
201 u64_stats_update_end(&dp->rsync);
202
203 if (!(from & (AT_INGRESS|AT_EGRESS)) || !skb->skb_iif) {
204 dev_kfree_skb(skb);
205 dev->stats.rx_dropped++;
206 return NETDEV_TX_OK;
207 }
208
209 if (skb_queue_len(&dp->rq) >= dev->tx_queue_len) {
210 netif_stop_queue(dev);
211 }
212
213 __skb_queue_tail(&dp->rq, skb);
214 if (!dp->tasklet_pending) {
215 dp->tasklet_pending = 1;
216 tasklet_schedule(&dp->ifb_tasklet);
217 }
218
219 return NETDEV_TX_OK;
220}
221
222static int ifb_close(struct net_device *dev)
223{
224 struct ifb_private *dp = netdev_priv(dev);
225
226 tasklet_kill(&dp->ifb_tasklet);
227 netif_stop_queue(dev);
228 __skb_queue_purge(&dp->rq);
229 __skb_queue_purge(&dp->tq);
230 return 0;
231}
232
233static int ifb_open(struct net_device *dev)
234{
235 struct ifb_private *dp = netdev_priv(dev);
236
237 tasklet_init(&dp->ifb_tasklet, ri_tasklet, (unsigned long)dev);
238 __skb_queue_head_init(&dp->rq);
239 __skb_queue_head_init(&dp->tq);
240 netif_start_queue(dev);
241
242 return 0;
243}
244
245static int ifb_validate(struct nlattr *tb[], struct nlattr *data[])
246{
247 if (tb[IFLA_ADDRESS]) {
248 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
249 return -EINVAL;
250 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
251 return -EADDRNOTAVAIL;
252 }
253 return 0;
254}
255
256static struct rtnl_link_ops ifb_link_ops __read_mostly = {
257 .kind = "ifb",
258 .priv_size = sizeof(struct ifb_private),
259 .setup = ifb_setup,
260 .validate = ifb_validate,
261};
262
263
264module_param(numifbs, int, 0);
265MODULE_PARM_DESC(numifbs, "Number of ifb devices");
266
267static int __init ifb_init_one(int index)
268{
269 struct net_device *dev_ifb;
270 struct ifb_private *dp;
271 int err;
272
273 dev_ifb = alloc_netdev(sizeof(struct ifb_private), "ifb%d",
274 NET_NAME_UNKNOWN, ifb_setup);
275
276 if (!dev_ifb)
277 return -ENOMEM;
278
279 dp = netdev_priv(dev_ifb);
280 u64_stats_init(&dp->rsync);
281 u64_stats_init(&dp->tsync);
282
283 dev_ifb->rtnl_link_ops = &ifb_link_ops;
284 err = register_netdevice(dev_ifb);
285 if (err < 0)
286 goto err;
287
288 return 0;
289
290err:
291 free_netdev(dev_ifb);
292 return err;
293}
294
295static int __init ifb_init_module(void)
296{
297 int i, err;
298
299 rtnl_lock();
300 err = __rtnl_link_register(&ifb_link_ops);
301 if (err < 0)
302 goto out;
303
304 for (i = 0; i < numifbs && !err; i++) {
305 err = ifb_init_one(i);
306 cond_resched();
307 }
308 if (err)
309 __rtnl_link_unregister(&ifb_link_ops);
310
311out:
312 rtnl_unlock();
313
314 return err;
315}
316
317static void __exit ifb_cleanup_module(void)
318{
319 rtnl_link_unregister(&ifb_link_ops);
320}
321
322module_init(ifb_init_module);
323module_exit(ifb_cleanup_module);
324MODULE_LICENSE("GPL");
325MODULE_AUTHOR("Jamal Hadi Salim");
326MODULE_ALIAS_RTNL_LINK("ifb");
327
