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 += skb->len;
87 sch->bstats.packets++;
97 teql_requeue(struct sk_buff *skb, struct Qdisc* sch)
99 struct teql_sched_data *q = qdisc_priv(sch);
101 __skb_queue_head(&q->q, skb);
102 sch->qstats.requeues++;
106 static struct sk_buff *
107 teql_dequeue(struct Qdisc* sch)
109 struct teql_sched_data *dat = qdisc_priv(sch);
110 struct netdev_queue *dat_queue;
113 skb = __skb_dequeue(&dat->q);
114 dat_queue = netdev_get_tx_queue(dat->m->dev, 0);
116 struct net_device *m = qdisc_dev(dat_queue->qdisc);
118 dat->m->slaves = sch;
122 sch->q.qlen = dat->q.qlen + dat_queue->qdisc->q.qlen;
126 static __inline__ void
127 teql_neigh_release(struct neighbour *n)
134 teql_reset(struct Qdisc* sch)
136 struct teql_sched_data *dat = qdisc_priv(sch);
138 skb_queue_purge(&dat->q);
140 teql_neigh_release(xchg(&dat->ncache, NULL));
144 teql_destroy(struct Qdisc* sch)
146 struct Qdisc *q, *prev;
147 struct teql_sched_data *dat = qdisc_priv(sch);
148 struct teql_master *master = dat->m;
150 if ((prev = master->slaves) != NULL) {
152 q = NEXT_SLAVE(prev);
154 NEXT_SLAVE(prev) = NEXT_SLAVE(q);
155 if (q == master->slaves) {
156 master->slaves = NEXT_SLAVE(q);
157 if (q == master->slaves) {
158 struct netdev_queue *txq;
160 txq = netdev_get_tx_queue(master->dev, 0);
161 master->slaves = NULL;
162 spin_lock_bh(&txq->lock);
163 qdisc_reset(txq->qdisc);
164 spin_unlock_bh(&txq->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;
279 int subq = skb_get_queue_mapping(skb);
280 struct sk_buff *skb_res = NULL;
282 start = master->slaves;
288 if ((q = start) == NULL)
292 struct net_device *slave = qdisc_dev(q);
293 struct netdev_queue *slave_txq;
295 slave_txq = netdev_get_tx_queue(slave, 0);
296 if (slave_txq->qdisc_sleeping != q)
298 if (netif_queue_stopped(slave) ||
299 __netif_subqueue_stopped(slave, subq) ||
300 !netif_running(slave)) {
305 switch (teql_resolve(skb, skb_res, slave)) {
307 if (netif_tx_trylock(slave)) {
308 if (!netif_queue_stopped(slave) &&
309 !__netif_subqueue_stopped(slave, subq) &&
310 slave->hard_start_xmit(skb, slave) == 0) {
311 netif_tx_unlock(slave);
312 master->slaves = NEXT_SLAVE(q);
313 netif_wake_queue(dev);
314 master->stats.tx_packets++;
315 master->stats.tx_bytes += len;
318 netif_tx_unlock(slave);
320 if (netif_queue_stopped(dev))
324 master->slaves = NEXT_SLAVE(q);
330 __skb_pull(skb, skb_network_offset(skb));
331 } while ((q = NEXT_SLAVE(q)) != start);
333 if (nores && skb_res == NULL) {
339 netif_stop_queue(dev);
342 master->stats.tx_errors++;
345 master->stats.tx_dropped++;
350 static int teql_master_open(struct net_device *dev)
353 struct teql_master *m = netdev_priv(dev);
355 unsigned flags = IFF_NOARP|IFF_MULTICAST;
357 if (m->slaves == NULL)
364 struct net_device *slave = qdisc_dev(q);
369 if (slave->mtu < mtu)
371 if (slave->hard_header_len > LL_MAX_HEADER)
374 /* If all the slaves are BROADCAST, master is BROADCAST
375 If all the slaves are PtP, master is PtP
376 Otherwise, master is NBMA.
378 if (!(slave->flags&IFF_POINTOPOINT))
379 flags &= ~IFF_POINTOPOINT;
380 if (!(slave->flags&IFF_BROADCAST))
381 flags &= ~IFF_BROADCAST;
382 if (!(slave->flags&IFF_MULTICAST))
383 flags &= ~IFF_MULTICAST;
384 } while ((q = NEXT_SLAVE(q)) != m->slaves);
387 m->dev->flags = (m->dev->flags&~FMASK) | flags;
388 netif_start_queue(m->dev);
392 static int teql_master_close(struct net_device *dev)
394 netif_stop_queue(dev);
398 static struct net_device_stats *teql_master_stats(struct net_device *dev)
400 struct teql_master *m = netdev_priv(dev);
404 static int teql_master_mtu(struct net_device *dev, int new_mtu)
406 struct teql_master *m = netdev_priv(dev);
415 if (new_mtu > qdisc_dev(q)->mtu)
417 } while ((q=NEXT_SLAVE(q)) != m->slaves);
424 static __init void teql_master_setup(struct net_device *dev)
426 struct teql_master *master = netdev_priv(dev);
427 struct Qdisc_ops *ops = &master->qops;
430 ops->priv_size = sizeof(struct teql_sched_data);
432 ops->enqueue = teql_enqueue;
433 ops->dequeue = teql_dequeue;
434 ops->requeue = teql_requeue;
435 ops->init = teql_qdisc_init;
436 ops->reset = teql_reset;
437 ops->destroy = teql_destroy;
438 ops->owner = THIS_MODULE;
440 dev->open = teql_master_open;
441 dev->hard_start_xmit = teql_master_xmit;
442 dev->stop = teql_master_close;
443 dev->get_stats = teql_master_stats;
444 dev->change_mtu = teql_master_mtu;
445 dev->type = ARPHRD_VOID;
447 dev->tx_queue_len = 100;
448 dev->flags = IFF_NOARP;
449 dev->hard_header_len = LL_MAX_HEADER;
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");