blob: 537223642b6e834423b7b02a7a26a6bc7664ba5d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/types.h>
13#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/errno.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020016#include <linux/if_arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/netdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/skbuff.h>
20#include <linux/moduleparam.h>
Patrick McHardy0ba48052007-07-02 22:49:07 -070021#include <net/dst.h>
22#include <net/neighbour.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#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
55struct 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
64struct 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
Roel Kluincc8fd142008-01-31 17:08:47 -080074#define FMASK (IFF_BROADCAST|IFF_POINTOPOINT)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76/* "teql*" qdisc routines */
77
78static int
79teql_enqueue(struct sk_buff *skb, struct Qdisc* sch)
80{
David S. Miller5ce2d482008-07-08 17:06:30 -070081 struct net_device *dev = qdisc_dev(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 struct teql_sched_data *q = qdisc_priv(sch);
83
Krishna Kumar4cd8c9e2007-05-08 18:57:50 -070084 if (q->q.qlen < dev->tx_queue_len) {
85 __skb_queue_tail(&q->q, skb);
Jussi Kivilinna0abf77e2008-07-20 00:08:27 -070086 sch->bstats.bytes += qdisc_pkt_len(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 sch->bstats.packets++;
88 return 0;
89 }
90
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 kfree_skb(skb);
92 sch->qstats.drops++;
93 return NET_XMIT_DROP;
94}
95
96static int
97teql_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
106static struct sk_buff *
107teql_dequeue(struct Qdisc* sch)
108{
109 struct teql_sched_data *dat = qdisc_priv(sch);
David S. Millerb0e1e642008-07-08 17:42:10 -0700110 struct netdev_queue *dat_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 struct sk_buff *skb;
112
113 skb = __skb_dequeue(&dat->q);
David S. Millere8a04642008-07-17 00:34:19 -0700114 dat_queue = netdev_get_tx_queue(dat->m->dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 if (skb == NULL) {
David S. Millerb0e1e642008-07-08 17:42:10 -0700116 struct net_device *m = qdisc_dev(dat_queue->qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 if (m) {
118 dat->m->slaves = sch;
119 netif_wake_queue(m);
120 }
121 }
David S. Millerb0e1e642008-07-08 17:42:10 -0700122 sch->q.qlen = dat->q.qlen + dat_queue->qdisc->q.qlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 return skb;
124}
125
126static __inline__ void
127teql_neigh_release(struct neighbour *n)
128{
129 if (n)
130 neigh_release(n);
131}
132
133static void
134teql_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
143static void
144teql_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) {
David S. Millere8a04642008-07-17 00:34:19 -0700158 struct netdev_queue *txq;
David S. Miller838740002008-07-17 00:53:03 -0700159 spinlock_t *root_lock;
David S. Millere8a04642008-07-17 00:34:19 -0700160
161 txq = netdev_get_tx_queue(master->dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 master->slaves = NULL;
David S. Miller838740002008-07-17 00:53:03 -0700163
164 root_lock = qdisc_root_lock(txq->qdisc);
165 spin_lock_bh(root_lock);
David S. Millere8a04642008-07-17 00:34:19 -0700166 qdisc_reset(txq->qdisc);
David S. Miller838740002008-07-17 00:53:03 -0700167 spin_unlock_bh(root_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 }
169 }
170 skb_queue_purge(&dat->q);
171 teql_neigh_release(xchg(&dat->ncache, NULL));
172 break;
173 }
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 } while ((prev = q) != master->slaves);
176 }
177}
178
Patrick McHardy1e904742008-01-22 22:11:17 -0800179static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180{
David S. Miller5ce2d482008-07-08 17:06:30 -0700181 struct net_device *dev = qdisc_dev(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
224static int
225__teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
226{
David S. Millere8a04642008-07-17 00:34:19 -0700227 struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, 0);
228 struct teql_sched_data *q = qdisc_priv(dev_queue->qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 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;
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 read_lock(&n->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700246 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
247 n->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 read_unlock(&n->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 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
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700261static inline int teql_resolve(struct sk_buff *skb,
262 struct sk_buff *skb_res, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263{
David S. Millere8a04642008-07-17 00:34:19 -0700264 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
265 if (txq->qdisc == &noop_qdisc)
Evgeniy Polyakov4f9f8312007-11-06 03:08:09 -0800266 return -ENODEV;
267
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700268 if (dev->header_ops == NULL ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 skb->dst == NULL ||
270 skb->dst->neighbour == NULL)
271 return 0;
272 return __teql_resolve(skb, skb_res, dev);
273}
274
275static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
276{
Patrick McHardy2941a482006-01-08 22:05:26 -0800277 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 struct Qdisc *start, *q;
279 int busy;
280 int nores;
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -0700281 int subq = skb_get_queue_mapping(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 struct sk_buff *skb_res = NULL;
283
284 start = master->slaves;
285
286restart:
287 nores = 0;
288 busy = 0;
289
290 if ((q = start) == NULL)
291 goto drop;
292
293 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700294 struct net_device *slave = qdisc_dev(q);
David S. Millere8a04642008-07-17 00:34:19 -0700295 struct netdev_queue *slave_txq;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900296
David S. Millere8a04642008-07-17 00:34:19 -0700297 slave_txq = netdev_get_tx_queue(slave, 0);
298 if (slave_txq->qdisc_sleeping != q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 continue;
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700300 if (__netif_subqueue_stopped(slave, subq) ||
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700301 !netif_running(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 busy = 1;
303 continue;
304 }
305
306 switch (teql_resolve(skb, skb_res, slave)) {
307 case 0:
Herbert Xu932ff272006-06-09 12:20:56 -0700308 if (netif_tx_trylock(slave)) {
David S. Millerfd2ea0a2008-07-17 01:56:23 -0700309 if (!__netif_subqueue_stopped(slave, subq) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 slave->hard_start_xmit(skb, slave) == 0) {
Herbert Xu932ff272006-06-09 12:20:56 -0700311 netif_tx_unlock(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 master->slaves = NEXT_SLAVE(q);
313 netif_wake_queue(dev);
314 master->stats.tx_packets++;
Jussi Kivilinna0abf77e2008-07-20 00:08:27 -0700315 master->stats.tx_bytes +=
316 qdisc_pkt_len(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 return 0;
318 }
Herbert Xu932ff272006-06-09 12:20:56 -0700319 netif_tx_unlock(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 }
321 if (netif_queue_stopped(dev))
322 busy = 1;
323 break;
324 case 1:
325 master->slaves = NEXT_SLAVE(q);
326 return 0;
327 default:
328 nores = 1;
329 break;
330 }
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300331 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 } while ((q = NEXT_SLAVE(q)) != start);
333
334 if (nores && skb_res == NULL) {
335 skb_res = skb;
336 goto restart;
337 }
338
339 if (busy) {
340 netif_stop_queue(dev);
341 return 1;
342 }
343 master->stats.tx_errors++;
344
345drop:
346 master->stats.tx_dropped++;
347 dev_kfree_skb(skb);
348 return 0;
349}
350
351static int teql_master_open(struct net_device *dev)
352{
353 struct Qdisc * q;
Patrick McHardy2941a482006-01-08 22:05:26 -0800354 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 int mtu = 0xFFFE;
356 unsigned flags = IFF_NOARP|IFF_MULTICAST;
357
358 if (m->slaves == NULL)
359 return -EUNATCH;
360
361 flags = FMASK;
362
363 q = m->slaves;
364 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700365 struct net_device *slave = qdisc_dev(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367 if (slave == NULL)
368 return -EUNATCH;
369
370 if (slave->mtu < mtu)
371 mtu = slave->mtu;
372 if (slave->hard_header_len > LL_MAX_HEADER)
373 return -EINVAL;
374
375 /* If all the slaves are BROADCAST, master is BROADCAST
376 If all the slaves are PtP, master is PtP
377 Otherwise, master is NBMA.
378 */
379 if (!(slave->flags&IFF_POINTOPOINT))
380 flags &= ~IFF_POINTOPOINT;
381 if (!(slave->flags&IFF_BROADCAST))
382 flags &= ~IFF_BROADCAST;
383 if (!(slave->flags&IFF_MULTICAST))
384 flags &= ~IFF_MULTICAST;
385 } while ((q = NEXT_SLAVE(q)) != m->slaves);
386
387 m->dev->mtu = mtu;
388 m->dev->flags = (m->dev->flags&~FMASK) | flags;
389 netif_start_queue(m->dev);
390 return 0;
391}
392
393static int teql_master_close(struct net_device *dev)
394{
395 netif_stop_queue(dev);
396 return 0;
397}
398
399static struct net_device_stats *teql_master_stats(struct net_device *dev)
400{
Patrick McHardy2941a482006-01-08 22:05:26 -0800401 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 return &m->stats;
403}
404
405static int teql_master_mtu(struct net_device *dev, int new_mtu)
406{
Patrick McHardy2941a482006-01-08 22:05:26 -0800407 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 struct Qdisc *q;
409
410 if (new_mtu < 68)
411 return -EINVAL;
412
413 q = m->slaves;
414 if (q) {
415 do {
David S. Miller5ce2d482008-07-08 17:06:30 -0700416 if (new_mtu > qdisc_dev(q)->mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return -EINVAL;
418 } while ((q=NEXT_SLAVE(q)) != m->slaves);
419 }
420
421 dev->mtu = new_mtu;
422 return 0;
423}
424
425static __init void teql_master_setup(struct net_device *dev)
426{
Patrick McHardy2941a482006-01-08 22:05:26 -0800427 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 struct Qdisc_ops *ops = &master->qops;
429
430 master->dev = dev;
431 ops->priv_size = sizeof(struct teql_sched_data);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 ops->enqueue = teql_enqueue;
434 ops->dequeue = teql_dequeue;
435 ops->requeue = teql_requeue;
436 ops->init = teql_qdisc_init;
437 ops->reset = teql_reset;
438 ops->destroy = teql_destroy;
439 ops->owner = THIS_MODULE;
440
441 dev->open = teql_master_open;
442 dev->hard_start_xmit = teql_master_xmit;
443 dev->stop = teql_master_close;
444 dev->get_stats = teql_master_stats;
445 dev->change_mtu = teql_master_mtu;
446 dev->type = ARPHRD_VOID;
447 dev->mtu = 1500;
448 dev->tx_queue_len = 100;
449 dev->flags = IFF_NOARP;
450 dev->hard_header_len = LL_MAX_HEADER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451}
452
453static LIST_HEAD(master_dev_list);
454static int max_equalizers = 1;
455module_param(max_equalizers, int, 0);
456MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
457
458static int __init teql_init(void)
459{
460 int i;
461 int err = -ENODEV;
462
463 for (i = 0; i < max_equalizers; i++) {
464 struct net_device *dev;
465 struct teql_master *master;
466
467 dev = alloc_netdev(sizeof(struct teql_master),
468 "teql%d", teql_master_setup);
469 if (!dev) {
470 err = -ENOMEM;
471 break;
472 }
473
474 if ((err = register_netdev(dev))) {
475 free_netdev(dev);
476 break;
477 }
478
Patrick McHardy2941a482006-01-08 22:05:26 -0800479 master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
481 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
482 err = register_qdisc(&master->qops);
483
484 if (err) {
485 unregister_netdev(dev);
486 free_netdev(dev);
487 break;
488 }
489
490 list_add_tail(&master->master_list, &master_dev_list);
491 }
492 return i ? 0 : err;
493}
494
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900495static void __exit teql_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
497 struct teql_master *master, *nxt;
498
499 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
500
501 list_del(&master->master_list);
502
503 unregister_qdisc(&master->qops);
504 unregister_netdev(master->dev);
505 free_netdev(master->dev);
506 }
507}
508
509module_init(teql_init);
510module_exit(teql_exit);
511
512MODULE_LICENSE("GPL");