[linux-2.6-block.git] / net / sched / sch_teql.c

/* net/sched/sch_teql.c	"True" (or "trivial") link equalizer.
 *
 *		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:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/if_arp.h>
#include <linux/netdevice.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/moduleparam.h>
#include <net/dst.h>
#include <net/neighbour.h>
#include <net/pkt_sched.h>

/*
   How to setup it.
   ----------------

   After loading this module you will find a new device teqlN
   and new qdisc with the same name. To join a slave to the equalizer
   you should just set this qdisc on a device f.e.

   # tc qdisc add dev eth0 root teql0
   # tc qdisc add dev eth1 root teql0

   That's all. Full PnP 8)

   Applicability.
   --------------

   1. Slave devices MUST be active devices, i.e., they must raise the tbusy
      signal and generate EOI events. If you want to equalize virtual devices
      like tunnels, use a normal eql device.
   2. This device puts no limitations on physical slave characteristics
      f.e. it will equalize 9600baud line and 100Mb ethernet perfectly :-)
      Certainly, large difference in link speeds will make the resulting
      eqalized link unusable, because of huge packet reordering.
      I estimate an upper useful difference as ~10 times.
   3. If the slave requires address resolution, only protocols using
      neighbour cache (IPv4/IPv6) will work over the equalized link.
      Other protocols are still allowed to use the slave device directly,
      which will not break load balancing, though native slave
      traffic will have the highest priority.  */

struct teql_master
{
	struct Qdisc_ops qops;
	struct net_device *dev;
	struct Qdisc *slaves;
	struct list_head master_list;
	struct net_device_stats stats;
};

struct teql_sched_data
{
	struct Qdisc *next;
	struct teql_master *m;
	struct neighbour *ncache;
	struct sk_buff_head q;
};

#define NEXT_SLAVE(q) (((struct teql_sched_data*)qdisc_priv(q))->next)

#define FMASK (IFF_BROADCAST|IFF_POINTOPOINT)

/* "teql*" qdisc routines */

static int
teql_enqueue(struct sk_buff *skb, struct Qdisc* sch)
{
	struct net_device *dev = qdisc_dev(sch);
	struct teql_sched_data *q = qdisc_priv(sch);

	if (q->q.qlen < dev->tx_queue_len) {
		__skb_queue_tail(&q->q, skb);
		sch->bstats.bytes += qdisc_pkt_len(skb);
		sch->bstats.packets++;
		return 0;
	}

	kfree_skb(skb);
	sch->qstats.drops++;
	return NET_XMIT_DROP;
}

static int
teql_requeue(struct sk_buff *skb, struct Qdisc* sch)
{
	struct teql_sched_data *q = qdisc_priv(sch);

	__skb_queue_head(&q->q, skb);
	sch->qstats.requeues++;
	return 0;
}

static struct sk_buff *
teql_dequeue(struct Qdisc* sch)
{
	struct teql_sched_data *dat = qdisc_priv(sch);
	struct netdev_queue *dat_queue;
	struct sk_buff *skb;

	skb = __skb_dequeue(&dat->q);
	dat_queue = netdev_get_tx_queue(dat->m->dev, 0);
	if (skb == NULL) {
		struct net_device *m = qdisc_dev(dat_queue->qdisc);
		if (m) {
			dat->m->slaves = sch;
			netif_wake_queue(m);
		}
	}
	sch->q.qlen = dat->q.qlen + dat_queue->qdisc->q.qlen;
	return skb;
}

static __inline__ void
teql_neigh_release(struct neighbour *n)
{
	if (n)
		neigh_release(n);
}

static void
teql_reset(struct Qdisc* sch)
{
	struct teql_sched_data *dat = qdisc_priv(sch);

	skb_queue_purge(&dat->q);
	sch->q.qlen = 0;
	teql_neigh_release(xchg(&dat->ncache, NULL));
}

