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 }; 62 63 struct teql_sched_data 64 { 65 struct Qdisc *next; 66 struct teql_master *m; 67 struct neighbour *ncache; 68 struct sk_buff_head q; 69 }; 70 71 #define NEXT_SLAVE(q) (((struct teql_sched_data*)qdisc_priv(q))->next) 72 73 #define FMASK (IFF_BROADCAST|IFF_POINTOPOINT) 74 75 /* "teql*" qdisc routines */ 76 77 static int 78 teql_enqueue(struct sk_buff *skb, struct Qdisc* sch) 79 { 80 struct net_device *dev = qdisc_dev(sch); 81 struct teql_sched_data *q = qdisc_priv(sch); 82 83 if (q->q.qlen < dev->tx_queue_len) { 84 __skb_queue_tail(&q->q, skb); 85 sch->bstats.bytes += qdisc_pkt_len(skb); 86 sch->bstats.packets++; 87 return 0; 88 } 89 90 kfree_skb(skb); 91 sch->qstats.drops++; 92 return NET_XMIT_DROP; 93 } 94 95 static struct sk_buff * 96 teql_dequeue(struct Qdisc* sch) 97 { 98 struct teql_sched_data *dat = qdisc_priv(sch); 99 struct netdev_queue *dat_queue; 100 struct sk_buff *skb; 101 102 skb = __skb_dequeue(&dat->q); 103 dat_queue = netdev_get_tx_queue(dat->m->dev, 0); 104 if (skb == NULL) { 105 struct net_device *m = qdisc_dev(dat_queue->qdisc); 106 if (m) { 107 dat->m->slaves = sch; 108 netif_wake_queue(m); 109 } 110 } 111 sch->q.qlen = dat->q.qlen + dat_queue->qdisc->q.qlen; 112 return skb; 113 } 114 115 static struct sk_buff * 116 teql_peek(struct Qdisc* sch) 117 { 118 /* teql is meant to be used as root qdisc */ 119 return NULL; 120 } 121 122 static __inline__ void 123 teql_neigh_release(struct neighbour *n) 124 { 125 if (n) 126 neigh_release(n); 127 } 128 129 static void 130 teql_reset(struct Qdisc* sch) 131 { 132 struct teql_sched_data *dat = qdisc_priv(sch); 133 134 skb_queue_purge(&dat->q); 135 sch->q.qlen = 0; 136 teql_neigh_release(xchg(&dat->ncache, NULL)); 137 } 138 139 static void 140 teql_destroy(struct Qdisc* sch) 141 { 142 struct Qdisc *q, *prev; 143 struct teql_sched_data *dat = qdisc_priv(sch); 144 struct teql_master *master = dat->m; 145 146 if ((prev = master->slaves) != NULL) { 147 do { 148 q = NEXT_SLAVE(prev); 149 if (q == sch) { 150 NEXT_SLAVE(prev) = NEXT_SLAVE(q); 151 if (q == master->slaves) { 152 master->slaves = NEXT_SLAVE(q); 153 if (q == master->slaves) { 154 struct netdev_queue *txq; 155 spinlock_t *root_lock; 156 157 txq = netdev_get_tx_queue(master->dev, 0); 158 master->slaves = NULL; 159 160 root_lock = qdisc_root_sleeping_lock(txq->qdisc); 161 spin_lock_bh(root_lock); 162 qdisc_reset(txq->qdisc); 163 spin_unlock_bh(root_lock); 164 } 165 } 166 skb_queue_purge(&dat->q); 167 teql_neigh_release(xchg(&dat->ncache, NULL)); 168 break; 169 } 170 171 } while ((prev = q) != master->slaves); 172 } 173 } 174 175 static int teql_qdisc_init(struct Qdisc *sch, struct nlattr *opt) 176 { 177 struct net_device *dev = qdisc_dev(sch); 178 struct teql_master *m = (struct teql_master*)sch->ops; 179 struct teql_sched_data *q = qdisc_priv(sch); 180 181 if (dev->hard_header_len > m->dev->hard_header_len) 182 return -EINVAL; 183 184 if (m->dev == dev) 185 return -ELOOP; 186 187 q->m = m; 188 189 skb_queue_head_init(&q->q); 190 191 if (m->slaves) { 192 if (m->dev->flags & IFF_UP) { 193 if ((m->dev->flags & IFF_POINTOPOINT && 194 !(dev->flags & IFF_POINTOPOINT)) || 195 (m->dev->flags & IFF_BROADCAST && 196 !(dev->flags & IFF_BROADCAST)) || 197 (m->dev->flags & IFF_MULTICAST && 198 !(dev->flags & IFF_MULTICAST)) || 199 dev->mtu < m->dev->mtu) 200 return -EINVAL; 201 } else { 202 if (!(dev->flags&IFF_POINTOPOINT)) 203 m->dev->flags &= ~IFF_POINTOPOINT; 204 if (!(dev->flags&IFF_BROADCAST)) 205 m->dev->flags &= ~IFF_BROADCAST; 206 if (!(dev->flags&IFF_MULTICAST)) 207 m->dev->flags &= ~IFF_MULTICAST; 208 if (dev->mtu < m->dev->mtu) 209 m->dev->mtu = dev->mtu; 210 } 211 q->next = NEXT_SLAVE(m->slaves); 212 NEXT_SLAVE(m->slaves) = sch; 213 } else { 214 q->next = sch; 215 m->slaves = sch; 216 m->dev->mtu = dev->mtu; 217 m->dev->flags = (m->dev->flags&~FMASK)|(dev->flags&FMASK); 218 } 219 return 0; 220 } 221 222 223 static int 224 __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev) 225 { 226 struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, 0); 227 struct teql_sched_data *q = qdisc_priv(dev_queue->qdisc); 228 struct neighbour *mn = skb_dst(skb)->neighbour; 229 struct neighbour *n = q->ncache; 230 231 if (mn->tbl == NULL) 232 return -EINVAL; 233 if (n && n->tbl == mn->tbl && 234 memcmp(n->primary_key, mn->primary_key, mn->tbl->key_len) == 0) { 235 atomic_inc(&n->refcnt); 236 } else { 237 n = __neigh_lookup_errno(mn->tbl, mn->primary_key, dev); 238 if (IS_ERR(n)) 239 return PTR_ERR(n); 240 } 241 if (neigh_event_send(n, skb_res) == 0) { 242 int err; 243 244 read_lock(&n->lock); 245 err = dev_hard_header(skb, dev, ntohs(skb->protocol), 246 n->ha, NULL, skb->len); 247 read_unlock(&n->lock); 248 249 if (err < 0) { 250 neigh_release(n); 251 return -EINVAL; 252 } 253 teql_neigh_release(xchg(&q->ncache, n)); 254 return 0; 255 } 256 neigh_release(n); 257 return (skb_res == NULL) ? -EAGAIN : 1; 258 } 259 260 static inline int teql_resolve(struct sk_buff *skb, 261 struct sk_buff *skb_res, struct net_device *dev) 262 { 263 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0); 264 if (txq->qdisc == &noop_qdisc) 265 return -ENODEV; 266 267 if (dev->header_ops == NULL || 268 skb_dst(skb) == NULL || 269 skb_dst(skb)->neighbour == NULL) 270 return 0; 271 return __teql_resolve(skb, skb_res, dev); 272 } 273 274 static netdev_tx_t teql_master_xmit(struct sk_buff *skb, struct net_device *dev) 275 { 276 struct teql_master *master = netdev_priv(dev); 277 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0); 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 = netdev_get_tx_queue(slave, 0); 296 const struct net_device_ops *slave_ops = slave->netdev_ops; 297 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 unsigned int length = qdisc_pkt_len(skb); 310 311 if (!netif_tx_queue_stopped(slave_txq) && 312 !netif_tx_queue_frozen(slave_txq) && 313 slave_ops->ndo_start_xmit(skb, slave) == NETDEV_TX_OK) { 314 txq_trans_update(slave_txq); 315 __netif_tx_unlock(slave_txq); 316 master->slaves = NEXT_SLAVE(q); 317 netif_wake_queue(dev); 318 txq->tx_packets++; 319 txq->tx_bytes += length; 320 return NETDEV_TX_OK; 321 } 322 __netif_tx_unlock(slave_txq); 323 } 324 if (netif_queue_stopped(dev)) 325 busy = 1; 326 break; 327 case 1: 328 master->slaves = NEXT_SLAVE(q); 329 return NETDEV_TX_OK; 330 default: 331 nores = 1; 332 break; 333 } 334 __skb_pull(skb, skb_network_offset(skb)); 335 } while ((q = NEXT_SLAVE(q)) != start); 336 337 if (nores && skb_res == NULL) { 338 skb_res = skb; 339 goto restart; 340 } 341 342 if (busy) { 343 netif_stop_queue(dev); 344 return NETDEV_TX_BUSY; 345 } 346 dev->stats.tx_errors++; 347 348 drop: 349 txq->tx_dropped++; 350 dev_kfree_skb(skb); 351 return NETDEV_TX_OK; 352 } 353 354 static int teql_master_open(struct net_device *dev) 355 { 356 struct Qdisc * q; 357 struct teql_master *m = netdev_priv(dev); 358 int mtu = 0xFFFE; 359 unsigned flags = IFF_NOARP|IFF_MULTICAST; 360 361 if (m->slaves == NULL) 362 return -EUNATCH; 363 364 flags = FMASK; 365 366 q = m->slaves; 367 do { 368 struct net_device *slave = qdisc_dev(q); 369 370 if (slave == NULL) 371 return -EUNATCH; 372 373 if (slave->mtu < mtu) 374 mtu = slave->mtu; 375 if (slave->hard_header_len > LL_MAX_HEADER) 376 return -EINVAL; 377 378 /* If all the slaves are BROADCAST, master is BROADCAST 379 If all the slaves are PtP, master is PtP 380 Otherwise, master is NBMA. 381 */ 382 if (!(slave->flags&IFF_POINTOPOINT)) 383 flags &= ~IFF_POINTOPOINT; 384 if (!(slave->flags&IFF_BROADCAST)) 385 flags &= ~IFF_BROADCAST; 386 if (!(slave->flags&IFF_MULTICAST)) 387 flags &= ~IFF_MULTICAST; 388 } while ((q = NEXT_SLAVE(q)) != m->slaves); 389 390 m->dev->mtu = mtu; 391 m->dev->flags = (m->dev->flags&~FMASK) | flags; 392 netif_start_queue(m->dev); 393 return 0; 394 } 395 396 static int teql_master_close(struct net_device *dev) 397 { 398 netif_stop_queue(dev); 399 return 0; 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 const struct net_device_ops teql_netdev_ops = { 423 .ndo_open = teql_master_open, 424 .ndo_stop = teql_master_close, 425 .ndo_start_xmit = teql_master_xmit, 426 .ndo_change_mtu = teql_master_mtu, 427 }; 428 429 static __init void teql_master_setup(struct net_device *dev) 430 { 431 struct teql_master *master = netdev_priv(dev); 432 struct Qdisc_ops *ops = &master->qops; 433 434 master->dev = dev; 435 ops->priv_size = sizeof(struct teql_sched_data); 436 437 ops->enqueue = teql_enqueue; 438 ops->dequeue = teql_dequeue; 439 ops->peek = teql_peek; 440 ops->init = teql_qdisc_init; 441 ops->reset = teql_reset; 442 ops->destroy = teql_destroy; 443 ops->owner = THIS_MODULE; 444 445 dev->netdev_ops = &teql_netdev_ops; 446 dev->type = ARPHRD_VOID; 447 dev->mtu = 1500; 448 dev->tx_queue_len = 100; 449 dev->flags = IFF_NOARP; 450 dev->hard_header_len = LL_MAX_HEADER; 451 } 452 453 static LIST_HEAD(master_dev_list); 454 static int max_equalizers = 1; 455 module_param(max_equalizers, int, 0); 456 MODULE_PARM_DESC(max_equalizers, "Max number of link equalizers"); 457 458 static int __init teql_init(void) 459 { 460 int i; 461 int err = -ENODEV; 462 463 for (i = 0; i < max_equalizers; i++) { 464 struct net_device *dev; 465 struct teql_master *master; 466 467 dev = alloc_netdev(sizeof(struct teql_master), 468 "teql%d", teql_master_setup); 469 if (!dev) { 470 err = -ENOMEM; 471 break; 472 } 473 474 if ((err = register_netdev(dev))) { 475 free_netdev(dev); 476 break; 477 } 478 479 master = netdev_priv(dev); 480 481 strlcpy(master->qops.id, dev->name, IFNAMSIZ); 482 err = register_qdisc(&master->qops); 483 484 if (err) { 485 unregister_netdev(dev); 486 free_netdev(dev); 487 break; 488 } 489 490 list_add_tail(&master->master_list, &master_dev_list); 491 } 492 return i ? 0 : err; 493 } 494 495 static void __exit teql_exit(void) 496 { 497 struct teql_master *master, *nxt; 498 499 list_for_each_entry_safe(master, nxt, &master_dev_list, master_list) { 500 501 list_del(&master->master_list); 502 503 unregister_qdisc(&master->qops); 504 unregister_netdev(master->dev); 505 free_netdev(master->dev); 506 } 507 } 508 509 module_init(teql_init); 510 module_exit(teql_exit); 511 512 MODULE_LICENSE("GPL"); 513