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