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_subqueue_stopped(slave, subq) ||
 299                     !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_subqueue_stopped(slave, subq) &&
 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 = qdisc_dev(q);
 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 > qdisc_dev(q)->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 }
 449
 450 static LIST_HEAD(master_dev_list);
 451 static int max_equalizers = 1;
 452 module_param(max_equalizers, int, 0);
 453 MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers");
 454
 455 static int __init teql_init(void)
 456 {
 457         int i;
 458         int err = -ENODEV;
 459
 460         for (i = 0; i < max_equalizers; i++) {
 461                 struct net_device *dev;
 462                 struct teql_master *master;
 463
 464                 dev = alloc_netdev(sizeof(struct teql_master),
 465                                   "teql%d", teql_master_setup);
 466                 if (!dev) {
 467                         err = -ENOMEM;
 468                         break;
 469                 }
 470
 471                 if ((err = register_netdev(dev))) {
 472                         free_netdev(dev);
 473                         break;
 474                 }
 475
 476                 master = netdev_priv(dev);
 477
 478                 strlcpy(master->qops.id, dev->name, IFNAMSIZ);
 479                 err = register_qdisc(&master->qops);
 480
 481                 if (err) {
 482                         unregister_netdev(dev);
 483                         free_netdev(dev);
 484                         break;
 485                 }
 486
 487                 list_add_tail(&master->master_list, &master_dev_list);
 488         }
 489         return i ? 0 : err;
 490 }
 491
 492 static void __exit teql_exit(void)
 493 {
 494         struct teql_master *master, *nxt;
 495
 496         list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) {
 497
 498                 list_del(&master->master_list);
 499
 500                 unregister_qdisc(&master->qops);
 501                 unregister_netdev(master->dev);
 502                 free_netdev(master->dev);
 503         }
 504 }
 505
 506 module_init(teql_init);
 507 module_exit(teql_exit);
 508
 509 MODULE_LICENSE("GPL");