netdev: Move rest of qdisc state into struct netdev_queue
[linux-2.6.git] / net / sched / sch_teql.c
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 <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>
21 #include <net/dst.h>
22 #include <net/neighbour.h>
23 #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
55 struct 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
64 struct 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
74 #define FMASK (IFF_BROADCAST|IFF_POINTOPOINT)
75
76 /* "teql*" qdisc routines */
77
78 static int
79 teql_enqueue(struct sk_buff *skb, struct Qdisc* sch)
80 {
81         struct net_device *dev = qdisc_dev(sch);
82         struct teql_sched_data *q = qdisc_priv(sch);
83
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++;
88                 return 0;
89         }
90
91         kfree_skb(skb);
92         sch->qstats.drops++;
93         return NET_XMIT_DROP;
94 }
95
96 static int
97 teql_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
106 static struct sk_buff *
107 teql_dequeue(struct Qdisc* sch)
108 {
109         struct teql_sched_data *dat = qdisc_priv(sch);
110         struct netdev_queue *dat_queue;
111         struct sk_buff *skb;
112
113         skb = __skb_dequeue(&dat->q);
114         dat_queue = &dat->m->dev->tx_queue;
115         if (skb == NULL) {
116                 struct net_device *m = qdisc_dev(dat_queue->qdisc);
117                 if (m) {
118                         dat->m->slaves = sch;
119                         netif_wake_queue(m);
120                 }
121         }
122         sch->q.qlen = dat->q.qlen + dat_queue->qdisc->q.qlen;
123         return skb;
124 }
125
126 static __inline__ void
127 teql_neigh_release(struct neighbour *n)
128 {
129         if (n)
130                 neigh_release(n);
131 }
132
133 static void
134 teql_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
143 static void
144 teql_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) {
158                                                 master->slaves = NULL;
159                                                 spin_lock_bh(&master->dev->tx_queue.lock);
160                                                 qdisc_reset(master->dev->tx_queue.qdisc);
161                                                 spin_unlock_bh(&master->dev->tx_queue.lock);
162                                         }
163                                 }
164                                 skb_queue_purge(&dat->q);
165                                 teql_neigh_release(xchg(&dat->ncache, NULL));
166                                 break;
167                         }
168
169                 } while ((prev = q) != master->slaves);
170         }
171 }
172
173 static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt)
174 {
175         struct net_device *dev = qdisc_dev(sch);
176         struct teql_master *m = (struct teql_master*)sch->ops;
177         struct teql_sched_data *q = qdisc_priv(sch);
178
179         if (dev->hard_header_len > m->dev->hard_header_len)
180                 return -EINVAL;
181
182         if (m->dev == dev)
183                 return -ELOOP;
184
185         q->m = m;
186
187         skb_queue_head_init(&q->q);
188
189         if (m->slaves) {
190                 if (m->dev->flags & IFF_UP) {
191                         if ((m->dev->flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT))
192                             || (m->dev->flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST))
193                             || (m->dev->flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST))
194                             || dev->mtu < m->dev->mtu)
195                                 return -EINVAL;
196                 } else {
197                         if (!(dev->flags&IFF_POINTOPOINT))
198                                 m->dev->flags &= ~IFF_POINTOPOINT;
199                         if (!(dev->flags&IFF_BROADCAST))
200                                 m->dev->flags &= ~IFF_BROADCAST;
201                         if (!(dev->flags&IFF_MULTICAST))
202                                 m->dev->flags &= ~IFF_MULTICAST;
203                         if (dev->mtu < m->dev->mtu)
204                                 m->dev->mtu = dev->mtu;
205                 }
206                 q->next = NEXT_SLAVE(m->slaves);
207                 NEXT_SLAVE(m->slaves) = sch;
208         } else {
209                 q->next = sch;
210                 m->slaves = sch;
211                 m->dev->mtu = dev->mtu;
212                 m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK);
213         }
214         return 0;
215 }
216
217
218 static int
219 __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
220 {
221         struct teql_sched_data *q = qdisc_priv(dev->tx_queue.qdisc);
222         struct neighbour *mn = skb->dst->neighbour;
223         struct neighbour *n = q->ncache;
224
225         if (mn->tbl == NULL)
226                 return -EINVAL;
227         if (n && n->tbl == mn->tbl &&
228             memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) {
229                 atomic_inc(&n->refcnt);
230         } else {
231                 n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev);
232                 if (IS_ERR(n))
233                         return PTR_ERR(n);
234         }
235         if (neigh_event_send(n, skb_res) == 0) {
236                 int err;
237
238                 read_lock(&n->lock);
239                 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
240                                       n->ha, NULL, skb->len);
241                 read_unlock(&n->lock);
242
243                 if (err < 0) {
244                         neigh_release(n);
245                         return -EINVAL;
246                 }
247                 teql_neigh_release(xchg(&q->ncache, n));
248                 return 0;
249         }
250         neigh_release(n);
251         return (skb_res == NULL) ? -EAGAIN : 1;
252 }
253
254 static inline int teql_resolve(struct sk_buff *skb,
255                                struct sk_buff *skb_res, struct net_device *dev)
256 {
257         if (dev->tx_queue.qdisc == &noop_qdisc)
258                 return -ENODEV;
259
260         if (dev->header_ops == NULL ||
261             skb->dst == NULL ||
262             skb->dst->neighbour == NULL)
263                 return 0;
264         return __teql_resolve(skb, skb_res, dev);
265 }
266
267 static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
268 {
269         struct teql_master *master = netdev_priv(dev);
270         struct Qdisc *start, *q;
271         int busy;
272         int nores;
273         int len = skb->len;
274         int subq = skb_get_queue_mapping(skb);
275         struct sk_buff *skb_res = NULL;
276
277         start = master->slaves;
278
279 restart:
280         nores = 0;
281         busy = 0;
282
283         if ((q = start) == NULL)
284                 goto drop;
285
286         do {
287                 struct net_device *slave = qdisc_dev(q);
288
289                 if (slave->tx_queue.qdisc_sleeping != q)
290                         continue;
291                 if (netif_queue_stopped(slave) ||
292                     __netif_subqueue_stopped(slave, subq) ||
293                     !netif_running(slave)) {
294                         busy = 1;
295                         continue;
296                 }
297
298                 switch (teql_resolve(skb, skb_res, slave)) {
299                 case 0:
300                         if (netif_tx_trylock(slave)) {
301                                 if (!netif_queue_stopped(slave) &&
302                                     !__netif_subqueue_stopped(slave, subq) &&
303                                     slave->hard_start_xmit(skb, slave) == 0) {
304                                         netif_tx_unlock(slave);
305                                         master->slaves = NEXT_SLAVE(q);
306                                         netif_wake_queue(dev);
307                                         master->stats.tx_packets++;
308                                         master->stats.tx_bytes += len;
309                                         return 0;
310                                 }
311                                 netif_tx_unlock(slave);
312                         }
313                         if (netif_queue_stopped(dev))
314                                 busy = 1;
315                         break;
316                 case 1:
317                         master->slaves = NEXT_SLAVE(q);
318                         return 0;
319                 default:
320                         nores = 1;
321                         break;
322                 }
323                 __skb_pull(skb, skb_network_offset(skb));
324         } while ((q = NEXT_SLAVE(q)) != start);
325
326         if (nores && skb_res == NULL) {
327                 skb_res = skb;
328                 goto restart;
329         }
330
331         if (busy) {
332                 netif_stop_queue(dev);
333                 return 1;
334         }
335         master->stats.tx_errors++;
336
337 drop:
338         master->stats.tx_dropped++;
339         dev_kfree_skb(skb);
340         return 0;
341 }
342
343 static int teql_master_open(struct net_device *dev)
344 {
345         struct Qdisc * q;
346         struct teql_master *m = netdev_priv(dev);
347         int mtu = 0xFFFE;
348         unsigned flags = IFF_NOARP|IFF_MULTICAST;
349
350         if (m->slaves == NULL)
351                 return -EUNATCH;
352
353         flags = FMASK;
354
355         q = m->slaves;
356         do {
357                 struct net_device *slave = qdisc_dev(q);
358
359                 if (slave == NULL)
360                         return -EUNATCH;
361
362                 if (slave->mtu < mtu)
363                         mtu = slave->mtu;
364                 if (slave->hard_header_len > LL_MAX_HEADER)
365                         return -EINVAL;
366
367                 /* If all the slaves are BROADCAST, master is BROADCAST
368                    If all the slaves are PtP, master is PtP
369                    Otherwise, master is NBMA.
370                  */
371                 if (!(slave->flags&IFF_POINTOPOINT))
372                         flags &= ~IFF_POINTOPOINT;
373                 if (!(slave->flags&IFF_BROADCAST))
374                         flags &= ~IFF_BROADCAST;
375                 if (!(slave->flags&IFF_MULTICAST))
376                         flags &= ~IFF_MULTICAST;
377         } while ((q = NEXT_SLAVE(q)) != m->slaves);
378
379         m->dev->mtu = mtu;
380         m->dev->flags = (m->dev->flags&~FMASK) | flags;
381         netif_start_queue(m->dev);
382         return 0;
383 }
384
385 static int teql_master_close(struct net_device *dev)
386 {
387         netif_stop_queue(dev);
388         return 0;
389 }
390
391 static struct net_device_stats *teql_master_stats(struct net_device *dev)
392 {
393         struct teql_master *m = netdev_priv(dev);
394         return &m->stats;
395 }
396
397 static int teql_master_mtu(struct net_device *dev, int new_mtu)
398 {
399         struct teql_master *m = netdev_priv(dev);
400         struct Qdisc *q;
401
402         if (new_mtu < 68)
403                 return -EINVAL;
404
405         q = m->slaves;
406         if (q) {
407                 do {
408                         if (new_mtu > qdisc_dev(q)->mtu)
409                                 return -EINVAL;
410                 } while ((q=NEXT_SLAVE(q)) != m->slaves);
411         }
412
413         dev->mtu = new_mtu;
414         return 0;
415 }
416
417 static __init void teql_master_setup(struct net_device *dev)
418 {
419         struct teql_master *master = netdev_priv(dev);
420         struct Qdisc_ops *ops = &master->qops;
421
422         master->dev     = dev;
423         ops->priv_size  = sizeof(struct teql_sched_data);
424
425         ops->enqueue    =       teql_enqueue;
426         ops->dequeue    =       teql_dequeue;
427         ops->requeue    =       teql_requeue;
428         ops->init       =       teql_qdisc_init;
429         ops->reset      =       teql_reset;
430         ops->destroy    =       teql_destroy;
431         ops->owner      =       THIS_MODULE;
432
433         dev->open               = teql_master_open;
434         dev->hard_start_xmit    = teql_master_xmit;
435         dev->stop               = teql_master_close;
436         dev->get_stats          = teql_master_stats;
437         dev->change_mtu         = teql_master_mtu;
438         dev->type               = ARPHRD_VOID;
439         dev->mtu                = 1500;
440         dev->tx_queue_len       = 100;
441         dev->flags              = IFF_NOARP;
442         dev->hard_header_len    = LL_MAX_HEADER;
443 }
444
445 static LIST_HEAD(master_dev_list);
446 static int max_equalizers = 1;
447 module_param(max_equalizers, int, 0);
448 MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
449
450 static int __init teql_init(void)
451 {
452         int i;
453         int err = -ENODEV;
454
455         for (i = 0; i < max_equalizers; i++) {
456                 struct net_device *dev;
457                 struct teql_master *master;
458
459                 dev = alloc_netdev(sizeof(struct teql_master),
460                                   "teql%d", teql_master_setup);
461                 if (!dev) {
462                         err = -ENOMEM;
463                         break;
464                 }
465
466                 if ((err = register_netdev(dev))) {
467                         free_netdev(dev);
468                         break;
469                 }
470
471                 master = netdev_priv(dev);
472
473                 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
474                 err = register_qdisc(&master->qops);
475
476                 if (err) {
477                         unregister_netdev(dev);
478                         free_netdev(dev);
479                         break;
480                 }
481
482                 list_add_tail(&master->master_list, &master_dev_list);
483         }
484         return i ? 0 : err;
485 }
486
487 static void __exit teql_exit(void)
488 {
489         struct teql_master *master, *nxt;
490
491         list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
492
493                 list_del(&master->master_list);
494
495                 unregister_qdisc(&master->qops);
496                 unregister_netdev(master->dev);
497                 free_netdev(master->dev);
498         }
499 }
500
501 module_init(teql_init);
502 module_exit(teql_exit);
503
504 MODULE_LICENSE("GPL");