[linux-2.6-block.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/interrupt.h>
#include <linux/moduleparam.h>
#include <net/pkt_sched.h>
#include <net/net_namespace.h>

#define TX_Q_LIMIT    32
struct ifb_q_private {
	struct net_device	*dev;
	struct tasklet_struct   ifb_tasklet;
	int			tasklet_pending;
	int			txqnum;
	struct sk_buff_head     rq;
	u64			rx_packets;
	u64			rx_bytes;
	struct u64_stats_sync	rsync;

	struct u64_stats_sync	tsync;
	u64			tx_packets;
	u64			tx_bytes;
	struct sk_buff_head     tq;
} ____cacheline_aligned_in_smp;

struct ifb_dev_private {
	struct ifb_q_private *tx_private;
};

static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev);
static int ifb_open(struct net_device *dev);
static int ifb_close(struct net_device *dev);

static void ifb_ri_tasklet(unsigned long _txp)
{
	struct ifb_q_private *txp = (struct ifb_q_private *)_txp;
	struct netdev_queue *txq;
	struct sk_buff *skb;

	txq = netdev_get_tx_queue(txp->dev, txp->txqnum);
	skb = skb_peek(&txp->tq);
	if (!skb) {
		if (!__netif_tx_trylock(txq))
			goto resched;
		skb_queue_splice_tail_init(&txp->rq, &txp->tq);
		__netif_tx_unlock(txq);
	}

	while ((skb = __skb_dequeue(&txp->tq)) != NULL) {
		u32 from = G_TC_FROM(skb->tc_verd);

		skb->tc_verd = 0;
		skb->tc_verd = SET_TC_NCLS(skb->tc_verd);

		u64_stats_update_begin(&txp->tsync);
		txp->tx_packets++;
		txp->tx_bytes += skb->len;
		u64_stats_update_end(&txp->tsync);

		rcu_read_lock();
		skb->dev = dev_get_by_index_rcu(dev_net(txp->dev), skb->skb_iif);
		if (!skb->dev) {
			rcu_read_unlock();
			dev_kfree_skb(skb);
			txp->dev->stats.tx_dropped++;
			if (skb_queue_len(&txp->tq) != 0)
				goto resched;
			break;
		}
		rcu_read_unlock();
		skb->skb_iif = txp->dev->ifindex;

		if (from & AT_EGRESS) {
			dev_queue_xmit(skb);
		} else if (from & AT_INGRESS) {
			skb_pull(skb, skb->mac_len);
			netif_receive_skb(skb);
		} else
			BUG();
	}

	if (__netif_tx_trylock(txq)) {
		skb = skb_peek(&txp->rq);
		if (!skb) {
			txp->tasklet_pending = 0;
			if (netif_tx_queue_stopped(txq))
				netif_tx_wake_queue(txq);
		} else {
			__netif_tx_unlock(txq);
			goto resched;
		}
		__netif_tx_unlock(txq);
	} else {
resched:
		txp->tasklet_pending = 1;
		tasklet_schedule(&txp->ifb_tasklet);
	}

}

static struct rtnl_link_stats64 *ifb_stats64(struct net_device *dev,
					     struct rtnl_link_stats64 *stats)
{
	struct ifb_dev_private *dp = netdev_priv(dev);
	struct ifb_q_private *txp = dp->tx_private;
	unsigned int start;
	u64 packets, bytes;
	int i;

	for (i = 0; i < dev->num_tx_queues; i++,txp++) {
		do {
			start = u64_stats_fetch_begin_irq(&txp->rsync);
			packets = txp->rx_packets;
			bytes = txp->rx_bytes;
		} while (u64_stats_fetch_retry_irq(&txp->rsync, start));
		stats->rx_packets += packets;
		stats->rx_bytes += bytes;

		do {
			start = u64_stats_fetch_begin_irq(&txp->tsync);
			packets = txp->tx_packets;
			bytes = txp->tx_bytes;
		} while (u64_stats_fetch_retry_irq(&txp->tsync, start));
		stats->tx_packets += packets;
		stats->tx_bytes += bytes;
	}
	stats->rx_dropped = dev->stats.rx_dropped;
	stats->tx_dropped = dev->stats.tx_dropped;

	return stats;
}

