net/sched/sch_netem.c

   1 /*
   2  * net/sched/sch_netem.c        Network emulator
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  *              Many of the algorithms and ideas for this came from
  10  *              NIST Net which is not copyrighted.
  11  *
  12  * Authors:     Stephen Hemminger <shemminger@osdl.org>
  13  *              Catalin(ux aka Dino) BOIE <catab at umbrella dot ro>
  14  */
  15
  16 #include <linux/config.h>
  17 #include <linux/module.h>
  18 #include <linux/bitops.h>
  19 #include <linux/types.h>
  20 #include <linux/kernel.h>
  21 #include <linux/errno.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/skbuff.h>
  24 #include <linux/rtnetlink.h>
  25
  26 #include <net/pkt_sched.h>
  27
  28 /*      Network Emulation Queuing algorithm.
  29         ====================================
  30
  31         Sources: [1] Mark Carson, Darrin Santay, "NIST Net - A Linux-based
  32                  Network Emulation Tool
  33                  [2] Luigi Rizzo, DummyNet for FreeBSD
  34
  35          ----------------------------------------------------------------
  36
  37          This started out as a simple way to delay outgoing packets to
  38          test TCP but has grown to include most of the functionality
  39          of a full blown network emulator like NISTnet. It can delay
  40          packets and add random jitter (and correlation). The random
  41          distribution can be loaded from a table as well to provide
  42          normal, Pareto, or experimental curves. Packet loss,
  43          duplication, and reordering can also be emulated.
  44
  45          This qdisc does not do classification that can be handled in
  46          layering other disciplines.  It does not need to do bandwidth
  47          control either since that can be handled by using token
  48          bucket or other rate control.
  49
  50          The simulator is limited by the Linux timer resolution
  51          and will create packet bursts on the HZ boundary (1ms).
  52 */
  53
  54 struct netem_sched_data {
  55         struct Qdisc    *qdisc;
  56         struct timer_list timer;
  57
  58         u32 latency;
  59         u32 loss;
  60         u32 limit;
  61         u32 counter;
  62         u32 gap;
  63         u32 jitter;
  64         u32 duplicate;
  65         u32 reorder;
  66
  67         struct crndstate {
  68                 unsigned long last;
  69                 unsigned long rho;
  70         } delay_cor, loss_cor, dup_cor, reorder_cor;
  71
  72         struct disttable {
  73                 u32  size;
  74                 s16 table[0];
  75         } *delay_dist;
  76 };
  77
  78 /* Time stamp put into socket buffer control block */
  79 struct netem_skb_cb {
  80         psched_time_t   time_to_send;
  81 };
  82
  83 /* init_crandom - initialize correlated random number generator
  84  * Use entropy source for initial seed.
  85  */
  86 static void init_crandom(struct crndstate *state, unsigned long rho)
  87 {
  88         state->rho = rho;
  89         state->last = net_random();
  90 }
  91
  92 /* get_crandom - correlated random number generator
  93  * Next number depends on last value.
  94  * rho is scaled to avoid floating point.
  95  */
  96 static unsigned long get_crandom(struct crndstate *state)
  97 {
  98         u64 value, rho;
  99         unsigned long answer;
 100
 101         if (state->rho == 0)    /* no correllation */
 102                 return net_random();
 103
 104         value = net_random();
 105         rho = (u64)state->rho + 1;
 106         answer = (value * ((1ull<<32) - rho) + state->last * rho) >> 32;
 107         state->last = answer;
 108         return answer;
 109 }
 110
 111 /* tabledist - return a pseudo-randomly distributed value with mean mu and
 112  * std deviation sigma.  Uses table lookup to approximate the desired
 113  * distribution, and a uniformly-distributed pseudo-random source.
 114  */
 115 static long tabledist(unsigned long mu, long sigma,
 116                       struct crndstate *state, const struct disttable *dist)
 117 {
 118         long t, x;
 119         unsigned long rnd;
 120
 121         if (sigma == 0)
 122                 return mu;
 123
 124         rnd = get_crandom(state);
 125
 126         /* default uniform distribution */
 127         if (dist == NULL)
 128                 return (rnd % (2*sigma)) - sigma + mu;
 129
 130         t = dist->table[rnd % dist->size];
 131         x = (sigma % NETEM_DIST_SCALE) * t;
 132         if (x >= 0)
 133                 x += NETEM_DIST_SCALE/2;
 134         else
 135                 x -= NETEM_DIST_SCALE/2;
 136
 137         return  x / NETEM_DIST_SCALE + (sigma / NETEM_DIST_SCALE) * t + mu;
 138 }
 139
 140 /*
 141  * Insert one skb into qdisc.
 142  * Note: parent depends on return value to account for queue length.
 143  *      NET_XMIT_DROP: queue length didn't change.
 144  *      NET_XMIT_SUCCESS: one skb was queued.
 145  */
 146 static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 147 {
 148         struct netem_sched_data *q = qdisc_priv(sch);
 149         struct netem_skb_cb *cb = (struct netem_skb_cb *)skb->cb;
 150         struct sk_buff *skb2;
 151         int ret;
 152         int count = 1;
 153
 154         pr_debug("netem_enqueue skb=%p\n", skb);
 155
 156         /* Random duplication */
 157         if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor))
 158                 ++count;
 159
 160         /* Random packet drop 0 => none, ~0 => all */
 161         if (q->loss && q->loss >= get_crandom(&q->loss_cor))
 162                 --count;
 163
 164         if (count == 0) {
 165                 sch->qstats.drops++;
 166                 kfree_skb(skb);
 167                 return NET_XMIT_DROP;
 168         }
 169
 170         /*
 171          * If we need to duplicate packet, then re-insert at top of the
 172          * qdisc tree, since parent queuer expects that only one
 173          * skb will be queued.
 174          */
 175         if (count > 1 && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) {
 176                 struct Qdisc *rootq = sch->dev->qdisc;
 177                 u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
 178                 q->duplicate = 0;
 179
 180                 rootq->enqueue(skb2, rootq);
 181                 q->duplicate = dupsave;
 182         }
 183
 184         if (q->gap == 0                 /* not doing reordering */
 185             || q->counter < q->gap      /* inside last reordering gap */
 186             || q->reorder < get_crandom(&q->reorder_cor)) {
 187                 psched_time_t now;
 188                 PSCHED_GET_TIME(now);
 189                 PSCHED_TADD2(now, tabledist(q->latency, q->jitter,
 190                                             &q->delay_cor, q->delay_dist),
 191                              cb->time_to_send);
 192                 ++q->counter;
 193                 ret = q->qdisc->enqueue(skb, q->qdisc);
 194         } else {
 195                 /*
 196                  * Do re-ordering by putting one out of N packets at the front
 197                  * of the queue.
 198                  */
 199                 PSCHED_GET_TIME(cb->time_to_send);
 200                 q->counter = 0;
 201                 ret = q->qdisc->ops->requeue(skb, q->qdisc);
 202         }
 203
 204         if (likely(ret == NET_XMIT_SUCCESS)) {
 205                 sch->q.qlen++;
 206                 sch->bstats.bytes += skb->len;
 207                 sch->bstats.packets++;
 208         } else
 209                 sch->qstats.drops++;
 210
 211         pr_debug("netem: enqueue ret %d\n", ret);
 212         return ret;
 213 }
 214
 215 /* Requeue packets but don't change time stamp */
 216 static int netem_requeue(struct sk_buff *skb, struct Qdisc *sch)
 217 {
 218         struct netem_sched_data *q = qdisc_priv(sch);
 219         int ret;
 220
 221         if ((ret = q->qdisc->ops->requeue(skb, q->qdisc)) == 0) {
 222                 sch->q.qlen++;
 223                 sch->qstats.requeues++;
 224         }
 225
 226         return ret;
 227 }
 228
 229 static unsigned int netem_drop(struct Qdisc* sch)
 230 {
 231         struct netem_sched_data *q = qdisc_priv(sch);
 232         unsigned int len;
 233
 234         if ((len = q->qdisc->ops->drop(q->qdisc)) != 0) {
 235                 sch->q.qlen--;
 236                 sch->qstats.drops++;
 237         }
 238         return len;
 239 }
 240
 241 static struct sk_buff *netem_dequeue(struct Qdisc *sch)
 242 {
 243         struct netem_sched_data *q = qdisc_priv(sch);
 244         struct sk_buff *skb;
 245
 246         skb = q->qdisc->dequeue(q->qdisc);
 247         if (skb) {
 248                 const struct netem_skb_cb *cb
 249                         = (const struct netem_skb_cb *)skb->cb;
 250                 psched_time_t now;
 251                 long delay;
 252
 253                 /* if more time remaining? */
 254                 PSCHED_GET_TIME(now);
 255                 delay = PSCHED_US2JIFFIE(PSCHED_TDIFF(cb->time_to_send, now));
 256                 pr_debug("netem_run: skb=%p delay=%ld\n", skb, delay);
 257                 if (delay <= 0) {
 258                         pr_debug("netem_dequeue: return skb=%p\n", skb);
 259                         sch->q.qlen--;
 260                         sch->flags &= ~TCQ_F_THROTTLED;
 261                         return skb;
 262                 }
 263
 264                 mod_timer(&q->timer, jiffies + delay);
 265                 sch->flags |= TCQ_F_THROTTLED;
 266
 267                 if (q->qdisc->ops->requeue(skb, q->qdisc) != 0)
 268                         sch->qstats.drops++;
 269         }
 270
 271         return NULL;
 272 }
 273
 274 static void netem_watchdog(unsigned long arg)
 275 {
 276         struct Qdisc *sch = (struct Qdisc *)arg;
 277
 278         pr_debug("netem_watchdog qlen=%d\n", sch->q.qlen);
 279         sch->flags &= ~TCQ_F_THROTTLED;
 280         netif_schedule(sch->dev);
 281 }
 282
 283 static void netem_reset(struct Qdisc *sch)
 284 {
 285         struct netem_sched_data *q = qdisc_priv(sch);
 286
 287         qdisc_reset(q->qdisc);
 288         sch->q.qlen = 0;
 289         sch->flags &= ~TCQ_F_THROTTLED;
 290         del_timer_sync(&q->timer);
 291 }
 292
 293 static int set_fifo_limit(struct Qdisc *q, int limit)
 294 {
 295         struct rtattr *rta;
 296         int ret = -ENOMEM;
 297
 298         rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
 299         if (rta) {
 300                 rta->rta_type = RTM_NEWQDISC;
 301                 rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
 302                 ((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;
 303
 304                 ret = q->ops->change(q, rta);
 305                 kfree(rta);
 306         }
 307         return ret;
 308 }
 309
 310 /*
 311  * Distribution data is a variable size payload containing
 312  * signed 16 bit values.
 313  */
 314 static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr)
 315 {
 316         struct netem_sched_data *q = qdisc_priv(sch);
 317         unsigned long n = RTA_PAYLOAD(attr)/sizeof(__s16);
 318         const __s16 *data = RTA_DATA(attr);
 319         struct disttable *d;
 320         int i;
 321
 322         if (n > 65536)
 323                 return -EINVAL;
 324
 325         d = kmalloc(sizeof(*d) + n*sizeof(d->table[0]), GFP_KERNEL);
 326         if (!d)
 327                 return -ENOMEM;
 328
 329         d->size = n;
 330         for (i = 0; i < n; i++)
 331                 d->table[i] = data[i];
 332
 333         spin_lock_bh(&sch->dev->queue_lock);
 334         d = xchg(&q->delay_dist, d);
 335         spin_unlock_bh(&sch->dev->queue_lock);
 336
 337         kfree(d);
 338         return 0;
 339 }
 340
 341 static int get_correlation(struct Qdisc *sch, const struct rtattr *attr)
 342 {
 343         struct netem_sched_data *q = qdisc_priv(sch);
 344         const struct tc_netem_corr *c = RTA_DATA(attr);
 345
 346         if (RTA_PAYLOAD(attr) != sizeof(*c))
 347                 return -EINVAL;
 348
 349         init_crandom(&q->delay_cor, c->delay_corr);
 350         init_crandom(&q->loss_cor, c->loss_corr);
 351         init_crandom(&q->dup_cor, c->dup_corr);
 352         return 0;
 353 }
 354
 355 static int get_reorder(struct Qdisc *sch, const struct rtattr *attr)
 356 {
 357         struct netem_sched_data *q = qdisc_priv(sch);
 358         const struct tc_netem_reorder *r = RTA_DATA(attr);
 359
 360         if (RTA_PAYLOAD(attr) != sizeof(*r))
 361                 return -EINVAL;
 362
 363         q->reorder = r->probability;
 364         init_crandom(&q->reorder_cor, r->correlation);
 365         return 0;
 366 }
 367
 368 static int netem_change(struct Qdisc *sch, struct rtattr *opt)
 369 {
 370         struct netem_sched_data *q = qdisc_priv(sch);
 371         struct tc_netem_qopt *qopt;
 372         int ret;
 373
 374         if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt))
 375                 return -EINVAL;
 376
 377         qopt = RTA_DATA(opt);
 378         ret = set_fifo_limit(q->qdisc, qopt->limit);
 379         if (ret) {
 380                 pr_debug("netem: can't set fifo limit\n");
 381                 return ret;
 382         }
 383
 384         q->latency = qopt->latency;
 385         q->jitter = qopt->jitter;
 386         q->limit = qopt->limit;
 387         q->gap = qopt->gap;
 388         q->counter = 0;
 389         q->loss = qopt->loss;
 390         q->duplicate = qopt->duplicate;
 391
 392         /* for compatiablity with earlier versions.
 393          * if gap is set, need to assume 100% probablity
 394          */
 395         q->reorder = ~0;
 396
 397         /* Handle nested options after initial queue options.
 398          * Should have put all options in nested format but too late now.
 399          */
 400         if (RTA_PAYLOAD(opt) > sizeof(*qopt)) {
 401                 struct rtattr *tb[TCA_NETEM_MAX];
 402                 if (rtattr_parse(tb, TCA_NETEM_MAX,
 403                                  RTA_DATA(opt) + sizeof(*qopt),
 404                                  RTA_PAYLOAD(opt) - sizeof(*qopt)))
 405                         return -EINVAL;
 406
 407                 if (tb[TCA_NETEM_CORR-1]) {
 408                         ret = get_correlation(sch, tb[TCA_NETEM_CORR-1]);
 409                         if (ret)
 410                                 return ret;
 411                 }
 412
 413                 if (tb[TCA_NETEM_DELAY_DIST-1]) {
 414                         ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST-1]);
 415                         if (ret)
 416                                 return ret;
 417                 }
 418                 if (tb[TCA_NETEM_REORDER-1]) {
 419                         ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]);
 420                         if (ret)
 421                                 return ret;
 422                 }
 423         }
 424
 425
 426         return 0;
 427 }
 428
 429 static int netem_init(struct Qdisc *sch, struct rtattr *opt)
 430 {
 431         struct netem_sched_data *q = qdisc_priv(sch);
 432         int ret;
 433
 434         if (!opt)
 435                 return -EINVAL;
 436
 437         init_timer(&q->timer);
 438         q->timer.function = netem_watchdog;
 439         q->timer.data = (unsigned long) sch;
 440
 441         q->qdisc = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops);
 442         if (!q->qdisc) {
 443                 pr_debug("netem: qdisc create failed\n");
 444                 return -ENOMEM;
 445         }
 446
 447         ret = netem_change(sch, opt);
 448         if (ret) {
 449                 pr_debug("netem: change failed\n");
 450                 qdisc_destroy(q->qdisc);
 451         }
 452         return ret;
 453 }
 454
 455 static void netem_destroy(struct Qdisc *sch)
 456 {
 457         struct netem_sched_data *q = qdisc_priv(sch);
 458
 459         del_timer_sync(&q->timer);
 460         qdisc_destroy(q->qdisc);
 461         kfree(q->delay_dist);
 462 }
 463
 464 static int netem_dump(struct Qdisc *sch, struct sk_buff *skb)
 465 {
 466         const struct netem_sched_data *q = qdisc_priv(sch);
 467         unsigned char    *b = skb->tail;
 468         struct rtattr *rta = (struct rtattr *) b;
 469         struct tc_netem_qopt qopt;
 470         struct tc_netem_corr cor;
 471         struct tc_netem_reorder reorder;
 472
 473         qopt.latency = q->latency;
 474         qopt.jitter = q->jitter;
 475         qopt.limit = q->limit;
 476         qopt.loss = q->loss;
 477         qopt.gap = q->gap;
 478         qopt.duplicate = q->duplicate;
 479         RTA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);
 480
 481         cor.delay_corr = q->delay_cor.rho;
 482         cor.loss_corr = q->loss_cor.rho;
 483         cor.dup_corr = q->dup_cor.rho;
 484         RTA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor);
 485
 486         reorder.probability = q->reorder;
 487         reorder.correlation = q->reorder_cor.rho;
 488         RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
 489
 490         rta->rta_len = skb->tail - b;
 491
 492         return skb->len;
 493
 494 rtattr_failure:
 495         skb_trim(skb, b - skb->data);
 496         return -1;
 497 }
 498
 499 static int netem_dump_class(struct Qdisc *sch, unsigned long cl,
 500                           struct sk_buff *skb, struct tcmsg *tcm)
 501 {
 502         struct netem_sched_data *q = qdisc_priv(sch);
 503
 504         if (cl != 1)    /* only one class */
 505                 return -ENOENT;
 506
 507         tcm->tcm_handle |= TC_H_MIN(1);
 508         tcm->tcm_info = q->qdisc->handle;
 509
 510         return 0;
 511 }
 512
 513 static int netem_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
 514                      struct Qdisc **old)
 515 {
 516         struct netem_sched_data *q = qdisc_priv(sch);
 517
 518         if (new == NULL)
 519                 new = &noop_qdisc;
 520
 521         sch_tree_lock(sch);
 522         *old = xchg(&q->qdisc, new);
 523         qdisc_reset(*old);
 524         sch->q.qlen = 0;
 525         sch_tree_unlock(sch);
 526
 527         return 0;
 528 }
 529
 530 static struct Qdisc *netem_leaf(struct Qdisc *sch, unsigned long arg)
 531 {
 532         struct netem_sched_data *q = qdisc_priv(sch);
 533         return q->qdisc;
 534 }
 535
 536 static unsigned long netem_get(struct Qdisc *sch, u32 classid)
 537 {
 538         return 1;
 539 }
 540
 541 static void netem_put(struct Qdisc *sch, unsigned long arg)
 542 {
 543 }
 544
 545 static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
 546                             struct rtattr **tca, unsigned long *arg)
 547 {
 548         return -ENOSYS;
 549 }
 550
 551 static int netem_delete(struct Qdisc *sch, unsigned long arg)
 552 {
 553         return -ENOSYS;
 554 }
 555
 556 static void netem_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 557 {
 558         if (!walker->stop) {
 559                 if (walker->count >= walker->skip)
 560                         if (walker->fn(sch, 1, walker) < 0) {
 561                                 walker->stop = 1;
 562                                 return;
 563                         }
 564                 walker->count++;
 565         }
 566 }
 567
 568 static struct tcf_proto **netem_find_tcf(struct Qdisc *sch, unsigned long cl)
 569 {
 570         return NULL;
 571 }
 572
 573 static struct Qdisc_class_ops netem_class_ops = {
 574         .graft          =       netem_graft,
 575         .leaf           =       netem_leaf,
 576         .get            =       netem_get,
 577         .put            =       netem_put,
 578         .change         =       netem_change_class,
 579         .delete         =       netem_delete,
 580         .walk           =       netem_walk,
 581         .tcf_chain      =       netem_find_tcf,
 582         .dump           =       netem_dump_class,
 583 };
 584
 585 static struct Qdisc_ops netem_qdisc_ops = {
 586         .id             =       "netem",
 587         .cl_ops         =       &netem_class_ops,
 588         .priv_size      =       sizeof(struct netem_sched_data),
 589         .enqueue        =       netem_enqueue,
 590         .dequeue        =       netem_dequeue,
 591         .requeue        =       netem_requeue,
 592         .drop           =       netem_drop,
 593         .init           =       netem_init,
 594         .reset          =       netem_reset,
 595         .destroy        =       netem_destroy,
 596         .change         =       netem_change,
 597         .dump           =       netem_dump,
 598         .owner          =       THIS_MODULE,
 599 };
 600
 601
 602 static int __init netem_module_init(void)
 603 {
 604         return register_qdisc(&netem_qdisc_ops);
 605 }
 606 static void __exit netem_module_exit(void)
 607 {
 608         unregister_qdisc(&netem_qdisc_ops);
 609 }
 610 module_init(netem_module_init)
 611 module_exit(netem_module_exit)
 612 MODULE_LICENSE("GPL");