ifb.c 6.3 KB
Newer Older
1
/* drivers/net/ifb.c:
2 3 4 5 6 7 8 9 10

	The purpose of this driver is to provide a device that allows
	for sharing of resources:

	1) qdiscs/policies that are per device as opposed to system wide.
	ifb allows for a device which can be redirected to thus providing
	an impression of sharing.

	2) Allows for queueing incoming traffic for shaping instead of
11 12
	dropping.

13 14 15 16 17 18 19 20 21 22 23
	The original concept is based on what is known as the IMQ
	driver initially written by Martin Devera, later rewritten
	by Patrick McHardy and then maintained by Andre Correa.

	You need the tc action  mirror or redirect to feed this device
       	packets.

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version
	2 of the License, or (at your option) any later version.
24

25
  	Authors:	Jamal Hadi Salim (2005)
26

27 28 29 30 31 32 33 34
*/


#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#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 41 42 43 44 45 46 47

#define TX_Q_LIMIT    32
struct ifb_private {
	struct tasklet_struct   ifb_tasklet;
	int     tasklet_pending;
	struct sk_buff_head     rq;
	struct sk_buff_head     tq;
};

48
static int numifbs = 2;
49 50

static void ri_tasklet(unsigned long dev);
51
static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev);
52 53 54
static int ifb_open(struct net_device *dev);
static int ifb_close(struct net_device *dev);

55
static void ri_tasklet(unsigned long dev)
56 57 58 59
{

	struct net_device *_dev = (struct net_device *)dev;
	struct ifb_private *dp = netdev_priv(_dev);
60
	struct net_device_stats *stats = &_dev->stats;
61
	struct netdev_queue *txq;
62 63
	struct sk_buff *skb;

64
	txq = netdev_get_tx_queue(_dev, 0);
65
	if ((skb = skb_peek(&dp->tq)) == NULL) {
66
		if (__netif_tx_trylock(txq)) {
67
			skb_queue_splice_tail_init(&dp->rq, &dp->tq);
68
			__netif_tx_unlock(txq);
69 70 71 72 73 74
		} else {
			/* reschedule */
			goto resched;
		}
	}

E
Eric Dumazet 已提交
75
	while ((skb = __skb_dequeue(&dp->tq)) != NULL) {
76 77 78 79 80 81
		u32 from = G_TC_FROM(skb->tc_verd);

		skb->tc_verd = 0;
		skb->tc_verd = SET_TC_NCLS(skb->tc_verd);
		stats->tx_packets++;
		stats->tx_bytes +=skb->len;
82

83
		rcu_read_lock();
84
		skb->dev = dev_get_by_index_rcu(&init_net, skb->skb_iif);
85
		if (!skb->dev) {
86
			rcu_read_unlock();
87 88
			dev_kfree_skb(skb);
			stats->tx_dropped++;
89 90
			if (skb_queue_len(&dp->tq) != 0)
				goto resched;
91 92
			break;
		}
93
		rcu_read_unlock();
94
		skb->skb_iif = _dev->ifindex;
95

96 97 98
		if (from & AT_EGRESS) {
			dev_queue_xmit(skb);
		} else if (from & AT_INGRESS) {
99
			skb_pull(skb, skb->dev->hard_header_len);
100
			netif_receive_skb(skb);
101 102
		} else
			BUG();
103 104
	}

105
	if (__netif_tx_trylock(txq)) {
106 107 108 109 110
		if ((skb = skb_peek(&dp->rq)) == NULL) {
			dp->tasklet_pending = 0;
			if (netif_queue_stopped(_dev))
				netif_wake_queue(_dev);
		} else {
111
			__netif_tx_unlock(txq);
112 113
			goto resched;
		}
114
		__netif_tx_unlock(txq);
115 116 117 118 119 120 121 122
	} else {
resched:
		dp->tasklet_pending = 1;
		tasklet_schedule(&dp->ifb_tasklet);
	}

}

S
Stephen Hemminger 已提交
123 124 125
static const struct net_device_ops ifb_netdev_ops = {
	.ndo_open	= ifb_open,
	.ndo_stop	= ifb_close,
126 127
	.ndo_start_xmit	= ifb_xmit,
	.ndo_validate_addr = eth_validate_addr,
S
Stephen Hemminger 已提交
128 129
};

E
Eric Dumazet 已提交
130 131 132 133
#define IFB_FEATURES (NETIF_F_NO_CSUM | NETIF_F_SG  | NETIF_F_FRAGLIST	| \
		      NETIF_F_TSO_ECN | NETIF_F_TSO | NETIF_F_TSO6	| \
		      NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_TX)

