[mirror_ubuntu-artful-kernel.git] / drivers / net / ifb.c

/* drivers/net/ifb.c:

	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
	dropping.

	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.

  	Authors:	Jamal Hadi Salim (2005)

*/


#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <net/pkt_sched.h>
#include <net/net_namespace.h>

#define TX_TIMEOUT  (2*HZ)

#define TX_Q_LIMIT    32
struct ifb_private {
	struct net_device_stats stats;
	struct tasklet_struct   ifb_tasklet;
	int     tasklet_pending;
	/* mostly debug stats leave in for now */
	unsigned long   st_task_enter; /* tasklet entered */
	unsigned long   st_txq_refl_try; /* transmit queue refill attempt */
	unsigned long   st_rxq_enter; /* receive queue entered */
	unsigned long   st_rx2tx_tran; /* receive to trasmit transfers */
	unsigned long   st_rxq_notenter; /*receiveQ not entered, resched */
	unsigned long   st_rx_frm_egr; /* received from egress path */
	unsigned long   st_rx_frm_ing; /* received from ingress path */
	unsigned long   st_rxq_check;
	unsigned long   st_rxq_rsch;
	struct sk_buff_head     rq;
	struct sk_buff_head     tq;
};

static int numifbs = 2;

static void ri_tasklet(unsigned long dev);
static int ifb_xmit(struct sk_buff *skb, struct net_device *dev);
static struct net_device_stats *ifb_get_stats(struct net_device *dev);
static int ifb_open(struct net_device *dev);
static int ifb_close(struct net_device *dev);

static void ri_tasklet(unsigned long dev)
{

	struct net_device *_dev = (struct net_device *)dev;
	struct ifb_private *dp = netdev_priv(_dev);
	struct net_device_stats *stats = &dp->stats;
	struct sk_buff *skb;

	dp->st_task_enter++;
	if ((skb = skb_peek(&dp->tq)) == NULL) {
		dp->st_txq_refl_try++;
		if (netif_tx_trylock(_dev)) {
			dp->st_rxq_enter++;
			while ((skb = skb_dequeue(&dp->rq)) != NULL) {
				skb_queue_tail(&dp->tq, skb);
				dp->st_rx2tx_tran++;
			}
			netif_tx_unlock(_dev);
		} else {
			/* reschedule */
			dp->st_rxq_notenter++;
			goto resched;
		}
	}

	while ((skb = skb_dequeue(&dp->tq)) != NULL) {
		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;

		skb->dev = __dev_get_by_index(&init_net, skb->iif);
		if (!skb->dev) {
			dev_kfree_skb(skb);
			stats->tx_dropped++;
			break;
		}
		skb->iif = _dev->ifindex;

		if (from & AT_EGRESS) {
			dp->st_rx_frm_egr++;
			dev_queue_xmit(skb);
		} else if (from & AT_INGRESS) {
			dp->st_rx_frm_ing++;
			skb_pull(skb, skb->dev->hard_header_len);
			netif_rx(skb);
		} else
			BUG();
	}

	if (netif_tx_trylock(_dev)) {
		dp->st_rxq_check++;
		if ((skb = skb_peek(&dp->rq)) == NULL) {
			dp->tasklet_pending = 0;
			if (netif_queue_stopped(_dev))
				netif_wake_queue(_dev);
		} else {
			dp->st_rxq_rsch++;
			netif_tx_unlock(_dev);
			goto resched;
		}
		netif_tx_unlock(_dev);
	} else {
resched:
		dp->tasklet_pending = 1;
		tasklet_schedule(&dp->ifb_tasklet);
	}

}

static void ifb_setup(struct net_device *dev)
{
	/* Initialize the device structure. */
	dev->get_stats = ifb_get_stats;
	dev->hard_start_xmit = ifb_xmit;
	dev->open = &ifb_open;
	dev->stop = &ifb_close;
	dev->destructor = free_netdev;

	/* Fill in device structure with ethernet-generic values. */
	ether_setup(dev);
	dev->tx_queue_len = TX_Q_LIMIT;
	dev->change_mtu = NULL;
	dev->flags |= IFF_NOARP;
	dev->flags &= ~IFF_MULTICAST;
	random_ether_addr(dev->dev_addr);
}

static int ifb_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct ifb_private *dp = netdev_priv(dev);
	struct net_device_stats *stats = &dp->stats;
	int ret = 0;
	u32 from = G_TC_FROM(skb->tc_verd);

	stats->rx_packets++;
	stats->rx_bytes+=skb->len;

	if (!(from & (AT_INGRESS|AT_EGRESS)) || !skb->iif) {
		dev_kfree_skb(skb);
		stats->rx_dropped++;
		return ret;
	}

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

	dev->trans_start = jiffies;
	skb_queue_tail(&dp->rq, skb);
	if (!dp->tasklet_pending) {
		dp->tasklet_pending = 1;
		tasklet_schedule(&dp->ifb_tasklet);
	}

	return ret;
}

