1 /* net/sched/sch_teql.c "True" (or "trivial") link equalizer.
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.
8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
11 #include <linux/module.h>
12 #include <asm/uaccess.h>
13 #include <asm/system.h>
14 #include <linux/bitops.h>
15 #include <linux/types.h>
16 #include <linux/kernel.h>
17 #include <linux/string.h>
19 #include <linux/socket.h>
20 #include <linux/sockios.h>
22 #include <linux/errno.h>
23 #include <linux/interrupt.h>
24 #include <linux/if_arp.h>
25 #include <linux/if_ether.h>
26 #include <linux/inet.h>
27 #include <linux/netdevice.h>
28 #include <linux/etherdevice.h>
29 #include <linux/notifier.h>
30 #include <linux/init.h>
32 #include <net/route.h>
33 #include <linux/skbuff.h>
34 #include <linux/moduleparam.h>
36 #include <net/pkt_sched.h>
42 After loading this module you will find a new device teqlN
43 and new qdisc with the same name. To join a slave to the equalizer
44 you should just set this qdisc on a device f.e.
46 # tc qdisc add dev eth0 root teql0
47 # tc qdisc add dev eth1 root teql0
49 That's all. Full PnP 8)
54 1. Slave devices MUST be active devices, i.e., they must raise the tbusy
55 signal and generate EOI events. If you want to equalize virtual devices
56 like tunnels, use a normal eql device.
57 2. This device puts no limitations on physical slave characteristics
58 f.e. it will equalize 9600baud line and 100Mb ethernet perfectly :-)
59 Certainly, large difference in link speeds will make the resulting
60 eqalized link unusable, because of huge packet reordering.
61 I estimate an upper useful difference as ~10 times.
62 3. If the slave requires address resolution, only protocols using
63 neighbour cache (IPv4/IPv6) will work over the equalized link.
64 Other protocols are still allowed to use the slave device directly,
65 which will not break load balancing, though native slave
66 traffic will have the highest priority. */
70 struct Qdisc_ops qops;
71 struct net_device *dev;
73 struct list_head master_list;
74 struct net_device_stats stats;
77 struct teql_sched_data
80 struct teql_master *m;
81 struct neighbour *ncache;
82 struct sk_buff_head q;
85 #define NEXT_SLAVE(q) (((struct teql_sched_data*)qdisc_priv(q))->next)
87 #define FMASK (IFF_BROADCAST|IFF_POINTOPOINT|IFF_BROADCAST)
89 /* "teql*" qdisc routines */
92 teql_enqueue(struct sk_buff *skb, struct Qdisc* sch)
94 struct net_device *dev = sch->dev;
95 struct teql_sched_data *q = qdisc_priv(sch);
97 if (q->q.qlen < dev->tx_queue_len) {
98 __skb_queue_tail(&q->q, skb);
99 sch->bstats.bytes += skb->len;
100 sch->bstats.packets++;
106 return NET_XMIT_DROP;
110 teql_requeue(struct sk_buff *skb, struct Qdisc* sch)
112 struct teql_sched_data *q = qdisc_priv(sch);
114 __skb_queue_head(&q->q, skb);
115 sch->qstats.requeues++;
119 static struct sk_buff *
120 teql_dequeue(struct Qdisc* sch)
122 struct teql_sched_data *dat = qdisc_priv(sch);
125 skb = __skb_dequeue(&dat->q);
127 struct net_device *m = dat->m->dev->qdisc->dev;
129 dat->m->slaves = sch;
133 sch->q.qlen = dat->q.qlen + dat->m->dev->qdisc->q.qlen;
137 static __inline__ void
138 teql_neigh_release(struct neighbour *n)
145 teql_reset(struct Qdisc* sch)
147 struct teql_sched_data *dat = qdisc_priv(sch);
149 skb_queue_purge(&dat->q);
151 teql_neigh_release(xchg(&dat->ncache, NULL));
155 teql_destroy(struct Qdisc* sch)
157 struct Qdisc *q, *prev;
158 struct teql_sched_data *dat = qdisc_priv(sch);
159 struct teql_master *master = dat->m;
161 if ((prev = master->slaves) != NULL) {
163 q = NEXT_SLAVE(prev);
165 NEXT_SLAVE(prev) = NEXT_SLAVE(q);
166 if (q == master->slaves) {
167 master->slaves = NEXT_SLAVE(q);
168 if (q == master->slaves) {
169 master->slaves = NULL;
170 spin_lock_bh(&master->dev->queue_lock);
171 qdisc_reset(master->dev->qdisc);
172 spin_unlock_bh(&master->dev->queue_lock);
175 skb_queue_purge(&dat->q);
176 teql_neigh_release(xchg(&dat->ncache, NULL));
180 } while ((prev = q) != master->slaves);
184 static int teql_qdisc_init(struct Qdisc *sch, struct rtattr *opt)
186 struct net_device *dev = sch->dev;
187 struct teql_master *m = (struct teql_master*)sch->ops;
188 struct teql_sched_data *q = qdisc_priv(sch);
190 if (dev->hard_header_len > m->dev->hard_header_len)
198 skb_queue_head_init(&q->q);
201 if (m->dev->flags & IFF_UP) {
202 if ((m->dev->flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT))
203 || (m->dev->flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST))
204 || (m->dev->flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST))
205 || dev->mtu < m->dev->mtu)
208 if (!(dev->flags&IFF_POINTOPOINT))
209 m->dev->flags &= ~IFF_POINTOPOINT;
210 if (!(dev->flags&IFF_BROADCAST))
211 m->dev->flags &= ~IFF_BROADCAST;
212 if (!(dev->flags&IFF_MULTICAST))
213 m->dev->flags &= ~IFF_MULTICAST;
214 if (dev->mtu < m->dev->mtu)
215 m->dev->mtu = dev->mtu;
217 q->next = NEXT_SLAVE(m->slaves);
218 NEXT_SLAVE(m->slaves) = sch;
222 m->dev->mtu = dev->mtu;
223 m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK);
228 /* "teql*" netdevice routines */
231 __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
233 struct teql_sched_data *q = qdisc_priv(dev->qdisc);
234 struct neighbour *mn = skb->dst->neighbour;
235 struct neighbour *n = q->ncache;
239 if (n && n->tbl == mn->tbl &&
240 memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) {
241 atomic_inc(&n->refcnt);
243 n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev);
247 if (neigh_event_send(n, skb_res) == 0) {
250 err = dev->hard_header(skb, dev, ntohs(skb->protocol), n->ha, NULL, skb->len);
251 read_unlock(&n->lock);
256 teql_neigh_release(xchg(&q->ncache, n));
260 return (skb_res == NULL) ? -EAGAIN : 1;
263 static __inline__ int
264 teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
266 if (dev->hard_header == NULL ||
268 skb->dst->neighbour == NULL)
270 return __teql_resolve(skb, skb_res, dev);
273 static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
275 struct teql_master *master = netdev_priv(dev);
276 struct Qdisc *start, *q;
280 int subq = skb->queue_mapping;
281 struct sk_buff *skb_res = NULL;
283 start = master->slaves;
289 if ((q = start) == NULL)
293 struct net_device *slave = q->dev;
295 if (slave->qdisc_sleeping != q)
297 if (netif_queue_stopped(slave) ||
298 netif_subqueue_stopped(slave, subq) ||
299 !netif_running(slave)) {
304 switch (teql_resolve(skb, skb_res, slave)) {
306 if (netif_tx_trylock(slave)) {
307 if (!netif_queue_stopped(slave) &&
308 !netif_subqueue_stopped(slave, subq) &&
309 slave->hard_start_xmit(skb, slave) == 0) {
310 netif_tx_unlock(slave);
311 master->slaves = NEXT_SLAVE(q);
312 netif_wake_queue(dev);
313 master->stats.tx_packets++;
314 master->stats.tx_bytes += len;
317 netif_tx_unlock(slave);
319 if (netif_queue_stopped(dev))
323 master->slaves = NEXT_SLAVE(q);
329 __skb_pull(skb, skb_network_offset(skb));
330 } while ((q = NEXT_SLAVE(q)) != start);
332 if (nores && skb_res == NULL) {
338 netif_stop_queue(dev);
341 master->stats.tx_errors++;
344 master->stats.tx_dropped++;
349 static int teql_master_open(struct net_device *dev)
352 struct teql_master *m = netdev_priv(dev);
354 unsigned flags = IFF_NOARP|IFF_MULTICAST;
356 if (m->slaves == NULL)
363 struct net_device *slave = q->dev;
368 if (slave->mtu < mtu)
370 if (slave->hard_header_len > LL_MAX_HEADER)
373 /* If all the slaves are BROADCAST, master is BROADCAST
374 If all the slaves are PtP, master is PtP
375 Otherwise, master is NBMA.
377 if (!(slave->flags&IFF_POINTOPOINT))
378 flags &= ~IFF_POINTOPOINT;
379 if (!(slave->flags&IFF_BROADCAST))
380 flags &= ~IFF_BROADCAST;
381 if (!(slave->flags&IFF_MULTICAST))
382 flags &= ~IFF_MULTICAST;
383 } while ((q = NEXT_SLAVE(q)) != m->slaves);
386 m->dev->flags = (m->dev->flags&~FMASK) | flags;
387 netif_start_queue(m->dev);
391 static int teql_master_close(struct net_device *dev)
393 netif_stop_queue(dev);
397 static struct net_device_stats *teql_master_stats(struct net_device *dev)
399 struct teql_master *m = netdev_priv(dev);
403 static int teql_master_mtu(struct net_device *dev, int new_mtu)
405 struct teql_master *m = netdev_priv(dev);
414 if (new_mtu > q->dev->mtu)
416 } while ((q=NEXT_SLAVE(q)) != m->slaves);
423 static __init void teql_master_setup(struct net_device *dev)
425 struct teql_master *master = netdev_priv(dev);
426 struct Qdisc_ops *ops = &master->qops;
429 ops->priv_size = sizeof(struct teql_sched_data);
431 ops->enqueue = teql_enqueue;
432 ops->dequeue = teql_dequeue;
433 ops->requeue = teql_requeue;
434 ops->init = teql_qdisc_init;
435 ops->reset = teql_reset;
436 ops->destroy = teql_destroy;
437 ops->owner = THIS_MODULE;
439 dev->open = teql_master_open;
440 dev->hard_start_xmit = teql_master_xmit;
441 dev->stop = teql_master_close;
442 dev->get_stats = teql_master_stats;
443 dev->change_mtu = teql_master_mtu;
444 dev->type = ARPHRD_VOID;
446 dev->tx_queue_len = 100;
447 dev->flags = IFF_NOARP;
448 dev->hard_header_len = LL_MAX_HEADER;
449 SET_MODULE_OWNER(dev);
452 static LIST_HEAD(master_dev_list);
453 static int max_equalizers = 1;
454 module_param(max_equalizers, int, 0);
455 MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
457 static int __init teql_init(void)
462 for (i = 0; i < max_equalizers; i++) {
463 struct net_device *dev;
464 struct teql_master *master;
466 dev = alloc_netdev(sizeof(struct teql_master),
467 "teql%d", teql_master_setup);
473 if ((err = register_netdev(dev))) {
478 master = netdev_priv(dev);
480 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
481 err = register_qdisc(&master->qops);
484 unregister_netdev(dev);
489 list_add_tail(&master->master_list, &master_dev_list);
494 static void __exit teql_exit(void)
496 struct teql_master *master, *nxt;
498 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
500 list_del(&master->master_list);
502 unregister_qdisc(&master->qops);
503 unregister_netdev(master->dev);
504 free_netdev(master->dev);
508 module_init(teql_init);
509 module_exit(teql_exit);
511 MODULE_LICENSE("GPL");