[GitHub/LineageOS/android_kernel_samsung_universal7580.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>

#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(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 __init 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;

	/* 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;
	SET_MODULE_OWNER(dev);
	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 struct net_device **ifbs;

/* 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 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 __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;

	if ((err = register_netdev(dev_ifb))) {
		free_netdev(dev_ifb);
		dev_ifb = NULL;
	} else {
		ifbs[index] = dev_ifb;
	}

	return err;
}

static void ifb_free_one(int index)
{
	unregister_netdev(ifbs[index]);
	free_netdev(ifbs[index]);
}

static int __init ifb_init_module(void)
{
	int i, err = 0;
	ifbs = kmalloc(numifbs * sizeof(void *), GFP_KERNEL);
	if (!ifbs)
		return -ENOMEM;
	for (i = 0; i < numifbs && !err; i++)
		err = ifb_init_one(i);
	if (err) {
		i--;
		while (--i >= 0)
			ifb_free_one(i);
	}

	return err;
}

static void __exit ifb_cleanup_module(void)
{
	int i;

	for (i = 0; i < numifbs; i++)
		ifb_free_one(i);
	kfree(ifbs);
}

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