static struct net_device_stats *ifb_get_stats(struct net_device *dev)
{
	struct ifb_private *dp = netdev_priv(dev);
	struct net_device_stats *stats = &dp->stats;

	pr_debug("tasklets stats %ld:%ld:%ld:%ld:%ld:%ld:%ld:%ld:%ld \n",
		dp->st_task_enter, dp->st_txq_refl_try, dp->st_rxq_enter,
		dp->st_rx2tx_tran, dp->st_rxq_notenter, dp->st_rx_frm_egr,
		dp->st_rx_frm_ing, dp->st_rxq_check, dp->st_rxq_rsch);

	return stats;
}

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

	tasklet_kill(&dp->ifb_tasklet);
	netif_stop_queue(dev);
	skb_queue_purge(&dp->rq);
	skb_queue_purge(&dp->tq);
	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);
	skb_queue_head_init(&dp->rq);
	skb_queue_head_init(&dp->tq);
	netif_start_queue(dev);

	return 0;
}

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;
}

static struct rtnl_link_ops ifb_link_ops __read_mostly = {
	.kind		= "ifb",
	.priv_size	= sizeof(struct ifb_private),
	.setup		= ifb_setup,
	.validate	= ifb_validate,
};

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

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;

	err = dev_alloc_name(dev_ifb, dev_ifb->name);
	if (err < 0)
		goto err;

	dev_ifb->rtnl_link_ops = &ifb_link_ops;
	err = register_netdevice(dev_ifb);
	if (err < 0)
		goto err;
	return 0;

err:
	free_netdev(dev_ifb);
	return err;
}

static int __init ifb_init_module(void)
{
	int i, err;

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

	for (i = 0; i < numifbs && !err; i++)
		err = ifb_init_one(i);
	if (err)
		__rtnl_link_unregister(&ifb_link_ops);
	rtnl_unlock();

	return err;
}

static void __exit ifb_cleanup_module(void)
{
	rtnl_link_unregister(&ifb_link_ops);
}

module_init(ifb_init_module);
module_exit(ifb_cleanup_module);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jamal Hadi Salim");
MODULE_ALIAS_RTNL_LINK("ifb");
Commit	Line	Data
6aa20a22	1	/* drivers/net/ifb.c:
253af423 JHS	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
6aa20a22 JG	11	dropping.
6aa20a22 JG	12
253af423 JHS	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.
6aa20a22	24
253af423	25	Authors: Jamal Hadi Salim (2005)
6aa20a22	26
253af423 JHS	27	*/
	28
	29
253af423 JHS	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/moduleparam.h>
6aa20a22	36	#include <net/pkt_sched.h>
881d966b	37	#include <net/net_namespace.h>
253af423 JHS	38
253af423 JHS	39	#define TX_TIMEOUT (2*HZ)
6aa20a22	40
253af423 JHS	41	#define TX_Q_LIMIT 32
	42	struct ifb_private {
	43	struct net_device_stats stats;
	44	struct tasklet_struct ifb_tasklet;
	45	int tasklet_pending;
	46	/* mostly debug stats leave in for now */
	47	unsigned long st_task_enter; /* tasklet entered */
	48	unsigned long st_txq_refl_try; /* transmit queue refill attempt */
	49	unsigned long st_rxq_enter; /* receive queue entered */
	50	unsigned long st_rx2tx_tran; /* receive to trasmit transfers */
	51	unsigned long st_rxq_notenter; /receiveQ not entered, resched /
	52	unsigned long st_rx_frm_egr; /* received from egress path */
	53	unsigned long st_rx_frm_ing; /* received from ingress path */
	54	unsigned long st_rxq_check;
	55	unsigned long st_rxq_rsch;
	56	struct sk_buff_head rq;
	57	struct sk_buff_head tq;
	58	};
	59
35eaa31e	60	static int numifbs = 2;
253af423 JHS	61
	62	static void ri_tasklet(unsigned long dev);
	63	static int ifb_xmit(struct sk_buff skb, struct net_device dev);
	64	static struct net_device_stats ifb_get_stats(struct net_device dev);
	65	static int ifb_open(struct net_device *dev);
	66	static int ifb_close(struct net_device *dev);
	67
