21 #include <netlink-private/netlink.h> 22 #include <netlink-private/tc.h> 23 #include <netlink/netlink.h> 24 #include <netlink/utils.h> 25 #include <netlink-private/route/tc-api.h> 26 #include <netlink/route/qdisc.h> 27 #include <netlink/route/qdisc/netem.h> 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 46 static struct nla_policy netem_policy[TCA_NETEM_MAX+1] = {
47 [TCA_NETEM_CORR] = { .
minlen =
sizeof(
struct tc_netem_corr) },
48 [TCA_NETEM_REORDER] = { .minlen =
sizeof(
struct tc_netem_reorder) },
49 [TCA_NETEM_CORRUPT] = { .minlen =
sizeof(
struct tc_netem_corrupt) },
52 static int netem_msg_parser(
struct rtnl_tc *tc,
void *data)
54 struct rtnl_netem *netem = data;
55 struct tc_netem_qopt *opts;
58 if (tc->tc_opts->d_size <
sizeof(*opts))
61 opts = (
struct tc_netem_qopt *) tc->tc_opts->d_data;
62 netem->qnm_latency = opts->latency;
63 netem->qnm_limit = opts->limit;
64 netem->qnm_loss = opts->loss;
65 netem->qnm_gap = opts->gap;
66 netem->qnm_duplicate = opts->duplicate;
67 netem->qnm_jitter = opts->jitter;
69 netem->qnm_mask = (SCH_NETEM_ATTR_LATENCY | SCH_NETEM_ATTR_LIMIT |
70 SCH_NETEM_ATTR_LOSS | SCH_NETEM_ATTR_GAP |
71 SCH_NETEM_ATTR_DUPLICATE | SCH_NETEM_ATTR_JITTER);
73 len = tc->tc_opts->d_size -
sizeof(*opts);
76 struct nlattr *tb[TCA_NETEM_MAX+1];
78 err =
nla_parse(tb, TCA_NETEM_MAX, (
struct nlattr *)
79 ((
char *) tc->tc_opts->d_data +
sizeof(*opts)),
86 if (tb[TCA_NETEM_CORR]) {
87 struct tc_netem_corr cor;
89 nla_memcpy(&cor, tb[TCA_NETEM_CORR],
sizeof(cor));
90 netem->qnm_corr.nmc_delay = cor.delay_corr;
91 netem->qnm_corr.nmc_loss = cor.loss_corr;
92 netem->qnm_corr.nmc_duplicate = cor.dup_corr;
94 netem->qnm_mask |= (SCH_NETEM_ATTR_DELAY_CORR |
95 SCH_NETEM_ATTR_LOSS_CORR |
96 SCH_NETEM_ATTR_DUP_CORR);
99 if (tb[TCA_NETEM_REORDER]) {
100 struct tc_netem_reorder ro;
102 nla_memcpy(&ro, tb[TCA_NETEM_REORDER],
sizeof(ro));
103 netem->qnm_ro.nmro_probability = ro.probability;
104 netem->qnm_ro.nmro_correlation = ro.correlation;
106 netem->qnm_mask |= (SCH_NETEM_ATTR_RO_PROB |
107 SCH_NETEM_ATTR_RO_CORR);
110 if (tb[TCA_NETEM_CORRUPT]) {
111 struct tc_netem_corrupt corrupt;
113 nla_memcpy(&corrupt, tb[TCA_NETEM_CORRUPT],
sizeof(corrupt));
114 netem->qnm_crpt.nmcr_probability = corrupt.probability;
115 netem->qnm_crpt.nmcr_correlation = corrupt.correlation;
117 netem->qnm_mask |= (SCH_NETEM_ATTR_CORRUPT_PROB |
118 SCH_NETEM_ATTR_CORRUPT_CORR);
122 netem->qnm_dist.dist_data = NULL;
123 netem->qnm_dist.dist_size = 0;
129 static void netem_free_data(
struct rtnl_tc *tc,
void *data)
131 struct rtnl_netem *netem = data;
136 free(netem->qnm_dist.dist_data);
139 static void netem_dump_line(
struct rtnl_tc *tc,
void *data,
142 struct rtnl_netem *netem = data;
145 if (netem->qnm_mask & SCH_NETEM_ATTR_LIMIT && netem->qnm_limit > 0)
146 nl_dump(p,
" limit %dpkts", netem->qnm_limit);
152 static void netem_dump_details(
struct rtnl_tc *tc,
void *data,
155 struct rtnl_netem *netem = data;
159 if (netem->qnm_mask & SCH_NETEM_ATTR_LATENCY && netem->qnm_latency > 0) {
161 nl_dump(p,
" latency %s", buf);
163 if (netem->qnm_mask & SCH_NETEM_ATTR_JITTER && netem->qnm_jitter > 0) {
167 if (netem->qnm_mask & SCH_NETEM_ATTR_DELAY_CORR && netem->qnm_corr.nmc_delay > 0)
168 nl_dump(p,
" %d%", netem->qnm_corr.nmc_delay);
172 if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS && netem->qnm_loss > 0) {
173 nl_dump(p,
" loss %d%", netem->qnm_loss);
175 if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS_CORR && netem->qnm_corr.nmc_loss > 0)
176 nl_dump(p,
" %d%", netem->qnm_corr.nmc_loss);
179 if (netem->qnm_mask & SCH_NETEM_ATTR_DUPLICATE && netem->qnm_duplicate > 0) {
180 nl_dump(p,
" duplicate %d%", netem->qnm_duplicate);
182 if (netem->qnm_mask & SCH_NETEM_ATTR_DUP_CORR && netem->qnm_corr.nmc_duplicate > 0)
183 nl_dump(p,
" %d%", netem->qnm_corr.nmc_duplicate);
186 if (netem->qnm_mask & SCH_NETEM_ATTR_RO_PROB && netem->qnm_ro.nmro_probability > 0) {
187 nl_dump(p,
" reorder %d%", netem->qnm_ro.nmro_probability);
189 if (netem->qnm_mask & SCH_NETEM_ATTR_RO_CORR && netem->qnm_ro.nmro_correlation > 0)
190 nl_dump(p,
" %d%", netem->qnm_ro.nmro_correlation);
192 if (netem->qnm_mask & SCH_NETEM_ATTR_GAP && netem->qnm_gap > 0)
193 nl_dump(p,
" gap %d", netem->qnm_gap);
196 if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_PROB && netem->qnm_crpt.nmcr_probability > 0) {
197 nl_dump(p,
" reorder %d%", netem->qnm_crpt.nmcr_probability);
199 if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_CORR && netem->qnm_crpt.nmcr_correlation > 0)
200 nl_dump(p,
" %d%", netem->qnm_crpt.nmcr_correlation);
205 static int netem_msg_fill_raw(
struct rtnl_tc *tc,
void *data,
209 struct tc_netem_qopt opts;
210 struct tc_netem_corr cor;
211 struct tc_netem_reorder reorder;
212 struct tc_netem_corrupt corrupt;
213 struct rtnl_netem *netem = data;
215 unsigned char set_correlation = 0, set_reorder = 0;
216 unsigned char set_corrupt = 0, set_dist = 0;
225 memset(&opts, 0,
sizeof(opts));
226 memset(&cor, 0,
sizeof(cor));
227 memset(&reorder, 0,
sizeof(reorder));
228 memset(&corrupt, 0,
sizeof(corrupt));
230 msg->nm_nlh->nlmsg_flags |= NLM_F_REQUEST;
232 if (netem->qnm_ro.nmro_probability != 0) {
233 if (netem->qnm_latency == 0)
234 return -NLE_MISSING_ATTR;
235 if (netem->qnm_gap == 0)
237 }
else if (netem->qnm_gap)
238 return -NLE_MISSING_ATTR;
240 if (netem->qnm_corr.nmc_delay != 0) {
241 if (netem->qnm_latency == 0 || netem->qnm_jitter == 0)
242 return -NLE_MISSING_ATTR;
246 if (netem->qnm_corr.nmc_loss != 0) {
247 if (netem->qnm_loss == 0)
248 return -NLE_MISSING_ATTR;
252 if (netem->qnm_corr.nmc_duplicate != 0) {
253 if (netem->qnm_duplicate == 0)
254 return -NLE_MISSING_ATTR;
258 if (netem->qnm_ro.nmro_probability != 0)
260 else if (netem->qnm_ro.nmro_correlation != 0)
261 return -NLE_MISSING_ATTR;
263 if (netem->qnm_crpt.nmcr_probability != 0)
265 else if (netem->qnm_crpt.nmcr_correlation != 0)
266 return -NLE_MISSING_ATTR;
268 if (netem->qnm_dist.dist_data && netem->qnm_dist.dist_size) {
269 if (netem->qnm_latency == 0 || netem->qnm_jitter == 0)
270 return -NLE_MISSING_ATTR;
273 int new_msg_len = msg->nm_size + netem->qnm_dist.dist_size *
274 sizeof(netem->qnm_dist.dist_data[0]);
275 struct nlmsghdr *new_nlh = realloc(msg->nm_nlh, new_msg_len);
279 msg->nm_nlh = new_nlh;
280 msg->nm_size = new_msg_len;
285 opts.latency = netem->qnm_latency;
286 opts.limit = netem->qnm_limit ? netem->qnm_limit : 1000;
287 opts.loss = netem->qnm_loss;
288 opts.gap = netem->qnm_gap;
289 opts.duplicate = netem->qnm_duplicate;
290 opts.jitter = netem->qnm_jitter;
292 NLA_PUT(msg, TCA_OPTIONS,
sizeof(opts), &opts);
294 if (set_correlation) {
295 cor.delay_corr = netem->qnm_corr.nmc_delay;
296 cor.loss_corr = netem->qnm_corr.nmc_loss;
297 cor.dup_corr = netem->qnm_corr.nmc_duplicate;
299 NLA_PUT(msg, TCA_NETEM_CORR,
sizeof(cor), &cor);
303 reorder.probability = netem->qnm_ro.nmro_probability;
304 reorder.correlation = netem->qnm_ro.nmro_correlation;
306 NLA_PUT(msg, TCA_NETEM_REORDER,
sizeof(reorder), &reorder);
310 corrupt.probability = netem->qnm_crpt.nmcr_probability;
311 corrupt.correlation = netem->qnm_crpt.nmcr_correlation;
313 NLA_PUT(msg, TCA_NETEM_CORRUPT,
sizeof(corrupt), &corrupt);
317 NLA_PUT(msg, TCA_NETEM_DELAY_DIST,
318 netem->qnm_dist.dist_size *
sizeof(netem->qnm_dist.dist_data[0]),
319 netem->qnm_dist.dist_data);
326 head = (
struct nlattr *)(((
char *) NLMSG_DATA(msg->nm_nlh)) +
327 NLMSG_LENGTH(
sizeof(
struct tcmsg)) - NLMSG_ALIGNTO);
329 tail = (
struct nlattr *)(((
char *) (msg->nm_nlh)) +
330 NLMSG_ALIGN(msg->nm_nlh->nlmsg_len));
332 old_len = head->nla_len;
333 head->nla_len = (
char *)tail - (
char *)head;
334 msg->nm_nlh->nlmsg_len += (head->nla_len - old_len);
354 struct rtnl_netem *netem;
359 netem->qnm_limit = limit;
360 netem->qnm_mask |= SCH_NETEM_ATTR_LIMIT;
370 struct rtnl_netem *netem;
375 if (netem->qnm_mask & SCH_NETEM_ATTR_LIMIT)
376 return netem->qnm_limit;
396 struct rtnl_netem *netem;
401 netem->qnm_gap = gap;
402 netem->qnm_mask |= SCH_NETEM_ATTR_GAP;
412 struct rtnl_netem *netem;
417 if (netem->qnm_mask & SCH_NETEM_ATTR_GAP)
418 return netem->qnm_gap;
431 struct rtnl_netem *netem;
436 netem->qnm_ro.nmro_probability = prob;
437 netem->qnm_mask |= SCH_NETEM_ATTR_RO_PROB;
447 struct rtnl_netem *netem;
452 if (netem->qnm_mask & SCH_NETEM_ATTR_RO_PROB)
453 return netem->qnm_ro.nmro_probability;
466 struct rtnl_netem *netem;
471 netem->qnm_ro.nmro_correlation = prob;
472 netem->qnm_mask |= SCH_NETEM_ATTR_RO_CORR;
482 struct rtnl_netem *netem;
487 if (netem->qnm_mask & SCH_NETEM_ATTR_RO_CORR)
488 return netem->qnm_ro.nmro_correlation;
508 struct rtnl_netem *netem;
513 netem->qnm_crpt.nmcr_probability = prob;
514 netem->qnm_mask |= SCH_NETEM_ATTR_CORRUPT_PROB;
524 struct rtnl_netem *netem;
529 if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_PROB)
530 return netem->qnm_crpt.nmcr_probability;
543 struct rtnl_netem *netem;
548 netem->qnm_crpt.nmcr_correlation = prob;
549 netem->qnm_mask |= SCH_NETEM_ATTR_CORRUPT_CORR;
559 struct rtnl_netem *netem;
564 if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_CORR)
565 return netem->qnm_crpt.nmcr_correlation;
585 struct rtnl_netem *netem;
590 netem->qnm_loss = prob;
591 netem->qnm_mask |= SCH_NETEM_ATTR_LOSS;
601 struct rtnl_netem *netem;
606 if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS)
607 return netem->qnm_loss;
620 struct rtnl_netem *netem;
625 netem->qnm_corr.nmc_loss = prob;
626 netem->qnm_mask |= SCH_NETEM_ATTR_LOSS_CORR;
636 struct rtnl_netem *netem;
641 if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS_CORR)
642 return netem->qnm_corr.nmc_loss;
662 struct rtnl_netem *netem;
667 netem->qnm_duplicate = prob;
668 netem->qnm_mask |= SCH_NETEM_ATTR_DUPLICATE;
678 struct rtnl_netem *netem;
683 if (netem->qnm_mask & SCH_NETEM_ATTR_DUPLICATE)
684 return netem->qnm_duplicate;
697 struct rtnl_netem *netem;
702 netem->qnm_corr.nmc_duplicate = prob;
703 netem->qnm_mask |= SCH_NETEM_ATTR_DUP_CORR;
713 struct rtnl_netem *netem;
718 if (netem->qnm_mask & SCH_NETEM_ATTR_DUP_CORR)
719 return netem->qnm_corr.nmc_duplicate;
739 struct rtnl_netem *netem;
745 netem->qnm_mask |= SCH_NETEM_ATTR_LATENCY;
755 struct rtnl_netem *netem;
760 if (netem->qnm_mask & SCH_NETEM_ATTR_LATENCY)
774 struct rtnl_netem *netem;
780 netem->qnm_mask |= SCH_NETEM_ATTR_JITTER;
790 struct rtnl_netem *netem;
795 if (netem->qnm_mask & SCH_NETEM_ATTR_JITTER)
808 struct rtnl_netem *netem;
813 netem->qnm_corr.nmc_delay = prob;
814 netem->qnm_mask |= SCH_NETEM_ATTR_DELAY_CORR;
824 struct rtnl_netem *netem;
829 if (netem->qnm_mask & SCH_NETEM_ATTR_DELAY_CORR)
830 return netem->qnm_corr.nmc_delay;
842 struct rtnl_netem *netem;
847 if (netem->qnm_mask & SCH_NETEM_ATTR_DIST)
848 return netem->qnm_dist.dist_size;
861 struct rtnl_netem *netem;
866 if (netem->qnm_mask & SCH_NETEM_ATTR_DIST) {
867 *dist_ptr = netem->qnm_dist.dist_data;
879 struct rtnl_netem *netem;
888 new_data = (int16_t *) calloc(len,
sizeof(int16_t));
892 free (netem->qnm_dist.dist_data);
893 netem->qnm_dist.dist_data = new_data;
895 memcpy(netem->qnm_dist.dist_data, data, len *
sizeof(int16_t));
897 netem->qnm_dist.dist_size = len;
898 netem->qnm_mask |= SCH_NETEM_ATTR_DIST;
916 char dist_suffix[] =
".dist";
921 char *test_path[] = {
926 "/usr/local/lib/tc/",
930 test_suffix = strstr(dist_type, dist_suffix);
931 if (test_suffix != NULL && strlen(test_suffix) == 5)
932 strcpy(dist_suffix,
"");
934 for (i = 0; i < ARRAY_SIZE(test_path); i++) {
935 snprintf(name, NAME_MAX,
"%s%s%s", test_path[i], dist_type, dist_suffix);
936 if ((f = fopen(name,
"re")))
941 return -nl_syserr2nlerr(errno);
943 data = (int16_t *) calloc (MAXDIST,
sizeof(int16_t));
945 line = (
char *) calloc (
sizeof(
char), len + 1);
947 while (getline(&line, &len, f) != -1) {
950 if (*line ==
'\n' || *line ==
'#')
953 for (p = line; ; p = endp) {
954 long x = strtol(p, &endp, 0);
955 if (endp == p)
break;
976 static struct rtnl_tc_ops netem_ops = {
978 .to_type = RTNL_TC_TYPE_QDISC,
979 .to_size =
sizeof(
struct rtnl_netem),
980 .to_msg_parser = netem_msg_parser,
981 .to_free_data = netem_free_data,
984 .to_msg_fill_raw = netem_msg_fill_raw,
987 static void __init netem_init(
void)
992 static void __exit netem_exit(
void)
Dump object briefly on one line.
int rtnl_tc_register(struct rtnl_tc_ops *ops)
Register a traffic control module.
int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len, const struct nla_policy *policy)
Create attribute index based on a stream of attributes.
int rtnl_netem_get_gap(struct rtnl_qdisc *qdisc)
Get re-ordering gap of netem qdisc.
void rtnl_netem_set_delay(struct rtnl_qdisc *qdisc, int delay)
Set packet delay of netem qdisc.
Attribute validation policy.
void rtnl_netem_set_limit(struct rtnl_qdisc *qdisc, int limit)
Set limit of netem qdisc.
int rtnl_netem_get_loss(struct rtnl_qdisc *qdisc)
Get packet loss probability of netem qdisc.
int rtnl_netem_get_corruption_probability(struct rtnl_qdisc *qdisc)
Get corruption probability of netem qdisc.
int rtnl_netem_get_delay(struct rtnl_qdisc *qdisc)
Get packet delay of netem qdisc.
char * nl_msec2str(uint64_t msec, char *buf, size_t len)
Convert milliseconds to a character string.
int rtnl_netem_get_reorder_correlation(struct rtnl_qdisc *qdisc)
Get re-ordering correlation probability of netem qdisc.
void rtnl_netem_set_reorder_probability(struct rtnl_qdisc *qdisc, int prob)
Set re-ordering probability of netem qdisc.
int rtnl_netem_set_delay_distribution_data(struct rtnl_qdisc *qdisc, const int16_t *data, size_t len)
Set the delay distribution data.
int rtnl_netem_get_duplicate_correlation(struct rtnl_qdisc *qdisc)
Get packet duplication correlation probability of netem qdisc.
Dump all attributes but no statistics.
void rtnl_netem_set_corruption_correlation(struct rtnl_qdisc *qdisc, int prob)
Set corruption correlation probability of netem qdisc.
int rtnl_netem_get_reorder_probability(struct rtnl_qdisc *qdisc)
Get re-ordering probability of netem qdisc.
int rtnl_netem_get_jitter(struct rtnl_qdisc *qdisc)
Get packet delay jitter of netem qdisc.
int rtnl_netem_get_duplicate(struct rtnl_qdisc *qdisc)
Get packet duplication probability of netem qdisc.
void rtnl_tc_unregister(struct rtnl_tc_ops *ops)
Unregister a traffic control module.
void rtnl_netem_set_duplicate_correlation(struct rtnl_qdisc *qdisc, int prob)
Set packet duplication correlation probability of netem qdisc.
int nla_memcpy(void *dest, const struct nlattr *src, int count)
Copy attribute payload to another memory area.
void rtnl_netem_set_reorder_correlation(struct rtnl_qdisc *qdisc, int prob)
Set re-order correlation probability of netem qdisc.
#define TC_CAST(ptr)
Macro to cast qdisc/class/classifier to tc object.
#define NLA_PUT(msg, attrtype, attrlen, data)
Add unspecific attribute to netlink message.
void rtnl_netem_set_duplicate(struct rtnl_qdisc *qdisc, int prob)
Set packet duplication probability of netem qdisc.
void rtnl_netem_set_loss_correlation(struct rtnl_qdisc *qdisc, int prob)
Set packet loss correlation probability of netem qdisc.
int rtnl_netem_get_delay_distribution_size(struct rtnl_qdisc *qdisc)
Get the size of the distribution table.
int rtnl_netem_get_loss_correlation(struct rtnl_qdisc *qdisc)
Get packet loss correlation probability of netem qdisc.
uint32_t nl_ticks2us(uint32_t ticks)
Convert ticks to micro seconds.
int rtnl_netem_get_limit(struct rtnl_qdisc *qdisc)
Get limit of netem qdisc.
uint16_t minlen
Minimal length of payload required.
void rtnl_netem_set_gap(struct rtnl_qdisc *qdisc, int gap)
Set re-ordering gap of netem qdisc.
void * rtnl_tc_data(struct rtnl_tc *tc)
Return pointer to private data of traffic control object.
void rtnl_netem_set_delay_correlation(struct rtnl_qdisc *qdisc, int prob)
Set packet delay correlation probability of netem qdisc.
uint32_t nl_us2ticks(uint32_t us)
Convert micro seconds to ticks.
int rtnl_netem_get_delay_correlation(struct rtnl_qdisc *qdisc)
Get packet delay correlation probability of netem qdisc.
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
int rtnl_netem_get_corruption_correlation(struct rtnl_qdisc *qdisc)
Get corruption correlation probability of netem qdisc.
void rtnl_netem_set_corruption_probability(struct rtnl_qdisc *qdisc, int prob)
Set corruption probability of netem qdisc.
int rtnl_netem_set_delay_distribution(struct rtnl_qdisc *qdisc, const char *dist_type)
Load the delay distribution from a file.
int rtnl_netem_get_delay_distribution(struct rtnl_qdisc *qdisc, int16_t **dist_ptr)
Get a pointer to the distribution table.
void rtnl_netem_set_jitter(struct rtnl_qdisc *qdisc, int jitter)
Set packet delay jitter of netem qdisc.
void rtnl_netem_set_loss(struct rtnl_qdisc *qdisc, int prob)
Set packet loss probability of netem qdisc.