1 /*
2 * lib/route/sch/netem.c Network Emulator Qdisc
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation version 2.1
7 * of the License.
8 *
9 * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
10 */
11
12 /**
13 * @ingroup qdisc_api
14 * @defgroup netem Network Emulator
15 * @brief
16 *
17 * For further documentation see http://linux-net.osdl.org/index.php/Netem
18 * @{
19 */
20
21 #include <netlink-local.h>
22 #include <netlink-tc.h>
23 #include <netlink/netlink.h>
24 #include <netlink/utils.h>
25 #include <netlink/route/qdisc.h>
26 #include <netlink/route/qdisc-modules.h>
27 #include <netlink/route/sch/netem.h>
28
29 /** @cond SKIP */
30 #define SCH_NETEM_ATTR_LATENCY 0x0001
31 #define SCH_NETEM_ATTR_LIMIT 0x0002
32 #define SCH_NETEM_ATTR_LOSS 0x0004
33 #define SCH_NETEM_ATTR_GAP 0x0008
34 #define SCH_NETEM_ATTR_DUPLICATE 0x0010
35 #define SCH_NETEM_ATTR_JITTER 0x0020
36 #define SCH_NETEM_ATTR_DELAY_CORR 0x0040
37 #define SCH_NETEM_ATTR_LOSS_CORR 0x0080
38 #define SCH_NETEM_ATTR_DUP_CORR 0x0100
39 #define SCH_NETEM_ATTR_RO_PROB 0x0200
40 #define SCH_NETEM_ATTR_RO_CORR 0x0400
41 #define SCH_NETEM_ATTR_CORRUPT_PROB 0x0800
42 #define SCH_NETEM_ATTR_CORRUPT_CORR 0x1000
43 #define SCH_NETEM_ATTR_DIST 0x2000
44 /** @endcond */
45
netem_qdisc(struct rtnl_qdisc * qdisc)46 static inline struct rtnl_netem *netem_qdisc(struct rtnl_qdisc *qdisc)
47 {
48 return (struct rtnl_netem *) qdisc->q_subdata;
49 }
50
netem_alloc(struct rtnl_qdisc * qdisc)51 static inline struct rtnl_netem *netem_alloc(struct rtnl_qdisc *qdisc)
52 {
53 if (!qdisc->q_subdata)
54 qdisc->q_subdata = calloc(1, sizeof(struct rtnl_netem));
55
56 return netem_qdisc(qdisc);
57 }
58
59 static struct nla_policy netem_policy[TCA_NETEM_MAX+1] = {
60 [TCA_NETEM_CORR] = { .minlen = sizeof(struct tc_netem_corr) },
61 [TCA_NETEM_REORDER] = { .minlen = sizeof(struct tc_netem_reorder) },
62 [TCA_NETEM_CORRUPT] = { .minlen = sizeof(struct tc_netem_corrupt) },
63 };
64
netem_msg_parser(struct rtnl_qdisc * qdisc)65 static int netem_msg_parser(struct rtnl_qdisc *qdisc)
66 {
67 int len, err = 0;
68 struct rtnl_netem *netem;
69 struct tc_netem_qopt *opts;
70
71 if (qdisc->q_opts->d_size < sizeof(*opts))
72 return -NLE_INVAL;
73
74 netem = netem_alloc(qdisc);
75 if (!netem)
76 return -NLE_NOMEM;
77
78 opts = (struct tc_netem_qopt *) qdisc->q_opts->d_data;
79 netem->qnm_latency = opts->latency;
80 netem->qnm_limit = opts->limit;
81 netem->qnm_loss = opts->loss;
82 netem->qnm_gap = opts->gap;
83 netem->qnm_duplicate = opts->duplicate;
84 netem->qnm_jitter = opts->jitter;
85
86 netem->qnm_mask = (SCH_NETEM_ATTR_LATENCY | SCH_NETEM_ATTR_LIMIT |
87 SCH_NETEM_ATTR_LOSS | SCH_NETEM_ATTR_GAP |
88 SCH_NETEM_ATTR_DUPLICATE | SCH_NETEM_ATTR_JITTER);
89
90 len = qdisc->q_opts->d_size - sizeof(*opts);
91
92 if (len > 0) {
93 struct nlattr *tb[TCA_NETEM_MAX+1];
94
95 err = nla_parse(tb, TCA_NETEM_MAX, (struct nlattr *)
96 (qdisc->q_opts->d_data + sizeof(*opts)),
97 len, netem_policy);
98 if (err < 0) {
99 free(netem);
100 return err;
101 }
102
103 if (tb[TCA_NETEM_CORR]) {
104 struct tc_netem_corr cor;
105
106 nla_memcpy(&cor, tb[TCA_NETEM_CORR], sizeof(cor));
107 netem->qnm_corr.nmc_delay = cor.delay_corr;
108 netem->qnm_corr.nmc_loss = cor.loss_corr;
109 netem->qnm_corr.nmc_duplicate = cor.dup_corr;
110
111 netem->qnm_mask |= (SCH_NETEM_ATTR_DELAY_CORR |
112 SCH_NETEM_ATTR_LOSS_CORR |
113 SCH_NETEM_ATTR_DUP_CORR);
114 }
115
116 if (tb[TCA_NETEM_REORDER]) {
117 struct tc_netem_reorder ro;
118
119 nla_memcpy(&ro, tb[TCA_NETEM_REORDER], sizeof(ro));
120 netem->qnm_ro.nmro_probability = ro.probability;
121 netem->qnm_ro.nmro_correlation = ro.correlation;
122
123 netem->qnm_mask |= (SCH_NETEM_ATTR_RO_PROB |
124 SCH_NETEM_ATTR_RO_CORR);
125 }
126
127 if (tb[TCA_NETEM_CORRUPT]) {
128 struct tc_netem_corrupt corrupt;
129
130 nla_memcpy(&corrupt, tb[TCA_NETEM_CORRUPT], sizeof(corrupt));
131 netem->qnm_crpt.nmcr_probability = corrupt.probability;
132 netem->qnm_crpt.nmcr_correlation = corrupt.correlation;
133
134 netem->qnm_mask |= (SCH_NETEM_ATTR_CORRUPT_PROB |
135 SCH_NETEM_ATTR_CORRUPT_CORR);
136 }
137
138 /* sch_netem does not currently dump TCA_NETEM_DELAY_DIST */
139 netem->qnm_dist.dist_data = NULL;
140 netem->qnm_dist.dist_size = 0;
141 }
142
143 return 0;
144 }
145
netem_free_data(struct rtnl_qdisc * qdisc)146 static void netem_free_data(struct rtnl_qdisc *qdisc)
147 {
148 struct rtnl_netem *netem;
149
150 if ( ! qdisc ) return;
151
152 netem = netem_qdisc(qdisc);
153 if ( ! netem ) return;
154
155 if ( netem->qnm_dist.dist_data )
156 free(netem->qnm_dist.dist_data);
157
158 netem = NULL;
159
160 free (qdisc->q_subdata);
161 }
162
netem_dump_line(struct rtnl_qdisc * qdisc,struct nl_dump_params * p)163 static void netem_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
164 {
165 struct rtnl_netem *netem = netem_qdisc(qdisc);
166
167 if (netem)
168 nl_dump(p, "limit %d", netem->qnm_limit);
169 }
170
netem_build_msg(struct rtnl_qdisc * qdisc,struct nl_msg * msg)171 int netem_build_msg(struct rtnl_qdisc *qdisc, struct nl_msg *msg)
172 {
173 int err = 0;
174 struct tc_netem_qopt opts;
175 struct tc_netem_corr cor;
176 struct tc_netem_reorder reorder;
177 struct tc_netem_corrupt corrupt;
178 struct rtnl_netem *netem;
179
180 unsigned char set_correlation = 0, set_reorder = 0,
181 set_corrupt = 0, set_dist = 0;
182
183 memset(&opts, 0, sizeof(opts));
184 memset(&cor, 0, sizeof(cor));
185 memset(&reorder, 0, sizeof(reorder));
186 memset(&corrupt, 0, sizeof(corrupt));
187
188 netem = netem_qdisc(qdisc);
189 if (!netem || !msg)
190 return EFAULT;
191
192 msg->nm_nlh->nlmsg_flags |= NLM_F_REQUEST;
193
194 if ( netem->qnm_ro.nmro_probability != 0 ) {
195 if (netem->qnm_latency == 0) {
196 return -NLE_MISSING_ATTR;
197 }
198 if (netem->qnm_gap == 0) netem->qnm_gap = 1;
199 }
200 else if ( netem->qnm_gap ) {
201 return -NLE_MISSING_ATTR;
202 }
203
204 if ( netem->qnm_corr.nmc_delay != 0 ) {
205 if ( netem->qnm_latency == 0 || netem->qnm_jitter == 0) {
206 return -NLE_MISSING_ATTR;
207 }
208 set_correlation = 1;
209 }
210
211 if ( netem->qnm_corr.nmc_loss != 0 ) {
212 if ( netem->qnm_loss == 0 ) {
213 return -NLE_MISSING_ATTR;
214 }
215 set_correlation = 1;
216 }
217
218 if ( netem->qnm_corr.nmc_duplicate != 0 ) {
219 if ( netem->qnm_duplicate == 0 ) {
220 return -NLE_MISSING_ATTR;
221 }
222 set_correlation = 1;
223 }
224
225 if ( netem->qnm_ro.nmro_probability != 0 ) set_reorder = 1;
226 else if ( netem->qnm_ro.nmro_correlation != 0 ) {
227 return -NLE_MISSING_ATTR;
228 }
229
230 if ( netem->qnm_crpt.nmcr_probability != 0 ) set_corrupt = 1;
231 else if ( netem->qnm_crpt.nmcr_correlation != 0 ) {
232 return -NLE_MISSING_ATTR;
233 }
234
235 if ( netem->qnm_dist.dist_data && netem->qnm_dist.dist_size ) {
236 if (netem->qnm_latency == 0 || netem->qnm_jitter == 0) {
237 return -NLE_MISSING_ATTR;
238 }
239 else {
240 /* Resize to accomodate the large distribution table */
241 int new_msg_len = msg->nm_size + netem->qnm_dist.dist_size *
242 sizeof(netem->qnm_dist.dist_data[0]);
243
244 msg->nm_nlh = (struct nlmsghdr *) realloc(msg->nm_nlh, new_msg_len);
245 if ( msg->nm_nlh == NULL )
246 return -NLE_NOMEM;
247 msg->nm_size = new_msg_len;
248 set_dist = 1;
249 }
250 }
251
252 opts.latency = netem->qnm_latency;
253 opts.limit = netem->qnm_limit ? netem->qnm_limit : 1000;
254 opts.loss = netem->qnm_loss;
255 opts.gap = netem->qnm_gap;
256 opts.duplicate = netem->qnm_duplicate;
257 opts.jitter = netem->qnm_jitter;
258
259 NLA_PUT(msg, TCA_OPTIONS, sizeof(opts), &opts);
260
261 if ( set_correlation ) {
262 cor.delay_corr = netem->qnm_corr.nmc_delay;
263 cor.loss_corr = netem->qnm_corr.nmc_loss;
264 cor.dup_corr = netem->qnm_corr.nmc_duplicate;
265
266 NLA_PUT(msg, TCA_NETEM_CORR, sizeof(cor), &cor);
267 }
268
269 if ( set_reorder ) {
270 reorder.probability = netem->qnm_ro.nmro_probability;
271 reorder.correlation = netem->qnm_ro.nmro_correlation;
272
273 NLA_PUT(msg, TCA_NETEM_REORDER, sizeof(reorder), &reorder);
274 }
275
276 if ( set_corrupt ) {
277 corrupt.probability = netem->qnm_crpt.nmcr_probability;
278 corrupt.correlation = netem->qnm_crpt.nmcr_correlation;
279
280 NLA_PUT(msg, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt);
281 }
282
283 if ( set_dist ) {
284 NLA_PUT(msg, TCA_NETEM_DELAY_DIST,
285 netem->qnm_dist.dist_size * sizeof(netem->qnm_dist.dist_data[0]),
286 netem->qnm_dist.dist_data);
287 }
288
289 /* Length specified in the TCA_OPTIONS section must span the entire
290 * remainder of the message. That's just the way that sch_netem expects it.
291 * Maybe there's a more succinct way to do this at a higher level.
292 */
293 struct nlattr* head = (struct nlattr *)(NLMSG_DATA(msg->nm_nlh) +
294 NLMSG_LENGTH(sizeof(struct tcmsg)) - NLMSG_ALIGNTO);
295
296 struct nlattr* tail = (struct nlattr *)(((void *) (msg->nm_nlh)) +
297 NLMSG_ALIGN(msg->nm_nlh->nlmsg_len));
298
299 int old_len = head->nla_len;
300 head->nla_len = (void *)tail - (void *)head;
301 msg->nm_nlh->nlmsg_len += (head->nla_len - old_len);
302
303 return err;
304 nla_put_failure:
305 return -NLE_MSGSIZE;
306 }
307
308 /**
309 * @name Queue Limit
310 * @{
311 */
312
313 /**
314 * Set limit of netem qdisc.
315 * @arg qdisc Netem qdisc to be modified.
316 * @arg limit New limit in bytes.
317 * @return 0 on success or a negative error code.
318 */
rtnl_netem_set_limit(struct rtnl_qdisc * qdisc,int limit)319 int rtnl_netem_set_limit(struct rtnl_qdisc *qdisc, int limit)
320 {
321 struct rtnl_netem *netem;
322
323 netem = netem_alloc(qdisc);
324 if (!netem)
325 return -NLE_NOMEM;
326
327 netem->qnm_limit = limit;
328 netem->qnm_mask |= SCH_NETEM_ATTR_LIMIT;
329
330 return 0;
331 }
332
333 /**
334 * Get limit of netem qdisc.
335 * @arg qdisc Netem qdisc.
336 * @return Limit in bytes or a negative error code.
337 */
rtnl_netem_get_limit(struct rtnl_qdisc * qdisc)338 int rtnl_netem_get_limit(struct rtnl_qdisc *qdisc)
339 {
340 struct rtnl_netem *netem;
341
342 netem = netem_qdisc(qdisc);
343 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_LIMIT))
344 return netem->qnm_limit;
345 else
346 return -NLE_NOATTR;
347 }
348
349 /** @} */
350
351 /**
352 * @name Packet Re-ordering
353 * @{
354 */
355
356 /**
357 * Set re-ordering gap of netem qdisc.
358 * @arg qdisc Netem qdisc to be modified.
359 * @arg gap New gap in number of packets.
360 * @return 0 on success or a negative error code.
361 */
rtnl_netem_set_gap(struct rtnl_qdisc * qdisc,int gap)362 int rtnl_netem_set_gap(struct rtnl_qdisc *qdisc, int gap)
363 {
364 struct rtnl_netem *netem;
365
366 netem = netem_alloc(qdisc);
367 if (!netem)
368 return -NLE_NOMEM;
369
370 netem->qnm_gap = gap;
371 netem->qnm_mask |= SCH_NETEM_ATTR_GAP;
372
373 return 0;
374 }
375
376 /**
377 * Get re-ordering gap of netem qdisc.
378 * @arg qdisc Netem qdisc.
379 * @return Re-ordering gap in packets or a negative error code.
380 */
rtnl_netem_get_gap(struct rtnl_qdisc * qdisc)381 int rtnl_netem_get_gap(struct rtnl_qdisc *qdisc)
382 {
383 struct rtnl_netem *netem;
384
385 netem = netem_qdisc(qdisc);
386 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_GAP))
387 return netem->qnm_gap;
388 else
389 return -NLE_NOATTR;
390 }
391
392 /**
393 * Set re-ordering probability of netem qdisc.
394 * @arg qdisc Netem qdisc to be modified.
395 * @arg prob New re-ordering probability.
396 * @return 0 on success or a negative error code.
397 */
rtnl_netem_set_reorder_probability(struct rtnl_qdisc * qdisc,int prob)398 int rtnl_netem_set_reorder_probability(struct rtnl_qdisc *qdisc, int prob)
399 {
400 struct rtnl_netem *netem;
401
402 netem = netem_alloc(qdisc);
403 if (!netem)
404 return -NLE_NOMEM;
405
406 netem->qnm_ro.nmro_probability = prob;
407 netem->qnm_mask |= SCH_NETEM_ATTR_RO_PROB;
408
409 return 0;
410 }
411
412 /**
413 * Get re-ordering probability of netem qdisc.
414 * @arg qdisc Netem qdisc.
415 * @return Re-ordering probability or a negative error code.
416 */
rtnl_netem_get_reorder_probability(struct rtnl_qdisc * qdisc)417 int rtnl_netem_get_reorder_probability(struct rtnl_qdisc *qdisc)
418 {
419 struct rtnl_netem *netem;
420
421 netem = netem_qdisc(qdisc);
422 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_RO_PROB))
423 return netem->qnm_ro.nmro_probability;
424 else
425 return -NLE_NOATTR;
426 }
427
428 /**
429 * Set re-order correlation probability of netem qdisc.
430 * @arg qdisc Netem qdisc to be modified.
431 * @arg prob New re-ordering correlation probability.
432 * @return 0 on success or a negative error code.
433 */
rtnl_netem_set_reorder_correlation(struct rtnl_qdisc * qdisc,int prob)434 int rtnl_netem_set_reorder_correlation(struct rtnl_qdisc *qdisc, int prob)
435 {
436 struct rtnl_netem *netem;
437
438 netem = netem_alloc(qdisc);
439 if (!netem)
440 return -NLE_NOMEM;
441
442 netem->qnm_ro.nmro_correlation = prob;
443 netem->qnm_mask |= SCH_NETEM_ATTR_RO_CORR;
444
445 return 0;
446 }
447
448 /**
449 * Get re-ordering correlation probability of netem qdisc.
450 * @arg qdisc Netem qdisc.
451 * @return Re-ordering correlation probability or a negative error code.
452 */
rtnl_netem_get_reorder_correlation(struct rtnl_qdisc * qdisc)453 int rtnl_netem_get_reorder_correlation(struct rtnl_qdisc *qdisc)
454 {
455 struct rtnl_netem *netem;
456
457 netem = netem_qdisc(qdisc);
458 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_RO_CORR))
459 return netem->qnm_ro.nmro_correlation;
460 else
461 return -NLE_NOATTR;
462 }
463
464 /** @} */
465
466 /**
467 * @name Corruption
468 * @{
469 */
470
471 /**
472 * Set corruption probability of netem qdisc.
473 * @arg qdisc Netem qdisc to be modified.
474 * @arg prob New corruption probability.
475 * @return 0 on success or a negative error code.
476 */
rtnl_netem_set_corruption_probability(struct rtnl_qdisc * qdisc,int prob)477 int rtnl_netem_set_corruption_probability(struct rtnl_qdisc *qdisc, int prob)
478 {
479 struct rtnl_netem *netem;
480
481 netem = netem_alloc(qdisc);
482 if (!netem)
483 return -NLE_NOMEM;
484
485 netem->qnm_crpt.nmcr_probability = prob;
486 netem->qnm_mask |= SCH_NETEM_ATTR_CORRUPT_PROB;
487
488 return 0;
489 }
490
491 /**
492 * Get corruption probability of netem qdisc.
493 * @arg qdisc Netem qdisc.
494 * @return Corruption probability or a negative error code.
495 */
rtnl_netem_get_corruption_probability(struct rtnl_qdisc * qdisc)496 int rtnl_netem_get_corruption_probability(struct rtnl_qdisc *qdisc)
497 {
498 struct rtnl_netem *netem;
499
500 netem = netem_qdisc(qdisc);
501 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_PROB))
502 return netem->qnm_crpt.nmcr_probability;
503 else
504 return -NLE_NOATTR;
505 }
506
507 /**
508 * Set corruption correlation probability of netem qdisc.
509 * @arg qdisc Netem qdisc to be modified.
510 * @arg prob New corruption correlation probability.
511 * @return 0 on success or a negative error code.
512 */
rtnl_netem_set_corruption_correlation(struct rtnl_qdisc * qdisc,int prob)513 int rtnl_netem_set_corruption_correlation(struct rtnl_qdisc *qdisc, int prob)
514 {
515 struct rtnl_netem *netem;
516
517 netem = netem_alloc(qdisc);
518 if (!netem)
519 return -NLE_NOMEM;
520
521 netem->qnm_crpt.nmcr_correlation = prob;
522 netem->qnm_mask |= SCH_NETEM_ATTR_CORRUPT_CORR;
523
524 return 0;
525 }
526
527 /**
528 * Get corruption correlation probability of netem qdisc.
529 * @arg qdisc Netem qdisc.
530 * @return Corruption correlation probability or a negative error code.
531 */
rtnl_netem_get_corruption_correlation(struct rtnl_qdisc * qdisc)532 int rtnl_netem_get_corruption_correlation(struct rtnl_qdisc *qdisc)
533 {
534 struct rtnl_netem *netem;
535
536 netem = netem_qdisc(qdisc);
537 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_CORR))
538 return netem->qnm_crpt.nmcr_correlation;
539 else
540 return -NLE_NOATTR;
541 }
542
543 /** @} */
544
545 /**
546 * @name Packet Loss
547 * @{
548 */
549
550 /**
551 * Set packet loss probability of netem qdisc.
552 * @arg qdisc Netem qdisc to be modified.
553 * @arg prob New packet loss probability.
554 * @return 0 on success or a negative error code.
555 */
rtnl_netem_set_loss(struct rtnl_qdisc * qdisc,int prob)556 int rtnl_netem_set_loss(struct rtnl_qdisc *qdisc, int prob)
557 {
558 struct rtnl_netem *netem;
559
560 netem = netem_alloc(qdisc);
561 if (!netem)
562 return -NLE_NOMEM;
563
564 netem->qnm_loss = prob;
565 netem->qnm_mask |= SCH_NETEM_ATTR_LOSS;
566
567 return 0;
568 }
569
570 /**
571 * Get packet loss probability of netem qdisc.
572 * @arg qdisc Netem qdisc.
573 * @return Packet loss probability or a negative error code.
574 */
rtnl_netem_get_loss(struct rtnl_qdisc * qdisc)575 int rtnl_netem_get_loss(struct rtnl_qdisc *qdisc)
576 {
577 struct rtnl_netem *netem;
578
579 netem = netem_qdisc(qdisc);
580 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_LOSS))
581 return netem->qnm_loss;
582 else
583 return -NLE_NOATTR;
584 }
585
586 /**
587 * Set packet loss correlation probability of netem qdisc.
588 * @arg qdisc Netem qdisc to be modified.
589 * @arg prob New packet loss correlation.
590 * @return 0 on success or a negative error code.
591 */
rtnl_netem_set_loss_correlation(struct rtnl_qdisc * qdisc,int prob)592 int rtnl_netem_set_loss_correlation(struct rtnl_qdisc *qdisc, int prob)
593 {
594 struct rtnl_netem *netem;
595
596 netem = netem_alloc(qdisc);
597 if (!netem)
598 return -NLE_NOMEM;
599
600 netem->qnm_corr.nmc_loss = prob;
601 netem->qnm_mask |= SCH_NETEM_ATTR_LOSS_CORR;
602
603 return 0;
604 }
605
606 /**
607 * Get packet loss correlation probability of netem qdisc.
608 * @arg qdisc Netem qdisc.
609 * @return Packet loss correlation probability or a negative error code.
610 */
rtnl_netem_get_loss_correlation(struct rtnl_qdisc * qdisc)611 int rtnl_netem_get_loss_correlation(struct rtnl_qdisc *qdisc)
612 {
613 struct rtnl_netem *netem;
614
615 netem = netem_qdisc(qdisc);
616 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_LOSS_CORR))
617 return netem->qnm_corr.nmc_loss;
618 else
619 return -NLE_NOATTR;
620 }
621
622 /** @} */
623
624 /**
625 * @name Packet Duplication
626 * @{
627 */
628
629 /**
630 * Set packet duplication probability of netem qdisc.
631 * @arg qdisc Netem qdisc to be modified.
632 * @arg prob New packet duplication probability.
633 * @return 0 on success or a negative error code.
634 */
rtnl_netem_set_duplicate(struct rtnl_qdisc * qdisc,int prob)635 int rtnl_netem_set_duplicate(struct rtnl_qdisc *qdisc, int prob)
636 {
637 struct rtnl_netem *netem;
638
639 netem = netem_alloc(qdisc);
640 if (!netem)
641 return -NLE_NOMEM;
642
643 netem->qnm_duplicate = prob;
644 netem->qnm_mask |= SCH_NETEM_ATTR_DUPLICATE;
645
646 return 0;
647 }
648
649 /**
650 * Get packet duplication probability of netem qdisc.
651 * @arg qdisc Netem qdisc.
652 * @return Packet duplication probability or a negative error code.
653 */
rtnl_netem_get_duplicate(struct rtnl_qdisc * qdisc)654 int rtnl_netem_get_duplicate(struct rtnl_qdisc *qdisc)
655 {
656 struct rtnl_netem *netem;
657
658 netem = netem_qdisc(qdisc);
659 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_DUPLICATE))
660 return netem->qnm_duplicate;
661 else
662 return -NLE_NOATTR;
663 }
664
665 /**
666 * Set packet duplication correlation probability of netem qdisc.
667 * @arg qdisc Netem qdisc to be modified.
668 * @arg prob New packet duplication correlation probability.
669 * @return 0 on sucess or a negative error code.
670 */
rtnl_netem_set_duplicate_correlation(struct rtnl_qdisc * qdisc,int prob)671 int rtnl_netem_set_duplicate_correlation(struct rtnl_qdisc *qdisc, int prob)
672 {
673 struct rtnl_netem *netem;
674
675 netem = netem_alloc(qdisc);
676 if (!netem)
677 return -NLE_NOMEM;
678
679 netem->qnm_corr.nmc_duplicate = prob;
680 netem->qnm_mask |= SCH_NETEM_ATTR_DUP_CORR;
681
682 return 0;
683 }
684
685 /**
686 * Get packet duplication correlation probability of netem qdisc.
687 * @arg qdisc Netem qdisc.
688 * @return Packet duplication correlation probability or a negative error code.
689 */
rtnl_netem_get_duplicate_correlation(struct rtnl_qdisc * qdisc)690 int rtnl_netem_get_duplicate_correlation(struct rtnl_qdisc *qdisc)
691 {
692 struct rtnl_netem *netem;
693
694 netem = netem_qdisc(qdisc);
695 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_DUP_CORR))
696 return netem->qnm_corr.nmc_duplicate;
697 else
698 return -NLE_NOATTR;
699 }
700
701 /** @} */
702
703 /**
704 * @name Packet Delay
705 * @{
706 */
707
708 /**
709 * Set packet delay of netem qdisc.
710 * @arg qdisc Netem qdisc to be modified.
711 * @arg delay New packet delay in micro seconds.
712 * @return 0 on success or a negative error code.
713 */
rtnl_netem_set_delay(struct rtnl_qdisc * qdisc,int delay)714 int rtnl_netem_set_delay(struct rtnl_qdisc *qdisc, int delay)
715 {
716 struct rtnl_netem *netem;
717
718 netem = netem_alloc(qdisc);
719 if (!netem)
720 return -NLE_NOMEM;
721
722 netem->qnm_latency = nl_us2ticks(delay);
723 netem->qnm_mask |= SCH_NETEM_ATTR_LATENCY;
724
725 return 0;
726 }
727
728 /**
729 * Get packet delay of netem qdisc.
730 * @arg qdisc Netem qdisc.
731 * @return Packet delay in micro seconds or a negative error code.
732 */
rtnl_netem_get_delay(struct rtnl_qdisc * qdisc)733 int rtnl_netem_get_delay(struct rtnl_qdisc *qdisc)
734 {
735 struct rtnl_netem *netem;
736
737 netem = netem_qdisc(qdisc);
738 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_LATENCY))
739 return nl_ticks2us(netem->qnm_latency);
740 else
741 return -NLE_NOATTR;
742 }
743
744 /**
745 * Set packet delay jitter of netem qdisc.
746 * @arg qdisc Netem qdisc to be modified.
747 * @arg jitter New packet delay jitter in micro seconds.
748 * @return 0 on success or a negative error code.
749 */
rtnl_netem_set_jitter(struct rtnl_qdisc * qdisc,int jitter)750 int rtnl_netem_set_jitter(struct rtnl_qdisc *qdisc, int jitter)
751 {
752 struct rtnl_netem *netem;
753
754 netem = netem_alloc(qdisc);
755 if (!netem)
756 return -NLE_NOMEM;
757
758 netem->qnm_jitter = nl_us2ticks(jitter);
759 netem->qnm_mask |= SCH_NETEM_ATTR_JITTER;
760
761 return 0;
762 }
763
764 /**
765 * Get packet delay jitter of netem qdisc.
766 * @arg qdisc Netem qdisc.
767 * @return Packet delay jitter in micro seconds or a negative error code.
768 */
rtnl_netem_get_jitter(struct rtnl_qdisc * qdisc)769 int rtnl_netem_get_jitter(struct rtnl_qdisc *qdisc)
770 {
771 struct rtnl_netem *netem;
772
773 netem = netem_qdisc(qdisc);
774 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_JITTER))
775 return nl_ticks2us(netem->qnm_jitter);
776 else
777 return -NLE_NOATTR;
778 }
779
780 /**
781 * Set packet delay correlation probability of netem qdisc.
782 * @arg qdisc Netem qdisc to be modified.
783 * @arg prob New packet delay correlation probability.
784 */
rtnl_netem_set_delay_correlation(struct rtnl_qdisc * qdisc,int prob)785 int rtnl_netem_set_delay_correlation(struct rtnl_qdisc *qdisc, int prob)
786 {
787 struct rtnl_netem *netem;
788
789 netem = netem_alloc(qdisc);
790 if (!netem)
791 return -NLE_NOMEM;
792
793 netem->qnm_corr.nmc_delay = prob;
794 netem->qnm_mask |= SCH_NETEM_ATTR_DELAY_CORR;
795
796 return 0;
797 }
798
799 /**
800 * Get packet delay correlation probability of netem qdisc.
801 * @arg qdisc Netem qdisc.
802 * @return Packet delay correlation probability or a negative error code.
803 */
rtnl_netem_get_delay_correlation(struct rtnl_qdisc * qdisc)804 int rtnl_netem_get_delay_correlation(struct rtnl_qdisc *qdisc)
805 {
806 struct rtnl_netem *netem;
807
808 netem = netem_qdisc(qdisc);
809 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_DELAY_CORR))
810 return netem->qnm_corr.nmc_delay;
811 else
812 return -NLE_NOATTR;
813 }
814
815 /**
816 * Get the size of the distribution table.
817 * @arg qdisc Netem qdisc.
818 * @return Distribution table size or a negative error code.
819 */
rtnl_netem_get_delay_distribution_size(struct rtnl_qdisc * qdisc)820 int rtnl_netem_get_delay_distribution_size(struct rtnl_qdisc *qdisc)
821 {
822 struct rtnl_netem *netem;
823
824 netem = netem_qdisc(qdisc);
825 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_DIST))
826 return netem->qnm_dist.dist_size;
827 else
828 return -NLE_NOATTR;
829 }
830
831 /**
832 * Get a pointer to the distribution table.
833 * @arg qdisc Netem qdisc.
834 * @arg dist_ptr The pointer to set.
835 * @return Negative error code on failure or 0 on success.
836 */
rtnl_netem_get_delay_distribution(struct rtnl_qdisc * qdisc,int16_t ** dist_ptr)837 int rtnl_netem_get_delay_distribution(struct rtnl_qdisc *qdisc, int16_t **dist_ptr)
838 {
839 struct rtnl_netem *netem;
840
841 netem = netem_qdisc(qdisc);
842 if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_DIST)) {
843 *dist_ptr = netem->qnm_dist.dist_data;
844 return 0;
845 }
846 else
847 return -NLE_NOATTR;
848 }
849
850 /**
851 * Set the delay distribution. Latency/jitter must be set before applying.
852 * @arg qdisc Netem qdisc.
853 * @arg dist_type The name of the distribution (type, file, path/file).
854 * @return 0 on success, error code on failure.
855 */
rtnl_netem_set_delay_distribution(struct rtnl_qdisc * qdisc,const char * dist_type)856 int rtnl_netem_set_delay_distribution(struct rtnl_qdisc *qdisc, const char *dist_type) {
857 struct rtnl_netem *netem;
858
859 netem = netem_alloc(qdisc);
860 if (!netem)
861 return -NLE_NOMEM;
862
863 FILE *f = NULL;
864 int i, n = 0;
865 size_t len = 2048;
866 char *line;
867 char name[NAME_MAX];
868 char dist_suffix[] = ".dist";
869
870 /* If the given filename already ends in .dist, don't append it later */
871 char *test_suffix = strstr(dist_type, dist_suffix);
872 if (test_suffix != NULL && strlen(test_suffix) == 5)
873 strcpy(dist_suffix, "");
874
875 /* Check several locations for the dist file */
876 char *test_path[] = { "", "./", "/usr/lib/tc/", "/usr/local/lib/tc/" };
877
878 for (i = 0; i < sizeof(test_path) && f == NULL; i++) {
879 snprintf(name, NAME_MAX, "%s%s%s", test_path[i], dist_type, dist_suffix);
880 f = fopen(name, "r");
881 }
882
883 if ( f == NULL )
884 return -nl_syserr2nlerr(errno);
885
886 netem->qnm_dist.dist_data = (int16_t *) calloc (MAXDIST, sizeof(int16_t));
887
888 line = (char *) calloc (sizeof(char), len + 1);
889
890 while (getline(&line, &len, f) != -1) {
891 char *p, *endp;
892
893 if (*line == '\n' || *line == '#')
894 continue;
895
896 for (p = line; ; p = endp) {
897 long x = strtol(p, &endp, 0);
898 if (endp == p) break;
899
900 if (n >= MAXDIST) {
901 free(line);
902 fclose(f);
903 return -NLE_INVAL;
904 }
905 netem->qnm_dist.dist_data[n++] = x;
906 }
907 }
908
909 free(line);
910
911 netem->qnm_dist.dist_size = n;
912 netem->qnm_mask |= SCH_NETEM_ATTR_DIST;
913
914 fclose(f);
915 return 0;
916 }
917
918 /** @} */
919
920 static struct rtnl_qdisc_ops netem_ops = {
921 .qo_kind = "netem",
922 .qo_msg_parser = netem_msg_parser,
923 .qo_free_data = netem_free_data,
924 .qo_dump[NL_DUMP_LINE] = netem_dump_line,
925 .qo_get_opts = 0,
926 .qo_build_msg = netem_build_msg
927 };
928
netem_init(void)929 static void __init netem_init(void)
930 {
931 rtnl_qdisc_register(&netem_ops);
932 }
933
netem_exit(void)934 static void __exit netem_exit(void)
935 {
936 rtnl_qdisc_unregister(&netem_ops);
937 }
938
939 /** @} */
940