blob: 0444fd0f0d2298228934a6f06ca54913f3280b8b [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{
81 struct net_device *dev = sch->dev;
82 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 sch->bstats.bytes += skb->len;
87 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);
110 struct sk_buff *skb;
111
112 skb = __skb_dequeue(&dat->q);
113 if (skb == NULL) {
114 struct net_device *m = dat->m->dev->qdisc->dev;
115 if (m) {
116 dat->m->slaves = sch;
117 netif_wake_queue(m);
118 }
119 }
120 sch->q.qlen = dat->q.qlen + dat->m->dev->qdisc->q.qlen;
121 return skb;
122}
123
124static __inline__ void
125teql_neigh_release(struct neighbour *n)
126{
127 if (n)
128 neigh_release(n);
129}
130
131static void
132teql_reset(struct Qdisc* sch)
133{
134 struct teql_sched_data *dat = qdisc_priv(sch);
135
136 skb_queue_purge(&dat->q);
137 sch->q.qlen = 0;
138 teql_neigh_release(xchg(&dat->ncache, NULL));
139}
140
141static void
142teql_destroy(struct Qdisc* sch)
143{
144 struct Qdisc *q, *prev;
145 struct teql_sched_data *dat = qdisc_priv(sch);
146 struct teql_master *master = dat->m;
147
148 if ((prev = master->slaves) != NULL) {
149 do {
150 q = NEXT_SLAVE(prev);
151 if (q == sch) {
152 NEXT_SLAVE(prev) = NEXT_SLAVE(q);
153 if (q == master->slaves) {
154 master->slaves = NEXT_SLAVE(q);
155 if (q == master->slaves) {
156 master->slaves = NULL;
157 spin_lock_bh(&master->dev->queue_lock);
158 qdisc_reset(master->dev->qdisc);
159 spin_unlock_bh(&master->dev->queue_lock);
160 }
161 }
162 skb_queue_purge(&dat->q);
163 teql_neigh_release(xchg(&dat->ncache, NULL));
164 break;
165 }
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 } while ((prev = q) != master->slaves);
168 }
169}
170
Patrick McHardy1e904742008-01-22 22:11:17 -0800171static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172{
173 struct net_device *dev = sch->dev;
174 struct teql_master *m = (struct teql_master*)sch->ops;
175 struct teql_sched_data *q = qdisc_priv(sch);
176
177 if (dev->hard_header_len > m->dev->hard_header_len)
178 return -EINVAL;
179
180 if (m->dev == dev)
181 return -ELOOP;
182
183 q->m = m;
184
185 skb_queue_head_init(&q->q);
186
187 if (m->slaves) {
188 if (m->dev->flags & IFF_UP) {
189 if ((m->dev->flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT))
190 || (m->dev->flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST))
191 || (m->dev->flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST))
192 || dev->mtu < m->dev->mtu)
193 return -EINVAL;
194 } else {
195 if (!(dev->flags&IFF_POINTOPOINT))
196 m->dev->flags &= ~IFF_POINTOPOINT;
197 if (!(dev->flags&IFF_BROADCAST))
198 m->dev->flags &= ~IFF_BROADCAST;
199 if (!(dev->flags&IFF_MULTICAST))
200 m->dev->flags &= ~IFF_MULTICAST;
201 if (dev->mtu < m->dev->mtu)
202 m->dev->mtu = dev->mtu;
203 }
204 q->next = NEXT_SLAVE(m->slaves);
205 NEXT_SLAVE(m->slaves) = sch;
206 } else {
207 q->next = sch;
208 m->slaves = sch;
209 m->dev->mtu = dev->mtu;
210 m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK);
211 }
212 return 0;
213}
214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216static int
217__teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
218{
219 struct teql_sched_data *q = qdisc_priv(dev->qdisc);
220 struct neighbour *mn = skb->dst->neighbour;
221 struct neighbour *n = q->ncache;
222
223 if (mn->tbl == NULL)
224 return -EINVAL;
225 if (n && n->tbl == mn->tbl &&
226 memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) {
227 atomic_inc(&n->refcnt);
228 } else {
229 n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev);
230 if (IS_ERR(n))
231 return PTR_ERR(n);
232 }
233 if (neigh_event_send(n, skb_res) == 0) {
234 int err;
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 read_lock(&n->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700237 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
238 n->ha, NULL, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 read_unlock(&n->lock);
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700240
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 if (err < 0) {
242 neigh_release(n);
243 return -EINVAL;
244 }
245 teql_neigh_release(xchg(&q->ncache, n));
246 return 0;
247 }
248 neigh_release(n);
249 return (skb_res == NULL) ? -EAGAIN : 1;
250}
251
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700252static inline int teql_resolve(struct sk_buff *skb,
253 struct sk_buff *skb_res, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
Evgeniy Polyakov4f9f8312007-11-06 03:08:09 -0800255 if (dev->qdisc == &noop_qdisc)
256 return -ENODEV;
257
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700258 if (dev->header_ops == NULL ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 skb->dst == NULL ||
260 skb->dst->neighbour == NULL)
261 return 0;
262 return __teql_resolve(skb, skb_res, dev);
263}
264
265static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
266{
Patrick McHardy2941a482006-01-08 22:05:26 -0800267 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 struct Qdisc *start, *q;
269 int busy;
270 int nores;
271 int len = skb->len;
Pavel Emelyanov4e3ab472007-10-21 17:01:29 -0700272 int subq = skb_get_queue_mapping(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 struct sk_buff *skb_res = NULL;
274
275 start = master->slaves;
276
277restart:
278 nores = 0;
279 busy = 0;
280
281 if ((q = start) == NULL)
282 goto drop;
283
284 do {
285 struct net_device *slave = q->dev;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 if (slave->qdisc_sleeping != q)
288 continue;
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700289 if (netif_queue_stopped(slave) ||
Pavel Emelyanov668f8952007-10-21 17:01:56 -0700290 __netif_subqueue_stopped(slave, subq) ||
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -0700291 !netif_running(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 busy = 1;
293 continue;
294 }
295
296 switch (teql_resolve(skb, skb_res, slave)) {
297 case 0:
Herbert Xu932ff272006-06-09 12:20:56 -0700298 if (netif_tx_trylock(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 if (!netif_queue_stopped(slave) &&
Pavel Emelyanov668f8952007-10-21 17:01:56 -0700300 !__netif_subqueue_stopped(slave, subq) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 slave->hard_start_xmit(skb, slave) == 0) {
Herbert Xu932ff272006-06-09 12:20:56 -0700302 netif_tx_unlock(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 master->slaves = NEXT_SLAVE(q);
304 netif_wake_queue(dev);
305 master->stats.tx_packets++;
306 master->stats.tx_bytes += len;
307 return 0;
308 }
Herbert Xu932ff272006-06-09 12:20:56 -0700309 netif_tx_unlock(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 }
311 if (netif_queue_stopped(dev))
312 busy = 1;
313 break;
314 case 1:
315 master->slaves = NEXT_SLAVE(q);
316 return 0;
317 default:
318 nores = 1;
319 break;
320 }
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300321 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 } while ((q = NEXT_SLAVE(q)) != start);
323
324 if (nores && skb_res == NULL) {
325 skb_res = skb;
326 goto restart;
327 }
328
329 if (busy) {
330 netif_stop_queue(dev);
331 return 1;
332 }
333 master->stats.tx_errors++;
334
335drop:
336 master->stats.tx_dropped++;
337 dev_kfree_skb(skb);
338 return 0;
339}
340
341static int teql_master_open(struct net_device *dev)
342{
343 struct Qdisc * q;
Patrick McHardy2941a482006-01-08 22:05:26 -0800344 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 int mtu = 0xFFFE;
346 unsigned flags = IFF_NOARP|IFF_MULTICAST;
347
348 if (m->slaves == NULL)
349 return -EUNATCH;
350
351 flags = FMASK;
352
353 q = m->slaves;
354 do {
355 struct net_device *slave = q->dev;
356
357 if (slave == NULL)
358 return -EUNATCH;
359
360 if (slave->mtu < mtu)
361 mtu = slave->mtu;
362 if (slave->hard_header_len > LL_MAX_HEADER)
363 return -EINVAL;
364
365 /* If all the slaves are BROADCAST, master is BROADCAST
366 If all the slaves are PtP, master is PtP
367 Otherwise, master is NBMA.
368 */
369 if (!(slave->flags&IFF_POINTOPOINT))
370 flags &= ~IFF_POINTOPOINT;
371 if (!(slave->flags&IFF_BROADCAST))
372 flags &= ~IFF_BROADCAST;
373 if (!(slave->flags&IFF_MULTICAST))
374 flags &= ~IFF_MULTICAST;
375 } while ((q = NEXT_SLAVE(q)) != m->slaves);
376
377 m->dev->mtu = mtu;
378 m->dev->flags = (m->dev->flags&~FMASK) | flags;
379 netif_start_queue(m->dev);
380 return 0;
381}
382
383static int teql_master_close(struct net_device *dev)
384{
385 netif_stop_queue(dev);
386 return 0;
387}
388
389static struct net_device_stats *teql_master_stats(struct net_device *dev)
390{
Patrick McHardy2941a482006-01-08 22:05:26 -0800391 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 return &m->stats;
393}
394
395static int teql_master_mtu(struct net_device *dev, int new_mtu)
396{
Patrick McHardy2941a482006-01-08 22:05:26 -0800397 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 struct Qdisc *q;
399
400 if (new_mtu < 68)
401 return -EINVAL;
402
403 q = m->slaves;
404 if (q) {
405 do {
406 if (new_mtu > q->dev->mtu)
407 return -EINVAL;
408 } while ((q=NEXT_SLAVE(q)) != m->slaves);
409 }
410
411 dev->mtu = new_mtu;
412 return 0;
413}
414
415static __init void teql_master_setup(struct net_device *dev)
416{
Patrick McHardy2941a482006-01-08 22:05:26 -0800417 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 struct Qdisc_ops *ops = &master->qops;
419
420 master->dev = dev;
421 ops->priv_size = sizeof(struct teql_sched_data);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 ops->enqueue = teql_enqueue;
424 ops->dequeue = teql_dequeue;
425 ops->requeue = teql_requeue;
426 ops->init = teql_qdisc_init;
427 ops->reset = teql_reset;
428 ops->destroy = teql_destroy;
429 ops->owner = THIS_MODULE;
430
431 dev->open = teql_master_open;
432 dev->hard_start_xmit = teql_master_xmit;
433 dev->stop = teql_master_close;
434 dev->get_stats = teql_master_stats;
435 dev->change_mtu = teql_master_mtu;
436 dev->type = ARPHRD_VOID;
437 dev->mtu = 1500;
438 dev->tx_queue_len = 100;
439 dev->flags = IFF_NOARP;
440 dev->hard_header_len = LL_MAX_HEADER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441}
442
443static LIST_HEAD(master_dev_list);
444static int max_equalizers = 1;
445module_param(max_equalizers, int, 0);
446MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
447
448static int __init teql_init(void)
449{
450 int i;
451 int err = -ENODEV;
452
453 for (i = 0; i < max_equalizers; i++) {
454 struct net_device *dev;
455 struct teql_master *master;
456
457 dev = alloc_netdev(sizeof(struct teql_master),
458 "teql%d", teql_master_setup);
459 if (!dev) {
460 err = -ENOMEM;
461 break;
462 }
463
464 if ((err = register_netdev(dev))) {
465 free_netdev(dev);
466 break;
467 }
468
Patrick McHardy2941a482006-01-08 22:05:26 -0800469 master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
471 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
472 err = register_qdisc(&master->qops);
473
474 if (err) {
475 unregister_netdev(dev);
476 free_netdev(dev);
477 break;
478 }
479
480 list_add_tail(&master->master_list, &master_dev_list);
481 }
482 return i ? 0 : err;
483}
484
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900485static void __exit teql_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486{
487 struct teql_master *master, *nxt;
488
489 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
490
491 list_del(&master->master_list);
492
493 unregister_qdisc(&master->qops);
494 unregister_netdev(master->dev);
495 free_netdev(master->dev);
496 }
497}
498
499module_init(teql_init);
500module_exit(teql_exit);
501
502MODULE_LICENSE("GPL");