?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC66 3.0.0.4.374.130 core
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / net / sched / sch_teql.c
blob656ccd919d3c6f785c994fdab7e0e136964deb26
1 /* 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>
17 #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>
24 #include <linux/if_arp.h>
25 #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
68 struct 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
77 struct 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
91 static int
92 teql_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
97 if (q->q.qlen < dev->tx_queue_len) {
98 __skb_queue_tail(&q->q, skb);
99 sch->bstats.bytes += skb->len;
100 sch->bstats.packets++;
101 return 0;
102 }
103
104 kfree_skb(skb);
105 sch->qstats.drops++;
106 return NET_XMIT_DROP;
107 }
108
109 static int
110 teql_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
119 static struct sk_buff *
120 teql_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
137 static __inline__ void
138 teql_neigh_release(struct neighbour *n)
139 {
140 if (n)
141 neigh_release(n);
142 }
143
144 static void
145 teql_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
154 static void
155 teql_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 }
179
180 } while ((prev = q) != master->slaves);
181 }
182 }
183
184 static 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
230 static 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
263 static __inline__ int
264 teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
265 {
266 if (dev->qdisc == &noop_qdisc)
267 return -ENODEV;
268
269 if (dev->hard_header == NULL ||
270 skb->dst == NULL ||
271 skb->dst->neighbour == NULL)
272 return 0;
273 return __teql_resolve(skb, skb_res, dev);
274 }
275
276 static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
277 {
278 struct teql_master *master = netdev_priv(dev);
279 struct Qdisc *start, *q;
280 int busy;
281 int nores;
282 int len = skb->len;
283 struct sk_buff *skb_res = NULL;
284
285 start = master->slaves;
286
287 restart:
288 nores = 0;
289 busy = 0;
290
291 if ((q = start) == NULL)
292 goto drop;
293
294 do {
295 struct net_device *slave = q->dev;
296
297 if (slave->qdisc_sleeping != q)
298 continue;
299 if (netif_queue_stopped(slave) || ! netif_running(slave)) {
300 busy = 1;
301 continue;
302 }
303
304 switch (teql_resolve(skb, skb_res, slave)) {
305 case 0:
306 if (netif_tx_trylock(slave)) {
307 if (!netif_queue_stopped(slave) &&
308 slave->hard_start_xmit(skb, slave) == 0) {
309 netif_tx_unlock(slave);
310 master->slaves = NEXT_SLAVE(q);
311 netif_wake_queue(dev);
312 master->stats.tx_packets++;
313 master->stats.tx_bytes += len;
314 return 0;
315 }
316 netif_tx_unlock(slave);
317 }
318 if (netif_queue_stopped(dev))
319 busy = 1;
320 break;
321 case 1:
322 master->slaves = NEXT_SLAVE(q);
323 return 0;
324 default:
325 nores = 1;
326 break;
327 }
328 __skb_pull(skb, skb_network_offset(skb));
329 } while ((q = NEXT_SLAVE(q)) != start);
330
331 if (nores && skb_res == NULL) {
332 skb_res = skb;
333 goto restart;
334 }
335
336 if (busy) {
337 netif_stop_queue(dev);
338 return 1;
339 }
340 master->stats.tx_errors++;
341
342 drop:
343 master->stats.tx_dropped++;
344 dev_kfree_skb(skb);
345 return 0;
346 }
347
348 static int teql_master_open(struct net_device *dev)
349 {
350 struct Qdisc * q;
351 struct teql_master *m = netdev_priv(dev);
352 int mtu = 0xFFFE;
353 unsigned flags = IFF_NOARP|IFF_MULTICAST;
354
355 if (m->slaves == NULL)
356 return -EUNATCH;
357
358 flags = FMASK;
359
360 q = m->slaves;
361 do {
362 struct net_device *slave = q->dev;
363
364 if (slave == NULL)
365 return -EUNATCH;
366
367 if (slave->mtu < mtu)
368 mtu = slave->mtu;
369 if (slave->hard_header_len > LL_MAX_HEADER)
370 return -EINVAL;
371
372 /* If all the slaves are BROADCAST, master is BROADCAST
373 If all the slaves are PtP, master is PtP
374 Otherwise, master is NBMA.
375 */
376 if (!(slave->flags&IFF_POINTOPOINT))
377 flags &= ~IFF_POINTOPOINT;
378 if (!(slave->flags&IFF_BROADCAST))
379 flags &= ~IFF_BROADCAST;
380 if (!(slave->flags&IFF_MULTICAST))
381 flags &= ~IFF_MULTICAST;
382 } while ((q = NEXT_SLAVE(q)) != m->slaves);
383
384 m->dev->mtu = mtu;
385 m->dev->flags = (m->dev->flags&~FMASK) | flags;
386 netif_start_queue(m->dev);
387 return 0;
388 }
389
390 static int teql_master_close(struct net_device *dev)
391 {
392 netif_stop_queue(dev);
393 return 0;
394 }
395
396 static struct net_device_stats *teql_master_stats(struct net_device *dev)
397 {
398 struct teql_master *m = netdev_priv(dev);
399 return &m->stats;
400 }
401
402 static int teql_master_mtu(struct net_device *dev, int new_mtu)
403 {
404 struct teql_master *m = netdev_priv(dev);
405 struct Qdisc *q;
406
407 if (new_mtu < 68)
408 return -EINVAL;
409
410 q = m->slaves;
411 if (q) {
412 do {
413 if (new_mtu > q->dev->mtu)
414 return -EINVAL;
415 } while ((q=NEXT_SLAVE(q)) != m->slaves);
416 }
417
418 dev->mtu = new_mtu;
419 return 0;
420 }
421
422 static __init void teql_master_setup(struct net_device *dev)
423 {
424 struct teql_master *master = netdev_priv(dev);
425 struct Qdisc_ops *ops = &master->qops;
426
427 master->dev = dev;
428 ops->priv_size = sizeof(struct teql_sched_data);
429
430 ops->enqueue = teql_enqueue;
431 ops->dequeue = teql_dequeue;
432 ops->requeue = teql_requeue;
433 ops->init = teql_qdisc_init;
434 ops->reset = teql_reset;
435 ops->destroy = teql_destroy;
436 ops->owner = THIS_MODULE;
437
438 dev->open = teql_master_open;
439 dev->hard_start_xmit = teql_master_xmit;
440 dev->stop = teql_master_close;
441 dev->get_stats = teql_master_stats;
442 dev->change_mtu = teql_master_mtu;
443 dev->type = ARPHRD_VOID;
444 dev->mtu = 1500;
445 dev->tx_queue_len = 100;
446 dev->flags = IFF_NOARP;
447 dev->hard_header_len = LL_MAX_HEADER;
448 SET_MODULE_OWNER(dev);
449 }
450
451 static LIST_HEAD(master_dev_list);
452 static int max_equalizers = 1;
453 module_param(max_equalizers, int, 0);
454 MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
455
456 static int __init teql_init(void)
457 {
458 int i;
459 int err = -ENODEV;
460
461 for (i = 0; i < max_equalizers; i++) {
462 struct net_device *dev;
463 struct teql_master *master;
464
465 dev = alloc_netdev(sizeof(struct teql_master),
466 "teql%d", teql_master_setup);
467 if (!dev) {
468 err = -ENOMEM;
469 break;
470 }
471
472 if ((err = register_netdev(dev))) {
473 free_netdev(dev);
474 break;
475 }
476
477 master = netdev_priv(dev);
478
479 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
480 err = register_qdisc(&master->qops);
481
482 if (err) {
483 unregister_netdev(dev);
484 free_netdev(dev);
485 break;
486 }
487
488 list_add_tail(&master->master_list, &master_dev_list);
489 }
490 return i ? 0 : err;
491 }
492
493 static void __exit teql_exit(void)
494 {
495 struct teql_master *master, *nxt;
496
497 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
498
499 list_del(&master->master_list);
500
501 unregister_qdisc(&master->qops);
502 unregister_netdev(master->dev);
503 free_netdev(master->dev);
504 }
505 }
506
507 module_init(teql_init);
508 module_exit(teql_exit);
509
510 MODULE_LICENSE("GPL");
Tomato firmware and modifications.