static int ifb_dev_init(struct net_device *dev)
{
	struct ifb_dev_private *dp = netdev_priv(dev);
	struct ifb_q_private *txp;
	int i;

	txp = kcalloc(dev->num_tx_queues, sizeof(*txp), GFP_KERNEL);
	if (!txp)
		return -ENOMEM;
	dp->tx_private = txp;
	for (i = 0; i < dev->num_tx_queues; i++,txp++) {
		txp->txqnum = i;
		txp->dev = dev;
		__skb_queue_head_init(&txp->rq);
		__skb_queue_head_init(&txp->tq);
		u64_stats_init(&txp->rsync);
		u64_stats_init(&txp->tsync);
		tasklet_init(&txp->ifb_tasklet, ifb_ri_tasklet,
			     (unsigned long)txp);
		netif_tx_start_queue(netdev_get_tx_queue(dev, i));
	}
	return 0;
}

static const struct net_device_ops ifb_netdev_ops = {
	.ndo_open	= ifb_open,
	.ndo_stop	= ifb_close,
	.ndo_get_stats64 = ifb_stats64,
	.ndo_start_xmit	= ifb_xmit,
	.ndo_validate_addr = eth_validate_addr,
	.ndo_init	= ifb_dev_init,
};

#define IFB_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG  | NETIF_F_FRAGLIST	| \
		      NETIF_F_TSO_ECN | NETIF_F_TSO | NETIF_F_TSO6	| \
		      NETIF_F_GSO_ENCAP_ALL 				| \
		      NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_CTAG_TX		| \
		      NETIF_F_HW_VLAN_STAG_TX)

static void ifb_dev_free(struct net_device *dev)
{
	struct ifb_dev_private *dp = netdev_priv(dev);
	struct ifb_q_private *txp = dp->tx_private;
	int i;

	for (i = 0; i < dev->num_tx_queues; i++,txp++) {
		tasklet_kill(&txp->ifb_tasklet);
		__skb_queue_purge(&txp->rq);
		__skb_queue_purge(&txp->tq);
	}
	kfree(dp->tx_private);
	free_netdev(dev);
}

static void ifb_setup(struct net_device *dev)
{
	/* Initialize the device structure. */
	dev->netdev_ops = &ifb_netdev_ops;

	/* Fill in device structure with ethernet-generic values. */
	ether_setup(dev);
	dev->tx_queue_len = TX_Q_LIMIT;

	dev->features |= IFB_FEATURES;
	dev->hw_features |= dev->features;
	dev->hw_enc_features |= dev->features;
	dev->vlan_features |= IFB_FEATURES & ~(NETIF_F_HW_VLAN_CTAG_TX |
					       NETIF_F_HW_VLAN_STAG_TX);

	dev->flags |= IFF_NOARP;
	dev->flags &= ~IFF_MULTICAST;
	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
	netif_keep_dst(dev);
	eth_hw_addr_random(dev);
	dev->destructor = ifb_dev_free;
}

static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct ifb_dev_private *dp = netdev_priv(dev);
	u32 from = G_TC_FROM(skb->tc_verd);
	struct ifb_q_private *txp = dp->tx_private + skb_get_queue_mapping(skb);

	u64_stats_update_begin(&txp->rsync);
	txp->rx_packets++;
	txp->rx_bytes += skb->len;
	u64_stats_update_end(&txp->rsync);

	if (!(from & (AT_INGRESS|AT_EGRESS)) || !skb->skb_iif) {
		dev_kfree_skb(skb);
		dev->stats.rx_dropped++;
		return NETDEV_TX_OK;
	}

	if (skb_queue_len(&txp->rq) >= dev->tx_queue_len)
		netif_tx_stop_queue(netdev_get_tx_queue(dev, txp->txqnum));

	__skb_queue_tail(&txp->rq, skb);
	if (!txp->tasklet_pending) {
		txp->tasklet_pending = 1;
		tasklet_schedule(&txp->ifb_tasklet);
	}

	return NETDEV_TX_OK;
}

static int ifb_close(struct net_device *dev)
{
	netif_tx_stop_all_queues(dev);
	return 0;
}

static int ifb_open(struct net_device *dev)
{
	netif_tx_start_all_queues(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_dev_private),
	.setup		= ifb_setup,
	.validate	= ifb_validate,
};

/* Number of ifb devices to be set up by this module.
 * Note that these legacy devices have one queue.
 * Prefer something like : ip link add ifb10 numtxqueues 8 type ifb
 */
