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