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