?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
i2c-dev: Drop the client template
[wandboard.git] / net / sched / sch_netem.c
blob45939bafbdf894dfcb61a0ed993d1d79204aa5a8
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/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 /*
174 * If we need to duplicate packet, then re-insert at top of the
175 * qdisc tree, since parent queuer expects that only one
176 * skb will be queued.
177 */
178 if (count > 1 && (skb2 = skb_clone(skb, GFP_ATOMIC)) != NULL) {
179 struct Qdisc *rootq = sch->dev->qdisc;
180 u32 dupsave = q->duplicate; /* prevent duplicating a dup... */
181 q->duplicate = 0;
182
183 rootq->enqueue(skb2, rootq);
184 q->duplicate = dupsave;
185 }
186
187 /*
188 * Randomized packet corruption.
189 * Make copy if needed since we are modifying
190 * If packet is going to be hardware checksummed, then
191 * do it now in software before we mangle it.
192 */
193 if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) {
194 if (!(skb = skb_unshare(skb, GFP_ATOMIC))
195 || (skb->ip_summed == CHECKSUM_PARTIAL
196 && skb_checksum_help(skb))) {
197 sch->qstats.drops++;
198 return NET_XMIT_DROP;
199 }
200
201 skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8);
202 }
203
204 cb = (struct netem_skb_cb *)skb->cb;
205 if (q->gap == 0 /* not doing reordering */
206 || q->counter < q->gap /* inside last reordering gap */
207 || q->reorder < get_crandom(&q->reorder_cor)) {
208 psched_time_t now;
209 psched_tdiff_t delay;
210
211 delay = tabledist(q->latency, q->jitter,
212 &q->delay_cor, q->delay_dist);
213
214 PSCHED_GET_TIME(now);
215 PSCHED_TADD2(now, delay, cb->time_to_send);
216 ++q->counter;
217 ret = q->qdisc->enqueue(skb, q->qdisc);
218 } else {
219 /*
220 * Do re-ordering by putting one out of N packets at the front
221 * of the queue.
222 */
223 PSCHED_GET_TIME(cb->time_to_send);
224 q->counter = 0;
225 ret = q->qdisc->ops->requeue(skb, q->qdisc);
226 }
227
228 if (likely(ret == NET_XMIT_SUCCESS)) {
229 sch->q.qlen++;
230 sch->bstats.bytes += skb->len;
231 sch->bstats.packets++;
232 } else
233 sch->qstats.drops++;
234
235 pr_debug("netem: enqueue ret %d\n", ret);
236 return ret;
237 }
238
239 /* Requeue packets but don't change time stamp */
240 static int netem_requeue(struct sk_buff *skb, struct Qdisc *sch)
241 {
242 struct netem_sched_data *q = qdisc_priv(sch);
243 int ret;
244
245 if ((ret = q->qdisc->ops->requeue(skb, q->qdisc)) == 0) {
246 sch->q.qlen++;
247 sch->qstats.requeues++;
248 }
249
250 return ret;
251 }
252
253 static unsigned int netem_drop(struct Qdisc* sch)
254 {
255 struct netem_sched_data *q = qdisc_priv(sch);
256 unsigned int len = 0;
257
258 if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
259 sch->q.qlen--;
260 sch->qstats.drops++;
261 }
262 return len;
263 }
264
265 static struct sk_buff *netem_dequeue(struct Qdisc *sch)
266 {
267 struct netem_sched_data *q = qdisc_priv(sch);
268 struct sk_buff *skb;
269
270 skb = q->qdisc->dequeue(q->qdisc);
271 if (skb) {
272 const struct netem_skb_cb *cb
273 = (const struct netem_skb_cb *)skb->cb;
274 psched_time_t now;
275
276 /* if more time remaining? */
277 PSCHED_GET_TIME(now);
278
279 if (PSCHED_TLESS(cb->time_to_send, now)) {
280 pr_debug("netem_dequeue: return skb=%p\n", skb);
281 sch->q.qlen--;
282 sch->flags &= ~TCQ_F_THROTTLED;
283 return skb;
284 } else {
285 psched_tdiff_t delay = PSCHED_TDIFF(cb->time_to_send, now);
286
287 if (q->qdisc->ops->requeue(skb, q->qdisc) != NET_XMIT_SUCCESS) {
288 sch->qstats.drops++;
289
290 /* After this qlen is confused */
291 printk(KERN_ERR "netem: queue discpline %s could not requeue\n",
292 q->qdisc->ops->id);
293
294 sch->q.qlen--;
295 }
296
297 mod_timer(&q->timer, jiffies + PSCHED_US2JIFFIE(delay));
298 sch->flags |= TCQ_F_THROTTLED;
299 }
300 }
301
302 return NULL;
303 }
304
305 static void netem_watchdog(unsigned long arg)
306 {
307 struct Qdisc *sch = (struct Qdisc *)arg;
308
309 pr_debug("netem_watchdog qlen=%d\n", sch->q.qlen);
310 sch->flags &= ~TCQ_F_THROTTLED;
311 netif_schedule(sch->dev);
312 }
313
314 static void netem_reset(struct Qdisc *sch)
315 {
316 struct netem_sched_data *q = qdisc_priv(sch);
317
318 qdisc_reset(q->qdisc);
319 sch->q.qlen = 0;
320 sch->flags &= ~TCQ_F_THROTTLED;
321 del_timer_sync(&q->timer);
322 }
323
324 /* Pass size change message down to embedded FIFO */
325 static int set_fifo_limit(struct Qdisc *q, int limit)
326 {
327 struct rtattr *rta;
328 int ret = -ENOMEM;
329
330 /* Hack to avoid sending change message to non-FIFO */
331 if (strncmp(q->ops->id + 1, "fifo", 4) != 0)
332 return 0;
333
334 rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
335 if (rta) {
336 rta->rta_type = RTM_NEWQDISC;
337 rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
338 ((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;
339
340 ret = q->ops->change(q, rta);
341 kfree(rta);
342 }
343 return ret;
344 }
345
346 /*
347 * Distribution data is a variable size payload containing
348 * signed 16 bit values.
349 */
350 static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr)
351 {
352 struct netem_sched_data *q = qdisc_priv(sch);
353 unsigned long n = RTA_PAYLOAD(attr)/sizeof(__s16);
354 const __s16 *data = RTA_DATA(attr);
355 struct disttable *d;
356 int i;
357
358 if (n > 65536)
359 return -EINVAL;
360
361 d = kmalloc(sizeof(*d) + n*sizeof(d->table[0]), GFP_KERNEL);
362 if (!d)
363 return -ENOMEM;
364
365 d->size = n;
366 for (i = 0; i < n; i++)
367 d->table[i] = data[i];
368
369 spin_lock_bh(&sch->dev->queue_lock);
370 d = xchg(&q->delay_dist, d);
371 spin_unlock_bh(&sch->dev->queue_lock);
372
373 kfree(d);
374 return 0;
375 }
376
377 static int get_correlation(struct Qdisc *sch, const struct rtattr *attr)
378 {
379 struct netem_sched_data *q = qdisc_priv(sch);
380 const struct tc_netem_corr *c = RTA_DATA(attr);
381
382 if (RTA_PAYLOAD(attr) != sizeof(*c))
383 return -EINVAL;
384
385 init_crandom(&q->delay_cor, c->delay_corr);
386 init_crandom(&q->loss_cor, c->loss_corr);
387 init_crandom(&q->dup_cor, c->dup_corr);
388 return 0;
389 }
390
391 static int get_reorder(struct Qdisc *sch, const struct rtattr *attr)
392 {
393 struct netem_sched_data *q = qdisc_priv(sch);
394 const struct tc_netem_reorder *r = RTA_DATA(attr);
395
396 if (RTA_PAYLOAD(attr) != sizeof(*r))
397 return -EINVAL;
398
399 q->reorder = r->probability;
400 init_crandom(&q->reorder_cor, r->correlation);
401 return 0;
402 }
403
404 static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr)
405 {
406 struct netem_sched_data *q = qdisc_priv(sch);
407 const struct tc_netem_corrupt *r = RTA_DATA(attr);
408
409 if (RTA_PAYLOAD(attr) != sizeof(*r))
410 return -EINVAL;
411
412 q->corrupt = r->probability;
413 init_crandom(&q->corrupt_cor, r->correlation);
414 return 0;
415 }
416
417 /* Parse netlink message to set options */
418 static int netem_change(struct Qdisc *sch, struct rtattr *opt)
419 {
420 struct netem_sched_data *q = qdisc_priv(sch);
421 struct tc_netem_qopt *qopt;
422 int ret;
423
424 if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt))
425 return -EINVAL;
426
427 qopt = RTA_DATA(opt);
428 ret = set_fifo_limit(q->qdisc, qopt->limit);
429 if (ret) {
430 pr_debug("netem: can't set fifo limit\n");
431 return ret;
432 }
433
434 q->latency = qopt->latency;
435 q->jitter = qopt->jitter;
436 q->limit = qopt->limit;
437 q->gap = qopt->gap;
438 q->counter = 0;
439 q->loss = qopt->loss;
440 q->duplicate = qopt->duplicate;
441
442 /* for compatiablity with earlier versions.
443 * if gap is set, need to assume 100% probablity
444 */
445 q->reorder = ~0;
446
447 /* Handle nested options after initial queue options.
448 * Should have put all options in nested format but too late now.
449 */
450 if (RTA_PAYLOAD(opt) > sizeof(*qopt)) {
451 struct rtattr *tb[TCA_NETEM_MAX];
452 if (rtattr_parse(tb, TCA_NETEM_MAX,
453 RTA_DATA(opt) + sizeof(*qopt),
454 RTA_PAYLOAD(opt) - sizeof(*qopt)))
455 return -EINVAL;
456
457 if (tb[TCA_NETEM_CORR-1]) {
458 ret = get_correlation(sch, tb[TCA_NETEM_CORR-1]);
459 if (ret)
460 return ret;
461 }
462
463 if (tb[TCA_NETEM_DELAY_DIST-1]) {
464 ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST-1]);
465 if (ret)
466 return ret;
467 }
468
469 if (tb[TCA_NETEM_REORDER-1]) {
470 ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]);
471 if (ret)
472 return ret;
473 }
474
475 if (tb[TCA_NETEM_CORRUPT-1]) {
476 ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT-1]);
477 if (ret)
478 return ret;
479 }
480 }
481
482 return 0;
483 }
484
485 /*
486 * Special case version of FIFO queue for use by netem.
487 * It queues in order based on timestamps in skb's
488 */
489 struct fifo_sched_data {
490 u32 limit;
491 };
492
493 static int tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch)
494 {
495 struct fifo_sched_data *q = qdisc_priv(sch);
496 struct sk_buff_head *list = &sch->q;
497 const struct netem_skb_cb *ncb
498 = (const struct netem_skb_cb *)nskb->cb;
499 struct sk_buff *skb;
500
501 if (likely(skb_queue_len(list) < q->limit)) {
502 skb_queue_reverse_walk(list, skb) {
503 const struct netem_skb_cb *cb
504 = (const struct netem_skb_cb *)skb->cb;
505
506 if (!PSCHED_TLESS(ncb->time_to_send, cb->time_to_send))
507 break;
508 }
509
510 __skb_queue_after(list, skb, nskb);
511
512 sch->qstats.backlog += nskb->len;
513 sch->bstats.bytes += nskb->len;
514 sch->bstats.packets++;
515
516 return NET_XMIT_SUCCESS;
517 }
518
519 return qdisc_drop(nskb, sch);
520 }
521
522 static int tfifo_init(struct Qdisc *sch, struct rtattr *opt)
523 {
524 struct fifo_sched_data *q = qdisc_priv(sch);
525
526 if (opt) {
527 struct tc_fifo_qopt *ctl = RTA_DATA(opt);
528 if (RTA_PAYLOAD(opt) < sizeof(*ctl))
529 return -EINVAL;
530
531 q->limit = ctl->limit;
532 } else
533 q->limit = max_t(u32, sch->dev->tx_queue_len, 1);
534
535 return 0;
536 }
537
538 static int tfifo_dump(struct Qdisc *sch, struct sk_buff *skb)
539 {
540 struct fifo_sched_data *q = qdisc_priv(sch);
541 struct tc_fifo_qopt opt = { .limit = q->limit };
542
543 RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
544 return skb->len;
545
546 rtattr_failure:
547 return -1;
548 }
549
550 static struct Qdisc_ops tfifo_qdisc_ops = {
551 .id = "tfifo",
552 .priv_size = sizeof(struct fifo_sched_data),
553 .enqueue = tfifo_enqueue,
554 .dequeue = qdisc_dequeue_head,
555 .requeue = qdisc_requeue,
556 .drop = qdisc_queue_drop,
557 .init = tfifo_init,
558 .reset = qdisc_reset_queue,
559 .change = tfifo_init,
560 .dump = tfifo_dump,
561 };
562
563 static int netem_init(struct Qdisc *sch, struct rtattr *opt)
564 {
565 struct netem_sched_data *q = qdisc_priv(sch);
566 int ret;
567
568 if (!opt)
569 return -EINVAL;
570
571 init_timer(&q->timer);
572 q->timer.function = netem_watchdog;
573 q->timer.data = (unsigned long) sch;
574
575 q->qdisc = qdisc_create_dflt(sch->dev, &tfifo_qdisc_ops);
576 if (!q->qdisc) {
577 pr_debug("netem: qdisc create failed\n");
578 return -ENOMEM;
579 }
580
581 ret = netem_change(sch, opt);
582 if (ret) {
583 pr_debug("netem: change failed\n");
584 qdisc_destroy(q->qdisc);
585 }
586 return ret;
587 }
588
589 static void netem_destroy(struct Qdisc *sch)
590 {
591 struct netem_sched_data *q = qdisc_priv(sch);
592
593 del_timer_sync(&q->timer);
594 qdisc_destroy(q->qdisc);
595 kfree(q->delay_dist);
596 }
597
598 static int netem_dump(struct Qdisc *sch, struct sk_buff *skb)
599 {
600 const struct netem_sched_data *q = qdisc_priv(sch);
601 unsigned char *b = skb->tail;
602 struct rtattr *rta = (struct rtattr *) b;
603 struct tc_netem_qopt qopt;
604 struct tc_netem_corr cor;
605 struct tc_netem_reorder reorder;
606 struct tc_netem_corrupt corrupt;
607
608 qopt.latency = q->latency;
609 qopt.jitter = q->jitter;
610 qopt.limit = q->limit;
611 qopt.loss = q->loss;
612 qopt.gap = q->gap;
613 qopt.duplicate = q->duplicate;
614 RTA_PUT(skb, TCA_OPTIONS, sizeof(qopt), &qopt);
615
616 cor.delay_corr = q->delay_cor.rho;
617 cor.loss_corr = q->loss_cor.rho;
618 cor.dup_corr = q->dup_cor.rho;
619 RTA_PUT(skb, TCA_NETEM_CORR, sizeof(cor), &cor);
620
621 reorder.probability = q->reorder;
622 reorder.correlation = q->reorder_cor.rho;
623 RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
624
625 corrupt.probability = q->corrupt;
626 corrupt.correlation = q->corrupt_cor.rho;
627 RTA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
628
629 rta->rta_len = skb->tail - b;
630
631 return skb->len;
632
633 rtattr_failure:
634 skb_trim(skb, b - skb->data);
635 return -1;
636 }
637
638 static int netem_dump_class(struct Qdisc *sch, unsigned long cl,
639 struct sk_buff *skb, struct tcmsg *tcm)
640 {
641 struct netem_sched_data *q = qdisc_priv(sch);
642
643 if (cl != 1) /* only one class */
644 return -ENOENT;
645
646 tcm->tcm_handle |= TC_H_MIN(1);
647 tcm->tcm_info = q->qdisc->handle;
648
649 return 0;
650 }
651
652 static int netem_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
653 struct Qdisc **old)
654 {
655 struct netem_sched_data *q = qdisc_priv(sch);
656
657 if (new == NULL)
658 new = &noop_qdisc;
659
660 sch_tree_lock(sch);
661 *old = xchg(&q->qdisc, new);
662 qdisc_reset(*old);
663 sch->q.qlen = 0;
664 sch_tree_unlock(sch);
665
666 return 0;
667 }
668
669 static struct Qdisc *netem_leaf(struct Qdisc *sch, unsigned long arg)
670 {
671 struct netem_sched_data *q = qdisc_priv(sch);
672 return q->qdisc;
673 }
674
675 static unsigned long netem_get(struct Qdisc *sch, u32 classid)
676 {
677 return 1;
678 }
679
680 static void netem_put(struct Qdisc *sch, unsigned long arg)
681 {
682 }
683
684 static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
685 struct rtattr **tca, unsigned long *arg)
686 {
687 return -ENOSYS;
688 }
689
690 static int netem_delete(struct Qdisc *sch, unsigned long arg)
691 {
692 return -ENOSYS;
693 }
694
695 static void netem_walk(struct Qdisc *sch, struct qdisc_walker *walker)
696 {
697 if (!walker->stop) {
698 if (walker->count >= walker->skip)
699 if (walker->fn(sch, 1, walker) < 0) {
700 walker->stop = 1;
701 return;
702 }
703 walker->count++;
704 }
705 }
706
707 static struct tcf_proto **netem_find_tcf(struct Qdisc *sch, unsigned long cl)
708 {
709 return NULL;
710 }
711
712 static struct Qdisc_class_ops netem_class_ops = {
713 .graft = netem_graft,
714 .leaf = netem_leaf,
715 .get = netem_get,
716 .put = netem_put,
717 .change = netem_change_class,
718 .delete = netem_delete,
719 .walk = netem_walk,
720 .tcf_chain = netem_find_tcf,
721 .dump = netem_dump_class,
722 };
723
724 static struct Qdisc_ops netem_qdisc_ops = {
725 .id = "netem",
726 .cl_ops = &netem_class_ops,
727 .priv_size = sizeof(struct netem_sched_data),
728 .enqueue = netem_enqueue,
729 .dequeue = netem_dequeue,
730 .requeue = netem_requeue,
731 .drop = netem_drop,
732 .init = netem_init,
733 .reset = netem_reset,
734 .destroy = netem_destroy,
735 .change = netem_change,
736 .dump = netem_dump,
737 .owner = THIS_MODULE,
738 };
739
740
741 static int __init netem_module_init(void)
742 {
743 pr_info("netem: version " VERSION "\n");
744 return register_qdisc(&netem_qdisc_ops);
745 }
746 static void __exit netem_module_exit(void)
747 {
748 unregister_qdisc(&netem_qdisc_ops);
749 }
750 module_init(netem_module_init)
751 module_exit(netem_module_exit)
752 MODULE_LICENSE("GPL");
WandBoard kernel