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