libnl 1.1
Modules | Defines | Enumerations
Traffic Control
Routing Netlink

Modules

 Queueing Classes
 Classifiers
 Queueing Disciplines

Defines

#define RTNL_TC_RTABLE_SIZE   256
 Number of entries in a transmission time lookup table.

Enumerations

enum  rtnl_tc_stats_id {
  RTNL_TC_PACKETS, RTNL_TC_BYTES, RTNL_TC_RATE_BPS, RTNL_TC_RATE_PPS,
  RTNL_TC_QLEN, RTNL_TC_BACKLOG, RTNL_TC_DROPS, RTNL_TC_REQUEUES,
  RTNL_TC_OVERLIMITS, __RTNL_TC_STATS_MAX
}
 TC statistics identifiers. More...

Utilities

int rtnl_tc_calc_txtime (int bufsize, int rate)
 Calculate time required to transmit buffer at a specific rate.
int rtnl_tc_calc_bufsize (int txtime, int rate)
 Calculate buffer size able to transmit in a specific time and rate.
int rtnl_tc_calc_cell_log (int cell_size)
 Calculate the binary logarithm for a specific cell size.

Rate Tables

int rtnl_tc_build_rate_table (uint32_t *dst, uint8_t mpu, uint8_t overhead, int cell, int rate)
 Compute a transmission time lookup table.

Traffic Control Handle Translations

char * rtnl_tc_handle2str (uint32_t handle, char *buf, size_t len)
 Convert a traffic control handle to a character string (Reentrant).
int rtnl_tc_str2handle (const char *name, uint32_t *res)
 Convert a charactering strint to a traffic control handle.

Enumeration Type Documentation

Enumerator:
RTNL_TC_PACKETS 

Packets seen.

RTNL_TC_BYTES 

Bytes seen.

RTNL_TC_RATE_BPS 

Current bits/s (rate estimator)

RTNL_TC_RATE_PPS 

Current packet/s (rate estimator)

RTNL_TC_QLEN 

Queue length.

RTNL_TC_BACKLOG 

Backlog length.

RTNL_TC_DROPS 

Packets dropped.

RTNL_TC_REQUEUES 

Number of requeues.

RTNL_TC_OVERLIMITS 

Number of overlimits.

Definition at line 27 of file tc.h.

                      {
        RTNL_TC_PACKETS,        /**< Packets seen */
        RTNL_TC_BYTES,          /**< Bytes seen */
        RTNL_TC_RATE_BPS,       /**< Current bits/s (rate estimator) */
        RTNL_TC_RATE_PPS,       /**< Current packet/s (rate estimator) */
        RTNL_TC_QLEN,           /**< Queue length */
        RTNL_TC_BACKLOG,        /**< Backlog length */
        RTNL_TC_DROPS,          /**< Packets dropped */
        RTNL_TC_REQUEUES,       /**< Number of requeues */
        RTNL_TC_OVERLIMITS,     /**< Number of overlimits */
        __RTNL_TC_STATS_MAX,
};

Function Documentation

int rtnl_tc_calc_txtime ( int  bufsize,
int  rate 
)
Parameters:
bufsizeSize of buffer to be transmited in bytes.
rateTransmit rate in bytes per second.

Calculates the number of micro seconds required to transmit a specific buffer at a specific transmit rate.

\[ txtime=\frac{bufsize}{rate}10^6 \]

Returns:
Required transmit time in micro seconds.

Definition at line 383 of file tc.c.

Referenced by rtnl_qdisc_tbf_set_peakrate(), rtnl_qdisc_tbf_set_rate(), and rtnl_tc_build_rate_table().

{
        double tx_time_secs;
        
        tx_time_secs = (double) bufsize / (double) rate;

        return tx_time_secs * 1000000.;
}
int rtnl_tc_calc_bufsize ( int  txtime,
int  rate 
)
Parameters:
txtimeAvailable transmit time in micro seconds.
rateTransmit rate in bytes per second.

Calculates the size of the buffer that can be transmitted in a specific time period at a specific transmit rate.

\[ bufsize=\frac{{txtime} \times {rate}}{10^6} \]

Returns:
Size of buffer in bytes.

Definition at line 406 of file tc.c.