static void
teql_destroy(struct Qdisc* sch)
{
	struct Qdisc *q, *prev;
	struct teql_sched_data *dat = qdisc_priv(sch);
	struct teql_master *master = dat->m;

	if ((prev = master->slaves) != NULL) {
		do {
			q = NEXT_SLAVE(prev);
			if (q == sch) {
				NEXT_SLAVE(prev) = NEXT_SLAVE(q);
				if (q == master->slaves) {
					master->slaves = NEXT_SLAVE(q);
					if (q == master->slaves) {
						struct netdev_queue *txq;
						spinlock_t *root_lock;

						txq = netdev_get_tx_queue(master->dev, 0);
						master->slaves = NULL;

						root_lock = qdisc_root_lock(txq->qdisc);
						spin_lock_bh(root_lock);
						qdisc_reset(txq->qdisc);
						spin_unlock_bh(root_lock);
					}
				}
				skb_queue_purge(&dat->q);
				teql_neigh_release(xchg(&dat->ncache, NULL));
				break;
			}

		} while ((prev = q) != master->slaves);
	}
}

static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
{
	struct net_device *dev = qdisc_dev(sch);
	struct teql_master *m = (struct teql_master*)sch->ops;
	struct teql_sched_data *q = qdisc_priv(sch);

	if (dev->hard_header_len > m->dev->hard_header_len)
		return -EINVAL;

	if (m->dev == dev)
		return -ELOOP;

	q->m = m;

	skb_queue_head_init(&q->q);

	if (m->slaves) {
		if (m->dev->flags & IFF_UP) {
			if ((m->dev->flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT))
			    || (m->dev->flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST))
			    || (m->dev->flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST))
			    || dev->mtu < m->dev->mtu)
				return -EINVAL;
		} else {
			if (!(dev->flags&IFF_POINTOPOINT))
				m->dev->flags &= ~IFF_POINTOPOINT;
			if (!(dev->flags&IFF_BROADCAST))
				m->dev->flags &= ~IFF_BROADCAST;
			if (!(dev->flags&IFF_MULTICAST))
				m->dev->flags &= ~IFF_MULTICAST;
			if (dev->mtu < m->dev->mtu)
				m->dev->mtu = dev->mtu;
		}
		q->next = NEXT_SLAVE(m->slaves);
		NEXT_SLAVE(m->slaves) = sch;
	} else {
		q->next = sch;
		m->slaves = sch;
		m->dev->mtu = dev->mtu;
		m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK);
	}
	return 0;
}


static int
__teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
{
	struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, 0);
	struct teql_sched_data *q = qdisc_priv(dev_queue->qdisc);
	struct neighbour *mn = skb->dst->neighbour;
	struct neighbour *n = q->ncache;

	if (mn->tbl == NULL)
		return -EINVAL;
	if (n && n->tbl == mn->tbl &&
	    memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) {
		atomic_inc(&n->refcnt);
	} else {
		n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev);
		if (IS_ERR(n))
			return PTR_ERR(n);
	}
	if (neigh_event_send(n, skb_res) == 0) {
		int err;

		read_lock(&n->lock);
		err = dev_hard_header(skb, dev, ntohs(skb->protocol),
				      n->ha, NULL, skb->len);
		read_unlock(&n->lock);

		if (err < 0) {
			neigh_release(n);
			return -EINVAL;
		}
		teql_neigh_release(xchg(&q->ncache, n));
		return 0;
	}
	neigh_release(n);
	return (skb_res == NULL) ? -EAGAIN : 1;
}

static inline int teql_resolve(struct sk_buff *skb,
			       struct sk_buff *skb_res, struct net_device *dev)
{
	struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
	if (txq->qdisc == &noop_qdisc)
		return -ENODEV;

	if (dev->header_ops == NULL ||
	    skb->dst == NULL ||
	    skb->dst->neighbour == NULL)
		return 0;
	return __teql_resolve(skb, skb_res, dev);
}

static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct teql_master *master = netdev_priv(dev);
	struct Qdisc *start, *q;
	int busy;
	int nores;
	int subq = skb_get_queue_mapping(skb);
	struct sk_buff *skb_res = NULL;

	start = master->slaves;

