static int htb_class_msg_fill(struct rtnl_tc *tc, void *data,
struct nl_msg *msg)
{
struct rtnl_htb_class *htb = data;
uint32_t mtu, rtable[RTNL_TC_RTABLE_SIZE], ctable[RTNL_TC_RTABLE_SIZE];
struct tc_htb_opt opts;
int buffer, cbuffer;
if (!htb || !(htb->ch_mask & SCH_HTB_HAS_RATE))
BUG();
/* if not set, zero (0) is used as priority */
if (htb->ch_mask & SCH_HTB_HAS_PRIO)
opts.prio = htb->ch_prio;
memset(&opts, 0, sizeof(opts));
mtu = rtnl_tc_get_mtu(tc);
rtnl_tc_build_rate_table(tc, &htb->ch_rate, rtable);
rtnl_rcopy_ratespec(&opts.rate, &htb->ch_rate);
if (htb->ch_mask & SCH_HTB_HAS_CEIL) {
rtnl_tc_build_rate_table(tc, &htb->ch_ceil, ctable);
rtnl_rcopy_ratespec(&opts.ceil, &htb->ch_ceil);
} else {
/*
* If not set, configured rate is used as ceil, which implies
* no borrowing.
*/
memcpy(&opts.ceil, &opts.rate, sizeof(struct tc_ratespec));
}
if (htb->ch_mask & SCH_HTB_HAS_RBUFFER)
buffer = htb->ch_rbuffer;
else
buffer = opts.rate.rate / nl_get_user_hz() + mtu; /* XXX */
opts.buffer = rtnl_tc_calc_txtime(buffer, opts.rate.rate);
if (htb->ch_mask & SCH_HTB_HAS_CBUFFER)
cbuffer = htb->ch_cbuffer;
else
cbuffer = opts.ceil.rate / nl_get_user_hz() + mtu; /* XXX */
opts.cbuffer = rtnl_tc_calc_txtime(cbuffer, opts.ceil.rate);
if (htb->ch_mask & SCH_HTB_HAS_QUANTUM)
opts.quantum = htb->ch_quantum;
NLA_PUT(msg, TCA_HTB_PARMS, sizeof(opts), &opts);
NLA_PUT(msg, TCA_HTB_RTAB, sizeof(rtable), &rtable);
NLA_PUT(msg, TCA_HTB_CTAB, sizeof(ctable), &ctable);
return 0;
nla_put_failure:
return -NLE_MSGSIZE;
}
static void update_tc_infos(struct element *e, struct rtnl_tc *tc)
{
char buf[64];
snprintf(buf, sizeof(buf), "%u", rtnl_tc_get_mtu(tc));
element_update_info(e, "MTU", buf);
snprintf(buf, sizeof(buf), "%u", rtnl_tc_get_mpu(tc));
element_update_info(e, "MPU", buf);
snprintf(buf, sizeof(buf), "%u", rtnl_tc_get_overhead(tc));
element_update_info(e, "Overhead", buf);
snprintf(buf, sizeof(buf), "%#x", rtnl_tc_get_handle(tc));
element_update_info(e, "Id", buf);
snprintf(buf, sizeof(buf), "%#x", rtnl_tc_get_parent(tc));
element_update_info(e, "Parent", buf);
}
/**
* Compute a transmission time lookup table
* @arg tc traffic control object
* @arg spec Rate specification
* @arg dst Destination buffer of RTNL_TC_RTABLE_SIZE uint32_t[].
*
* Computes a table of RTNL_TC_RTABLE_SIZE entries specyfing the
* transmission times for various packet sizes, e.g. the transmission
* time for a packet of size \c pktsize could be looked up:
* @code
* txtime = table[pktsize >> log2(mtu)];
* @endcode
*/
int rtnl_tc_build_rate_table(struct rtnl_tc *tc, struct rtnl_ratespec *spec,
uint32_t *dst)
{
uint32_t mtu = rtnl_tc_get_mtu(tc);
uint32_t linktype = rtnl_tc_get_linktype(tc);
uint8_t cell_log = spec->rs_cell_log;
unsigned int size, i;
spec->rs_mpu = rtnl_tc_get_mpu(tc);
spec->rs_overhead = rtnl_tc_get_overhead(tc);
if (mtu == 0)
mtu = 2047;
if (cell_log == UINT8_MAX) {
/*
* cell_log not specified, calculate it. It has to specify the
* minimum number of rshifts required to break the MTU to below
* RTNL_TC_RTABLE_SIZE.
*/
cell_log = 0;
while ((mtu >> cell_log) >= RTNL_TC_RTABLE_SIZE)
cell_log++;
}