static int numifbs = 2;
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_dev_private), "ifb%d",
			       NET_NAME_UNKNOWN, ifb_setup);

	if (!dev_ifb)
		return -ENOMEM;

	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);
	if (err < 0)
		goto out;

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

out:
	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>
a6b7a407	35	#include <linux/interrupt.h>
253af423	36	#include <linux/moduleparam.h>
6aa20a22	37	#include <net/pkt_sched.h>
881d966b	38	#include <net/net_namespace.h>
253af423	39
253af423	40	#define TX_Q_LIMIT 32
9e29e21a ED	41	struct ifb_q_private {
9e29e21a ED	42	struct net_device *dev;
253af423	43	struct tasklet_struct ifb_tasklet;
9e29e21a ED	44	int tasklet_pending;
9e29e21a ED	45	int txqnum;
253af423	46	struct sk_buff_head rq;
9e29e21a ED	47	u64 rx_packets;
	48	u64 rx_bytes;
	49	struct u64_stats_sync rsync;
3b0c9cbb	50
3b0c9cbb	51	struct u64_stats_sync tsync;
9e29e21a ED	52	u64 tx_packets;
9e29e21a ED	53	u64 tx_bytes;
253af423	54	struct sk_buff_head tq;
9e29e21a	55	} ____cacheline_aligned_in_smp;
253af423	56
9e29e21a ED	57	struct ifb_dev_private {
	58	struct ifb_q_private *tx_private;
	59	};
253af423	60
424efe9c	61	static netdev_tx_t ifb_xmit(struct sk_buff skb, struct net_device dev);
253af423 JHS	62	static int ifb_open(struct net_device *dev);
	63	static int ifb_close(struct net_device *dev);
	64
9e29e21a	65	static void ifb_ri_tasklet(unsigned long _txp)
253af423	66	{
9e29e21a	67	struct ifb_q_private txp = (struct ifb_q_private )_txp;
c3f26a26	68	struct netdev_queue *txq;
253af423 JHS	69	struct sk_buff *skb;
253af423 JHS	70
9e29e21a ED	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))
253af423	75	goto resched;
9e29e21a ED	76	skb_queue_splice_tail_init(&txp->rq, &txp->tq);
9e29e21a ED	77	__netif_tx_unlock(txq);
253af423 JHS	78	}
253af423 JHS	79
9e29e21a	80	while ((skb = __skb_dequeue(&txp->tq)) != NULL) {
253af423 JHS	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);
3b0c9cbb	85
9e29e21a ED	86	u64_stats_update_begin(&txp->tsync);
	87	txp->tx_packets++;
	88	txp->tx_bytes += skb->len;
	89	u64_stats_update_end(&txp->tsync);
c01003c2	90
05e8689c	91	rcu_read_lock();
9e29e21a	92	skb->dev = dev_get_by_index_rcu(dev_net(txp->dev), skb->skb_iif);
c01003c2	93	if (!skb->dev) {
05e8689c	94	rcu_read_unlock();
c01003c2	95	dev_kfree_skb(skb);
9e29e21a ED	96	txp->dev->stats.tx_dropped++;
9e29e21a ED	97	if (skb_queue_len(&txp->tq) != 0)
75c1c825	98	goto resched;
c01003c2 PM	99	break;
c01003c2 PM	100	}
05e8689c	101	rcu_read_unlock();
9e29e21a	102	skb->skb_iif = txp->dev->ifindex;
c01003c2	103
253af423	104	if (from & AT_EGRESS) {
253af423 JHS	105	dev_queue_xmit(skb);
253af423 JHS	106	} else if (from & AT_INGRESS) {
f40ae913	107	skb_pull(skb, skb->mac_len);
1a75972c	108	netif_receive_skb(skb);
c01003c2 PM	109	} else
c01003c2 PM	110	BUG();
253af423 JHS	111	}
253af423 JHS	112
c3f26a26	113	if (__netif_tx_trylock(txq)) {
9e29e21a ED	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);
253af423	119	} else {
c3f26a26	120	__netif_tx_unlock(txq);
253af423 JHS	121	goto resched;
253af423 JHS	122	}
c3f26a26	123	__netif_tx_unlock(txq);
253af423 JHS	124	} else {
253af423 JHS	125	resched:
9e29e21a ED	126	txp->tasklet_pending = 1;
9e29e21a ED	127	tasklet_schedule(&txp->ifb_tasklet);
253af423 JHS	128	}
	129
	130	}
	131
