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 <net/sock.h>
  35 #include <net/pkt_sched.h>
  36
  37 /*
  38    How to setup it.
  39    ----------------
  40
  41    After loading this module you will find a new device teqlN
  42    and new qdisc with the same name. To join a slave to the equalizer
  43    you should just set this qdisc on a device f.e.
  44
  45    # tc qdisc add dev eth0 root teql0
  46    # tc qdisc add dev eth1 root teql0
  47
  48    That's all. Full PnP 8)
  49
  50    Applicability.
  51    --------------
  52
  53    1. Slave devices MUST be active devices, i.e., they must raise the tbusy
  54       signal and generate EOI events. If you want to equalize virtual devices
  55       like tunnels, use a normal eql device.
  56    2. This device puts no limitations on physical slave characteristics
  57       f.e. it will equalize 9600baud line and 100Mb ethernet perfectly :-)
  58       Certainly, large difference in link speeds will make the resulting
  59       eqalized link unusable, because of huge packet reordering.
  60       I estimate an upper useful difference as ~10 times.
  61    3. If the slave requires address resolution, only protocols using
  62       neighbour cache (IPv4/IPv6) will work over the equalized link.
  63       Other protocols are still allowed to use the slave device directly,
  64       which will not break load balancing, though native slave
  65       traffic will have the highest priority.  */
  66
  67 struct teql_master
  68 {
  69         struct Qdisc_ops qops;
  70         struct net_device dev;
  71         struct Qdisc *slaves;
  72         struct net_device_stats stats;
  73         char name[IFNAMSIZ];
  74 };
  75
  76 struct teql_sched_data
  77 {
  78         struct Qdisc *next;
  79         struct teql_master *m;
  80         struct neighbour *ncache;
  81         struct sk_buff_head q;
  82 };
  83
  84 #define NEXT_SLAVE(q) (((struct teql_sched_data*)((q)->data))->next)
  85
  86 #define FMASK (IFF_BROADCAST|IFF_POINTOPOINT|IFF_BROADCAST)
  87
  88 /* "teql*" qdisc routines */
  89
  90 static int
  91 teql_enqueue(struct sk_buff *skb, struct Qdisc* sch)
  92 {
  93         struct net_device *dev = sch->dev;
  94         struct teql_sched_data *q = (struct teql_sched_data *)sch->data;
  95
  96         __skb_queue_tail(&q->q, skb);
  97         if (q->q.qlen <= dev->tx_queue_len) {
  98                 sch->stats.bytes += skb->len;
  99                 sch->stats.packets++;
 100                 return 0;
 101         }
 102
 103         __skb_unlink(skb, &q->q);
 104         kfree_skb(skb);
 105         sch->stats.drops++;
 106         return NET_XMIT_DROP;
 107 }
 108
 109 static int
 110 teql_requeue(struct sk_buff *skb, struct Qdisc* sch)
 111 {
 112         struct teql_sched_data *q = (struct teql_sched_data *)sch->data;
 113
 114         __skb_queue_head(&q->q, skb);
 115         return 0;
 116 }
 117
 118 static struct sk_buff *
 119 teql_dequeue(struct Qdisc* sch)
 120 {
 121         struct teql_sched_data *dat = (struct teql_sched_data *)sch->data;
 122         struct sk_buff *skb;
 123
 124         skb = __skb_dequeue(&dat->q);
 125         if (skb == NULL) {
 126                 struct net_device *m = dat->m->dev.qdisc->dev;
 127                 if (m) {
 128                         dat->m->slaves = sch;
 129                         netif_wake_queue(m);
 130                 }
 131         }
 132         sch->q.qlen = dat->q.qlen + dat->m->dev.qdisc->q.qlen;
 133         return skb;
 134 }
 135
 136 static __inline__ void
 137 teql_neigh_release(struct neighbour *n)
 138 {
 139         if (n)
 140                 neigh_release(n);
 141 }
 142
 143 static void
 144 teql_reset(struct Qdisc* sch)
 145 {
 146         struct teql_sched_data *dat = (struct teql_sched_data *)sch->data;
 147
 148         skb_queue_purge(&dat->q);
 149         sch->q.qlen = 0;
 150         teql_neigh_release(xchg(&dat->ncache, NULL));
 151 }
 152
 153 static void
 154 teql_destroy(struct Qdisc* sch)
 155 {
 156         struct Qdisc *q, *prev;
 157         struct teql_sched_data *dat = (struct teql_sched_data *)sch->data;
 158         struct teql_master *master = dat->m;
 159
 160         if ((prev = master->slaves) != NULL) {
 161                 do {
 162                         q = NEXT_SLAVE(prev);
 163                         if (q == sch) {
 164                                 NEXT_SLAVE(prev) = NEXT_SLAVE(q);
 165                                 if (q == master->slaves) {
 166                                         master->slaves = NEXT_SLAVE(q);
 167                                         if (q == master->slaves) {
 168                                                 master->slaves = NULL;
 169                                                 spin_lock_bh(&master->dev.queue_lock);
 170                                                 qdisc_reset(master->dev.qdisc);
 171                                                 spin_unlock_bh(&master->dev.queue_lock);
 172                                         }
 173                                 }
 174                                 skb_queue_purge(&dat->q);
 175                                 teql_neigh_release(xchg(&dat->ncache, NULL));
 176                                 break;
 177                         }
 178
 179                 } while ((prev = q) != master->slaves);
 180         }
 181
 182         MOD_DEC_USE_COUNT;
 183 }
 184
 185 static int teql_qdisc_init(struct Qdisc *sch, struct rtattr *opt)
 186 {
 187         struct net_device *dev = sch->dev;
 188         struct teql_master *m = (struct teql_master*)sch->ops;
 189         struct teql_sched_data *q = (struct teql_sched_data *)sch->data;
 190
 191         if (dev->hard_header_len > m->dev.hard_header_len)
 192                 return -EINVAL;
 193
 194         if (&m->dev == dev)
 195                 return -ELOOP;
 196
 197         q->m = m;
 198
 199         skb_queue_head_init(&q->q);
 200
 201         if (m->slaves) {
 202                 if (m->dev.flags & IFF_UP) {
 203                         if ((m->dev.flags&IFF_POINTOPOINT && !(dev->flags&IFF_POINTOPOINT))
 204                             || (m->dev.flags&IFF_BROADCAST && !(dev->flags&IFF_BROADCAST))
 205                             || (m->dev.flags&IFF_MULTICAST && !(dev->flags&IFF_MULTICAST))
 206                             || dev->mtu < m->dev.mtu)
 207                                 return -EINVAL;
 208                 } else {
 209                         if (!(dev->flags&IFF_POINTOPOINT))
 210                                 m->dev.flags &= ~IFF_POINTOPOINT;
 211                         if (!(dev->flags&IFF_BROADCAST))
 212                                 m->dev.flags &= ~IFF_BROADCAST;
 213                         if (!(dev->flags&IFF_MULTICAST))
 214                                 m->dev.flags &= ~IFF_MULTICAST;
 215                         if (dev->mtu < m->dev.mtu)
 216                                 m->dev.mtu = dev->mtu;
 217                 }
 218                 q->next = NEXT_SLAVE(m->slaves);
 219                 NEXT_SLAVE(m->slaves) = sch;
 220         } else {
 221                 q->next = sch;
 222                 m->slaves = sch;
 223                 m->dev.mtu = dev->mtu;
 224                 m->dev.flags = (m->dev.flags&~FMASK)|(dev->flags&FMASK);
 225         }
 226
 227         MOD_INC_USE_COUNT;
 228         return 0;
 229 }
 230
 231 /* "teql*" netdevice routines */
 232
 233 static int
 234 __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
 235 {
 236         struct teql_sched_data *q = (void*)dev->qdisc->data;
 237         struct neighbour *mn = skb->dst->neighbour;
 238         struct neighbour *n = q->ncache;
 239
 240         if (mn->tbl == NULL)
 241                 return -EINVAL;
 242         if (n && n->tbl == mn->tbl &&
 243             memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) {
 244                 atomic_inc(&n->refcnt);
 245         } else {
 246                 n = __neigh_lookup(mn->tbl, mn->primary_key, dev, 1);
 247                 if (n == NULL)
 248                         return -ENOBUFS;
 249         }
 250         if (neigh_event_send(n, skb_res) == 0) {
 251                 int err;
 252                 read_lock(&n->lock);
 253                 err = dev->hard_header(skb, dev, ntohs(skb->protocol), n->ha, NULL, skb->len);
 254                 read_unlock(&n->lock);
 255                 if (err < 0) {
 256                         neigh_release(n);
 257                         return -EINVAL;
 258                 }
 259                 teql_neigh_release(xchg(&q->ncache, n));
 260                 return 0;
 261         }
 262         neigh_release(n);
 263         return (skb_res == NULL) ? -EAGAIN : 1;
 264 }
 265
 266 static __inline__ int
 267 teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
 268 {
 269         if (dev->hard_header == NULL ||
 270             skb->dst == NULL ||
 271             skb->dst->neighbour == NULL)
 272                 return 0;
 273         return __teql_resolve(skb, skb_res, dev);
 274 }
 275
 276 static int teql_master_xmit(struct sk_buff *skb, struct net_device *dev)
 277 {
 278         struct teql_master *master = (void*)dev->priv;
 279         struct Qdisc *start, *q;
 280         int busy;
 281         int nores;
 282         int len = skb->len;
 283         struct sk_buff *skb_res = NULL;
 284
 285         start = master->slaves;
 286
 287 restart:
 288         nores = 0;
 289         busy = 0;
 290
 291         if ((q = start) == NULL)
 292                 goto drop;
 293
 294         do {
 295                 struct net_device *slave = q->dev;
 296
 297                 if (slave->qdisc_sleeping != q)
 298                         continue;
 299                 if (netif_queue_stopped(slave) || ! netif_running(slave)) {
 300                         busy = 1;
 301                         continue;
 302                 }
 303
 304                 switch (teql_resolve(skb, skb_res, slave)) {
 305                 case 0:
 306                         if (spin_trylock(&slave->xmit_lock)) {
 307                                 slave->xmit_lock_owner = smp_processor_id();
 308                                 if (!netif_queue_stopped(slave) &&
 309                                     slave->hard_start_xmit(skb, slave) == 0) {
 310                                         slave->xmit_lock_owner = -1;
 311                                         spin_unlock(&slave->xmit_lock);
 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                                 slave->xmit_lock_owner = -1;
 319                                 spin_unlock(&slave->xmit_lock);
 320                         }
 321                         if (netif_queue_stopped(dev))
 322                                 busy = 1;
 323                         break;
 324                 case 1:
 325                         master->slaves = NEXT_SLAVE(q);
 326                         return 0;
 327                 default:
 328                         nores = 1;
 329                         break;
 330                 }
 331                 __skb_pull(skb, skb->nh.raw - skb->data);
 332         } while ((q = NEXT_SLAVE(q)) != start);
 333
 334         if (nores && skb_res == NULL) {
 335                 skb_res = skb;
 336                 goto restart;
 337         }
 338
 339         if (busy) {
 340                 netif_stop_queue(dev);
 341                 return 1;
 342         }
 343         master->stats.tx_errors++;
 344
 345 drop:
 346         master->stats.tx_dropped++;
 347         dev_kfree_skb(skb);
 348         return 0;
 349 }
 350
 351 static int teql_master_open(struct net_device *dev)
 352 {
 353         struct Qdisc * q;
 354         struct teql_master *m = (void*)dev->priv;
 355         int mtu = 0xFFFE;
 356         unsigned flags = IFF_NOARP|IFF_MULTICAST;
 357
 358         if (m->slaves == NULL)
 359                 return -EUNATCH;
 360
 361         flags = FMASK;
 362
 363         q = m->slaves;
 364         do {
 365                 struct net_device *slave = q->dev;
 366
 367                 if (slave == NULL)
 368                         return -EUNATCH;
 369
 370                 if (slave->mtu < mtu)
 371                         mtu = slave->mtu;
 372                 if (slave->hard_header_len > LL_MAX_HEADER)
 373                         return -EINVAL;
 374
 375                 /* If all the slaves are BROADCAST, master is BROADCAST
 376                    If all the slaves are PtP, master is PtP
 377                    Otherwise, master is NBMA.
 378                  */
 379                 if (!(slave->flags&IFF_POINTOPOINT))
 380                         flags &= ~IFF_POINTOPOINT;
 381                 if (!(slave->flags&IFF_BROADCAST))
 382                         flags &= ~IFF_BROADCAST;
 383                 if (!(slave->flags&IFF_MULTICAST))
 384                         flags &= ~IFF_MULTICAST;
 385         } while ((q = NEXT_SLAVE(q)) != m->slaves);
 386
 387         m->dev.mtu = mtu;
 388         m->dev.flags = (m->dev.flags&~FMASK) | flags;
 389         netif_start_queue(&m->dev);
 390         MOD_INC_USE_COUNT;
 391         return 0;
 392 }
 393
 394 static int teql_master_close(struct net_device *dev)
 395 {
 396         netif_stop_queue(dev);
 397         MOD_DEC_USE_COUNT;
 398         return 0;
 399 }
 400
 401 static struct net_device_stats *teql_master_stats(struct net_device *dev)
 402 {
 403         struct teql_master *m = (void*)dev->priv;
 404         return &m->stats;
 405 }
 406
 407 static int teql_master_mtu(struct net_device *dev, int new_mtu)
 408 {
 409         struct teql_master *m = (void*)dev->priv;
 410         struct Qdisc *q;
 411
 412         if (new_mtu < 68)
 413                 return -EINVAL;
 414
 415         q = m->slaves;
 416         if (q) {
 417                 do {
 418                         if (new_mtu > q->dev->mtu)
 419                                 return -EINVAL;
 420                 } while ((q=NEXT_SLAVE(q)) != m->slaves);
 421         }
 422
 423         dev->mtu = new_mtu;
 424         return 0;
 425 }
 426
 427 static int teql_master_init(struct net_device *dev)
 428 {
 429         dev->open               = teql_master_open;
 430         dev->hard_start_xmit    = teql_master_xmit;
 431         dev->stop               = teql_master_close;
 432         dev->get_stats          = teql_master_stats;
 433         dev->change_mtu         = teql_master_mtu;
 434         dev->type               = ARPHRD_VOID;
 435         dev->mtu                = 1500;
 436         dev->tx_queue_len       = 100;
 437         dev->flags              = IFF_NOARP;
 438         dev->hard_header_len    = LL_MAX_HEADER;
 439         return 0;
 440 }
 441
 442 static struct teql_master the_master = {
 443 {
 444         NULL,
 445         NULL,
 446         "",
 447         sizeof(struct teql_sched_data),
 448
 449         teql_enqueue,
 450         teql_dequeue,
 451         teql_requeue,
 452         NULL,
 453
 454         teql_qdisc_init,
 455         teql_reset,
 456         teql_destroy,
 457         NULL,
 458 },};
 459
 460
 461 #ifdef MODULE
 462 int init_module(void)
 463 #else
 464 int __init teql_init(void)
 465 #endif
 466 {
 467         int err;
 468
 469         rtnl_lock();
 470
 471         the_master.dev.priv = (void*)&the_master;
 472         the_master.dev.name = (void*)&the_master.name;
 473         err = dev_alloc_name(&the_master.dev, "teql%d");
 474         if (err < 0)
 475                 return err;
 476         memcpy(the_master.qops.id, the_master.name, IFNAMSIZ);
 477         the_master.dev.init = teql_master_init;
 478
 479         err = register_netdevice(&the_master.dev);
 480         if (err == 0) {
 481                 err = register_qdisc(&the_master.qops);
 482                 if (err)
 483                         unregister_netdevice(&the_master.dev);
 484         }
 485         rtnl_unlock();
 486         return err;
 487 }
 488
 489 #ifdef MODULE
 490 void cleanup_module(void)
 491 {
 492         rtnl_lock();
 493         unregister_qdisc(&the_master.qops);
 494         unregister_netdevice(&the_master.dev);
 495         rtnl_unlock();
 496 }
 497 #endif