static void netem_dump_details(struct rtnl_tc *tc, void *data,
struct nl_dump_params *p)
{
struct rtnl_netem *netem = data;
char buf[32];
if (netem) {
if (netem->qnm_mask & SCH_NETEM_ATTR_LATENCY && netem->qnm_latency > 0) {
nl_msec2str(nl_ticks2us(netem->qnm_latency) / 1000, buf, sizeof(buf));
nl_dump(p, " latency %s", buf);
if (netem->qnm_mask & SCH_NETEM_ATTR_JITTER && netem->qnm_jitter > 0) {
nl_msec2str(nl_ticks2us(netem->qnm_jitter) / 1000, buf, sizeof(buf));
nl_dump(p, " jitter %s", buf);
if (netem->qnm_mask & SCH_NETEM_ATTR_DELAY_CORR && netem->qnm_corr.nmc_delay > 0)
nl_dump(p, " %d%", netem->qnm_corr.nmc_delay);
}
}
if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS && netem->qnm_loss > 0) {
nl_dump(p, " loss %d%", netem->qnm_loss);
if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS_CORR && netem->qnm_corr.nmc_loss > 0)
nl_dump(p, " %d%", netem->qnm_corr.nmc_loss);
}
if (netem->qnm_mask & SCH_NETEM_ATTR_DUPLICATE && netem->qnm_duplicate > 0) {
nl_dump(p, " duplicate %d%", netem->qnm_duplicate);
if (netem->qnm_mask & SCH_NETEM_ATTR_DUP_CORR && netem->qnm_corr.nmc_duplicate > 0)
nl_dump(p, " %d%", netem->qnm_corr.nmc_duplicate);
}
if (netem->qnm_mask & SCH_NETEM_ATTR_RO_PROB && netem->qnm_ro.nmro_probability > 0) {
nl_dump(p, " reorder %d%", netem->qnm_ro.nmro_probability);
if (netem->qnm_mask & SCH_NETEM_ATTR_RO_CORR && netem->qnm_ro.nmro_correlation > 0)
nl_dump(p, " %d%", netem->qnm_ro.nmro_correlation);
if (netem->qnm_mask & SCH_NETEM_ATTR_GAP && netem->qnm_gap > 0)
nl_dump(p, " gap %d", netem->qnm_gap);
}
if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_PROB && netem->qnm_crpt.nmcr_probability > 0) {
nl_dump(p, " reorder %d%", netem->qnm_crpt.nmcr_probability);
if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_CORR && netem->qnm_crpt.nmcr_correlation > 0)
nl_dump(p, " %d%", netem->qnm_crpt.nmcr_correlation);
}
}
}
/**
* Get packet delay jitter of netem qdisc.
* @arg qdisc Netem qdisc.
* @return Packet delay jitter in micro seconds or a negative error code.
*/
int rtnl_netem_get_jitter(struct rtnl_qdisc *qdisc)
{
struct rtnl_netem *netem;
netem = netem_qdisc(qdisc);
if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_JITTER))
return nl_ticks2us(netem->qnm_jitter);
else
return -NLE_NOATTR;
}
/**
* Get packet delay of netem qdisc.
* @arg qdisc Netem qdisc.
* @return Packet delay in micro seconds or a negative error code.
*/
int rtnl_netem_get_delay(struct rtnl_qdisc *qdisc)
{
struct rtnl_netem *netem;
netem = netem_qdisc(qdisc);
if (netem && (netem->qnm_mask & SCH_NETEM_ATTR_LATENCY))
return nl_ticks2us(netem->qnm_latency);
else
return -NLE_NOATTR;
}
static int sfq_dump_brief(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
{
struct rtnl_sfq *sfq = sfq_qdisc(qdisc);
if (sfq)
dp_dump(p, " quantum %u perturb %us",
sfq->qs_quantum,
nl_ticks2us(sfq->qs_perturb * nl_get_hz()));
return line;
}
/**
* Get packet delay jitter of netem qdisc.
* @arg qdisc Netem qdisc.
* @return Packet delay jitter in micro seconds or a negative error code.
*/
int rtnl_netem_get_jitter(struct rtnl_qdisc *qdisc)
{
struct rtnl_netem *netem;
if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
BUG();
if (netem->qnm_mask & SCH_NETEM_ATTR_JITTER)
return nl_ticks2us(netem->qnm_jitter);
else
return -NLE_NOATTR;
}
/**
* Get packet delay of netem qdisc.
* @arg qdisc Netem qdisc.
* @return Packet delay in micro seconds or a negative error code.
*/
int rtnl_netem_get_delay(struct rtnl_qdisc *qdisc)
{
struct rtnl_netem *netem;
if (!(netem = rtnl_tc_data(TC_CAST(qdisc))))
BUG();
if (netem->qnm_mask & SCH_NETEM_ATTR_LATENCY)
return nl_ticks2us(netem->qnm_latency);
else
return -NLE_NOATTR;
}
static int tbf_msg_parser(struct rtnl_qdisc *q)
{
int err;
struct nlattr *tb[TCA_TBF_MAX + 1];
struct rtnl_tbf *tbf;
err = tca_parse(tb, TCA_TBF_MAX, (struct rtnl_tca *) q, tbf_policy);
if (err < 0)
return err;
tbf = tbf_qdisc(q);
if (!tbf)
return nl_errno(ENOMEM);
if (tb[TCA_TBF_PARMS]) {
struct tc_tbf_qopt opts;
int bufsize;
nla_memcpy(&opts, tb[TCA_TBF_PARMS], sizeof(opts));
tbf->qt_limit = opts.limit;
tbf->qt_mpu = opts.rate.mpu;
rtnl_copy_ratespec(&tbf->qt_rate, &opts.rate);
tbf->qt_rate_txtime = opts.buffer;
bufsize = rtnl_tc_calc_bufsize(nl_ticks2us(opts.buffer),
opts.rate.rate);
tbf->qt_rate_bucket = bufsize;
rtnl_copy_ratespec(&tbf->qt_peakrate, &opts.peakrate);
tbf->qt_peakrate_txtime = opts.mtu;
bufsize = rtnl_tc_calc_bufsize(nl_ticks2us(opts.mtu),
opts.peakrate.rate);
tbf->qt_peakrate_bucket = bufsize;
tbf->qt_mask = (TBF_ATTR_LIMIT | TBF_ATTR_MPU | TBF_ATTR_RATE |
TBF_ATTR_PEAKRATE);
}
return 0;
}
static int tbf_msg_parser(struct rtnl_tc *tc, void *data)
{
struct nlattr *tb[TCA_TBF_MAX + 1];
struct rtnl_tbf *tbf = data;
int err;
if ((err = tca_parse(tb, TCA_TBF_MAX, tc, tbf_policy)) < 0)
return err;
if (tb[TCA_TBF_PARMS]) {
struct tc_tbf_qopt opts;
int bufsize;
nla_memcpy(&opts, tb[TCA_TBF_PARMS], sizeof(opts));
tbf->qt_limit = opts.limit;
rtnl_copy_ratespec(&tbf->qt_rate, &opts.rate);
tbf->qt_rate_txtime = opts.buffer;
bufsize = rtnl_tc_calc_bufsize(nl_ticks2us(opts.buffer),
opts.rate.rate);
tbf->qt_rate_bucket = bufsize;
rtnl_copy_ratespec(&tbf->qt_peakrate, &opts.peakrate);
tbf->qt_peakrate_txtime = opts.mtu;
bufsize = rtnl_tc_calc_bufsize(nl_ticks2us(opts.mtu),
opts.peakrate.rate);
tbf->qt_peakrate_bucket = bufsize;
rtnl_tc_set_mpu(tc, tbf->qt_rate.rs_mpu);
rtnl_tc_set_overhead(tc, tbf->qt_rate.rs_overhead);
tbf->qt_mask = (TBF_ATTR_LIMIT | TBF_ATTR_RATE | TBF_ATTR_PEAKRATE);
}
return 0;
}
static void cbq_dump_full(struct nl_cache *c, struct rtnl_tca *g, FILE *fd)
{
double w;
char *unit, ovl[32], split[32], p[32];
uint32_t el;
struct rtnl_cbq *q = (struct rtnl_cbq *) g->tc_subdata;
if (NULL == q)
return;
w = nl_sumup_bit((8 * q->cbq_wrr.weight), &unit);
fprintf(fd, "avgpkt %u mpu %u cell %u allot %u weight %.0f%s\n",
q->cbq_lss.avpkt,
q->cbq_rate.mpu,
1 << q->cbq_rate.cell_log,
q->cbq_wrr.allot, w, unit);
el = q->cbq_lss.ewma_log;
fprintf(fd, "%s minidle %uus maxidle %uus offtime %uus level %u " \
"ewma_log %u\n", nl_get_dump_prefix(),
nl_ticks2us(q->cbq_lss.minidle >> el),
nl_ticks2us(q->cbq_lss.maxidle >> el),
nl_ticks2us(q->cbq_lss.offtime >> el),
q->cbq_lss.level,
q->cbq_lss.ewma_log);
nl_handle2str_r(q->cbq_fopt.split, split, sizeof(split));
fprintf(fd, "%s penalty %uus strategy %s split %s defmap 0x%08x " \
"police %s", nl_get_dump_prefix(),
nl_ticks2us(q->cbq_ovl.penalty),
nl_ovl_strategy2str_r(q->cbq_ovl.strategy, ovl, sizeof(ovl)),
split, q->cbq_fopt.defmap,
nl_police2str_r(q->cbq_police.police, p, sizeof(p)));
}
