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 <asm/uaccess.h>
  13 #include <asm/system.h>
  14 #include <asm/bitops.h>
  15 #include <linux/types.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sched.h>
  18 #include <linux/string.h>
  19 #include <linux/mm.h>
  20 #include <linux/socket.h>
  21 #include <linux/sockios.h>
  22 #include <linux/in.h>
  23 #include <linux/errno.h>
  24 #include <linux/interrupt.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         __skb_queue_tail(&q->q, skb);
  98         if (q->q.qlen <= dev->tx_queue_len) {
  99                 sch->stats.bytes += skb->len;
 100                 sch->stats.packets++;
 101                 return 0;
 102         }
 103
 104         __skb_unlink(skb, &q->q);
 105         kfree_skb(skb);
 106         sch->stats.drops++;
 107         return NET_XMIT_DROP;
 108 }
 109
 110 static int
 111 teql_requeue(struct sk_buff *skb, struct Qdisc* sch)
 112 {
 113         struct teql_sched_data *q = qdisc_priv(sch);
 114
 115         __skb_queue_head(&q->q, skb);
 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->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
 273 static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
 274 {
 275         struct teql_master *master = (void*)dev->priv;
 276         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
 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 = q->dev;
 293
 294                 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:
 303                         if (spin_trylock(&slave->xmit_lock)) {
 304                                 slave->xmit_lock_owner = smp_processor_id();
 305                                 if (!netif_queue_stopped(slave) &&
 306                                     slave->hard_start_xmit(skb, slave) == 0) {
 307                                         slave->xmit_lock_owner = -1;
 308                                         spin_unlock(&slave->xmit_lock);
 309                                         master->slaves = NEXT_SLAVE(q);
 310                                         netif_wake_queue(dev);
 311                                         master->stats.tx_packets++;
 312                                         master->stats.tx_bytes += len;
 313                                         return 0;
 314                                 }
 315                                 slave->xmit_lock_owner = -1;
 316                                 spin_unlock(&slave->xmit_lock);
 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->nh.raw - skb->data);
 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 = (void*)dev->priv;
 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 = (void*)dev->priv;
 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 = (void*)dev->priv;
 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 = dev->priv;
 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 = dev->priv;
 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");