{
        double bufsize;

        bufsize = (double) txtime * (double) rate;

        return bufsize / 1000000.;
}
int rtnl_tc_calc_cell_log ( int  cell_size)
Parameters:
cell_sizeSize of cell, must be a power of two.
Returns:
Binary logirhtm of cell size or a negative error code.

Definition at line 420 of file tc.c.

Referenced by rtnl_tc_build_rate_table().

{
        int i;

        for (i = 0; i < 32; i++)
                if ((1 << i) == cell_size)
                        return i;

        return nl_errno(EINVAL);
}
int rtnl_tc_build_rate_table ( uint32_t *  dst,
uint8_t  mpu,
uint8_t  overhead,
int  cell,
int  rate 
)
Parameters:
dstDestination buffer of RTNL_TC_RTABLE_SIZE uint32_t[].
mpuMinimal size of a packet at all times.
overheadOverhead to be added to each packet.
cellSize of cell, i.e. size of step between entries in bytes.
rateRate in bytes per second.

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 pktsize could be looked up:

 txtime = table[pktsize >> log2(cell)];

Definition at line 454 of file tc.c.

References rtnl_tc_calc_cell_log(), rtnl_tc_calc_txtime(), and RTNL_TC_RTABLE_SIZE.

{
        int i, size, cell_log;

        cell_log = rtnl_tc_calc_cell_log(cell);
        if (cell_log < 0)
                return cell_log;

        for (i = 0; i < RTNL_TC_RTABLE_SIZE; i++) {
                size = (i << cell_log) + overhead;
                if (size < mpu)
                        size = mpu;

                dst[i] = rtnl_tc_calc_txtime(size, rate);
        }

        return 0;
}
char* rtnl_tc_handle2str ( uint32_t  handle,
char *  buf,
size_t  len 
)
Parameters:
handletraffic control handle
bufdestination buffer
lenbuffer length

Converts a tarffic control handle to a character string in the form of MAJ:MIN and stores it in the specified destination buffer.

Returns:
The destination buffer or the type encoded in hexidecimal form if no match was found.

Definition at line 493 of file tc.c.

{
        if (TC_H_ROOT == handle)
                snprintf(buf, len, "root");
        else if (TC_H_UNSPEC == handle)
                snprintf(buf, len, "none");
        else if (0 == TC_H_MAJ(handle))
                snprintf(buf, len, ":%02x", TC_H_MIN(handle));
        else if (0 == TC_H_MIN(handle))
                snprintf(buf, len, "%02x:", TC_H_MAJ(handle) >> 16);
        else
                snprintf(buf, len, "%02x:%02x",
                        TC_H_MAJ(handle) >> 16, TC_H_MIN(handle));

        return buf;
}
int rtnl_tc_str2handle ( const char *  name,
uint32_t *  res 
)
Parameters:
nametraffic control handle as character string
resdestination buffer

Converts the provided character string specifying a traffic control handle to the corresponding numeric value.

The handle must be provided in one of the following formats:

  • root
  • none
  • XXXX:
  • :YYYY
  • XXXX:YYYY
  • XXXXYYYY
Returns:
0 on success or a negative error code

Definition at line 528 of file tc.c.

{
        char *colon, *end;
        uint32_t h;

        if (!strcasecmp(name, "root")) {
                *res = TC_H_ROOT;
                return 0;
        }

        if (!strcasecmp(name, "none")) {
                *res = TC_H_UNSPEC;
                return 0;
        }

        h = strtoul(name, &colon, 16);

        if (colon == name) {
                /* :YYYY */
                h = 0;
                if (':' != *colon)
                        return -EINVAL;
        }

        if (':' == *colon) {
                /* check if we would lose bits */
                if (TC_H_MAJ(h))
                        return -ERANGE;
                h <<= 16;

                if ('\0' == colon[1]) {
                        /* XXXX: */
                        *res = h;
                } else {
                        /* XXXX:YYYY */
                        uint32_t l = strtoul(colon+1, &end, 16);

                        /* check if we overlap with major part */
                        if (TC_H_MAJ(l))
                                return -ERANGE;

                        if ('\0' != *end)
                                return -EINVAL;

                        *res = (h | l);
                }
        } else if ('\0' == *colon) {
                /* XXXXYYYY */
                *res = h;
        } else
                return -EINVAL;

        return 0;
}