restart:
	nores = 0;
	busy = 0;

	if ((q = start) == NULL)
		goto drop;

	do {
		struct net_device *slave = qdisc_dev(q);
		struct netdev_queue *slave_txq;

		slave_txq = netdev_get_tx_queue(slave, 0);
		if (slave_txq->qdisc_sleeping != q)
			continue;
		if (__netif_subqueue_stopped(slave, subq) ||
		    !netif_running(slave)) {
			busy = 1;
			continue;
		}

		switch (teql_resolve(skb, skb_res, slave)) {
		case 0:
			if (__netif_tx_trylock(slave_txq)) {
				if (!netif_tx_queue_stopped(slave_txq) &&
				    !netif_tx_queue_frozen(slave_txq) &&
				    slave->hard_start_xmit(skb, slave) == 0) {
					__netif_tx_unlock(slave_txq);
					master->slaves = NEXT_SLAVE(q);
					netif_wake_queue(dev);
					master->stats.tx_packets++;
					master->stats.tx_bytes +=
						qdisc_pkt_len(skb);
					return 0;
				}
				__netif_tx_unlock(slave_txq);
			}
			if (netif_queue_stopped(dev))
				busy = 1;
			break;
		case 1:
			master->slaves = NEXT_SLAVE(q);
			return 0;
		default:
			nores = 1;
			break;
		}
		__skb_pull(skb, skb_network_offset(skb));
	} while ((q = NEXT_SLAVE(q)) != start);

	if (nores && skb_res == NULL) {
		skb_res = skb;
		goto restart;
	}

	if (busy) {
		netif_stop_queue(dev);
		return 1;
	}
	master->stats.tx_errors++;

drop:
	master->stats.tx_dropped++;
	dev_kfree_skb(skb);
	return 0;
}

static int teql_master_open(struct net_device *dev)
{
	struct Qdisc * q;
	struct teql_master *m = netdev_priv(dev);
	int mtu = 0xFFFE;
	unsigned flags = IFF_NOARP|IFF_MULTICAST;

	if (m->slaves == NULL)
		return -EUNATCH;

	flags = FMASK;

	q = m->slaves;
	do {
		struct net_device *slave = qdisc_dev(q);

		if (slave == NULL)
			return -EUNATCH;

		if (slave->mtu < mtu)
			mtu = slave->mtu;
		if (slave->hard_header_len > LL_MAX_HEADER)
			return -EINVAL;

		/* If all the slaves are BROADCAST, master is BROADCAST
		   If all the slaves are PtP, master is PtP
		   Otherwise, master is NBMA.
		 */
		if (!(slave->flags&IFF_POINTOPOINT))
			flags &= ~IFF_POINTOPOINT;
		if (!(slave->flags&IFF_BROADCAST))
			flags &= ~IFF_BROADCAST;
		if (!(slave->flags&IFF_MULTICAST))
			flags &= ~IFF_MULTICAST;
	} while ((q = NEXT_SLAVE(q)) != m->slaves);

	m->dev->mtu = mtu;
	m->dev->flags = (m->dev->flags&~FMASK) | flags;
	netif_start_queue(m->dev);
	return 0;
}

static int teql_master_close(struct net_device *dev)
{
	netif_stop_queue(dev);
	return 0;
}

static struct net_device_stats *teql_master_stats(struct net_device *dev)
{
	struct teql_master *m = netdev_priv(dev);
	return &m->stats;
}

static int teql_master_mtu(struct net_device *dev, int new_mtu)
{
	struct teql_master *m = netdev_priv(dev);
	struct Qdisc *q;

	if (new_mtu < 68)
		return -EINVAL;

	q = m->slaves;
	if (q) {
		do {
			if (new_mtu > qdisc_dev(q)->mtu)
				return -EINVAL;
		} while ((q=NEXT_SLAVE(q)) != m->slaves);
	}

	dev->mtu = new_mtu;
	return 0;
}

static __init void teql_master_setup(struct net_device *dev)
{
	struct teql_master *master = netdev_priv(dev);
	struct Qdisc_ops *ops = &master->qops;

	master->dev	= dev;
	ops->priv_size  = sizeof(struct teql_sched_data);

	ops->enqueue	=	teql_enqueue;
	ops->dequeue	=	teql_dequeue;
	ops->requeue	=	teql_requeue;
	ops->init	=	teql_qdisc_init;
	ops->reset	=	teql_reset;
	ops->destroy	=	teql_destroy;
	ops->owner	=	THIS_MODULE;

	dev->open		= teql_master_open;
	dev->hard_start_xmit	= teql_master_xmit;
	dev->stop		= teql_master_close;
	dev->get_stats		= teql_master_stats;
	dev->change_mtu		= teql_master_mtu;
	dev->type		= ARPHRD_VOID;
	dev->mtu		= 1500;
	dev->tx_queue_len	= 100;
	dev->flags		= IFF_NOARP;
	dev->hard_header_len	= LL_MAX_HEADER;
}

