git.oblomov.eu Git - linux-2.6/blob - 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.
   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/module.h>
  17 #include <linux/bitops.h>
  18 #include <linux/types.h>
  19 #include <linux/kernel.h>
  20 #include <linux/errno.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/skbuff.h>
  23 #include <linux/rtnetlink.h>
  24
  25 #include <net/pkt_sched.h>
  26
  27 #define VERSION "1.2"
  28
  29 /*      Network Emulation Queuing algorithm.
  30         ====================================
  31
  32         Sources: [1] Mark Carson, Darrin Santay, "NIST Net - A Linux-based
  33                  Network Emulation Tool
  34                  [2] Luigi Rizzo, DummyNet for FreeBSD
  35
  36          ----------------------------------------------------------------
  37
  38          This started out as a simple way to delay outgoing packets to
  39          test TCP but has grown to include most of the functionality
  40          of a full blown network emulator like NISTnet. It can delay
  41          packets and add random jitter (and correlation). The random
  42          distribution can be loaded from a table as well to provide
  43          normal, Pareto, or experimental curves. Packet loss,
  44          duplication, and reordering can also be emulated.
  45
  46          This qdisc does not do classification that can be handled in
  47          layering other disciplines.  It does not need to do bandwidth
  48          control either since that can be handled by using token
  49          bucket or other rate control.
  50
  51          The simulator is limited by the Linux timer resolution
  52          and will create packet bursts on the HZ boundary (1ms).
  53 */
  54
  55 struct netem_sched_data {
  56         struct Qdisc    *qdisc;
  57         struct timer_list timer;
  58
  59         u32 latency;
  60         u32 loss;
  61         u32 limit;
  62         u32 counter;
  63         u32 gap;
  64         u32 jitter;
  65         u32 duplicate;
  66         u32 reorder;
  67         u32 corrupt;
  68
  69         struct crndstate {
  70                 unsigned long last;
  71                 unsigned long rho;
  72         } delay_cor, loss_cor, dup_cor, reorder_cor, corrupt_cor;
  73
  74         struct disttable {
  75                 u32  size;
  76                 s16 table[0];
  77         } *delay_dist;
  78 };
  79
  80 /* Time stamp put into socket buffer control block */
  81 struct netem_skb_cb {
  82         psched_time_t   time_to_send;
  83 };
  84
  85 /* init_crandom - initialize correlated random number generator
  86  * Use entropy source for initial seed.
  87  */
  88 static void init_crandom(struct crndstate *state, unsigned long rho)
  89 {
  90         state->rho = rho;
  91         state->last = net_random();
  92 }
  93
  94 /* get_crandom - correlated random number generator
  95  * Next number depends on last value.
  96  * rho is scaled to avoid floating point.
  97  */
  98 static unsigned long get_crandom(struct crndstate *state)
  99 {
 100         u64 value, rho;
 101         unsigned long answer;
 102
 103         if (state->rho == 0)    /* no correllation */
 104                 return net_random();
 105
 106         value = net_random();
 107         rho = (u64)state->rho + 1;
 108         answer = (value * ((1ull<<32) - rho) + state->last * rho) >> 32;
 109         state->last = answer;
 110         return answer;
 111 }
 112
 113 /* tabledist - return a pseudo-randomly distributed value with mean mu and
 114  * std deviation sigma.  Uses table lookup to approximate the desired
 115  * distribution, and a uniformly-distributed pseudo-random source.
 116  */
 117 static long tabledist(unsigned long mu, long sigma,
 118                       struct crndstate *state, const struct disttable *dist)
 119 {
 120         long t, x;
 121         unsigned long rnd;
 122
 123         if (sigma == 0)
 124                 return mu;
 125
 126         rnd = get_crandom(state);
 127
 128         /* default uniform distribution */
 129         if (dist == NULL)
 130                 return (rnd % (2*sigma)) - sigma + mu;
 131
 132         t = dist->table[rnd % dist->size];
 133         x = (sigma % NETEM_DIST_SCALE) * t;
 134         if (x >= 0)
 135                 x += NETEM_DIST_SCALE/2;
 136         else
 137                 x -= NETEM_DIST_SCALE/2;
 138
 139         return  x / NETEM_DIST_SCALE + (sigma / NETEM_DIST_SCALE) * t + mu;
 140 }
 141
 142 /*
 143  * Insert one skb into qdisc.
 144  * Note: parent depends on return value to account for queue length.
 145  *      NET_XMIT_DROP: queue length didn't change.
 146  *      NET_XMIT_SUCCESS: one skb was queued.
 147  */
 148 static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 149 {
 150         struct netem_sched_data *q = qdisc_priv(sch);
 151         /* We don't fill cb now as skb_unshare() may invalidate it */
 152         struct netem_skb_cb *cb;
 153         struct sk_buff *skb2;
 154         int ret;
 155         int count = 1;
 156
 157         pr_debug("netem_enqueue skb=%p\n", skb);
 158
 159         /* Random duplication */
 160         if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor))
 161                 ++count;
 162
 163         /* Random packet drop 0 => none, ~0 => all */
 164         if (q->loss && q->loss >= get_crandom(&q->loss_cor))
 165                 --count;
 166
 167         if (count == 0) {
 168                 sch->qstats.drops++;
 169                 kfree_skb(skb);
 170                 return NET_XMIT_BYPASS;
 171         }
 172
 173         skb_orphan(skb);
 174
 175         /*
 176          * If we need to duplicate packet, then re-insert at top of the
 177          * qdisc tree, since parent queuer expects that only one
 178          * skb will be queued.
 179          */
 180         if (count > 1 && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) {
 181                 struct Qdisc *rootq = sch->dev->qdisc;
 182                 u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
 183                 q->duplicate = 0;
 184
 185                 rootq->enqueue(skb2, rootq);
 186                 q->duplicate = dupsave;
 187         }
 188
 189         /*
 190          * Randomized packet corruption.
 191          * Make copy if needed since we are modifying
 192          * If packet is going to be hardware checksummed, then
 193          * do it now in software before we mangle it.
 194          */
 195         if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) {
 196                 if (!(skb = skb_unshare(skb, GFP_ATOMIC))
 197                     || (skb->ip_summed == CHECKSUM_PARTIAL
 198                         && skb_checksum_help(skb))) {
 199                         sch->qstats.drops++;
 200                         return NET_XMIT_DROP;
 201                 }
 202
 203                 skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8);
 204         }
 205
 206         cb = (struct netem_skb_cb *)skb->cb;
 207         if (q->gap == 0                 /* not doing reordering */
 208             || q->counter < q->gap      /* inside last reordering gap */
 209             || q->reorder < get_crandom(&q->reorder_cor)) {
 210                 psched_time_t now;
 211                 psched_tdiff_t delay;
 212
 213                 delay = tabledist(q->latency, q->jitter,
 214                                   &q->delay_cor, q->delay_dist);
 215
 216                 PSCHED_GET_TIME(now);
 217                 PSCHED_TADD2(now, delay, cb->time_to_send);
 218                 ++q->counter;
 219                 ret = q->qdisc->enqueue(skb, q->qdisc);
 220         } else {
 221                 /*
 222                  * Do re-ordering by putting one out of N packets at the front
 223                  * of the queue.
 224                  */
 225                 PSCHED_GET_TIME(cb->time_to_send);
 226                 q->counter = 0;
 227                 ret = q->qdisc->ops->requeue(skb, q->qdisc);
 228         }
 229
 230         if (likely(ret == NET_XMIT_SUCCESS)) {
 231                 sch->q.qlen++;
 232                 sch->bstats.bytes += skb->len;
 233                 sch->bstats.packets++;
 234         } else
 235                 sch->qstats.drops++;
 236
 237         pr_debug("netem: enqueue ret %d\n", ret);
 238         return ret;
 239 }
 240
 241 /* Requeue packets but don't change time stamp */
 242 static int netem_requeue(struct sk_buff *skb, struct Qdisc *sch)
 243 {
 244         struct netem_sched_data *q = qdisc_priv(sch);
 245         int ret;
 246
 247         if ((ret = q->qdisc->ops->requeue(skb, q->qdisc)) == 0) {
 248                 sch->q.qlen++;
 249                 sch->qstats.requeues++;
 250         }
 251
 252         return ret;
 253 }
 254
 255 static unsigned int netem_drop(struct Qdisc* sch)
 256 {
 257         struct netem_sched_data *q = qdisc_priv(sch);
 258         unsigned int len = 0;
 259
 260         if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
 261                 sch->q.qlen--;
 262                 sch->qstats.drops++;
 263         }
 264         return len;
 265 }
 266
 267 static struct sk_buff *netem_dequeue(struct Qdisc *sch)
 268 {
 269         struct netem_sched_data *q = qdisc_priv(sch);
 270         struct sk_buff *skb;
 271
 272         skb = q->qdisc->dequeue(q->qdisc);
 273         if (skb) {
 274                 const struct netem_skb_cb *cb
 275                         = (const struct netem_skb_cb *)skb->cb;
 276                 psched_time_t now;
 277
 278                 /* if more time remaining? */
 279                 PSCHED_GET_TIME(now);
 280
 281                 if (PSCHED_TLESS(cb->time_to_send, now)) {
 282                         pr_debug("netem_dequeue: return skb=%p\n", skb);
 283                         sch->q.qlen--;
 284                         sch->flags &= ~TCQ_F_THROTTLED;
 285                         return skb;
 286                 } else {
 287                         psched_tdiff_t delay = PSCHED_TDIFF(cb->time_to_send, now);
 288
 289                         if (q->qdisc->ops->requeue(skb, q->qdisc) != NET_XMIT_SUCCESS) {
 290                                 sch->qstats.drops++;
 291
 292                                 /* After this qlen is confused */
 293                                 printk(KERN_ERR "netem: queue discpline %s could not requeue\n",
 294                                        q->qdisc->ops->id);
 295
 296                                 sch->q.qlen--;
 297                         }
 298
 299                         mod_timer(&q->timer, jiffies + PSCHED_US2JIFFIE(delay));
 300                         sch->flags |= TCQ_F_THROTTLED;
 301                 }
 302         }
 303
 304         return NULL;
 305 }
 306
 307 static void netem_watchdog(unsigned long arg)
 308 {
 309         struct Qdisc *sch = (struct Qdisc *)arg;
 310
 311         pr_debug("netem_watchdog qlen=%d\n", sch->q.qlen);
 312         sch->flags &= ~TCQ_F_THROTTLED;
 313         netif_schedule(sch->dev);
 314 }
 315
 316 static void netem_reset(struct Qdisc *sch)
 317 {
 318         struct netem_sched_data *q = qdisc_priv(sch);
 319
 320         qdisc_reset(q->qdisc);
 321         sch->q.qlen = 0;
 322         sch->flags &= ~TCQ_F_THROTTLED;
 323         del_timer_sync(&q->timer);
 324 }
 325
 326 /* Pass size change message down to embedded FIFO */
 327 static int set_fifo_limit(struct Qdisc *q, int limit)
 328 {
 329         struct rtattr *rta;
 330         int ret = -ENOMEM;
 331
 332         /* Hack to avoid sending change message to non-FIFO */
 333         if (strncmp(q->ops->id + 1, "fifo", 4) != 0)
 334                 return 0;
 335
 336         rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
 337         if (rta) {
 338                 rta->rta_type = RTM_NEWQDISC;
 339                 rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
 340                 ((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;
 341
 342                 ret = q->ops->change(q, rta);
 343                 kfree(rta);
 344         }
 345         return ret;
 346 }
 347
 348 /*
 349  * Distribution data is a variable size payload containing
 350  * signed 16 bit values.
 351  */
 352 static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr)
 353 {
 354         struct netem_sched_data *q = qdisc_priv(sch);
 355         unsigned long n = RTA_PAYLOAD(attr)/sizeof(__s16);
 356         const __s16 *data = RTA_DATA(attr);
 357         struct disttable *d;
 358         int i;
 359
 360         if (n > 65536)
 361                 return -EINVAL;
 362
 363         d = kmalloc(sizeof(*d) + n*sizeof(d->table[0]), GFP_KERNEL);
 364         if (!d)
 365                 return -ENOMEM;
 366
 367         d->size = n;
 368         for (i = 0; i < n; i++)
 369                 d->table[i] = data[i];
 370
 371         spin_lock_bh(&sch->dev->queue_lock);
 372         d = xchg(&q->delay_dist, d);
 373         spin_unlock_bh(&sch->dev->queue_lock);
 374
 375         kfree(d);
 376         return 0;
 377 }
 378
 379 static int get_correlation(struct Qdisc *sch, const struct rtattr *attr)
 380 {
 381         struct netem_sched_data *q = qdisc_priv(sch);
 382         const struct tc_netem_corr *c = RTA_DATA(attr);
 383
 384         if (RTA_PAYLOAD(attr) != sizeof(*c))
 385                 return -EINVAL;
 386
 387         init_crandom(&q->delay_cor, c->delay_corr);
 388         init_crandom(&q->loss_cor, c->loss_corr);
 389         init_crandom(&q->dup_cor, c->dup_corr);
 390         return 0;
 391 }
 392
 393 static int get_reorder(struct Qdisc *sch, const struct rtattr *attr)
 394 {
 395         struct netem_sched_data *q = qdisc_priv(sch);
 396         const struct tc_netem_reorder *r = RTA_DATA(attr);
 397
 398         if (RTA_PAYLOAD(attr) != sizeof(*r))
 399                 return -EINVAL;
 400
 401         q->reorder = r->probability;
 402         init_crandom(&q->reorder_cor, r->correlation);
 403         return 0;
 404 }
 405
 406 static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr)
 407 {
 408         struct netem_sched_data *q = qdisc_priv(sch);
 409         const struct tc_netem_corrupt *r = RTA_DATA(attr);
 410
 411         if (RTA_PAYLOAD(attr) != sizeof(*r))
 412                 return -EINVAL;
 413
 414         q->corrupt = r->probability;
 415         init_crandom(&q->corrupt_cor, r->correlation);
 416         return 0;
 417 }
 418
 419 /* Parse netlink message to set options */
 420 static int netem_change(struct Qdisc *sch, struct rtattr *opt)
 421 {
 422         struct netem_sched_data *q = qdisc_priv(sch);
 423         struct tc_netem_qopt *qopt;
 424         int ret;
 425
 426         if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt))
 427                 return -EINVAL;
 428
 429         qopt = RTA_DATA(opt);
 430         ret = set_fifo_limit(q->qdisc, qopt->limit);
 431         if (ret) {
 432                 pr_debug("netem: can't set fifo limit\n");
 433                 return ret;
 434         }
 435
 436         q->latency = qopt->latency;
 437         q->jitter = qopt->jitter;
 438         q->limit = qopt->limit;
 439         q->gap = qopt->gap;
 440         q->counter = 0;
 441         q->loss = qopt->loss;
 442         q->duplicate = qopt->duplicate;
 443
 444         /* for compatiablity with earlier versions.
 445          * if gap is set, need to assume 100% probablity
 446          */
 447         q->reorder = ~0;
 448
 449         /* Handle nested options after initial queue options.
 450          * Should have put all options in nested format but too late now.
 451          */
 452         if (RTA_PAYLOAD(opt) > sizeof(*qopt)) {
 453                 struct rtattr *tb[TCA_NETEM_MAX];
 454                 if (rtattr_parse(tb, TCA_NETEM_MAX,
 455                                  RTA_DATA(opt) + sizeof(*qopt),
 456                                  RTA_PAYLOAD(opt) - sizeof(*qopt)))
 457                         return -EINVAL;
 458
 459                 if (tb[TCA_NETEM_CORR-1]) {
 460                         ret = get_correlation(sch, tb[TCA_NETEM_CORR-1]);
 461                         if (ret)
 462                                 return ret;
 463                 }
 464
 465                 if (tb[TCA_NETEM_DELAY_DIST-1]) {
 466                         ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST-1]);
 467                         if (ret)
 468                                 return ret;
 469                 }
 470
 471                 if (tb[TCA_NETEM_REORDER-1]) {
 472                         ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]);
 473                         if (ret)
 474                                 return ret;
 475                 }
 476
 477                 if (tb[TCA_NETEM_CORRUPT-1]) {
 478                         ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT-1]);
 479                         if (ret)
 480                                 return ret;
 481                 }
 482         }
 483
 484         return 0;
 485 }
 486
 487 /*
 488  * Special case version of FIFO queue for use by netem.
 489  * It queues in order based on timestamps in skb's
 490  */
 491 struct fifo_sched_data {
 492         u32 limit;
 493 };
 494
 495 static int tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch)
 496 {
 497         struct fifo_sched_data *q = qdisc_priv(sch);
 498         struct sk_buff_head *list = &sch->q;
 499         const struct netem_skb_cb *ncb
 500                 = (const struct netem_skb_cb *)nskb->cb;
 501         struct sk_buff *skb;
 502
 503         if (likely(skb_queue_len(list) < q->limit)) {
 504                 skb_queue_reverse_walk(list, skb) {
 505                         const struct netem_skb_cb *cb
 506                                 = (const struct netem_skb_cb *)skb->cb;
 507
 508                         if (!PSCHED_TLESS(ncb->time_to_send, cb->time_to_send))
 509                                 break;
 510                 }
 511
 512                 __skb_queue_after(list, skb, nskb);
 513
 514                 sch->qstats.backlog += nskb->len;
 515                 sch->bstats.bytes += nskb->len;
 516                 sch->bstats.packets++;
 517
 518                 return NET_XMIT_SUCCESS;
 519         }
 520
 521         return qdisc_drop(nskb, sch);
 522 }
 523
 524 static int tfifo_init(struct Qdisc *sch, struct rtattr *opt)
 525 {
 526         struct fifo_sched_data *q = qdisc_priv(sch);
 527
 528         if (opt) {
 529                 struct tc_fifo_qopt *ctl = RTA_DATA(opt);
 530                 if (RTA_PAYLOAD(opt) < sizeof(*ctl))
 531                         return -EINVAL;
 532
 533                 q->limit = ctl->limit;
 534         } else
 535                 q->limit = max_t(u32, sch->dev->tx_queue_len, 1);
 536
 537         return 0;
 538 }
 539
 540 static int tfifo_dump(struct Qdisc *sch, struct sk_buff *skb)
 541 {
 542         struct fifo_sched_data *q = qdisc_priv(sch);
 543         struct tc_fifo_qopt opt = { .limit = q->limit };
 544
 545         RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
 546         return skb->len;
 547
 548 rtattr_failure:
 549         return -1;
 550 }
 551
 552 static struct Qdisc_ops tfifo_qdisc_ops = {
 553         .id             =       "tfifo",
 554         .priv_size      =       sizeof(struct fifo_sched_data),
 555         .enqueue        =       tfifo_enqueue,
 556         .dequeue        =       qdisc_dequeue_head,
 557         .requeue        =       qdisc_requeue,
 558         .drop           =       qdisc_queue_drop,
 559         .init           =       tfifo_init,
 560         .reset          =       qdisc_reset_queue,
 561         .change         =       tfifo_init,
 562         .dump           =       tfifo_dump,
 563 };
 564
 565 static int netem_init(struct Qdisc *sch, struct rtattr *opt)
 566 {
 567         struct netem_sched_data *q = qdisc_priv(sch);
 568         int ret;
 569
 570         if (!opt)
 571                 return -EINVAL;
 572
 573         init_timer(&q->timer);
 574         q->timer.function = netem_watchdog;
 575         q->timer.data = (unsigned long) sch;
 576
 577         q->qdisc = qdisc_create_dflt(sch->dev, &tfifo_qdisc_ops);
 578         if (!q->qdisc) {
 579                 pr_debug("netem: qdisc create failed\n");
 580                 return -ENOMEM;
 581         }
 582
 583         ret = netem_change(sch, opt);
 584         if (ret) {
 585                 pr_debug("netem: change failed\n");
 586                 qdisc_destroy(q->qdisc);
 587         }
 588         return ret;
 589 }
 590
 591 static void netem_destroy(struct Qdisc *sch)
 592 {
 593         struct netem_sched_data *q = qdisc_priv(sch);
 594
 595         del_timer_sync(&q->timer);
 596         qdisc_destroy(q->qdisc);
 597         kfree(q->delay_dist);
 598 }
 599
 600 static int netem_dump(struct Qdisc *sch, struct sk_buff *skb)
 601 {
 602         const struct netem_sched_data *q = qdisc_priv(sch);
 603         unsigned char    *b = skb->tail;
 604         struct rtattr *rta = (struct rtattr *) b;
 605         struct tc_netem_qopt qopt;
 606         struct tc_netem_corr cor;
 607         struct tc_netem_reorder reorder;
 608         struct tc_netem_corrupt corrupt;
 609
 610         qopt.latency = q->latency;
 611         qopt.jitter = q->jitter;
 612         qopt.limit = q->limit;
 613         qopt.loss = q->loss;
 614         qopt.gap = q->gap;
 615         qopt.duplicate = q->duplicate;
 616         RTA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);
 617
 618         cor.delay_corr = q->delay_cor.rho;
 619         cor.loss_corr = q->loss_cor.rho;
 620         cor.dup_corr = q->dup_cor.rho;
 621         RTA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor);
 622
 623         reorder.probability = q->reorder;
 624         reorder.correlation = q->reorder_cor.rho;
 625         RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
 626
 627         corrupt.probability = q->corrupt;
 628         corrupt.correlation = q->corrupt_cor.rho;
 629         RTA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
 630
 631         rta->rta_len = skb->tail - b;
 632
 633         return skb->len;
 634
 635 rtattr_failure:
 636         skb_trim(skb, b - skb->data);
 637         return -1;
 638 }
 639
 640 static int netem_dump_class(struct Qdisc *sch, unsigned long cl,
 641                           struct sk_buff *skb, struct tcmsg *tcm)
 642 {
 643         struct netem_sched_data *q = qdisc_priv(sch);
 644
 645         if (cl != 1)    /* only one class */
 646                 return -ENOENT;
 647
 648         tcm->tcm_handle |= TC_H_MIN(1);
 649         tcm->tcm_info = q->qdisc->handle;
 650
 651         return 0;
 652 }
 653
 654 static int netem_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
 655                      struct Qdisc **old)
 656 {
 657         struct netem_sched_data *q = qdisc_priv(sch);
 658
 659         if (new == NULL)
 660                 new = &noop_qdisc;
 661
 662         sch_tree_lock(sch);
 663         *old = xchg(&q->qdisc, new);
 664         qdisc_reset(*old);
 665         sch->q.qlen = 0;
 666         sch_tree_unlock(sch);
 667
 668         return 0;
 669 }
 670
 671 static struct Qdisc *netem_leaf(struct Qdisc *sch, unsigned long arg)
 672 {
 673         struct netem_sched_data *q = qdisc_priv(sch);
 674         return q->qdisc;
 675 }
 676
 677 static unsigned long netem_get(struct Qdisc *sch, u32 classid)
 678 {
 679         return 1;
 680 }
 681
 682 static void netem_put(struct Qdisc *sch, unsigned long arg)
 683 {
 684 }
 685
 686 static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
 687                             struct rtattr **tca, unsigned long *arg)
 688 {
 689         return -ENOSYS;
 690 }
 691
 692 static int netem_delete(struct Qdisc *sch, unsigned long arg)
 693 {
 694         return -ENOSYS;
 695 }
 696
 697 static void netem_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 698 {
 699         if (!walker->stop) {
 700                 if (walker->count >= walker->skip)
 701                         if (walker->fn(sch, 1, walker) < 0) {
 702                                 walker->stop = 1;
 703                                 return;
 704                         }
 705                 walker->count++;
 706         }
 707 }
 708
 709 static struct tcf_proto **netem_find_tcf(struct Qdisc *sch, unsigned long cl)
 710 {
 711         return NULL;
 712 }
 713
 714 static struct Qdisc_class_ops netem_class_ops = {
 715         .graft          =       netem_graft,
 716         .leaf           =       netem_leaf,
 717         .get            =       netem_get,
 718         .put            =       netem_put,
 719         .change         =       netem_change_class,
 720         .delete         =       netem_delete,
 721         .walk           =       netem_walk,
 722         .tcf_chain      =       netem_find_tcf,
 723         .dump           =       netem_dump_class,
 724 };
 725
 726 static struct Qdisc_ops netem_qdisc_ops = {
 727         .id             =       "netem",
 728         .cl_ops         =       &netem_class_ops,
 729         .priv_size      =       sizeof(struct netem_sched_data),
 730         .enqueue        =       netem_enqueue,
 731         .dequeue        =       netem_dequeue,
 732         .requeue        =       netem_requeue,
 733         .drop           =       netem_drop,
 734         .init           =       netem_init,
 735         .reset          =       netem_reset,
 736         .destroy        =       netem_destroy,
 737         .change         =       netem_change,
 738         .dump           =       netem_dump,
 739         .owner          =       THIS_MODULE,
 740 };
 741
 742
 743 static int __init netem_module_init(void)
 744 {
 745         pr_info("netem: version " VERSION "\n");
 746         return register_qdisc(&netem_qdisc_ops);
 747 }
 748 static void __exit netem_module_exit(void)
 749 {
 750         unregister_qdisc(&netem_qdisc_ops);
 751 }
 752 module_init(netem_module_init)
 753 module_exit(netem_module_exit)
 754 MODULE_LICENSE("GPL");