3b0c9cbb	132	static struct rtnl_link_stats64 ifb_stats64(struct net_device dev,
	133	struct rtnl_link_stats64 *stats)
	134	{
9e29e21a ED	135	struct ifb_dev_private *dp = netdev_priv(dev);
9e29e21a ED	136	struct ifb_q_private *txp = dp->tx_private;
3b0c9cbb	137	unsigned int start;
9e29e21a ED	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	}
3b0c9cbb	158	stats->rx_dropped = dev->stats.rx_dropped;
	159	stats->tx_dropped = dev->stats.tx_dropped;
	160
	161	return stats;
	162	}
	163
9e29e21a ED	164	static 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	}
3b0c9cbb	187
8dfcdf34	188	static const struct net_device_ops ifb_netdev_ops = {
8dfcdf34 SH	189	.ndo_open = ifb_open,
8dfcdf34 SH	190	.ndo_stop = ifb_close,
3b0c9cbb	191	.ndo_get_stats64 = ifb_stats64,
00829823 SH	192	.ndo_start_xmit = ifb_xmit,
00829823 SH	193	.ndo_validate_addr = eth_validate_addr,
9e29e21a	194	.ndo_init = ifb_dev_init,
8dfcdf34 SH	195	};
8dfcdf34 SH	196
34324dc2	197	#define IFB_FEATURES (NETIF_F_HW_CSUM \| NETIF_F_SG \| NETIF_F_FRAGLIST \| \
39980292	198	NETIF_F_TSO_ECN \| NETIF_F_TSO \| NETIF_F_TSO6 \| \
7d945796	199	NETIF_F_GSO_ENCAP_ALL \| \
28d2b136 PM	200	NETIF_F_HIGHDMA \| NETIF_F_HW_VLAN_CTAG_TX \| \
28d2b136 PM	201	NETIF_F_HW_VLAN_STAG_TX)
39980292	202
9e29e21a ED	203	static 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
9ba2cd65	218	static void ifb_setup(struct net_device *dev)
253af423 JHS	219	{
253af423 JHS	220	/* Initialize the device structure. */
8dfcdf34	221	dev->netdev_ops = &ifb_netdev_ops;
253af423 JHS	222
	223	/* Fill in device structure with ethernet-generic values. */
	224	ether_setup(dev);
	225	dev->tx_queue_len = TX_Q_LIMIT;
8dfcdf34	226
39980292	227	dev->features \|= IFB_FEATURES;
7d945796 ED	228	dev->hw_features \|= dev->features;
7d945796 ED	229	dev->hw_enc_features \|= dev->features;
8dd6e147 VY	230	dev->vlan_features \|= IFB_FEATURES & ~(NETIF_F_HW_VLAN_CTAG_TX \|
8dd6e147 VY	231	NETIF_F_HW_VLAN_STAG_TX);
39980292	232
253af423 JHS	233	dev->flags \|= IFF_NOARP;
253af423 JHS	234	dev->flags &= ~IFF_MULTICAST;
02875878 ED	235	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
02875878 ED	236	netif_keep_dst(dev);
f2cedb63	237	eth_hw_addr_random(dev);
9e29e21a	238	dev->destructor = ifb_dev_free;
253af423 JHS	239	}
253af423 JHS	240
424efe9c	241	static netdev_tx_t ifb_xmit(struct sk_buff skb, struct net_device dev)
253af423	242	{
9e29e21a	243	struct ifb_dev_private *dp = netdev_priv(dev);
253af423	244	u32 from = G_TC_FROM(skb->tc_verd);
9e29e21a	245	struct ifb_q_private *txp = dp->tx_private + skb_get_queue_mapping(skb);
253af423	246
9e29e21a ED	247	u64_stats_update_begin(&txp->rsync);
	248	txp->rx_packets++;
	249	txp->rx_bytes += skb->len;
	250	u64_stats_update_end(&txp->rsync);
253af423	251
8964be4a	252	if (!(from & (AT_INGRESS\|AT_EGRESS)) \|\| !skb->skb_iif) {
253af423	253	dev_kfree_skb(skb);
3b0c9cbb	254	dev->stats.rx_dropped++;
424efe9c	255	return NETDEV_TX_OK;
253af423 JHS	256	}
253af423 JHS	257
9e29e21a ED	258	if (skb_queue_len(&txp->rq) >= dev->tx_queue_len)
9e29e21a ED	259	netif_tx_stop_queue(netdev_get_tx_queue(dev, txp->txqnum));
253af423	260
9e29e21a ED	261	__skb_queue_tail(&txp->rq, skb);
	262	if (!txp->tasklet_pending) {
	263	txp->tasklet_pending = 1;
	264	tasklet_schedule(&txp->ifb_tasklet);
253af423 JHS	265	}
253af423 JHS	266
424efe9c	267	return NETDEV_TX_OK;
253af423 JHS	268	}
253af423 JHS	269
253af423 JHS	270	static int ifb_close(struct net_device *dev)
253af423 JHS	271	{
9e29e21a	272	netif_tx_stop_all_queues(dev);
253af423 JHS	273	return 0;
	274	}
	275
	276	static int ifb_open(struct net_device *dev)
	277	{
9e29e21a	278	netif_tx_start_all_queues(dev);
253af423 JHS	279	return 0;
	280	}
	281