6aa20a22	68	static void ri_tasklet(unsigned long dev)
253af423 JHS	69	{
	70
	71	struct net_device _dev = (struct net_device )dev;
	72	struct ifb_private *dp = netdev_priv(_dev);
	73	struct net_device_stats *stats = &dp->stats;
	74	struct sk_buff *skb;
	75
	76	dp->st_task_enter++;
	77	if ((skb = skb_peek(&dp->tq)) == NULL) {
	78	dp->st_txq_refl_try++;
932ff279	79	if (netif_tx_trylock(_dev)) {
253af423 JHS	80	dp->st_rxq_enter++;
	81	while ((skb = skb_dequeue(&dp->rq)) != NULL) {
	82	skb_queue_tail(&dp->tq, skb);
	83	dp->st_rx2tx_tran++;
	84	}
932ff279	85	netif_tx_unlock(_dev);
253af423 JHS	86	} else {
	87	/* reschedule */
	88	dp->st_rxq_notenter++;
	89	goto resched;
	90	}
	91	}
	92
	93	while ((skb = skb_dequeue(&dp->tq)) != NULL) {
	94	u32 from = G_TC_FROM(skb->tc_verd);
	95
	96	skb->tc_verd = 0;
	97	skb->tc_verd = SET_TC_NCLS(skb->tc_verd);
	98	stats->tx_packets++;
	99	stats->tx_bytes +=skb->len;
c01003c2	100
881d966b	101	skb->dev = __dev_get_by_index(&init_net, skb->iif);
c01003c2 PM	102	if (!skb->dev) {
	103	dev_kfree_skb(skb);
	104	stats->tx_dropped++;
	105	break;
	106	}
	107	skb->iif = _dev->ifindex;
	108
253af423 JHS	109	if (from & AT_EGRESS) {
	110	dp->st_rx_frm_egr++;
	111	dev_queue_xmit(skb);
	112	} else if (from & AT_INGRESS) {
253af423	113	dp->st_rx_frm_ing++;
c01003c2	114	skb_pull(skb, skb->dev->hard_header_len);
253af423	115	netif_rx(skb);
c01003c2 PM	116	} else
c01003c2 PM	117	BUG();
253af423 JHS	118	}
253af423 JHS	119
932ff279	120	if (netif_tx_trylock(_dev)) {
253af423 JHS	121	dp->st_rxq_check++;
	122	if ((skb = skb_peek(&dp->rq)) == NULL) {
	123	dp->tasklet_pending = 0;
	124	if (netif_queue_stopped(_dev))
	125	netif_wake_queue(_dev);
	126	} else {
	127	dp->st_rxq_rsch++;
932ff279	128	netif_tx_unlock(_dev);
253af423 JHS	129	goto resched;
253af423 JHS	130	}
932ff279	131	netif_tx_unlock(_dev);
253af423 JHS	132	} else {
	133	resched:
	134	dp->tasklet_pending = 1;
	135	tasklet_schedule(&dp->ifb_tasklet);
	136	}
	137
	138	}
	139
9ba2cd65	140	static void ifb_setup(struct net_device *dev)
253af423 JHS	141	{
	142	/* Initialize the device structure. */
	143	dev->get_stats = ifb_get_stats;
	144	dev->hard_start_xmit = ifb_xmit;
	145	dev->open = &ifb_open;
	146	dev->stop = &ifb_close;
9ba2cd65	147	dev->destructor = free_netdev;
253af423 JHS	148
	149	/* Fill in device structure with ethernet-generic values. */
	150	ether_setup(dev);
	151	dev->tx_queue_len = TX_Q_LIMIT;
	152	dev->change_mtu = NULL;
	153	dev->flags \|= IFF_NOARP;
	154	dev->flags &= ~IFF_MULTICAST;
253af423 JHS	155	random_ether_addr(dev->dev_addr);
	156	}
	157
	158	static int ifb_xmit(struct sk_buff skb, struct net_device dev)
	159	{
	160	struct ifb_private *dp = netdev_priv(dev);
	161	struct net_device_stats *stats = &dp->stats;
	162	int ret = 0;
	163	u32 from = G_TC_FROM(skb->tc_verd);
	164
3136dcb3	165	stats->rx_packets++;
3136dcb3	166	stats->rx_bytes+=skb->len;
253af423	167
c01003c2	168	if (!(from & (AT_INGRESS\|AT_EGRESS)) \|\| !skb->iif) {
253af423 JHS	169	dev_kfree_skb(skb);
	170	stats->rx_dropped++;
	171	return ret;
253af423 JHS	172	}
	173
	174	if (skb_queue_len(&dp->rq) >= dev->tx_queue_len) {
	175	netif_stop_queue(dev);
	176	}
	177
	178	dev->trans_start = jiffies;
	179	skb_queue_tail(&dp->rq, skb);
	180	if (!dp->tasklet_pending) {
	181	dp->tasklet_pending = 1;
	182	tasklet_schedule(&dp->ifb_tasklet);
	183	}
	184
	185	return ret;
	186	}
	187
	188	static struct net_device_stats ifb_get_stats(struct net_device dev)
	189	{
	190	struct ifb_private *dp = netdev_priv(dev);
	191	struct net_device_stats *stats = &dp->stats;
	192
	193	pr_debug("tasklets stats %ld:%ld:%ld:%ld:%ld:%ld:%ld:%ld:%ld \n",
6aa20a22	194	dp->st_task_enter, dp->st_txq_refl_try, dp->st_rxq_enter,
8057de64 ZB	195	dp->st_rx2tx_tran, dp->st_rxq_notenter, dp->st_rx_frm_egr,
8057de64 ZB	196	dp->st_rx_frm_ing, dp->st_rxq_check, dp->st_rxq_rsch);
253af423 JHS	197
	198	return stats;
	199	}
	200
