projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'battery' into release
[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/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");
Linux kernel - Deliverables
This page took 0.046985 seconds and 5 git commands to generate.