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