static LIST_HEAD(master_dev_list);
static int max_equalizers = 1;
module_param(max_equalizers, int, 0);
MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");

static int __init teql_init(void)
{
	int i;
	int err = -ENODEV;

	for (i = 0; i < max_equalizers; i++) {
		struct net_device *dev;
		struct teql_master *master;

		dev = alloc_netdev(sizeof(struct teql_master),
				  "teql%d", teql_master_setup);
		if (!dev) {
			err = -ENOMEM;
			break;
		}

		if ((err = register_netdev(dev))) {
			free_netdev(dev);
			break;
		}

		master = netdev_priv(dev);

		strlcpy(master->qops.id, dev->name, IFNAMSIZ);
		err = register_qdisc(&master->qops);

		if (err) {
			unregister_netdev(dev);
			free_netdev(dev);
			break;
		}

		list_add_tail(&master->master_list, &master_dev_list);
	}
	return i ? 0 : err;
}

static void __exit teql_exit(void)
{
	struct teql_master *master, *nxt;

	list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {

		list_del(&master->master_list);

		unregister_qdisc(&master->qops);
		unregister_netdev(master->dev);
		free_netdev(master->dev);
	}
}

module_init(teql_init);
module_exit(teql_exit);

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/* net/sched/sch_teql.c "True" (or "trivial") link equalizer.
	2	*
	3	* This program is free software; you can redistribute it and/or
	4	* modify it under the terms of the GNU General Public License
	5	* as published by the Free Software Foundation; either version
	6	* 2 of the License, or (at your option) any later version.
	7	*
	8	* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
	9	*/
	10
	11	#include <linux/module.h>
1da177e4 LT	12	#include <linux/types.h>
1da177e4 LT	13	#include <linux/kernel.h>
1da177e4	14	#include <linux/string.h>
1da177e4	15	#include <linux/errno.h>
14c85021	16	#include <linux/if_arp.h>
1da177e4	17	#include <linux/netdevice.h>
1da177e4	18	#include <linux/init.h>
1da177e4 LT	19	#include <linux/skbuff.h>
1da177e4 LT	20	#include <linux/moduleparam.h>
0ba48053 PM	21	#include <net/dst.h>
0ba48053 PM	22	#include <net/neighbour.h>
1da177e4 LT	23	#include <net/pkt_sched.h>
	24
	25	/*
	26	How to setup it.
	27	----------------
	28
	29	After loading this module you will find a new device teqlN
	30	and new qdisc with the same name. To join a slave to the equalizer
	31	you should just set this qdisc on a device f.e.
	32
	33	# tc qdisc add dev eth0 root teql0
	34	# tc qdisc add dev eth1 root teql0
	35
	36	That's all. Full PnP 8)
	37
	38	Applicability.
	39	--------------
	40
	41	1. Slave devices MUST be active devices, i.e., they must raise the tbusy
	42	signal and generate EOI events. If you want to equalize virtual devices
	43	like tunnels, use a normal eql device.
	44	2. This device puts no limitations on physical slave characteristics
	45	f.e. it will equalize 9600baud line and 100Mb ethernet perfectly :-)
	46	Certainly, large difference in link speeds will make the resulting
	47	eqalized link unusable, because of huge packet reordering.
	48	I estimate an upper useful difference as ~10 times.
	49	3. If the slave requires address resolution, only protocols using
	50	neighbour cache (IPv4/IPv6) will work over the equalized link.
	51	Other protocols are still allowed to use the slave device directly,
	52	which will not break load balancing, though native slave
	53	traffic will have the highest priority. */
	54
	55	struct teql_master
	56	{
	57	struct Qdisc_ops qops;
	58	struct net_device *dev;
	59	struct Qdisc *slaves;
	60	struct list_head master_list;
	61	struct net_device_stats stats;
	62	};
	63
	64	struct teql_sched_data
	65	{
	66	struct Qdisc *next;
	67	struct teql_master *m;
	68	struct neighbour *ncache;
	69	struct sk_buff_head q;
	70	};
	71
	72	#define NEXT_SLAVE(q) (((struct teql_sched_data*)qdisc_priv(q))->next)
	73
