blob: 79542af9dab1fb3213778011d3222e34bd202e0c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Stephen Hemminger798b6b12006-10-22 20:16:57 -07007 * 2 of the License.
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#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
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -080027#define VERSION "1.2"
Stephen Hemmingereb229c42005-11-03 13:49:01 -080028
Linus Torvalds1da177e2005-04-16 15:20:36 -070029/* 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
55struct netem_sched_data {
56 struct Qdisc *qdisc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 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;
Stephen Hemminger0dca51d2005-05-26 12:55:48 -070066 u32 reorder;
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -080067 u32 corrupt;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
69 struct crndstate {
70 unsigned long last;
71 unsigned long rho;
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -080072 } delay_cor, loss_cor, dup_cor, reorder_cor, corrupt_cor;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74 struct disttable {
75 u32 size;
76 s16 table[0];
77 } *delay_dist;
78};
79
80/* Time stamp put into socket buffer control block */
81struct 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 */
88static 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 */
98static 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 */
117static 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
Stephen Hemminger0afb51e2005-05-26 12:53:49 -0700142/*
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch)
149{
150 struct netem_sched_data *q = qdisc_priv(sch);
Guillaume Chazarain89e1df72006-07-21 14:45:25 -0700151 /* We don't fill cb now as skb_unshare() may invalidate it */
152 struct netem_skb_cb *cb;
Stephen Hemminger0afb51e2005-05-26 12:53:49 -0700153 struct sk_buff *skb2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 int ret;
Stephen Hemminger0afb51e2005-05-26 12:53:49 -0700155 int count = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Stephen Hemminger771018e2005-05-03 16:24:32 -0700157 pr_debug("netem_enqueue skb=%p\n", skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Stephen Hemminger0afb51e2005-05-26 12:53:49 -0700159 /* Random duplication */
160 if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor))
161 ++count;
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 /* Random packet drop 0 => none, ~0 => all */
Stephen Hemminger0afb51e2005-05-26 12:53:49 -0700164 if (q->loss && q->loss >= get_crandom(&q->loss_cor))
165 --count;
166
167 if (count == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 sch->qstats.drops++;
169 kfree_skb(skb);
Stephen Hemminger89bbb0a32006-04-28 12:11:36 -0700170 return NET_XMIT_BYPASS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 }
172
David S. Miller4e8a5202006-10-22 21:00:33 -0700173 skb_orphan(skb);
174
Stephen Hemminger0afb51e2005-05-26 12:53:49 -0700175 /*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Stephen Hemminger0afb51e2005-05-26 12:53:49 -0700185 rootq->enqueue(skb2, rootq);
186 q->duplicate = dupsave;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 }
188
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -0800189 /*
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))
Patrick McHardy84fa7932006-08-29 16:44:56 -0700197 || (skb->ip_summed == CHECKSUM_PARTIAL
198 && skb_checksum_help(skb))) {
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -0800199 sch->qstats.drops++;
200 return NET_XMIT_DROP;
201 }
202
203 skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8);
204 }
205
Guillaume Chazarain89e1df72006-07-21 14:45:25 -0700206 cb = (struct netem_skb_cb *)skb->cb;
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700207 if (q->gap == 0 /* not doing reordering */
208 || q->counter < q->gap /* inside last reordering gap */
209 || q->reorder < get_crandom(&q->reorder_cor)) {
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700210 psched_time_t now;
Stephen Hemminger07aaa112005-11-03 13:43:07 -0800211 psched_tdiff_t delay;
212
213 delay = tabledist(q->latency, q->jitter,
214 &q->delay_cor, q->delay_dist);
215
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700216 PSCHED_GET_TIME(now);
Stephen Hemminger07aaa112005-11-03 13:43:07 -0800217 PSCHED_TADD2(now, delay, cb->time_to_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 ++q->counter;
219 ret = q->qdisc->enqueue(skb, q->qdisc);
220 } else {
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700221 /*
222 * Do re-ordering by putting one out of N packets at the front
223 * of the queue.
224 */
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700225 PSCHED_GET_TIME(cb->time_to_send);
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700226 q->counter = 0;
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700227 ret = q->qdisc->ops->requeue(skb, q->qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
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
Stephen Hemmingerd5d75cd2005-05-03 16:24:57 -0700237 pr_debug("netem: enqueue ret %d\n", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 return ret;
239}
240
241/* Requeue packets but don't change time stamp */
242static 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
255static unsigned int netem_drop(struct Qdisc* sch)
256{
257 struct netem_sched_data *q = qdisc_priv(sch);
Patrick McHardy6d037a22006-03-20 19:00:49 -0800258 unsigned int len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Patrick McHardy6d037a22006-03-20 19:00:49 -0800260 if (q->qdisc->ops->drop && (len = q->qdisc->ops->drop(q->qdisc)) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 sch->q.qlen--;
262 sch->qstats.drops++;
263 }
264 return len;
265}
266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267static 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);
Stephen Hemminger771018e2005-05-03 16:24:32 -0700273 if (skb) {
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700274 const struct netem_skb_cb *cb
275 = (const struct netem_skb_cb *)skb->cb;
276 psched_time_t now;
Stephen Hemminger771018e2005-05-03 16:24:32 -0700277
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700278 /* if more time remaining? */
279 PSCHED_GET_TIME(now);
Stephen Hemminger07aaa112005-11-03 13:43:07 -0800280
281 if (PSCHED_TLESS(cb->time_to_send, now)) {
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700282 pr_debug("netem_dequeue: return skb=%p\n", skb);
283 sch->q.qlen--;
284 sch->flags &= ~TCQ_F_THROTTLED;
285 return skb;
Stephen Hemminger07aaa112005-11-03 13:43:07 -0800286 } 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) {
Patrick McHardye488eaf2006-11-29 17:37:42 -0800290 qdisc_tree_decrease_qlen(q->qdisc, 1);
Stephen Hemminger07aaa112005-11-03 13:43:07 -0800291 sch->qstats.drops++;
Stephen Hemminger07aaa112005-11-03 13:43:07 -0800292 printk(KERN_ERR "netem: queue discpline %s could not requeue\n",
293 q->qdisc->ops->id);
Stephen Hemminger07aaa112005-11-03 13:43:07 -0800294 }
295
296 mod_timer(&q->timer, jiffies + PSCHED_US2JIFFIE(delay));
297 sch->flags |= TCQ_F_THROTTLED;
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700298 }
Stephen Hemminger0f9f32a2005-05-26 12:55:01 -0700299 }
300
301 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302}
303
304static void netem_watchdog(unsigned long arg)
305{
306 struct Qdisc *sch = (struct Qdisc *)arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Stephen Hemminger771018e2005-05-03 16:24:32 -0700308 pr_debug("netem_watchdog qlen=%d\n", sch->q.qlen);
309 sch->flags &= ~TCQ_F_THROTTLED;
310 netif_schedule(sch->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311}
312
313static void netem_reset(struct Qdisc *sch)
314{
315 struct netem_sched_data *q = qdisc_priv(sch);
316
317 qdisc_reset(q->qdisc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 sch->q.qlen = 0;
Stephen Hemminger771018e2005-05-03 16:24:32 -0700319 sch->flags &= ~TCQ_F_THROTTLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 del_timer_sync(&q->timer);
321}
322
Stephen Hemminger300ce172005-10-30 13:47:34 -0800323/* Pass size change message down to embedded FIFO */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324static int set_fifo_limit(struct Qdisc *q, int limit)
325{
326 struct rtattr *rta;
327 int ret = -ENOMEM;
328
Stephen Hemminger300ce172005-10-30 13:47:34 -0800329 /* Hack to avoid sending change message to non-FIFO */
330 if (strncmp(q->ops->id + 1, "fifo", 4) != 0)
331 return 0;
332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 rta = kmalloc(RTA_LENGTH(sizeof(struct tc_fifo_qopt)), GFP_KERNEL);
334 if (rta) {
335 rta->rta_type = RTM_NEWQDISC;
336 rta->rta_len = RTA_LENGTH(sizeof(struct tc_fifo_qopt));
337 ((struct tc_fifo_qopt *)RTA_DATA(rta))->limit = limit;
338
339 ret = q->ops->change(q, rta);
340 kfree(rta);
341 }
342 return ret;
343}
344
345/*
346 * Distribution data is a variable size payload containing
347 * signed 16 bit values.
348 */
349static int get_dist_table(struct Qdisc *sch, const struct rtattr *attr)
350{
351 struct netem_sched_data *q = qdisc_priv(sch);
352 unsigned long n = RTA_PAYLOAD(attr)/sizeof(__s16);
353 const __s16 *data = RTA_DATA(attr);
354 struct disttable *d;
355 int i;
356
357 if (n > 65536)
358 return -EINVAL;
359
360 d = kmalloc(sizeof(*d) + n*sizeof(d->table[0]), GFP_KERNEL);
361 if (!d)
362 return -ENOMEM;
363
364 d->size = n;
365 for (i = 0; i < n; i++)
366 d->table[i] = data[i];
367
368 spin_lock_bh(&sch->dev->queue_lock);
369 d = xchg(&q->delay_dist, d);
370 spin_unlock_bh(&sch->dev->queue_lock);
371
372 kfree(d);
373 return 0;
374}
375
376static int get_correlation(struct Qdisc *sch, const struct rtattr *attr)
377{
378 struct netem_sched_data *q = qdisc_priv(sch);
379 const struct tc_netem_corr *c = RTA_DATA(attr);
380
381 if (RTA_PAYLOAD(attr) != sizeof(*c))
382 return -EINVAL;
383
384 init_crandom(&q->delay_cor, c->delay_corr);
385 init_crandom(&q->loss_cor, c->loss_corr);
386 init_crandom(&q->dup_cor, c->dup_corr);
387 return 0;
388}
389
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700390static int get_reorder(struct Qdisc *sch, const struct rtattr *attr)
391{
392 struct netem_sched_data *q = qdisc_priv(sch);
393 const struct tc_netem_reorder *r = RTA_DATA(attr);
394
395 if (RTA_PAYLOAD(attr) != sizeof(*r))
396 return -EINVAL;
397
398 q->reorder = r->probability;
399 init_crandom(&q->reorder_cor, r->correlation);
400 return 0;
401}
402
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -0800403static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr)
404{
405 struct netem_sched_data *q = qdisc_priv(sch);
406 const struct tc_netem_corrupt *r = RTA_DATA(attr);
407
408 if (RTA_PAYLOAD(attr) != sizeof(*r))
409 return -EINVAL;
410
411 q->corrupt = r->probability;
412 init_crandom(&q->corrupt_cor, r->correlation);
413 return 0;
414}
415
416/* Parse netlink message to set options */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417static int netem_change(struct Qdisc *sch, struct rtattr *opt)
418{
419 struct netem_sched_data *q = qdisc_priv(sch);
420 struct tc_netem_qopt *qopt;
421 int ret;
422
423 if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt))
424 return -EINVAL;
425
426 qopt = RTA_DATA(opt);
427 ret = set_fifo_limit(q->qdisc, qopt->limit);
428 if (ret) {
429 pr_debug("netem: can't set fifo limit\n");
430 return ret;
431 }
432
433 q->latency = qopt->latency;
434 q->jitter = qopt->jitter;
435 q->limit = qopt->limit;
436 q->gap = qopt->gap;
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700437 q->counter = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 q->loss = qopt->loss;
439 q->duplicate = qopt->duplicate;
440
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700441 /* for compatiablity with earlier versions.
442 * if gap is set, need to assume 100% probablity
443 */
444 q->reorder = ~0;
445
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 /* Handle nested options after initial queue options.
447 * Should have put all options in nested format but too late now.
448 */
449 if (RTA_PAYLOAD(opt) > sizeof(*qopt)) {
450 struct rtattr *tb[TCA_NETEM_MAX];
451 if (rtattr_parse(tb, TCA_NETEM_MAX,
452 RTA_DATA(opt) + sizeof(*qopt),
453 RTA_PAYLOAD(opt) - sizeof(*qopt)))
454 return -EINVAL;
455
456 if (tb[TCA_NETEM_CORR-1]) {
457 ret = get_correlation(sch, tb[TCA_NETEM_CORR-1]);
458 if (ret)
459 return ret;
460 }
461
462 if (tb[TCA_NETEM_DELAY_DIST-1]) {
463 ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST-1]);
464 if (ret)
465 return ret;
466 }
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -0800467
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700468 if (tb[TCA_NETEM_REORDER-1]) {
469 ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]);
470 if (ret)
471 return ret;
472 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -0800474 if (tb[TCA_NETEM_CORRUPT-1]) {
475 ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT-1]);
476 if (ret)
477 return ret;
478 }
479 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
481 return 0;
482}
483
Stephen Hemminger300ce172005-10-30 13:47:34 -0800484/*
485 * Special case version of FIFO queue for use by netem.
486 * It queues in order based on timestamps in skb's
487 */
488struct fifo_sched_data {
489 u32 limit;
490};
491
492static int tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch)
493{
494 struct fifo_sched_data *q = qdisc_priv(sch);
495 struct sk_buff_head *list = &sch->q;
496 const struct netem_skb_cb *ncb
497 = (const struct netem_skb_cb *)nskb->cb;
498 struct sk_buff *skb;
499
500 if (likely(skb_queue_len(list) < q->limit)) {
501 skb_queue_reverse_walk(list, skb) {
502 const struct netem_skb_cb *cb
503 = (const struct netem_skb_cb *)skb->cb;
504
Andrea Bittauaa875162005-11-20 13:41:05 -0800505 if (!PSCHED_TLESS(ncb->time_to_send, cb->time_to_send))
Stephen Hemminger300ce172005-10-30 13:47:34 -0800506 break;
507 }
508
509 __skb_queue_after(list, skb, nskb);
510
511 sch->qstats.backlog += nskb->len;
512 sch->bstats.bytes += nskb->len;
513 sch->bstats.packets++;
514
515 return NET_XMIT_SUCCESS;
516 }
517
518 return qdisc_drop(nskb, sch);
519}
520
521static int tfifo_init(struct Qdisc *sch, struct rtattr *opt)
522{
523 struct fifo_sched_data *q = qdisc_priv(sch);
524
525 if (opt) {
526 struct tc_fifo_qopt *ctl = RTA_DATA(opt);
527 if (RTA_PAYLOAD(opt) < sizeof(*ctl))
528 return -EINVAL;
529
530 q->limit = ctl->limit;
531 } else
532 q->limit = max_t(u32, sch->dev->tx_queue_len, 1);
533
534 return 0;
535}
536
537static int tfifo_dump(struct Qdisc *sch, struct sk_buff *skb)
538{
539 struct fifo_sched_data *q = qdisc_priv(sch);
540 struct tc_fifo_qopt opt = { .limit = q->limit };
541
542 RTA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
543 return skb->len;
544
545rtattr_failure:
546 return -1;
547}
548
549static struct Qdisc_ops tfifo_qdisc_ops = {
550 .id = "tfifo",
551 .priv_size = sizeof(struct fifo_sched_data),
552 .enqueue = tfifo_enqueue,
553 .dequeue = qdisc_dequeue_head,
554 .requeue = qdisc_requeue,
555 .drop = qdisc_queue_drop,
556 .init = tfifo_init,
557 .reset = qdisc_reset_queue,
558 .change = tfifo_init,
559 .dump = tfifo_dump,
560};
561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562static int netem_init(struct Qdisc *sch, struct rtattr *opt)
563{
564 struct netem_sched_data *q = qdisc_priv(sch);
565 int ret;
566
567 if (!opt)
568 return -EINVAL;
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 init_timer(&q->timer);
571 q->timer.function = netem_watchdog;
572 q->timer.data = (unsigned long) sch;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Patrick McHardy9f9afec2006-11-29 17:35:18 -0800574 q->qdisc = qdisc_create_dflt(sch->dev, &tfifo_qdisc_ops,
575 TC_H_MAKE(sch->handle, 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 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
589static 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
598static 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;
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700605 struct tc_netem_reorder reorder;
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -0800606 struct tc_netem_corrupt corrupt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
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);
Stephen Hemminger0dca51d2005-05-26 12:55:48 -0700620
621 reorder.probability = q->reorder;
622 reorder.correlation = q->reorder_cor.rho;
623 RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
624
Stephen Hemmingerc865e5d2005-12-21 19:03:44 -0800625 corrupt.probability = q->corrupt;
626 corrupt.correlation = q->corrupt_cor.rho;
627 RTA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
628
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 rta->rta_len = skb->tail - b;
630
631 return skb->len;
632
633rtattr_failure:
634 skb_trim(skb, b - skb->data);
635 return -1;
636}
637
638static 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
652static 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);
Patrick McHardy5e50da02006-11-29 17:36:20 -0800662 qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 qdisc_reset(*old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 sch_tree_unlock(sch);
665
666 return 0;
667}
668
669static 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
675static unsigned long netem_get(struct Qdisc *sch, u32 classid)
676{
677 return 1;
678}
679
680static void netem_put(struct Qdisc *sch, unsigned long arg)
681{
682}
683
684static int netem_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
685 struct rtattr **tca, unsigned long *arg)
686{
687 return -ENOSYS;
688}
689
690static int netem_delete(struct Qdisc *sch, unsigned long arg)
691{
692 return -ENOSYS;
693}
694
695static 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
707static struct tcf_proto **netem_find_tcf(struct Qdisc *sch, unsigned long cl)
708{
709 return NULL;
710}
711
712static 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
724static 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
741static int __init netem_module_init(void)
742{
Stephen Hemmingereb229c42005-11-03 13:49:01 -0800743 pr_info("netem: version " VERSION "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 return register_qdisc(&netem_qdisc_ops);
745}
746static void __exit netem_module_exit(void)
747{
748 unregister_qdisc(&netem_qdisc_ops);
749}
750module_init(netem_module_init)
751module_exit(netem_module_exit)
752MODULE_LICENSE("GPL");