1/* drivers/net/ifb.c:
2
3	The purpose of this driver is to provide a device that allows
4	for sharing of resources:
5
6	1) qdiscs/policies that are per device as opposed to system wide.
7	ifb allows for a device which can be redirected to thus providing
8	an impression of sharing.
9
10	2) Allows for queueing incoming traffic for shaping instead of
11	dropping.
12
13	The original concept is based on what is known as the IMQ
14	driver initially written by Martin Devera, later rewritten
15	by Patrick McHardy and then maintained by Andre Correa.
16
17	You need the tc action  mirror or redirect to feed this device
18       	packets.
19
20	This program is free software; you can redistribute it and/or
21	modify it under the terms of the GNU General Public License
22	as published by the Free Software Foundation; either version
23	2 of the License, or (at your option) any later version.
24
25  	Authors:	Jamal Hadi Salim (2005)
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			/* reschedule */
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->mac_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	/* Initialize the device structure. */
175	dev->destructor = free_netdev;
176	dev->netdev_ops = &ifb_netdev_ops;
177
178	/* Fill in device structure with ethernet-generic values. */
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/* Number of ifb devices to be set up by this module. */
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