static int tbf_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_TBF_PTAB+1]; struct tc_tbf_qopt *qopt; double buffer, mtu; double latency; SPRINT_BUF(b1); SPRINT_BUF(b2); if (opt == NULL) return 0; memset(tb, 0, sizeof(tb)); parse_rtattr(tb, TCA_TBF_PTAB, RTA_DATA(opt), RTA_PAYLOAD(opt)); if (tb[TCA_TBF_PARMS] == NULL) return -1; qopt = RTA_DATA(tb[TCA_TBF_PARMS]); if (RTA_PAYLOAD(tb[TCA_TBF_PARMS]) < sizeof(*qopt)) return -1; fprintf(f, "rate %s ", sprint_rate(qopt->rate.rate, b1)); buffer = ((double)qopt->rate.rate*tc_core_tick2usec(qopt->buffer))/1000000; if (show_details) { fprintf(f, "burst %s/%u mpu %s ", sprint_size(buffer, b1), 1<<qopt->rate.cell_log, sprint_size(qopt->rate.mpu, b2)); } else { fprintf(f, "burst %s ", sprint_size(buffer, b1)); } if (show_raw) fprintf(f, "[%08x] ", qopt->buffer); if (qopt->peakrate.rate) { fprintf(f, "peakrate %s ", sprint_rate(qopt->peakrate.rate, b1)); if (qopt->mtu || qopt->peakrate.mpu) { mtu = ((double)qopt->peakrate.rate*tc_core_tick2usec(qopt->mtu))/1000000; if (show_details) { fprintf(f, "mtu %s/%u mpu %s ", sprint_size(mtu, b1), 1<<qopt->peakrate.cell_log, sprint_size(qopt->peakrate.mpu, b2)); } else { fprintf(f, "minburst %s ", sprint_size(mtu, b1)); } if (show_raw) fprintf(f, "[%08x] ", qopt->mtu); } } if (show_raw) fprintf(f, "limit %s ", sprint_size(qopt->limit, b1)); latency = 1000000*(qopt->limit/(double)qopt->rate.rate) - tc_core_tick2usec(qopt->buffer); if (qopt->peakrate.rate) { double lat2 = 1000000*(qopt->limit/(double)qopt->peakrate.rate) - tc_core_tick2usec(qopt->mtu); if (lat2 > latency) latency = lat2; } fprintf(f, "lat %s ", sprint_usecs(tc_core_tick2usec(latency), b1)); return 0; }
static int tbf_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_TBF_PTAB+1]; struct tc_tbf_qopt *qopt; double buffer, mtu; double latency; SPRINT_BUF(b1); SPRINT_BUF(b2); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_TBF_PTAB, opt); if (tb[TCA_TBF_PARMS] == NULL) return -1; qopt = RTA_DATA(tb[TCA_TBF_PARMS]); if (RTA_PAYLOAD(tb[TCA_TBF_PARMS]) < sizeof(*qopt)) return -1; fprintf(f, "rate %s ", sprint_rate(qopt->rate.rate, b1)); buffer = tc_calc_xmitsize(qopt->rate.rate, qopt->buffer); if (show_details) { fprintf(f, "burst %s/%u mpu %s ", sprint_size(buffer, b1), 1<<qopt->rate.cell_log, sprint_size(qopt->rate.mpu, b2)); } else { fprintf(f, "burst %s ", sprint_size(buffer, b1)); } if (show_raw) fprintf(f, "[%08x] ", qopt->buffer); if (qopt->peakrate.rate) { fprintf(f, "peakrate %s ", sprint_rate(qopt->peakrate.rate, b1)); if (qopt->mtu || qopt->peakrate.mpu) { mtu = tc_calc_xmitsize(qopt->peakrate.rate, qopt->mtu); if (show_details) { fprintf(f, "mtu %s/%u mpu %s ", sprint_size(mtu, b1), 1<<qopt->peakrate.cell_log, sprint_size(qopt->peakrate.mpu, b2)); } else { fprintf(f, "minburst %s ", sprint_size(mtu, b1)); } if (show_raw) fprintf(f, "[%08x] ", qopt->mtu); } } if (show_raw) fprintf(f, "limit %s ", sprint_size(qopt->limit, b1)); latency = TIME_UNITS_PER_SEC*(qopt->limit/(double)qopt->rate.rate) - tc_core_tick2time(qopt->buffer); if (qopt->peakrate.rate) { double lat2 = TIME_UNITS_PER_SEC*(qopt->limit/(double)qopt->peakrate.rate) - tc_core_tick2time(qopt->mtu); if (lat2 > latency) latency = lat2; } fprintf(f, "lat %s ", sprint_time(latency, b1)); return 0; }
static void hfsc_print_sc(FILE *f, char *name, struct tc_service_curve *sc) { SPRINT_BUF(b1); fprintf(f, "%s ", name); fprintf(f, "m1 %s ", sprint_rate(sc->m1, b1)); fprintf(f, "d %s ", sprint_time(tc_core_ktime2time(sc->d), b1)); fprintf(f, "m2 %s ", sprint_rate(sc->m2, b1)); }
int print_police(struct action_util *a, FILE *f, struct rtattr *arg) { SPRINT_BUF(b1); SPRINT_BUF(b2); struct tc_police *p; struct rtattr *tb[TCA_POLICE_MAX+1]; unsigned buffer; unsigned int linklayer; if (arg == NULL) return 0; parse_rtattr_nested(tb, TCA_POLICE_MAX, arg); if (tb[TCA_POLICE_TBF] == NULL) { fprintf(f, "[NULL police tbf]"); return 0; } #ifndef STOOPID_8BYTE if (RTA_PAYLOAD(tb[TCA_POLICE_TBF]) < sizeof(*p)) { fprintf(f, "[truncated police tbf]"); return -1; } #endif p = RTA_DATA(tb[TCA_POLICE_TBF]); fprintf(f, " police 0x%x ", p->index); fprintf(f, "rate %s ", sprint_rate(p->rate.rate, b1)); buffer = tc_calc_xmitsize(p->rate.rate, p->burst); fprintf(f, "burst %s ", sprint_size(buffer, b1)); fprintf(f, "mtu %s ", sprint_size(p->mtu, b1)); if (show_raw) fprintf(f, "[%08x] ", p->burst); if (p->peakrate.rate) fprintf(f, "peakrate %s ", sprint_rate(p->peakrate.rate, b1)); if (tb[TCA_POLICE_AVRATE]) fprintf(f, "avrate %s ", sprint_rate(rta_getattr_u32(tb[TCA_POLICE_AVRATE]), b1)); fprintf(f, "action %s", police_action_n2a(p->action, b1, sizeof(b1))); if (tb[TCA_POLICE_RESULT]) { fprintf(f, "/%s ", police_action_n2a(*(int*)RTA_DATA(tb[TCA_POLICE_RESULT]), b1, sizeof(b1))); } else fprintf(f, " "); fprintf(f, "overhead %ub ", p->rate.overhead); linklayer = (p->rate.linklayer & TC_LINKLAYER_MASK); if (linklayer > TC_LINKLAYER_ETHERNET || show_details) fprintf(f, "linklayer %s ", sprint_linklayer(linklayer, b2)); fprintf(f, "\nref %d bind %d\n",p->refcnt, p->bindcnt); return 0; }
static int htb_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_HTB_RTAB+1]; struct tc_htb_opt *hopt; struct tc_htb_glob *gopt; double buffer,cbuffer; SPRINT_BUF(b1); SPRINT_BUF(b2); SPRINT_BUF(b3); if (opt == NULL) return 0; memset(tb, 0, sizeof(tb)); parse_rtattr(tb, TCA_HTB_RTAB, RTA_DATA(opt), RTA_PAYLOAD(opt)); if (tb[TCA_HTB_PARMS]) { hopt = RTA_DATA(tb[TCA_HTB_PARMS]); if (RTA_PAYLOAD(tb[TCA_HTB_PARMS]) < sizeof(*hopt)) return -1; if (!hopt->level) { fprintf(f, "prio %d ", (int)hopt->prio); if (show_details) fprintf(f, "quantum %d ", (int)hopt->quantum); } fprintf(f, "rate %s ", sprint_rate(hopt->rate.rate, b1)); buffer = ((double)hopt->rate.rate*tc_core_tick2usec(hopt->buffer))/1000000; fprintf(f, "ceil %s ", sprint_rate(hopt->ceil.rate, b1)); cbuffer = ((double)hopt->ceil.rate*tc_core_tick2usec(hopt->cbuffer))/1000000; if (show_details) { fprintf(f, "burst %s/%u mpu %s overhead %s ", sprint_size(buffer, b1), 1<<hopt->rate.cell_log, sprint_size(hopt->rate.mpu&0xFF, b2), sprint_size((hopt->rate.mpu>>8)&0xFF, b3)); fprintf(f, "cburst %s/%u mpu %s overhead %s ", sprint_size(cbuffer, b1), 1<<hopt->ceil.cell_log, sprint_size(hopt->ceil.mpu&0xFF, b2), sprint_size((hopt->ceil.mpu>>8)&0xFF, b3)); fprintf(f, "level %d ", (int)hopt->level); } else { fprintf(f, "burst %s ", sprint_size(buffer, b1)); fprintf(f, "cburst %s ", sprint_size(cbuffer, b1)); } if (show_raw) fprintf(f, "buffer [%08x] cbuffer [%08x] ", hopt->buffer,hopt->cbuffer); }
static int psp_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_PSP_MAX+1]; struct tc_psp_copt *copt; struct tc_psp_qopt *qopt; SPRINT_BUF(b); if (opt == NULL) return 0; memset(tb, 0, sizeof(tb)); parse_rtattr_nested(tb, TCA_PSP_MAX, opt); if (tb[TCA_PSP_COPT]) { copt = RTA_DATA(tb[TCA_PSP_COPT]); if (RTA_PAYLOAD(tb[TCA_PSP_COPT]) < sizeof(*copt)) return -1; fprintf(f, "level %d ", (int)copt->level); switch (copt->mode) { case TC_PSP_MODE_NORMAL: fprintf(f, "mode NORMAL "); break; case TC_PSP_MODE_STATIC: fprintf(f, "mode STATIC (%s) ", sprint_rate(copt->rate, b)); break; } } if (tb[TCA_PSP_QOPT]) { qopt = RTA_DATA(tb[TCA_PSP_QOPT]); if (RTA_PAYLOAD(tb[TCA_PSP_QOPT]) < sizeof(*qopt)) return -1; fprintf(f, "default %x direct pkts %u max rate %s ifg %u", qopt->defcls, qopt->direct_pkts, sprint_rate(qopt->rate, b), qopt->ifg); } return 0; }
void print_tcstats(FILE *fp, struct tc_stats *st) { SPRINT_BUF(b1); fprintf(fp, " Sent %llu bytes %u pkts (dropped %u, overlimits %u) ", (unsigned long long)st->bytes, st->packets, st->drops, st->overlimits); if (st->bps || st->pps || st->qlen || st->backlog) { fprintf(fp, "\n "); if (st->bps || st->pps) { fprintf(fp, "rate "); if (st->bps) fprintf(fp, "%s ", sprint_rate(st->bps, b1)); if (st->pps) fprintf(fp, "%upps ", st->pps); } if (st->qlen || st->backlog) { fprintf(fp, "backlog "); if (st->backlog) fprintf(fp, "%s ", sprint_size(st->backlog, b1)); if (st->qlen) fprintf(fp, "%up ", st->qlen); } } }
static int fq_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_FQ_MAX + 1]; unsigned int plimit, flow_plimit; unsigned int buckets_log; int pacing; unsigned int rate, quantum; unsigned int refill_delay; unsigned int orphan_mask; unsigned int ce_threshold; SPRINT_BUF(b1); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_FQ_MAX, opt); if (tb[TCA_FQ_PLIMIT] && RTA_PAYLOAD(tb[TCA_FQ_PLIMIT]) >= sizeof(__u32)) { plimit = rta_getattr_u32(tb[TCA_FQ_PLIMIT]); fprintf(f, "limit %up ", plimit); } if (tb[TCA_FQ_FLOW_PLIMIT] && RTA_PAYLOAD(tb[TCA_FQ_FLOW_PLIMIT]) >= sizeof(__u32)) { flow_plimit = rta_getattr_u32(tb[TCA_FQ_FLOW_PLIMIT]); fprintf(f, "flow_limit %up ", flow_plimit); } if (tb[TCA_FQ_BUCKETS_LOG] && RTA_PAYLOAD(tb[TCA_FQ_BUCKETS_LOG]) >= sizeof(__u32)) { buckets_log = rta_getattr_u32(tb[TCA_FQ_BUCKETS_LOG]); fprintf(f, "buckets %u ", 1U << buckets_log); } if (tb[TCA_FQ_ORPHAN_MASK] && RTA_PAYLOAD(tb[TCA_FQ_ORPHAN_MASK]) >= sizeof(__u32)) { orphan_mask = rta_getattr_u32(tb[TCA_FQ_ORPHAN_MASK]); fprintf(f, "orphan_mask %u ", orphan_mask); } if (tb[TCA_FQ_RATE_ENABLE] && RTA_PAYLOAD(tb[TCA_FQ_RATE_ENABLE]) >= sizeof(int)) { pacing = rta_getattr_u32(tb[TCA_FQ_RATE_ENABLE]); if (pacing == 0) fprintf(f, "nopacing "); } if (tb[TCA_FQ_QUANTUM] && RTA_PAYLOAD(tb[TCA_FQ_QUANTUM]) >= sizeof(__u32)) { quantum = rta_getattr_u32(tb[TCA_FQ_QUANTUM]); fprintf(f, "quantum %u ", quantum); } if (tb[TCA_FQ_INITIAL_QUANTUM] && RTA_PAYLOAD(tb[TCA_FQ_INITIAL_QUANTUM]) >= sizeof(__u32)) { quantum = rta_getattr_u32(tb[TCA_FQ_INITIAL_QUANTUM]); fprintf(f, "initial_quantum %u ", quantum); } if (tb[TCA_FQ_FLOW_MAX_RATE] && RTA_PAYLOAD(tb[TCA_FQ_FLOW_MAX_RATE]) >= sizeof(__u32)) { rate = rta_getattr_u32(tb[TCA_FQ_FLOW_MAX_RATE]); if (rate != ~0U) fprintf(f, "maxrate %s ", sprint_rate(rate, b1)); } if (tb[TCA_FQ_FLOW_DEFAULT_RATE] && RTA_PAYLOAD(tb[TCA_FQ_FLOW_DEFAULT_RATE]) >= sizeof(__u32)) { rate = rta_getattr_u32(tb[TCA_FQ_FLOW_DEFAULT_RATE]); if (rate != 0) fprintf(f, "defrate %s ", sprint_rate(rate, b1)); } if (tb[TCA_FQ_LOW_RATE_THRESHOLD] && RTA_PAYLOAD(tb[TCA_FQ_LOW_RATE_THRESHOLD]) >= sizeof(__u32)) { rate = rta_getattr_u32(tb[TCA_FQ_LOW_RATE_THRESHOLD]); if (rate != 0) fprintf(f, "low_rate_threshold %s ", sprint_rate(rate, b1)); } if (tb[TCA_FQ_FLOW_REFILL_DELAY] && RTA_PAYLOAD(tb[TCA_FQ_FLOW_REFILL_DELAY]) >= sizeof(__u32)) { refill_delay = rta_getattr_u32(tb[TCA_FQ_FLOW_REFILL_DELAY]); fprintf(f, "refill_delay %s ", sprint_time(refill_delay, b1)); } if (tb[TCA_FQ_CE_THRESHOLD] && RTA_PAYLOAD(tb[TCA_FQ_CE_THRESHOLD]) >= sizeof(__u32)) { ce_threshold = rta_getattr_u32(tb[TCA_FQ_CE_THRESHOLD]); if (ce_threshold != ~0U) fprintf(f, "ce_threshold %s ", sprint_time(ce_threshold, b1)); } return 0; }
static int fq_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_FQ_MAX + 1]; unsigned int plimit, flow_plimit; unsigned int buckets_log; int pacing; unsigned int rate, quantum; SPRINT_BUF(b1); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_FQ_MAX, opt); if (tb[TCA_FQ_PLIMIT] && RTA_PAYLOAD(tb[TCA_FQ_PLIMIT]) >= sizeof(__u32)) { plimit = rta_getattr_u32(tb[TCA_FQ_PLIMIT]); fprintf(f, "limit %up ", plimit); } if (tb[TCA_FQ_FLOW_PLIMIT] && RTA_PAYLOAD(tb[TCA_FQ_FLOW_PLIMIT]) >= sizeof(__u32)) { flow_plimit = rta_getattr_u32(tb[TCA_FQ_FLOW_PLIMIT]); fprintf(f, "flow_limit %up ", flow_plimit); } if (tb[TCA_FQ_BUCKETS_LOG] && RTA_PAYLOAD(tb[TCA_FQ_BUCKETS_LOG]) >= sizeof(__u32)) { buckets_log = rta_getattr_u32(tb[TCA_FQ_BUCKETS_LOG]); fprintf(f, "buckets %u ", 1U << buckets_log); } if (tb[TCA_FQ_RATE_ENABLE] && RTA_PAYLOAD(tb[TCA_FQ_RATE_ENABLE]) >= sizeof(int)) { pacing = rta_getattr_u32(tb[TCA_FQ_RATE_ENABLE]); if (pacing == 0) fprintf(f, "nopacing "); } if (tb[TCA_FQ_QUANTUM] && RTA_PAYLOAD(tb[TCA_FQ_QUANTUM]) >= sizeof(__u32)) { quantum = rta_getattr_u32(tb[TCA_FQ_QUANTUM]); fprintf(f, "quantum %u ", quantum); } if (tb[TCA_FQ_INITIAL_QUANTUM] && RTA_PAYLOAD(tb[TCA_FQ_INITIAL_QUANTUM]) >= sizeof(__u32)) { quantum = rta_getattr_u32(tb[TCA_FQ_INITIAL_QUANTUM]); fprintf(f, "initial_quantum %u ", quantum); } if (tb[TCA_FQ_FLOW_MAX_RATE] && RTA_PAYLOAD(tb[TCA_FQ_FLOW_MAX_RATE]) >= sizeof(__u32)) { rate = rta_getattr_u32(tb[TCA_FQ_FLOW_MAX_RATE]); if (rate != ~0U) fprintf(f, "maxrate %s ", sprint_rate(rate, b1)); } if (tb[TCA_FQ_FLOW_DEFAULT_RATE] && RTA_PAYLOAD(tb[TCA_FQ_FLOW_DEFAULT_RATE]) >= sizeof(__u32)) { rate = rta_getattr_u32(tb[TCA_FQ_FLOW_DEFAULT_RATE]); if (rate != 0) fprintf(f, "defrate %s ", sprint_rate(rate, b1)); } return 0; }
static int netem_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n) { int dist_size = 0; struct rtattr *tail; struct tc_netem_qopt opt = { .limit = 1000 }; struct tc_netem_corr cor; struct tc_netem_reorder reorder; struct tc_netem_corrupt corrupt; struct tc_netem_gimodel gimodel; struct tc_netem_gemodel gemodel; struct tc_netem_rate rate; __s16 *dist_data = NULL; __u16 loss_type = NETEM_LOSS_UNSPEC; int present[__TCA_NETEM_MAX]; __u64 rate64 = 0; memset(&cor, 0, sizeof(cor)); memset(&reorder, 0, sizeof(reorder)); memset(&corrupt, 0, sizeof(corrupt)); memset(&rate, 0, sizeof(rate)); memset(present, 0, sizeof(present)); for( ; argc > 0; --argc, ++argv) { if (matches(*argv, "limit") == 0) { NEXT_ARG(); if (get_size(&opt.limit, *argv)) { explain1("limit"); return -1; } } else if (matches(*argv, "latency") == 0 || matches(*argv, "delay") == 0) { NEXT_ARG(); if (get_ticks(&opt.latency, *argv)) { explain1("latency"); return -1; } if (NEXT_IS_NUMBER()) { NEXT_ARG(); if (get_ticks(&opt.jitter, *argv)) { explain1("latency"); return -1; } if (NEXT_IS_NUMBER()) { NEXT_ARG(); ++present[TCA_NETEM_CORR]; if (get_percent(&cor.delay_corr, *argv)) { explain1("latency"); return -1; } } } } else if (matches(*argv, "loss") == 0 || matches(*argv, "drop") == 0) { if (opt.loss > 0 || loss_type != NETEM_LOSS_UNSPEC) { explain1("duplicate loss argument\n"); return -1; } NEXT_ARG(); /* Old (deprecated) random loss model syntax */ if (isdigit(argv[0][0])) goto random_loss_model; if (!strcmp(*argv, "random")) { NEXT_ARG(); random_loss_model: if (get_percent(&opt.loss, *argv)) { explain1("loss percent"); return -1; } if (NEXT_IS_NUMBER()) { NEXT_ARG(); ++present[TCA_NETEM_CORR]; if (get_percent(&cor.loss_corr, *argv)) { explain1("loss correllation"); return -1; } } } else if (!strcmp(*argv, "state")) { double p13; NEXT_ARG(); if (parse_percent(&p13, *argv)) { explain1("loss p13"); return -1; } /* set defaults */ set_percent(&gimodel.p13, p13); set_percent(&gimodel.p31, 1. - p13); set_percent(&gimodel.p32, 0); set_percent(&gimodel.p23, 1.); set_percent(&gimodel.p14, 0); loss_type = NETEM_LOSS_GI; if (!NEXT_IS_NUMBER()) continue; NEXT_ARG(); if (get_percent(&gimodel.p31, *argv)) { explain1("loss p31"); return -1; } if (!NEXT_IS_NUMBER()) continue; NEXT_ARG(); if (get_percent(&gimodel.p32, *argv)) { explain1("loss p32"); return -1; } if (!NEXT_IS_NUMBER()) continue; NEXT_ARG(); if (get_percent(&gimodel.p23, *argv)) { explain1("loss p23"); return -1; } if (!NEXT_IS_NUMBER()) continue; NEXT_ARG(); if (get_percent(&gimodel.p14, *argv)) { explain1("loss p14"); return -1; } } else if (!strcmp(*argv, "gemodel")) { NEXT_ARG(); if (get_percent(&gemodel.p, *argv)) { explain1("loss gemodel p"); return -1; } /* set defaults */ set_percent(&gemodel.r, 1.); set_percent(&gemodel.h, 0); set_percent(&gemodel.k1, 0); loss_type = NETEM_LOSS_GE; if (!NEXT_IS_NUMBER()) continue; NEXT_ARG(); if (get_percent(&gemodel.r, *argv)) { explain1("loss gemodel r"); return -1; } if (!NEXT_IS_NUMBER()) continue; NEXT_ARG(); if (get_percent(&gemodel.h, *argv)) { explain1("loss gemodel h"); return -1; } /* netem option is "1-h" but kernel * expects "h". */ gemodel.h = max_percent_value - gemodel.h; if (!NEXT_IS_NUMBER()) continue; NEXT_ARG(); if (get_percent(&gemodel.k1, *argv)) { explain1("loss gemodel k"); return -1; } } else { fprintf(stderr, "Unknown loss parameter: %s\n", *argv); return -1; } } else if (matches(*argv, "ecn") == 0) { present[TCA_NETEM_ECN] = 1; } else if (matches(*argv, "reorder") == 0) { NEXT_ARG(); present[TCA_NETEM_REORDER] = 1; if (get_percent(&reorder.probability, *argv)) { explain1("reorder"); return -1; } if (NEXT_IS_NUMBER()) { NEXT_ARG(); ++present[TCA_NETEM_CORR]; if (get_percent(&reorder.correlation, *argv)) { explain1("reorder"); return -1; } } } else if (matches(*argv, "corrupt") == 0) { NEXT_ARG(); present[TCA_NETEM_CORRUPT] = 1; if (get_percent(&corrupt.probability, *argv)) { explain1("corrupt"); return -1; } if (NEXT_IS_NUMBER()) { NEXT_ARG(); ++present[TCA_NETEM_CORR]; if (get_percent(&corrupt.correlation, *argv)) { explain1("corrupt"); return -1; } } } else if (matches(*argv, "gap") == 0) { NEXT_ARG(); if (get_u32(&opt.gap, *argv, 0)) { explain1("gap"); return -1; } } else if (matches(*argv, "duplicate") == 0) { NEXT_ARG(); if (get_percent(&opt.duplicate, *argv)) { explain1("duplicate"); return -1; } if (NEXT_IS_NUMBER()) { NEXT_ARG(); if (get_percent(&cor.dup_corr, *argv)) { explain1("duplicate"); return -1; } } } else if (matches(*argv, "distribution") == 0) { NEXT_ARG(); dist_data = calloc(sizeof(dist_data[0]), MAX_DIST); dist_size = get_distribution(*argv, dist_data, MAX_DIST); if (dist_size <= 0) { free(dist_data); return -1; } } else if (matches(*argv, "rate") == 0) { ++present[TCA_NETEM_RATE]; NEXT_ARG(); if (get_rate64(&rate64, *argv)) { explain1("rate"); return -1; } if (NEXT_IS_SIGNED_NUMBER()) { NEXT_ARG(); if (get_s32(&rate.packet_overhead, *argv, 0)) { explain1("rate"); return -1; } } if (NEXT_IS_NUMBER()) { NEXT_ARG(); if (get_u32(&rate.cell_size, *argv, 0)) { explain1("rate"); return -1; } } if (NEXT_IS_SIGNED_NUMBER()) { NEXT_ARG(); if (get_s32(&rate.cell_overhead, *argv, 0)) { explain1("rate"); return -1; } } } else if (strcmp(*argv, "help") == 0) { explain(); return -1; } else { fprintf(stderr, "What is \"%s\"?\n", *argv); explain(); return -1; } } tail = NLMSG_TAIL(n); if (reorder.probability) { if (opt.latency == 0) { fprintf(stderr, "reordering not possible without specifying some delay\n"); explain(); return -1; } if (opt.gap == 0) opt.gap = 1; } else if (opt.gap > 0) { fprintf(stderr, "gap specified without reorder probability\n"); explain(); return -1; } if (present[TCA_NETEM_ECN]) { if (opt.loss <= 0 && loss_type == NETEM_LOSS_UNSPEC) { fprintf(stderr, "ecn requested without loss model\n"); explain(); return -1; } } if (dist_data && (opt.latency == 0 || opt.jitter == 0)) { fprintf(stderr, "distribution specified but no latency and jitter values\n"); explain(); return -1; } if (addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt)) < 0) return -1; if (present[TCA_NETEM_CORR] && addattr_l(n, 1024, TCA_NETEM_CORR, &cor, sizeof(cor)) < 0) return -1; if (present[TCA_NETEM_REORDER] && addattr_l(n, 1024, TCA_NETEM_REORDER, &reorder, sizeof(reorder)) < 0) return -1; if (present[TCA_NETEM_ECN] && addattr_l(n, 1024, TCA_NETEM_ECN, &present[TCA_NETEM_ECN], sizeof(present[TCA_NETEM_ECN])) < 0) return -1; if (present[TCA_NETEM_CORRUPT] && addattr_l(n, 1024, TCA_NETEM_CORRUPT, &corrupt, sizeof(corrupt)) < 0) return -1; if (loss_type != NETEM_LOSS_UNSPEC) { struct rtattr *start; start = addattr_nest(n, 1024, TCA_NETEM_LOSS | NLA_F_NESTED); if (loss_type == NETEM_LOSS_GI) { if (addattr_l(n, 1024, NETEM_LOSS_GI, &gimodel, sizeof(gimodel)) < 0) return -1; } else if (loss_type == NETEM_LOSS_GE) { if (addattr_l(n, 1024, NETEM_LOSS_GE, &gemodel, sizeof(gemodel)) < 0) return -1; } else { fprintf(stderr, "loss in the weeds!\n"); return -1; } addattr_nest_end(n, start); } if (present[TCA_NETEM_RATE]) { if (rate64 >= (1ULL << 32)) { if (addattr_l(n, 1024, TCA_NETEM_RATE64, &rate64, sizeof(rate64)) < 0) return -1; rate.rate = ~0U; } else { rate.rate = rate64; } if (addattr_l(n, 1024, TCA_NETEM_RATE, &rate, sizeof(rate)) < 0) return -1; } if (dist_data) { if (addattr_l(n, MAX_DIST * sizeof(dist_data[0]), TCA_NETEM_DELAY_DIST, dist_data, dist_size * sizeof(dist_data[0])) < 0) return -1; free(dist_data); } tail->rta_len = (void *) NLMSG_TAIL(n) - (void *) tail; return 0; } static int netem_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { const struct tc_netem_corr *cor = NULL; const struct tc_netem_reorder *reorder = NULL; const struct tc_netem_corrupt *corrupt = NULL; const struct tc_netem_gimodel *gimodel = NULL; const struct tc_netem_gemodel *gemodel = NULL; int *ecn = NULL; struct tc_netem_qopt qopt; const struct tc_netem_rate *rate = NULL; int len = RTA_PAYLOAD(opt) - sizeof(qopt); __u64 rate64 = 0; SPRINT_BUF(b1); if (opt == NULL) return 0; if (len < 0) { fprintf(stderr, "options size error\n"); return -1; } memcpy(&qopt, RTA_DATA(opt), sizeof(qopt)); if (len > 0) { struct rtattr *tb[TCA_NETEM_MAX+1]; parse_rtattr(tb, TCA_NETEM_MAX, RTA_DATA(opt) + sizeof(qopt), len); if (tb[TCA_NETEM_CORR]) { if (RTA_PAYLOAD(tb[TCA_NETEM_CORR]) < sizeof(*cor)) return -1; cor = RTA_DATA(tb[TCA_NETEM_CORR]); } if (tb[TCA_NETEM_REORDER]) { if (RTA_PAYLOAD(tb[TCA_NETEM_REORDER]) < sizeof(*reorder)) return -1; reorder = RTA_DATA(tb[TCA_NETEM_REORDER]); } if (tb[TCA_NETEM_CORRUPT]) { if (RTA_PAYLOAD(tb[TCA_NETEM_CORRUPT]) < sizeof(*corrupt)) return -1; corrupt = RTA_DATA(tb[TCA_NETEM_CORRUPT]); } if (tb[TCA_NETEM_LOSS]) { struct rtattr *lb[NETEM_LOSS_MAX + 1]; parse_rtattr_nested(lb, NETEM_LOSS_MAX, tb[TCA_NETEM_LOSS]); if (lb[NETEM_LOSS_GI]) gimodel = RTA_DATA(lb[NETEM_LOSS_GI]); if (lb[NETEM_LOSS_GE]) gemodel = RTA_DATA(lb[NETEM_LOSS_GE]); } if (tb[TCA_NETEM_RATE]) { if (RTA_PAYLOAD(tb[TCA_NETEM_RATE]) < sizeof(*rate)) return -1; rate = RTA_DATA(tb[TCA_NETEM_RATE]); } if (tb[TCA_NETEM_ECN]) { if (RTA_PAYLOAD(tb[TCA_NETEM_ECN]) < sizeof(*ecn)) return -1; ecn = RTA_DATA(tb[TCA_NETEM_ECN]); } if (tb[TCA_NETEM_RATE64]) { if (RTA_PAYLOAD(tb[TCA_NETEM_RATE64]) < sizeof(rate64)) return -1; rate64 = rta_getattr_u64(tb[TCA_NETEM_RATE64]); } } fprintf(f, "limit %d", qopt.limit); if (qopt.latency) { fprintf(f, " delay %s", sprint_ticks(qopt.latency, b1)); if (qopt.jitter) { fprintf(f, " %s", sprint_ticks(qopt.jitter, b1)); if (cor && cor->delay_corr) fprintf(f, " %s", sprint_percent(cor->delay_corr, b1)); } } if (qopt.loss) { fprintf(f, " loss %s", sprint_percent(qopt.loss, b1)); if (cor && cor->loss_corr) fprintf(f, " %s", sprint_percent(cor->loss_corr, b1)); } if (gimodel) { fprintf(f, " loss state p13 %s", sprint_percent(gimodel->p13, b1)); fprintf(f, " p31 %s", sprint_percent(gimodel->p31, b1)); fprintf(f, " p32 %s", sprint_percent(gimodel->p32, b1)); fprintf(f, " p23 %s", sprint_percent(gimodel->p23, b1)); fprintf(f, " p14 %s", sprint_percent(gimodel->p14, b1)); } if (gemodel) { fprintf(f, " loss gemodel p %s", sprint_percent(gemodel->p, b1)); fprintf(f, " r %s", sprint_percent(gemodel->r, b1)); fprintf(f, " 1-h %s", sprint_percent(max_percent_value - gemodel->h, b1)); fprintf(f, " 1-k %s", sprint_percent(gemodel->k1, b1)); } if (qopt.duplicate) { fprintf(f, " duplicate %s", sprint_percent(qopt.duplicate, b1)); if (cor && cor->dup_corr) fprintf(f, " %s", sprint_percent(cor->dup_corr, b1)); } if (reorder && reorder->probability) { fprintf(f, " reorder %s", sprint_percent(reorder->probability, b1)); if (reorder->correlation) fprintf(f, " %s", sprint_percent(reorder->correlation, b1)); } if (corrupt && corrupt->probability) { fprintf(f, " corrupt %s", sprint_percent(corrupt->probability, b1)); if (corrupt->correlation) fprintf(f, " %s", sprint_percent(corrupt->correlation, b1)); } if (rate && rate->rate) { if (rate64) fprintf(f, " rate %s", sprint_rate(rate64, b1)); else fprintf(f, " rate %s", sprint_rate(rate->rate, b1)); if (rate->packet_overhead) fprintf(f, " packetoverhead %d", rate->packet_overhead); if (rate->cell_size) fprintf(f, " cellsize %u", rate->cell_size); if (rate->cell_overhead) fprintf(f, " celloverhead %d", rate->cell_overhead); } if (ecn) fprintf(f, " ecn "); if (qopt.gap) fprintf(f, " gap %lu", (unsigned long)qopt.gap); return 0; } struct qdisc_util netem_qdisc_util = { .id = "netem", .parse_qopt = netem_parse_opt, .print_qopt = netem_print_opt, };
static int cake_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats) { /* fq_codel stats format borrowed */ struct tc_fq_codel_xstats *st; struct tc_cake_old_xstats *stc; SPRINT_BUF(b1); if (xstats == NULL) return 0; if (RTA_PAYLOAD(xstats) < sizeof(st->type)) return -1; st = RTA_DATA(xstats); stc = RTA_DATA(xstats); if (st->type == TCA_FQ_CODEL_XSTATS_QDISC && RTA_PAYLOAD(xstats) >= sizeof(*st)) { fprintf(f, " maxpacket %u drop_overlimit %u new_flow_count %u ecn_mark %u", st->qdisc_stats.maxpacket, st->qdisc_stats.drop_overlimit, st->qdisc_stats.new_flow_count, st->qdisc_stats.ecn_mark); fprintf(f, "\n new_flows_len %u old_flows_len %u", st->qdisc_stats.new_flows_len, st->qdisc_stats.old_flows_len); } else if (st->type == TCA_FQ_CODEL_XSTATS_CLASS && RTA_PAYLOAD(xstats) >= sizeof(*st)) { fprintf(f, " deficit %d count %u lastcount %u ldelay %s", st->class_stats.deficit, st->class_stats.count, st->class_stats.lastcount, sprint_time(st->class_stats.ldelay, b1)); if (st->class_stats.dropping) { fprintf(f, " dropping"); if (st->class_stats.drop_next < 0) fprintf(f, " drop_next -%s", sprint_time(-st->class_stats.drop_next, b1)); else fprintf(f, " drop_next %s", sprint_time(st->class_stats.drop_next, b1)); } } else if (stc->type == 0xCAFE && RTA_PAYLOAD(xstats) >= sizeof(*stc)) { int i; fprintf(f, " "); for(i=0; i < stc->class_cnt; i++) fprintf(f, " Class %u ", i); fprintf(f, "\n"); fprintf(f, " rate "); for(i=0; i < stc->class_cnt; i++) fprintf(f, "%10s", sprint_rate(stc->cls[i].rate, b1)); fprintf(f, "\n"); fprintf(f, " target"); for(i=0; i < stc->class_cnt; i++) fprintf(f, "%10s", sprint_time(stc->cls[i].target_us, b1)); fprintf(f, "\n"); fprintf(f, "interval"); for(i=0; i < stc->class_cnt; i++) fprintf(f, "%10s", sprint_time(stc->cls[i].interval_us, b1)); fprintf(f, "\n"); fprintf(f, " pkts "); for(i=0; i < stc->class_cnt; i++) fprintf(f, "%10u", stc->cls[i].packets); fprintf(f, "\n"); fprintf(f, " bytes "); for(i=0; i < stc->class_cnt; i++) fprintf(f, "%10llu", stc->cls[i].bytes); fprintf(f, "\n"); fprintf(f, " drops "); for(i=0; i < stc->class_cnt; i++) fprintf(f, "%10u", stc->cls[i].dropped); fprintf(f, "\n"); fprintf(f, " marks "); for(i=0; i < stc->class_cnt; i++) fprintf(f, "%10u", stc->cls[i].ecn_marked); } else { return -1; } return 0; }
static int cake_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_CAKE_MAX + 1]; unsigned bandwidth = 0; unsigned diffserv = 0; unsigned flowmode = 0; int atm = -1; SPRINT_BUF(b1); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_CAKE_MAX, opt); if (tb[TCA_CAKE_BASE_RATE] && RTA_PAYLOAD(tb[TCA_CAKE_BASE_RATE]) >= sizeof(__u32)) { bandwidth = rta_getattr_u32(tb[TCA_CAKE_BASE_RATE]); if(bandwidth) fprintf(f, "bandwidth %s ", sprint_rate(bandwidth, b1)); else fprintf(f, "unlimited"); } if (tb[TCA_CAKE_DIFFSERV_MODE] && RTA_PAYLOAD(tb[TCA_CAKE_DIFFSERV_MODE]) >= sizeof(__u32)) { diffserv = rta_getattr_u32(tb[TCA_CAKE_DIFFSERV_MODE]); switch(diffserv) { case 1: fprintf(f, "besteffort "); break; case 2: fprintf(f, "precedence "); break; case 3: fprintf(f, "diffserv "); break; default: fprintf(f, "(?diffserv?) "); break; }; } if (tb[TCA_CAKE_FLOW_MODE] && RTA_PAYLOAD(tb[TCA_CAKE_FLOW_MODE]) >= sizeof(__u32)) { flowmode = rta_getattr_u32(tb[TCA_CAKE_FLOW_MODE]); switch(flowmode) { case 0: fprintf(f, "flowblind "); break; case 1: fprintf(f, "srchost "); break; case 2: fprintf(f, "dsthost "); break; case 3: fprintf(f, "hosts "); break; case 4: fprintf(f, "flows "); break; default: fprintf(f, "(?flowmode?) "); break; }; } if (tb[TCA_CAKE_ATM] && RTA_PAYLOAD(tb[TCA_CAKE_ATM]) >= sizeof(__u32)) { atm = rta_getattr_u32(tb[TCA_CAKE_ATM]); if (atm) fprintf(f, "atm "); } return 0; }
static int fq_pie_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) { struct rtattr *tb[TCA_FQ_PIE_MAX + 1]; unsigned int target; unsigned int tupdate; unsigned int alpha; unsigned int beta; unsigned ecn; unsigned bytemode; unsigned int plimit, flow_plimit; unsigned int buckets_log; int pacing; unsigned int rate, quantum; SPRINT_BUF(b1); if (opt == NULL) return 0; parse_rtattr_nested(tb, TCA_FQ_PIE_MAX, opt); if (tb[TCA_FQ_PIE_TARGET] && RTA_PAYLOAD(tb[TCA_FQ_PIE_TARGET]) >= sizeof(__u32)) { target = rta_getattr_u32(tb[TCA_FQ_PIE_TARGET]); fprintf(f, "target %s ", sprint_time(target, b1)); } if (tb[TCA_FQ_PIE_TUPDATE] && RTA_PAYLOAD(tb[TCA_FQ_PIE_TUPDATE]) >= sizeof(__u32)) { tupdate = rta_getattr_u32(tb[TCA_FQ_PIE_TUPDATE]); fprintf(f, "tupdate %s ", sprint_time(tupdate, b1)); } if (tb[TCA_FQ_PIE_ALPHA] && RTA_PAYLOAD(tb[TCA_FQ_PIE_ALPHA]) >= sizeof(__u32)) { alpha = rta_getattr_u32(tb[TCA_FQ_PIE_ALPHA]); fprintf(f, "alpha %u ", alpha); } if (tb[TCA_FQ_PIE_BETA] && RTA_PAYLOAD(tb[TCA_FQ_PIE_BETA]) >= sizeof(__u32)) { beta = rta_getattr_u32(tb[TCA_FQ_PIE_BETA]); fprintf(f, "beta %u ", beta); } if (tb[TCA_FQ_PIE_ECN] && RTA_PAYLOAD(tb[TCA_FQ_PIE_ECN]) >= sizeof(__u32)) { ecn = rta_getattr_u32(tb[TCA_FQ_PIE_ECN]); if (ecn) fprintf(f, "ecn "); } if (tb[TCA_FQ_PIE_BYTEMODE] && RTA_PAYLOAD(tb[TCA_FQ_PIE_BYTEMODE]) >= sizeof(__u32)) { bytemode = rta_getattr_u32(tb[TCA_FQ_PIE_BYTEMODE]); if (bytemode) fprintf(f, "bytemode "); } if (tb[TCA_FQ_PIE_PLIMIT] && RTA_PAYLOAD(tb[TCA_FQ_PIE_PLIMIT]) >= sizeof(__u32)) { plimit = rta_getattr_u32(tb[TCA_FQ_PIE_PLIMIT]); fprintf(f, "limit %up ", plimit); } if (tb[TCA_FQ_PIE_FLOW_PLIMIT] && RTA_PAYLOAD(tb[TCA_FQ_PIE_FLOW_PLIMIT]) >= sizeof(__u32)) { flow_plimit = rta_getattr_u32(tb[TCA_FQ_PIE_FLOW_PLIMIT]); fprintf(f, "flow_limit %up ", flow_plimit); } if (tb[TCA_FQ_PIE_BUCKETS_LOG] && RTA_PAYLOAD(tb[TCA_FQ_PIE_BUCKETS_LOG]) >= sizeof(__u32)) { buckets_log = rta_getattr_u32(tb[TCA_FQ_PIE_BUCKETS_LOG]); fprintf(f, "buckets %u ", 1U << buckets_log); } if (tb[TCA_FQ_PIE_RATE_ENABLE] && RTA_PAYLOAD(tb[TCA_FQ_PIE_RATE_ENABLE]) >= sizeof(int)) { pacing = rta_getattr_u32(tb[TCA_FQ_PIE_RATE_ENABLE]); if (pacing == 0) fprintf(f, "nopacing "); } if (tb[TCA_FQ_PIE_QUANTUM] && RTA_PAYLOAD(tb[TCA_FQ_PIE_QUANTUM]) >= sizeof(__u32)) { quantum = rta_getattr_u32(tb[TCA_FQ_PIE_QUANTUM]); fprintf(f, "quantum %u ", quantum); } if (tb[TCA_FQ_PIE_INITIAL_QUANTUM] && RTA_PAYLOAD(tb[TCA_FQ_PIE_INITIAL_QUANTUM]) >= sizeof(__u32)) { quantum = rta_getattr_u32(tb[TCA_FQ_PIE_INITIAL_QUANTUM]); fprintf(f, "initial_quantum %u ", quantum); } if (tb[TCA_FQ_PIE_FLOW_MAX_RATE] && RTA_PAYLOAD(tb[TCA_FQ_PIE_FLOW_MAX_RATE]) >= sizeof(__u32)) { rate = rta_getattr_u32(tb[TCA_FQ_PIE_FLOW_MAX_RATE]); if (rate != ~0U) fprintf(f, "maxrate %s ", sprint_rate(rate, b1)); } if (tb[TCA_FQ_PIE_FLOW_DEFAULT_RATE] && RTA_PAYLOAD(tb[TCA_FQ_PIE_FLOW_DEFAULT_RATE]) >= sizeof(__u32)) { rate = rta_getattr_u32(tb[TCA_FQ_PIE_FLOW_DEFAULT_RATE]); if (rate != 0) fprintf(f, "defrate %s ", sprint_rate(rate, b1)); } return 0; }