P
Patrick McHardy 已提交
134
static void ifb_setup(struct net_device *dev)
135 136
{
	/* Initialize the device structure. */
P
Patrick McHardy 已提交
137
	dev->destructor = free_netdev;
S
Stephen Hemminger 已提交
138
	dev->netdev_ops = &ifb_netdev_ops;
139 140 141 142

	/* Fill in device structure with ethernet-generic values. */
	ether_setup(dev);
	dev->tx_queue_len = TX_Q_LIMIT;
S
Stephen Hemminger 已提交
143

E
Eric Dumazet 已提交
144 145 146
	dev->features |= IFB_FEATURES;
	dev->vlan_features |= IFB_FEATURES;

147 148
	dev->flags |= IFF_NOARP;
	dev->flags &= ~IFF_MULTICAST;
149
	dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
150 151 152
	random_ether_addr(dev->dev_addr);
}

153
static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev)
154 155
{
	struct ifb_private *dp = netdev_priv(dev);
156
	struct net_device_stats *stats = &dev->stats;
157 158
	u32 from = G_TC_FROM(skb->tc_verd);

D
dean gaudet 已提交
159 160
	stats->rx_packets++;
	stats->rx_bytes+=skb->len;
161

162
	if (!(from & (AT_INGRESS|AT_EGRESS)) || !skb->skb_iif) {
163 164
		dev_kfree_skb(skb);
		stats->rx_dropped++;
165
		return NETDEV_TX_OK;
166 167 168 169 170 171
	}

	if (skb_queue_len(&dp->rq) >= dev->tx_queue_len) {
		netif_stop_queue(dev);
	}

172
	__skb_queue_tail(&dp->rq, skb);
173 174 175 176 177
	if (!dp->tasklet_pending) {
		dp->tasklet_pending = 1;
		tasklet_schedule(&dp->ifb_tasklet);
	}

178
	return NETDEV_TX_OK;
179 180 181 182 183 184 185 186
}

static int ifb_close(struct net_device *dev)
{
	struct ifb_private *dp = netdev_priv(dev);

	tasklet_kill(&dp->ifb_tasklet);
	netif_stop_queue(dev);
187 188
	__skb_queue_purge(&dp->rq);
	__skb_queue_purge(&dp->tq);
189 190 191 192 193 194 195 196
	return 0;
}

static int ifb_open(struct net_device *dev)
{
	struct ifb_private *dp = netdev_priv(dev);

	tasklet_init(&dp->ifb_tasklet, ri_tasklet, (unsigned long)dev);
197 198
	__skb_queue_head_init(&dp->rq);
	__skb_queue_head_init(&dp->tq);
199 200 201 202 203
	netif_start_queue(dev);

	return 0;
}

204 205 206 207 208 209 210 211 212 213 214
static int ifb_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}
	return 0;
}

P
Patrick McHardy 已提交
215 216 217 218
static struct rtnl_link_ops ifb_link_ops __read_mostly = {
	.kind		= "ifb",
	.priv_size	= sizeof(struct ifb_private),
	.setup		= ifb_setup,
219
	.validate	= ifb_validate,
P
Patrick McHardy 已提交
220 221
};

222 223 224 225
/* Number of ifb devices to be set up by this module. */
module_param(numifbs, int, 0);
MODULE_PARM_DESC(numifbs, "Number of ifb devices");

226 227 228 229 230 231 232 233 234 235 236
static int __init ifb_init_one(int index)
{
	struct net_device *dev_ifb;
	int err;

	dev_ifb = alloc_netdev(sizeof(struct ifb_private),
				 "ifb%d", ifb_setup);

	if (!dev_ifb)
		return -ENOMEM;

P
Patrick McHardy 已提交
237 238 239 240
	dev_ifb->rtnl_link_ops = &ifb_link_ops;
	err = register_netdevice(dev_ifb);
	if (err < 0)
		goto err;
241

P
Patrick McHardy 已提交
242
	return 0;
243

P
Patrick McHardy 已提交
244 245 246
err:
	free_netdev(dev_ifb);
	return err;
247
}
248 249

static int __init ifb_init_module(void)
250
{
P
Patrick McHardy 已提交
251 252 253 254
	int i, err;

	rtnl_lock();
	err = __rtnl_link_register(&ifb_link_ops);
255

256
	for (i = 0; i < numifbs && !err; i++)
257
		err = ifb_init_one(i);
258
	if (err)
P
Patrick McHardy 已提交
259 260
		__rtnl_link_unregister(&ifb_link_ops);
	rtnl_unlock();
261 262

	return err;
263
}
264 265 266

static void __exit ifb_cleanup_module(void)
{
267
	rtnl_link_unregister(&ifb_link_ops);
268 269 270 271 272 273
}

module_init(ifb_init_module);
module_exit(ifb_cleanup_module);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jamal Hadi Salim");
P
Patrick McHardy 已提交
274
MODULE_ALIAS_RTNL_LINK("ifb");