253af423 JHS	201	static int ifb_close(struct net_device *dev)
	202	{
	203	struct ifb_private *dp = netdev_priv(dev);
	204
	205	tasklet_kill(&dp->ifb_tasklet);
	206	netif_stop_queue(dev);
	207	skb_queue_purge(&dp->rq);
	208	skb_queue_purge(&dp->tq);
	209	return 0;
	210	}
	211
	212	static int ifb_open(struct net_device *dev)
	213	{
	214	struct ifb_private *dp = netdev_priv(dev);
	215
	216	tasklet_init(&dp->ifb_tasklet, ri_tasklet, (unsigned long)dev);
	217	skb_queue_head_init(&dp->rq);
	218	skb_queue_head_init(&dp->tq);
	219	netif_start_queue(dev);
	220
	221	return 0;
	222	}
	223
0e06877c PM	224	static int ifb_validate(struct nlattr tb[], struct nlattr data[])
	225	{
	226	if (tb[IFLA_ADDRESS]) {
	227	if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
	228	return -EINVAL;
	229	if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
	230	return -EADDRNOTAVAIL;
	231	}
	232	return 0;
	233	}
	234
9ba2cd65 PM	235	static struct rtnl_link_ops ifb_link_ops __read_mostly = {
	236	.kind = "ifb",
	237	.priv_size = sizeof(struct ifb_private),
	238	.setup = ifb_setup,
0e06877c	239	.validate = ifb_validate,
9ba2cd65 PM	240	};
9ba2cd65 PM	241
2d85cba2 PM	242	/* Number of ifb devices to be set up by this module. */
	243	module_param(numifbs, int, 0);
	244	MODULE_PARM_DESC(numifbs, "Number of ifb devices");
	245
253af423 JHS	246	static int __init ifb_init_one(int index)
	247	{
	248	struct net_device *dev_ifb;
	249	int err;
	250
	251	dev_ifb = alloc_netdev(sizeof(struct ifb_private),
	252	"ifb%d", ifb_setup);
	253
	254	if (!dev_ifb)
	255	return -ENOMEM;
	256
9ba2cd65 PM	257	err = dev_alloc_name(dev_ifb, dev_ifb->name);
	258	if (err < 0)
	259	goto err;
253af423	260
9ba2cd65 PM	261	dev_ifb->rtnl_link_ops = &ifb_link_ops;
	262	err = register_netdevice(dev_ifb);
	263	if (err < 0)
	264	goto err;
9ba2cd65	265	return 0;
62b7ffca	266
9ba2cd65 PM	267	err:
	268	free_netdev(dev_ifb);
	269	return err;
6aa20a22	270	}
253af423 JHS	271
253af423 JHS	272	static int __init ifb_init_module(void)
6aa20a22	273	{
9ba2cd65 PM	274	int i, err;
	275
	276	rtnl_lock();
	277	err = __rtnl_link_register(&ifb_link_ops);
62b7ffca	278
253af423	279	for (i = 0; i < numifbs && !err; i++)
6aa20a22	280	err = ifb_init_one(i);
2d85cba2	281	if (err)
9ba2cd65	282	__rtnl_link_unregister(&ifb_link_ops);
9ba2cd65	283	rtnl_unlock();
253af423 JHS	284
253af423 JHS	285	return err;
6aa20a22	286	}
253af423 JHS	287
	288	static void __exit ifb_cleanup_module(void)
	289	{
2d85cba2	290	rtnl_link_unregister(&ifb_link_ops);
253af423 JHS	291	}
	292
	293	module_init(ifb_init_module);
	294	module_exit(ifb_cleanup_module);
	295	MODULE_LICENSE("GPL");
	296	MODULE_AUTHOR("Jamal Hadi Salim");
9ba2cd65	297	MODULE_ALIAS_RTNL_LINK("ifb");