cc8fd14d	74	#define FMASK (IFF_BROADCAST\|IFF_POINTOPOINT)
1da177e4 LT	75
	76	/* "teql" qdisc routines /
	77
	78	static int
	79	teql_enqueue(struct sk_buff skb, struct Qdisc sch)
	80	{
5ce2d488	81	struct net_device *dev = qdisc_dev(sch);
1da177e4 LT	82	struct teql_sched_data *q = qdisc_priv(sch);
1da177e4 LT	83
4cd8c9e8 KK	84	if (q->q.qlen < dev->tx_queue_len) {
4cd8c9e8 KK	85	__skb_queue_tail(&q->q, skb);
0abf77e5	86	sch->bstats.bytes += qdisc_pkt_len(skb);
1da177e4 LT	87	sch->bstats.packets++;
	88	return 0;
	89	}
	90
1da177e4 LT	91	kfree_skb(skb);
	92	sch->qstats.drops++;
	93	return NET_XMIT_DROP;
	94	}
	95
	96	static int
	97	teql_requeue(struct sk_buff skb, struct Qdisc sch)
	98	{
	99	struct teql_sched_data *q = qdisc_priv(sch);
	100
	101	__skb_queue_head(&q->q, skb);
	102	sch->qstats.requeues++;
	103	return 0;
	104	}
	105
	106	static struct sk_buff *
	107	teql_dequeue(struct Qdisc* sch)
	108	{
	109	struct teql_sched_data *dat = qdisc_priv(sch);
b0e1e646	110	struct netdev_queue *dat_queue;
1da177e4 LT	111	struct sk_buff *skb;
	112
	113	skb = __skb_dequeue(&dat->q);
e8a0464c	114	dat_queue = netdev_get_tx_queue(dat->m->dev, 0);
1da177e4	115	if (skb == NULL) {
b0e1e646	116	struct net_device *m = qdisc_dev(dat_queue->qdisc);
1da177e4 LT	117	if (m) {
	118	dat->m->slaves = sch;
	119	netif_wake_queue(m);
	120	}
	121	}
b0e1e646	122	sch->q.qlen = dat->q.qlen + dat_queue->qdisc->q.qlen;
1da177e4 LT	123	return skb;
	124	}
	125
	126	static __inline__ void
	127	teql_neigh_release(struct neighbour *n)
	128	{
	129	if (n)
	130	neigh_release(n);
	131	}
	132
	133	static void
	134	teql_reset(struct Qdisc* sch)
	135	{
	136	struct teql_sched_data *dat = qdisc_priv(sch);
	137
	138	skb_queue_purge(&dat->q);
	139	sch->q.qlen = 0;
	140	teql_neigh_release(xchg(&dat->ncache, NULL));
	141	}
	142
	143	static void
	144	teql_destroy(struct Qdisc* sch)
	145	{
	146	struct Qdisc q, prev;
	147	struct teql_sched_data *dat = qdisc_priv(sch);
	148	struct teql_master *master = dat->m;
	149
	150	if ((prev = master->slaves) != NULL) {
	151	do {
	152	q = NEXT_SLAVE(prev);
	153	if (q == sch) {
	154	NEXT_SLAVE(prev) = NEXT_SLAVE(q);
	155	if (q == master->slaves) {
	156	master->slaves = NEXT_SLAVE(q);
	157	if (q == master->slaves) {
e8a0464c	158	struct netdev_queue *txq;
83874000	159	spinlock_t *root_lock;
e8a0464c DM	160
e8a0464c DM	161	txq = netdev_get_tx_queue(master->dev, 0);
1da177e4	162	master->slaves = NULL;
83874000 DM	163
	164	root_lock = qdisc_root_lock(txq->qdisc);
	165	spin_lock_bh(root_lock);
e8a0464c	166	qdisc_reset(txq->qdisc);
83874000	167	spin_unlock_bh(root_lock);
1da177e4 LT	168	}
	169	}
	170	skb_queue_purge(&dat->q);
	171	teql_neigh_release(xchg(&dat->ncache, NULL));
	172	break;
	173	}
10297b99	174
1da177e4 LT	175	} while ((prev = q) != master->slaves);
	176	}
	177	}
	178
1e90474c	179	static int teql_qdisc_init(struct Qdisc sch, struct nlattr opt)
1da177e4	180	{
5ce2d488	181	struct net_device *dev = qdisc_dev(sch);
1da177e4 LT	182	struct teql_master m = (struct teql_master)sch->ops;
	183	struct teql_sched_data *q = qdisc_priv(sch);
	184
	185	if (dev->hard_header_len > m->dev->hard_header_len)
	186	return -EINVAL;
	187
	188	if (m->dev == dev)
	189	return -ELOOP;
	190
	191	q->m = m;
	192
	193	skb_queue_head_init(&q->q);
	194
	195	if (m->slaves) {
	196	if (m->dev->flags & IFF_UP) {
	197	if ((m->dev->flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT))
	198	\|\| (m->dev->flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST))
	199	\|\| (m->dev->flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST))
	200	\|\| dev->mtu < m->dev->mtu)
	201	return -EINVAL;
	202	} else {
	203	if (!(dev->flags&IFF_POINTOPOINT))
	204	m->dev->flags &= ~IFF_POINTOPOINT;
	205	if (!(dev->flags&IFF_BROADCAST))
	206	m->dev->flags &= ~IFF_BROADCAST;
	207	if (!(dev->flags&IFF_MULTICAST))
	208	m->dev->flags &= ~IFF_MULTICAST;
	209	if (dev->mtu < m->dev->mtu)
	210	m->dev->mtu = dev->mtu;
	211	}
	212	q->next = NEXT_SLAVE(m->slaves);
	213	NEXT_SLAVE(m->slaves) = sch;
	214	} else {
	215	q->next = sch;
	216	m->slaves = sch;
	217	m->dev->mtu = dev->mtu;
	218	m->dev->flags = (m->dev->flags&~FMASK)\|(dev->flags&FMASK);
	219	}
	220	return 0;
	221	}
	222
1da177e4 LT	223
	224	static int
	225	__teql_resolve(struct sk_buff skb, struct sk_buff skb_res, struct net_device *dev)
	226	{
e8a0464c DM	227	struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, 0);
e8a0464c DM	228	struct teql_sched_data *q = qdisc_priv(dev_queue->qdisc);
1da177e4 LT	229	struct neighbour *mn = skb->dst->neighbour;
	230	struct neighbour *n = q->ncache;
	231
	232	if (mn->tbl == NULL)
	233	return -EINVAL;
	234	if (n && n->tbl == mn->tbl &&
	235	memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) {
	236	atomic_inc(&n->refcnt);
	237	} else {
	238	n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev);
	239	if (IS_ERR(n))
	240	return PTR_ERR(n);
	241	}
	242	if (neigh_event_send(n, skb_res) == 0) {
	243	int err;
0c4e8581	244
1da177e4	245	read_lock(&n->lock);
0c4e8581 SH	246	err = dev_hard_header(skb, dev, ntohs(skb->protocol),
0c4e8581 SH	247	n->ha, NULL, skb->len);
1da177e4	248	read_unlock(&n->lock);
0c4e8581	249
1da177e4 LT	250	if (err < 0) {
	251	neigh_release(n);
	252	return -EINVAL;
	253	}
	254	teql_neigh_release(xchg(&q->ncache, n));
	255	return 0;
	256	}
	257	neigh_release(n);
	258	return (skb_res == NULL) ? -EAGAIN : 1;
	259	}
	260
3b04ddde SH	261	static inline int teql_resolve(struct sk_buff *skb,
3b04ddde SH	262	struct sk_buff skb_res, struct net_device dev)
1da177e4	263	{
e8a0464c DM	264	struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
e8a0464c DM	265	if (txq->qdisc == &noop_qdisc)
4f9f8311 EP	266	return -ENODEV;
4f9f8311 EP	267
3b04ddde	268	if (dev->header_ops == NULL \|\|
1da177e4 LT	269	skb->dst == NULL \|\|
	270	skb->dst->neighbour == NULL)
	271	return 0;
	272	return __teql_resolve(skb, skb_res, dev);
	273	}
	274
	275	static int teql_master_xmit(struct sk_buff skb, struct net_device dev)
	276	{
2941a486	277	struct teql_master *master = netdev_priv(dev);
1da177e4 LT	278	struct Qdisc start, q;
	279	int busy;
	280	int nores;
4e3ab47a	281	int subq = skb_get_queue_mapping(skb);
1da177e4 LT	282	struct sk_buff *skb_res = NULL;
	283
	284	start = master->slaves;
	285
	286	restart:
	287	nores = 0;
	288	busy = 0;
	289
	290	if ((q = start) == NULL)
	291	goto drop;
	292
	293	do {
5ce2d488	294	struct net_device *slave = qdisc_dev(q);
e8a0464c	295	struct netdev_queue *slave_txq;
10297b99	296
e8a0464c DM	297	slave_txq = netdev_get_tx_queue(slave, 0);
e8a0464c DM	298	if (slave_txq->qdisc_sleeping != q)
1da177e4	299	continue;
fd2ea0a7	300	if (__netif_subqueue_stopped(slave, subq) \|\|
f25f4e44	301	!netif_running(slave)) {
1da177e4 LT	302	busy = 1;
	303	continue;
	304	}
	305
	306	switch (teql_resolve(skb, skb_res, slave)) {
	307	case 0:
c3f26a26 DM	308	if (__netif_tx_trylock(slave_txq)) {
	309	if (!netif_tx_queue_stopped(slave_txq) &&
	310	!netif_tx_queue_frozen(slave_txq) &&
1da177e4	311	slave->hard_start_xmit(skb, slave) == 0) {
c3f26a26	312	__netif_tx_unlock(slave_txq);
1da177e4 LT	313	master->slaves = NEXT_SLAVE(q);
	314	netif_wake_queue(dev);
	315	master->stats.tx_packets++;
0abf77e5 JK	316	master->stats.tx_bytes +=
0abf77e5 JK	317	qdisc_pkt_len(skb);
1da177e4 LT	318	return 0;
1da177e4 LT	319	}
c3f26a26	320	__netif_tx_unlock(slave_txq);
1da177e4 LT	321	}
	322	if (netif_queue_stopped(dev))
	323	busy = 1;
	324	break;
	325	case 1:
	326	master->slaves = NEXT_SLAVE(q);
	327	return 0;
	328	default:
	329	nores = 1;
	330	break;
	331	}
bbe735e4	332	__skb_pull(skb, skb_network_offset(skb));
1da177e4 LT	333	} while ((q = NEXT_SLAVE(q)) != start);
	334
	335	if (nores && skb_res == NULL) {
	336	skb_res = skb;
	337	goto restart;
	338	}
	339
	340	if (busy) {
	341	netif_stop_queue(dev);
	342	return 1;
	343	}
	344	master->stats.tx_errors++;
	345
	346	drop:
	347	master->stats.tx_dropped++;
	348	dev_kfree_skb(skb);
	349	return 0;
	350	}
	351
	352	static int teql_master_open(struct net_device *dev)
	353	{
	354	struct Qdisc * q;
2941a486	355	struct teql_master *m = netdev_priv(dev);
1da177e4 LT	356	int mtu = 0xFFFE;
	357	unsigned flags = IFF_NOARP\|IFF_MULTICAST;
	358
	359	if (m->slaves == NULL)
	360	return -EUNATCH;
	361
	362	flags = FMASK;
	363
	364	q = m->slaves;
	365	do {
5ce2d488	366	struct net_device *slave = qdisc_dev(q);
1da177e4 LT	367
	368	if (slave == NULL)
	369	return -EUNATCH;
	370
	371	if (slave->mtu < mtu)
	372	mtu = slave->mtu;
	373	if (slave->hard_header_len > LL_MAX_HEADER)
	374	return -EINVAL;
	375
	376	/* If all the slaves are BROADCAST, master is BROADCAST
	377	If all the slaves are PtP, master is PtP
	378	Otherwise, master is NBMA.
	379	*/
	380	if (!(slave->flags&IFF_POINTOPOINT))
	381	flags &= ~IFF_POINTOPOINT;
	382	if (!(slave->flags&IFF_BROADCAST))
	383	flags &= ~IFF_BROADCAST;
	384	if (!(slave->flags&IFF_MULTICAST))
	385	flags &= ~IFF_MULTICAST;
	386	} while ((q = NEXT_SLAVE(q)) != m->slaves);
	387
	388	m->dev->mtu = mtu;
	389	m->dev->flags = (m->dev->flags&~FMASK) \| flags;
	390	netif_start_queue(m->dev);
	391	return 0;
	392	}
	393
	394	static int teql_master_close(struct net_device *dev)
	395	{
	396	netif_stop_queue(dev);
	397	return 0;
	398	}
	399
	400	static struct net_device_stats teql_master_stats(struct net_device dev)
	401	{
2941a486	402	struct teql_master *m = netdev_priv(dev);
1da177e4 LT	403	return &m->stats;
	404	}
	405
	406	static int teql_master_mtu(struct net_device *dev, int new_mtu)
	407	{
2941a486	408	struct teql_master *m = netdev_priv(dev);
1da177e4 LT	409	struct Qdisc *q;
	410
	411	if (new_mtu < 68)
	412	return -EINVAL;
	413
	414	q = m->slaves;
	415	if (q) {
	416	do {
5ce2d488	417	if (new_mtu > qdisc_dev(q)->mtu)
1da177e4 LT	418	return -EINVAL;
	419	} while ((q=NEXT_SLAVE(q)) != m->slaves);
	420	}
	421
	422	dev->mtu = new_mtu;
	423	return 0;
	424	}
	425
	426	static __init void teql_master_setup(struct net_device *dev)
	427	{
2941a486	428	struct teql_master *master = netdev_priv(dev);
1da177e4 LT	429	struct Qdisc_ops *ops = &master->qops;
	430
	431	master->dev = dev;
	432	ops->priv_size = sizeof(struct teql_sched_data);
10297b99	433
1da177e4 LT	434	ops->enqueue = teql_enqueue;
	435	ops->dequeue = teql_dequeue;
	436	ops->requeue = teql_requeue;
	437	ops->init = teql_qdisc_init;
	438	ops->reset = teql_reset;
	439	ops->destroy = teql_destroy;
	440	ops->owner = THIS_MODULE;
	441
	442	dev->open = teql_master_open;
	443	dev->hard_start_xmit = teql_master_xmit;
	444	dev->stop = teql_master_close;
	445	dev->get_stats = teql_master_stats;
	446	dev->change_mtu = teql_master_mtu;
	447	dev->type = ARPHRD_VOID;
	448	dev->mtu = 1500;
	449	dev->tx_queue_len = 100;
	450	dev->flags = IFF_NOARP;
	451	dev->hard_header_len = LL_MAX_HEADER;
1da177e4 LT	452	}
	453
	454	static LIST_HEAD(master_dev_list);
	455	static int max_equalizers = 1;
	456	module_param(max_equalizers, int, 0);
	457	MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
	458
	459	static int __init teql_init(void)
	460	{
	461	int i;
	462	int err = -ENODEV;
	463
	464	for (i = 0; i < max_equalizers; i++) {
	465	struct net_device *dev;
	466	struct teql_master *master;
	467
	468	dev = alloc_netdev(sizeof(struct teql_master),
	469	"teql%d", teql_master_setup);
	470	if (!dev) {
	471	err = -ENOMEM;
	472	break;
	473	}
	474
	475	if ((err = register_netdev(dev))) {
	476	free_netdev(dev);
	477	break;
	478	}
	479
2941a486	480	master = netdev_priv(dev);
1da177e4 LT	481
	482	strlcpy(master->qops.id, dev->name, IFNAMSIZ);
	483	err = register_qdisc(&master->qops);
	484
	485	if (err) {
	486	unregister_netdev(dev);
	487	free_netdev(dev);
	488	break;
	489	}
	490
	491	list_add_tail(&master->master_list, &master_dev_list);
	492	}
	493	return i ? 0 : err;
	494	}
	495
10297b99	496	static void __exit teql_exit(void)
1da177e4 LT	497	{
	498	struct teql_master master, nxt;
	499
	500	list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
	501
	502	list_del(&master->master_list);
	503
	504	unregister_qdisc(&master->qops);
	505	unregister_netdev(master->dev);
	506	free_netdev(master->dev);
	507	}
	508	}
	509
	510	module_init(teql_init);
	511	module_exit(teql_exit);
	512
	513	MODULE_LICENSE("GPL");