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 <linux/types.h>
13 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/errno.h>
16 #include <linux/if_arp.h>
17 #include <linux/netdevice.h>
18 #include <linux/init.h>
19 #include <linux/skbuff.h>
20 #include <linux/moduleparam.h>
22 #include <net/neighbour.h>
23 #include <net/pkt_sched.h>
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.
33 # tc qdisc add dev eth0 root teql0
34 # tc qdisc add dev eth1 root teql0
36 That's all. Full PnP 8)
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. */
57 struct Qdisc_ops qops;
58 struct net_device *dev;
60 struct list_head master_list;
61 struct net_device_stats stats;
64 struct teql_sched_data
67 struct teql_master *m;
68 struct neighbour *ncache;
69 struct sk_buff_head q;
72 #define NEXT_SLAVE(q) (((struct teql_sched_data*)qdisc_priv(q))->next)
74 #define FMASK (IFF_BROADCAST|IFF_POINTOPOINT)
76 /* "teql*" qdisc routines */
79 teql_enqueue(struct sk_buff *skb, struct Qdisc* sch)
81 struct net_device *dev = qdisc_dev(sch);
82 struct teql_sched_data *q = qdisc_priv(sch);
84 if (q->q.qlen < dev->tx_queue_len) {
85 __skb_queue_tail(&q->q, skb);
86 sch->bstats.bytes += qdisc_pkt_len(skb);
87 sch->bstats.packets++;
96 static struct sk_buff *
97 teql_dequeue(struct Qdisc* sch)
99 struct teql_sched_data *dat = qdisc_priv(sch);
100 struct netdev_queue *dat_queue;
103 skb = __skb_dequeue(&dat->q);
104 dat_queue = netdev_get_tx_queue(dat->m->dev, 0);
106 struct net_device *m = qdisc_dev(dat_queue->qdisc);
108 dat->m->slaves = sch;
112 sch->q.qlen = dat->q.qlen + dat_queue->qdisc->q.qlen;
116 static struct sk_buff *
117 teql_peek(struct Qdisc* sch)
119 /* teql is meant to be used as root qdisc */
123 static __inline__ void
124 teql_neigh_release(struct neighbour *n)
131 teql_reset(struct Qdisc* sch)
133 struct teql_sched_data *dat = qdisc_priv(sch);
135 skb_queue_purge(&dat->q);
137 teql_neigh_release(xchg(&dat->ncache, NULL));
141 teql_destroy(struct Qdisc* sch)
143 struct Qdisc *q, *prev;
144 struct teql_sched_data *dat = qdisc_priv(sch);
145 struct teql_master *master = dat->m;
147 if ((prev = master->slaves) != NULL) {
149 q = NEXT_SLAVE(prev);
151 NEXT_SLAVE(prev) = NEXT_SLAVE(q);
152 if (q == master->slaves) {
153 master->slaves = NEXT_SLAVE(q);
154 if (q == master->slaves) {
155 struct netdev_queue *txq;
156 spinlock_t *root_lock;
158 txq = netdev_get_tx_queue(master->dev, 0);
159 master->slaves = NULL;
161 root_lock = qdisc_root_sleeping_lock(txq->qdisc);
162 spin_lock_bh(root_lock);
163 qdisc_reset(txq->qdisc);
164 spin_unlock_bh(root_lock);
167 skb_queue_purge(&dat->q);
168 teql_neigh_release(xchg(&dat->ncache, NULL));
172 } while ((prev = q) != master->slaves);
176 static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
178 struct net_device *dev = qdisc_dev(sch);
179 struct teql_master *m = (struct teql_master*)sch->ops;
180 struct teql_sched_data *q = qdisc_priv(sch);
182 if (dev->hard_header_len > m->dev->hard_header_len)
190 skb_queue_head_init(&q->q);
193 if (m->dev->flags & IFF_UP) {
194 if ((m->dev->flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT))
195 || (m->dev->flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST))
196 || (m->dev->flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST))
197 || dev->mtu < m->dev->mtu)
200 if (!(dev->flags&IFF_POINTOPOINT))
201 m->dev->flags &= ~IFF_POINTOPOINT;
202 if (!(dev->flags&IFF_BROADCAST))
203 m->dev->flags &= ~IFF_BROADCAST;
204 if (!(dev->flags&IFF_MULTICAST))
205 m->dev->flags &= ~IFF_MULTICAST;
206 if (dev->mtu < m->dev->mtu)
207 m->dev->mtu = dev->mtu;
209 q->next = NEXT_SLAVE(m->slaves);
210 NEXT_SLAVE(m->slaves) = sch;
214 m->dev->mtu = dev->mtu;
215 m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK);
222 __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
224 struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, 0);
225 struct teql_sched_data *q = qdisc_priv(dev_queue->qdisc);
226 struct neighbour *mn = skb->dst->neighbour;
227 struct neighbour *n = q->ncache;
231 if (n && n->tbl == mn->tbl &&
232 memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) {
233 atomic_inc(&n->refcnt);
235 n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev);
239 if (neigh_event_send(n, skb_res) == 0) {
243 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
244 n->ha, NULL, skb->len);
245 read_unlock(&n->lock);
251 teql_neigh_release(xchg(&q->ncache, n));
255 return (skb_res == NULL) ? -EAGAIN : 1;
258 static inline int teql_resolve(struct sk_buff *skb,
259 struct sk_buff *skb_res, struct net_device *dev)
261 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
262 if (txq->qdisc == &noop_qdisc)
265 if (dev->header_ops == NULL ||
267 skb->dst->neighbour == NULL)
269 return __teql_resolve(skb, skb_res, dev);
272 static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
274 struct teql_master *master = netdev_priv(dev);
275 struct Qdisc *start, *q;
278 int subq = skb_get_queue_mapping(skb);
279 struct sk_buff *skb_res = NULL;
281 start = master->slaves;
287 if ((q = start) == NULL)
291 struct net_device *slave = qdisc_dev(q);
292 struct netdev_queue *slave_txq = netdev_get_tx_queue(slave, 0);
293 const struct net_device_ops *slave_ops = slave->netdev_ops;
295 if (slave_txq->qdisc_sleeping != q)
297 if (__netif_subqueue_stopped(slave, subq) ||
298 !netif_running(slave)) {
303 switch (teql_resolve(skb, skb_res, slave)) {
305 if (__netif_tx_trylock(slave_txq)) {
306 if (!netif_tx_queue_stopped(slave_txq) &&
307 !netif_tx_queue_frozen(slave_txq) &&
308 slave_ops->ndo_start_xmit(skb, slave) == 0) {
309 __netif_tx_unlock(slave_txq);
310 master->slaves = NEXT_SLAVE(q);
311 netif_wake_queue(dev);
312 master->stats.tx_packets++;
313 master->stats.tx_bytes +=
317 __netif_tx_unlock(slave_txq);
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 = qdisc_dev(q);
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 > qdisc_dev(q)->mtu)
416 } while ((q=NEXT_SLAVE(q)) != m->slaves);
423 static const struct net_device_ops teql_netdev_ops = {
424 .ndo_open = teql_master_open,
425 .ndo_stop = teql_master_close,
426 .ndo_start_xmit = teql_master_xmit,
427 .ndo_get_stats = teql_master_stats,
428 .ndo_change_mtu = teql_master_mtu,
431 static __init void teql_master_setup(struct net_device *dev)
433 struct teql_master *master = netdev_priv(dev);
434 struct Qdisc_ops *ops = &master->qops;
437 ops->priv_size = sizeof(struct teql_sched_data);
439 ops->enqueue = teql_enqueue;
440 ops->dequeue = teql_dequeue;
441 ops->peek = teql_peek;
442 ops->init = teql_qdisc_init;
443 ops->reset = teql_reset;
444 ops->destroy = teql_destroy;
445 ops->owner = THIS_MODULE;
447 dev->netdev_ops = &teql_netdev_ops;
448 dev->type = ARPHRD_VOID;
450 dev->tx_queue_len = 100;
451 dev->flags = IFF_NOARP;
452 dev->hard_header_len = LL_MAX_HEADER;
455 static LIST_HEAD(master_dev_list);
456 static int max_equalizers = 1;
457 module_param(max_equalizers, int, 0);
458 MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
460 static int __init teql_init(void)
465 for (i = 0; i < max_equalizers; i++) {
466 struct net_device *dev;
467 struct teql_master *master;
469 dev = alloc_netdev(sizeof(struct teql_master),
470 "teql%d", teql_master_setup);
476 if ((err = register_netdev(dev))) {
481 master = netdev_priv(dev);
483 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
484 err = register_qdisc(&master->qops);
487 unregister_netdev(dev);
492 list_add_tail(&master->master_list, &master_dev_list);
497 static void __exit teql_exit(void)
499 struct teql_master *master, *nxt;
501 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
503 list_del(&master->master_list);
505 unregister_qdisc(&master->qops);
506 unregister_netdev(master->dev);
507 free_netdev(master->dev);
511 module_init(teql_init);
512 module_exit(teql_exit);
514 MODULE_LICENSE("GPL");