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