blob: f05ad9a30b4cd67bfef9d956023367303ddb5343 [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>
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/string.h>
18#include <linux/mm.h>
19#include <linux/socket.h>
20#include <linux/sockios.h>
21#include <linux/in.h>
22#include <linux/errno.h>
23#include <linux/interrupt.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020024#include <linux/if_arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#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>
31#include <net/ip.h>
32#include <net/route.h>
33#include <linux/skbuff.h>
34#include <linux/moduleparam.h>
35#include <net/sock.h>
36#include <net/pkt_sched.h>
37
38/*
39 How to setup it.
40 ----------------
41
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.
45
46 # tc qdisc add dev eth0 root teql0
47 # tc qdisc add dev eth1 root teql0
48
49 That's all. Full PnP 8)
50
51 Applicability.
52 --------------
53
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. */
67
68struct teql_master
69{
70 struct Qdisc_ops qops;
71 struct net_device *dev;
72 struct Qdisc *slaves;
73 struct list_head master_list;
74 struct net_device_stats stats;
75};
76
77struct teql_sched_data
78{
79 struct Qdisc *next;
80 struct teql_master *m;
81 struct neighbour *ncache;
82 struct sk_buff_head q;
83};
84
85#define NEXT_SLAVE(q) (((struct teql_sched_data*)qdisc_priv(q))->next)
86
87#define FMASK (IFF_BROADCAST|IFF_POINTOPOINT|IFF_BROADCAST)
88
89/* "teql*" qdisc routines */
90
91static int
92teql_enqueue(struct sk_buff *skb, struct Qdisc* sch)
93{
94 struct net_device *dev = sch->dev;
95 struct teql_sched_data *q = qdisc_priv(sch);
96
Krishna Kumar4cd8c9e2007-05-08 18:57:50 -070097 if (q->q.qlen < dev->tx_queue_len) {
98 __skb_queue_tail(&q->q, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 sch->bstats.bytes += skb->len;
100 sch->bstats.packets++;
101 return 0;
102 }
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 kfree_skb(skb);
105 sch->qstats.drops++;
106 return NET_XMIT_DROP;
107}
108
109static int
110teql_requeue(struct sk_buff *skb, struct Qdisc* sch)
111{
112 struct teql_sched_data *q = qdisc_priv(sch);
113
114 __skb_queue_head(&q->q, skb);
115 sch->qstats.requeues++;
116 return 0;
117}
118
119static struct sk_buff *
120teql_dequeue(struct Qdisc* sch)
121{
122 struct teql_sched_data *dat = qdisc_priv(sch);
123 struct sk_buff *skb;
124
125 skb = __skb_dequeue(&dat->q);
126 if (skb == NULL) {
127 struct net_device *m = dat->m->dev->qdisc->dev;
128 if (m) {
129 dat->m->slaves = sch;
130 netif_wake_queue(m);
131 }
132 }
133 sch->q.qlen = dat->q.qlen + dat->m->dev->qdisc->q.qlen;
134 return skb;
135}
136
137static __inline__ void
138teql_neigh_release(struct neighbour *n)
139{
140 if (n)
141 neigh_release(n);
142}
143
144static void
145teql_reset(struct Qdisc* sch)
146{
147 struct teql_sched_data *dat = qdisc_priv(sch);
148
149 skb_queue_purge(&dat->q);
150 sch->q.qlen = 0;
151 teql_neigh_release(xchg(&dat->ncache, NULL));
152}
153
154static void
155teql_destroy(struct Qdisc* sch)
156{
157 struct Qdisc *q, *prev;
158 struct teql_sched_data *dat = qdisc_priv(sch);
159 struct teql_master *master = dat->m;
160
161 if ((prev = master->slaves) != NULL) {
162 do {
163 q = NEXT_SLAVE(prev);
164 if (q == sch) {
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);
173 }
174 }
175 skb_queue_purge(&dat->q);
176 teql_neigh_release(xchg(&dat->ncache, NULL));
177 break;
178 }
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 } while ((prev = q) != master->slaves);
181 }
182}
183
184static int teql_qdisc_init(struct Qdisc *sch, struct rtattr *opt)
185{
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);
189
190 if (dev->hard_header_len > m->dev->hard_header_len)
191 return -EINVAL;
192
193 if (m->dev == dev)
194 return -ELOOP;
195
196 q->m = m;
197
198 skb_queue_head_init(&q->q);
199
200 if (m->slaves) {
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)
206 return -EINVAL;
207 } else {
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;
216 }
217 q->next = NEXT_SLAVE(m->slaves);
218 NEXT_SLAVE(m->slaves) = sch;
219 } else {
220 q->next = sch;
221 m->slaves = sch;
222 m->dev->mtu = dev->mtu;
223 m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK);
224 }
225 return 0;
226}
227
228/* "teql*" netdevice routines */
229
230static int
231__teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
232{
233 struct teql_sched_data *q = qdisc_priv(dev->qdisc);
234 struct neighbour *mn = skb->dst->neighbour;
235 struct neighbour *n = q->ncache;
236
237 if (mn->tbl == NULL)
238 return -EINVAL;
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);
242 } else {
243 n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev);
244 if (IS_ERR(n))
245 return PTR_ERR(n);
246 }
247 if (neigh_event_send(n, skb_res) == 0) {
248 int err;
249 read_lock(&n->lock);
250 err = dev->hard_header(skb, dev, ntohs(skb->protocol), n->ha, NULL, skb->len);
251 read_unlock(&n->lock);
252 if (err < 0) {
253 neigh_release(n);
254 return -EINVAL;
255 }
256 teql_neigh_release(xchg(&q->ncache, n));
257 return 0;
258 }
259 neigh_release(n);
260 return (skb_res == NULL) ? -EAGAIN : 1;
261}
262
263static __inline__ int
264teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
265{
266 if (dev->hard_header == NULL ||
267 skb->dst == NULL ||
268 skb->dst->neighbour == NULL)
269 return 0;
270 return __teql_resolve(skb, skb_res, dev);
271}
272
273static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
274{
Patrick McHardy2941a482006-01-08 22:05:26 -0800275 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 struct Qdisc *start, *q;
277 int busy;
278 int nores;
279 int len = skb->len;
280 struct sk_buff *skb_res = NULL;
281
282 start = master->slaves;
283
284restart:
285 nores = 0;
286 busy = 0;
287
288 if ((q = start) == NULL)
289 goto drop;
290
291 do {
292 struct net_device *slave = q->dev;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 if (slave->qdisc_sleeping != q)
295 continue;
296 if (netif_queue_stopped(slave) || ! netif_running(slave)) {
297 busy = 1;
298 continue;
299 }
300
301 switch (teql_resolve(skb, skb_res, slave)) {
302 case 0:
Herbert Xu932ff272006-06-09 12:20:56 -0700303 if (netif_tx_trylock(slave)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 if (!netif_queue_stopped(slave) &&
305 slave->hard_start_xmit(skb, slave) == 0) {
Herbert Xu932ff272006-06-09 12:20:56 -0700306 netif_tx_unlock(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 master->slaves = NEXT_SLAVE(q);
308 netif_wake_queue(dev);
309 master->stats.tx_packets++;
310 master->stats.tx_bytes += len;
311 return 0;
312 }
Herbert Xu932ff272006-06-09 12:20:56 -0700313 netif_tx_unlock(slave);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 }
315 if (netif_queue_stopped(dev))
316 busy = 1;
317 break;
318 case 1:
319 master->slaves = NEXT_SLAVE(q);
320 return 0;
321 default:
322 nores = 1;
323 break;
324 }
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300325 __skb_pull(skb, skb_network_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 } while ((q = NEXT_SLAVE(q)) != start);
327
328 if (nores && skb_res == NULL) {
329 skb_res = skb;
330 goto restart;
331 }
332
333 if (busy) {
334 netif_stop_queue(dev);
335 return 1;
336 }
337 master->stats.tx_errors++;
338
339drop:
340 master->stats.tx_dropped++;
341 dev_kfree_skb(skb);
342 return 0;
343}
344
345static int teql_master_open(struct net_device *dev)
346{
347 struct Qdisc * q;
Patrick McHardy2941a482006-01-08 22:05:26 -0800348 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 int mtu = 0xFFFE;
350 unsigned flags = IFF_NOARP|IFF_MULTICAST;
351
352 if (m->slaves == NULL)
353 return -EUNATCH;
354
355 flags = FMASK;
356
357 q = m->slaves;
358 do {
359 struct net_device *slave = q->dev;
360
361 if (slave == NULL)
362 return -EUNATCH;
363
364 if (slave->mtu < mtu)
365 mtu = slave->mtu;
366 if (slave->hard_header_len > LL_MAX_HEADER)
367 return -EINVAL;
368
369 /* If all the slaves are BROADCAST, master is BROADCAST
370 If all the slaves are PtP, master is PtP
371 Otherwise, master is NBMA.
372 */
373 if (!(slave->flags&IFF_POINTOPOINT))
374 flags &= ~IFF_POINTOPOINT;
375 if (!(slave->flags&IFF_BROADCAST))
376 flags &= ~IFF_BROADCAST;
377 if (!(slave->flags&IFF_MULTICAST))
378 flags &= ~IFF_MULTICAST;
379 } while ((q = NEXT_SLAVE(q)) != m->slaves);
380
381 m->dev->mtu = mtu;
382 m->dev->flags = (m->dev->flags&~FMASK) | flags;
383 netif_start_queue(m->dev);
384 return 0;
385}
386
387static int teql_master_close(struct net_device *dev)
388{
389 netif_stop_queue(dev);
390 return 0;
391}
392
393static struct net_device_stats *teql_master_stats(struct net_device *dev)
394{
Patrick McHardy2941a482006-01-08 22:05:26 -0800395 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 return &m->stats;
397}
398
399static int teql_master_mtu(struct net_device *dev, int new_mtu)
400{
Patrick McHardy2941a482006-01-08 22:05:26 -0800401 struct teql_master *m = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 struct Qdisc *q;
403
404 if (new_mtu < 68)
405 return -EINVAL;
406
407 q = m->slaves;
408 if (q) {
409 do {
410 if (new_mtu > q->dev->mtu)
411 return -EINVAL;
412 } while ((q=NEXT_SLAVE(q)) != m->slaves);
413 }
414
415 dev->mtu = new_mtu;
416 return 0;
417}
418
419static __init void teql_master_setup(struct net_device *dev)
420{
Patrick McHardy2941a482006-01-08 22:05:26 -0800421 struct teql_master *master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 struct Qdisc_ops *ops = &master->qops;
423
424 master->dev = dev;
425 ops->priv_size = sizeof(struct teql_sched_data);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 ops->enqueue = teql_enqueue;
428 ops->dequeue = teql_dequeue;
429 ops->requeue = teql_requeue;
430 ops->init = teql_qdisc_init;
431 ops->reset = teql_reset;
432 ops->destroy = teql_destroy;
433 ops->owner = THIS_MODULE;
434
435 dev->open = teql_master_open;
436 dev->hard_start_xmit = teql_master_xmit;
437 dev->stop = teql_master_close;
438 dev->get_stats = teql_master_stats;
439 dev->change_mtu = teql_master_mtu;
440 dev->type = ARPHRD_VOID;
441 dev->mtu = 1500;
442 dev->tx_queue_len = 100;
443 dev->flags = IFF_NOARP;
444 dev->hard_header_len = LL_MAX_HEADER;
445 SET_MODULE_OWNER(dev);
446}
447
448static LIST_HEAD(master_dev_list);
449static int max_equalizers = 1;
450module_param(max_equalizers, int, 0);
451MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
452
453static int __init teql_init(void)
454{
455 int i;
456 int err = -ENODEV;
457
458 for (i = 0; i < max_equalizers; i++) {
459 struct net_device *dev;
460 struct teql_master *master;
461
462 dev = alloc_netdev(sizeof(struct teql_master),
463 "teql%d", teql_master_setup);
464 if (!dev) {
465 err = -ENOMEM;
466 break;
467 }
468
469 if ((err = register_netdev(dev))) {
470 free_netdev(dev);
471 break;
472 }
473
Patrick McHardy2941a482006-01-08 22:05:26 -0800474 master = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
476 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
477 err = register_qdisc(&master->qops);
478
479 if (err) {
480 unregister_netdev(dev);
481 free_netdev(dev);
482 break;
483 }
484
485 list_add_tail(&master->master_list, &master_dev_list);
486 }
487 return i ? 0 : err;
488}
489
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900490static void __exit teql_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
492 struct teql_master *master, *nxt;
493
494 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
495
496 list_del(&master->master_list);
497
498 unregister_qdisc(&master->qops);
499 unregister_netdev(master->dev);
500 free_netdev(master->dev);
501 }
502}
503
504module_init(teql_init);
505module_exit(teql_exit);
506
507MODULE_LICENSE("GPL");