0e06877c PM	282	static 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
9ba2cd65 PM	293	static struct rtnl_link_ops ifb_link_ops __read_mostly = {
9ba2cd65 PM	294	.kind = "ifb",
9e29e21a	295	.priv_size = sizeof(struct ifb_dev_private),
9ba2cd65	296	.setup = ifb_setup,
0e06877c	297	.validate = ifb_validate,
9ba2cd65 PM	298	};
9ba2cd65 PM	299
9e29e21a ED	300	/* Number of ifb devices to be set up by this module.
	301	* Note that these legacy devices have one queue.
	302	* Prefer something like : ip link add ifb10 numtxqueues 8 type ifb
	303	*/
	304	static int numifbs = 2;
2d85cba2 PM	305	module_param(numifbs, int, 0);
	306	MODULE_PARM_DESC(numifbs, "Number of ifb devices");
	307
253af423 JHS	308	static int __init ifb_init_one(int index)
	309	{
	310	struct net_device *dev_ifb;
	311	int err;
	312
9e29e21a	313	dev_ifb = alloc_netdev(sizeof(struct ifb_dev_private), "ifb%d",
c835a677	314	NET_NAME_UNKNOWN, ifb_setup);
253af423 JHS	315
	316	if (!dev_ifb)
	317	return -ENOMEM;
	318
9ba2cd65 PM	319	dev_ifb->rtnl_link_ops = &ifb_link_ops;
	320	err = register_netdevice(dev_ifb);
	321	if (err < 0)
	322	goto err;
94833dfb	323
9ba2cd65	324	return 0;
62b7ffca	325
9ba2cd65 PM	326	err:
	327	free_netdev(dev_ifb);
	328	return err;
6aa20a22	329	}
253af423 JHS	330
253af423 JHS	331	static int __init ifb_init_module(void)
6aa20a22	332	{
9ba2cd65 PM	333	int i, err;
	334
	335	rtnl_lock();
	336	err = __rtnl_link_register(&ifb_link_ops);
f2966cd5	337	if (err < 0)
f2966cd5	338	goto out;
62b7ffca	339
440d57bc	340	for (i = 0; i < numifbs && !err; i++) {
6aa20a22	341	err = ifb_init_one(i);
440d57bc	342	cond_resched();
440d57bc	343	}
2d85cba2	344	if (err)
9ba2cd65	345	__rtnl_link_unregister(&ifb_link_ops);
f2966cd5	346
f2966cd5	347	out:
9ba2cd65	348	rtnl_unlock();
253af423 JHS	349
253af423 JHS	350	return err;
6aa20a22	351	}
253af423 JHS	352
	353	static void __exit ifb_cleanup_module(void)
	354	{
2d85cba2	355	rtnl_link_unregister(&ifb_link_ops);
253af423 JHS	356	}
	357
	358	module_init(ifb_init_module);
	359	module_exit(ifb_cleanup_module);
	360	MODULE_LICENSE("GPL");
	361	MODULE_AUTHOR("Jamal Hadi Salim");
9ba2cd65	362	MODULE_ALIAS_RTNL_LINK("ifb");