19 #include <netlink-private/netlink.h> 20 #include <netlink-private/tc.h> 21 #include <netlink/netlink.h> 22 #include <netlink/utils.h> 23 #include <netlink/route/rtnl.h> 24 #include <netlink/route/link.h> 25 #include <netlink/route/tc.h> 26 #include <netlink-private/route/tc-api.h> 28 #include "netlink-private/utils.h" 32 static struct nl_list_head tc_ops_list[__RTNL_TC_TYPE_MAX];
33 static struct rtnl_tc_type_ops *tc_type_ops[__RTNL_TC_TYPE_MAX];
35 static struct nla_policy tc_policy[TCA_MAX+1] = {
37 .maxlen = TCKINDSIZ },
38 [TCA_CHAIN] = { .type =
NLA_U32 },
39 [TCA_STATS] = { .minlen =
sizeof(
struct tc_stats) },
43 int tca_parse(
struct nlattr **tb,
int maxattr,
struct rtnl_tc *g,
47 if (g->ce_mask & TCA_ATTR_OPTS)
49 (
struct nlattr *) g->tc_opts->d_data,
50 g->tc_opts->d_size, policy);
54 memset(tb, 0,
sizeof(
struct nlattr *) * (maxattr + 1));
59 static struct nla_policy tc_stats2_policy[TCA_STATS_MAX+1] = {
60 [TCA_STATS_BASIC] = { .
minlen =
sizeof(
struct gnet_stats_basic) },
61 [TCA_STATS_RATE_EST] = { .minlen =
sizeof(
struct gnet_stats_rate_est) },
62 [TCA_STATS_QUEUE] = { .minlen =
sizeof(
struct gnet_stats_queue) },
65 int rtnl_tc_msg_parse(
struct nlmsghdr *n,
struct rtnl_tc *tc)
67 struct nl_cache *link_cache;
68 struct rtnl_tc_ops *ops;
69 struct nlattr *tb[TCA_MAX + 1];
74 tc->ce_msgtype = n->nlmsg_type;
76 err =
nlmsg_parse(n,
sizeof(*tm), tb, TCA_MAX, tc_policy);
80 if (tb[TCA_KIND] == NULL)
81 return -NLE_MISSING_ATTR;
90 tc->tc_family = tm->tcm_family;
91 tc->tc_ifindex = tm->tcm_ifindex;
92 tc->tc_handle = tm->tcm_handle;
93 tc->tc_parent = tm->tcm_parent;
94 tc->tc_info = tm->tcm_info;
96 tc->ce_mask |= (TCA_ATTR_FAMILY | TCA_ATTR_IFINDEX | TCA_ATTR_HANDLE|
97 TCA_ATTR_PARENT | TCA_ATTR_INFO);
99 if (tb[TCA_OPTIONS]) {
103 tc->ce_mask |= TCA_ATTR_OPTS;
106 if (tb[TCA_STATS2]) {
107 struct nlattr *tbs[TCA_STATS_MAX + 1];
114 if (tbs[TCA_STATS_BASIC]) {
115 struct gnet_stats_basic *bs;
117 bs =
nla_data(tbs[TCA_STATS_BASIC]);
122 if (tbs[TCA_STATS_RATE_EST]) {
123 struct gnet_stats_rate_est *re;
125 re =
nla_data(tbs[TCA_STATS_RATE_EST]);
130 if (tbs[TCA_STATS_QUEUE]) {
131 struct gnet_stats_queue *q;
141 tc->ce_mask |= TCA_ATTR_STATS;
143 if (tbs[TCA_STATS_APP]) {
145 if (tc->tc_xstats == NULL)
147 tc->ce_mask |= TCA_ATTR_XSTATS;
152 struct tc_stats *st =
nla_data(tb[TCA_STATS]);
163 tc->ce_mask |= TCA_ATTR_STATS;
167 if (tb[TCA_XSTATS]) {
169 if (tc->tc_xstats == NULL)
171 tc->ce_mask |= TCA_ATTR_XSTATS;
175 ops = rtnl_tc_get_ops(tc);
176 if (ops && ops->to_msg_parser) {
182 err = ops->to_msg_parser(tc, data);
187 if ((link_cache = __nl_cache_mngt_require(
"route/link"))) {
201 int rtnl_tc_msg_build(
struct rtnl_tc *tc,
int type,
int flags,
202 struct nl_msg **result)
205 struct rtnl_tc_ops *ops;
206 struct tcmsg tchdr = {
207 .tcm_family = AF_UNSPEC,
208 .tcm_ifindex = tc->tc_ifindex,
209 .tcm_handle = tc->tc_handle,
210 .tcm_parent = tc->tc_parent,
218 if (
nlmsg_append(msg, &tchdr,
sizeof(tchdr), NLMSG_ALIGNTO) < 0) {
223 if (tc->ce_mask & TCA_ATTR_KIND)
226 if (tc->ce_mask & TCA_ATTR_CHAIN)
229 ops = rtnl_tc_get_ops(tc);
230 if (ops && (ops->to_msg_fill || ops->to_msg_fill_raw)) {
234 if (ops->to_msg_fill) {
240 if ((err = ops->to_msg_fill(tc, data, msg)) < 0)
243 if (strcmp(
"cgroup", tc->tc_kind))
247 }
else if ((err = ops->to_msg_fill_raw(tc, data, msg)) < 0)
284 tc->ce_mask &= ~TCA_ATTR_LINK;
286 tc->tc_ifindex = ifindex;
287 tc->ce_mask |= TCA_ATTR_IFINDEX;
296 return tc->tc_ifindex;
322 tc->tc_ifindex = link->l_index;
323 tc->ce_mask |= TCA_ATTR_LINK | TCA_ATTR_IFINDEX;
368 tc->ce_mask |= TCA_ATTR_MTU;
382 if (tc->ce_mask & TCA_ATTR_MTU)
384 else if (tc->ce_mask & TCA_ATTR_LINK)
385 return tc->tc_link->l_mtu;
403 tc->ce_mask |= TCA_ATTR_MPU;
431 tc->tc_overhead = overhead;
432 tc->ce_mask |= TCA_ATTR_OVERHEAD;
443 return tc->tc_overhead;
459 tc->tc_linktype = type;
460 tc->ce_mask |= TCA_ATTR_LINKTYPE;
474 if (tc->ce_mask & TCA_ATTR_LINKTYPE)
475 return tc->tc_linktype;
476 else if (tc->ce_mask & TCA_ATTR_LINK)
477 return tc->tc_link->l_arptype;
490 tc->ce_mask |= TCA_ATTR_HANDLE;
499 return tc->tc_handle;
510 tc->tc_parent = parent;
511 tc->ce_mask |= TCA_ATTR_PARENT;
520 return tc->tc_parent;
532 if (tc->ce_mask & TCA_ATTR_KIND)
536 || strlen (kind) >=
sizeof (tc->tc_kind))
539 _nl_strncpy(tc->tc_kind, kind,
sizeof(tc->tc_kind));
541 tc->ce_mask |= TCA_ATTR_KIND;
557 if (tc->ce_mask & TCA_ATTR_KIND)
572 if ((
unsigned int)
id > RTNL_TC_STATS_MAX)
575 return tc->tc_stats[id];
586 tc->tc_chain = chain;
587 tc->ce_mask |= TCA_ATTR_CHAIN;
600 if (!(tc->ce_mask & TCA_ATTR_CHAIN))
601 return -NLE_MISSING_ATTR;
602 *out_value = tc->tc_chain;
613 static const struct trans_tbl tc_stats[] = {
625 char *rtnl_tc_stat2str(
enum rtnl_tc_stat st,
char *buf,
size_t len)
627 return __type2str(st, buf, len, tc_stats, ARRAY_SIZE(tc_stats));
630 int rtnl_tc_str2stat(
const char *name)
632 return __str2type(name, tc_stats, ARRAY_SIZE(tc_stats));
651 return ((
double) bufsize / (
double) rate) * 1000000.0;
670 return ((
double) txtime * (
double) rate) / 1000000.0;
682 for (i = 0; i < 32; i++)
683 if ((1 << i) == cell_size)
712 static unsigned int align_to_atm(
unsigned int size)
715 cells = size / ATM_CELL_PAYLOAD;
716 if ((size % ATM_CELL_PAYLOAD) > 0)
719 linksize = cells * ATM_CELL_SIZE;
723 static unsigned int adjust_size(
unsigned int size,
unsigned int mpu,
731 return align_to_atm(size);
757 uint8_t cell_log = spec->rs_cell_log;
758 unsigned int size, i;
766 if (cell_log == UINT8_MAX) {
773 while ((mtu >> cell_log) >= RTNL_TC_RTABLE_SIZE)
777 for (i = 0; i < RTNL_TC_RTABLE_SIZE; i++) {
778 size = adjust_size((i + 1) << cell_log, spec->rs_mpu, linktype);
779 dst[i] =
nl_us2ticks(rtnl_tc_calc_txtime64(size, spec->rs_rate64));
782 spec->rs_cell_align = -1;
783 spec->rs_cell_log = cell_log;
794 void rtnl_tc_free_data(
struct nl_object *obj)
796 struct rtnl_tc *tc =
TC_CAST(obj);
797 struct rtnl_tc_ops *ops;
803 if (tc->tc_subdata) {
804 ops = rtnl_tc_get_ops(tc);
805 if (ops && ops->to_free_data)
806 ops->to_free_data(tc,
nl_data_get(tc->tc_subdata));
812 int rtnl_tc_clone(
struct nl_object *dstobj,
struct nl_object *srcobj)
814 struct rtnl_tc *dst =
TC_CAST(dstobj);
815 struct rtnl_tc *src =
TC_CAST(srcobj);
816 struct rtnl_tc_ops *ops;
820 dst->tc_link = src->tc_link;
824 dst->tc_xstats = NULL;
825 dst->tc_subdata = NULL;
826 dst->ce_mask &= ~(TCA_ATTR_OPTS |
833 dst->ce_mask |= TCA_ATTR_OPTS;
836 if (src->tc_xstats) {
840 dst->ce_mask |= TCA_ATTR_XSTATS;
843 if (src->tc_subdata) {
849 ops = rtnl_tc_get_ops(src);
850 if (ops && ops->to_clone) {
858 return ops->to_clone(a, b);
864 static int tc_dump(
struct rtnl_tc *tc,
enum nl_dump_type type,
867 struct rtnl_tc_type_ops *type_ops;
868 struct rtnl_tc_ops *ops;
871 type_ops = tc_type_ops[tc->tc_type];
872 if (type_ops && type_ops->tt_dump[type])
873 type_ops->tt_dump[type](tc, p);
875 ops = rtnl_tc_get_ops(tc);
876 if (ops && ops->to_dump[type]) {
877 ops->to_dump[type](tc, data, p);
884 void rtnl_tc_dump_line(
struct nl_object *obj,
struct nl_dump_params *p)
886 struct rtnl_tc_type_ops *type_ops;
887 struct rtnl_tc *tc =
TC_CAST(obj);
888 struct nl_cache *link_cache;
893 type_ops = tc_type_ops[tc->tc_type];
894 if (type_ops && type_ops->tt_dump_prefix)
895 nl_dump(p,
"%s ", type_ops->tt_dump_prefix);
897 nl_dump(p,
"%s ", tc->tc_kind);
904 nl_dump(p,
"dev %u ", tc->tc_ifindex);
916 nl_cache_put(link_cache);
919 void rtnl_tc_dump_details(
struct nl_object *obj,
struct nl_dump_params *p)
921 struct rtnl_tc *tc =
TC_CAST(obj);
923 rtnl_tc_dump_line(OBJ_CAST(tc), p);
925 nl_dump_line(p,
" ");
927 if (tc->ce_mask & TCA_ATTR_MTU)
928 nl_dump(p,
" mtu %u", tc->tc_mtu);
930 if (tc->ce_mask & TCA_ATTR_MPU)
931 nl_dump(p,
" mpu %u", tc->tc_mpu);
933 if (tc->ce_mask & TCA_ATTR_OVERHEAD)
934 nl_dump(p,
" overhead %u", tc->tc_overhead);
941 void rtnl_tc_dump_stats(
struct nl_object *obj,
struct nl_dump_params *p)
943 struct rtnl_tc *tc =
TC_CAST(obj);
947 rtnl_tc_dump_details(OBJ_CAST(tc), p);
950 " stats: %-14s %-10s %-10s %-10s %-10s %-10s\n",
951 "bytes",
"packets",
"drops",
"overlimits",
"qlen",
"backlog");
956 " %10.2f %3s %10u %-10u %-10u %-10u %-10u\n",
967 " %10.2f %3s/s %10u/s\n",
973 uint64_t rtnl_tc_compare(
struct nl_object *aobj,
struct nl_object *bobj,
974 uint64_t attrs,
int flags)
976 struct rtnl_tc *a =
TC_CAST(aobj);
977 struct rtnl_tc *b =
TC_CAST(bobj);
980 #define TC_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, TCA_ATTR_##ATTR, a, b, EXPR) 982 diff |= TC_DIFF(HANDLE, a->tc_handle != b->tc_handle);
983 diff |= TC_DIFF(PARENT, a->tc_parent != b->tc_parent);
984 diff |= TC_DIFF(IFINDEX, a->tc_ifindex != b->tc_ifindex);
985 diff |= TC_DIFF(KIND, strcmp(a->tc_kind, b->tc_kind));
998 struct rtnl_tc_ops *rtnl_tc_lookup_ops(
enum rtnl_tc_type type,
const char *kind)
1000 struct rtnl_tc_ops *ops;
1002 nl_list_for_each_entry(ops, &tc_ops_list[type], to_list)
1003 if (!strcmp(kind, ops->to_kind))
1009 struct rtnl_tc_ops *rtnl_tc_get_ops(
struct rtnl_tc *tc)
1012 tc->tc_ops = rtnl_tc_lookup_ops(tc->tc_type, tc->tc_kind);
1023 static int init = 0;
1034 for (i = 0; i < __RTNL_TC_TYPE_MAX; i++)
1035 nl_init_list_head(&tc_ops_list[i]);
1040 if (!ops->to_kind || ops->to_type > RTNL_TC_TYPE_MAX)
1043 if (rtnl_tc_lookup_ops(ops->to_type, ops->to_kind))
1046 nl_list_add_tail(&ops->to_list, &tc_ops_list[ops->to_type]);
1057 nl_list_del(&ops->to_list);
1070 return tc->tc_subdata ?
nl_data_get(tc->tc_subdata) : NULL;
1084 if (!tc->tc_subdata) {
1088 if (!rtnl_tc_get_ops(tc))
1092 if (!(size = tc->tc_ops->to_size))
1121 if (tc->tc_ops != ops) {
1124 snprintf(buf,
sizeof(buf),
1125 "tc object %p used in %s context but is of type %s",
1126 tc, ops->to_kind, tc->tc_ops->to_kind);
1130 *err = -NLE_OPNOTSUPP;
1143 struct nl_af_group tc_groups[] = {
1144 { AF_UNSPEC, RTNLGRP_TC },
1145 { END_OF_GROUP_LIST },
1149 void rtnl_tc_type_register(
struct rtnl_tc_type_ops *ops)
1151 if (ops->tt_type > RTNL_TC_TYPE_MAX)
1154 tc_type_ops[ops->tt_type] = ops;
1157 void rtnl_tc_type_unregister(
struct rtnl_tc_type_ops *ops)
1159 if (ops->tt_type > RTNL_TC_TYPE_MAX)
1162 tc_type_ops[ops->tt_type] = NULL;
Dump object briefly on one line.
int rtnl_tc_register(struct rtnl_tc_ops *ops)
Register a traffic control module.
uint64_t rtnl_tc_get_stat(struct rtnl_tc *tc, enum rtnl_tc_stat id)
Return value of a statistical counter of a traffic control object.
void nl_new_line(struct nl_dump_params *params)
Handle a new line while dumping.
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_tc_calc_txtime(int bufsize, int rate)
Calculate time required to transmit buffer at a specific rate.
void nlmsg_free(struct nl_msg *msg)
Release a reference from an netlink message.
int nlmsg_parse(struct nlmsghdr *nlh, int hdrlen, struct nlattr *tb[], int maxtype, const struct nla_policy *policy)
parse attributes of a netlink message
int rtnl_tc_set_kind(struct rtnl_tc *tc, const char *kind)
Define the type of traffic control object.
void * nlmsg_data(const struct nlmsghdr *nlh)
Return pointer to message payload.
uint32_t rtnl_tc_get_linktype(struct rtnl_tc *tc)
Return the linktype of a traffic control object.
void * nl_data_get(const struct nl_data *data)
Get data buffer of abstract data object.
uint32_t rtnl_tc_get_overhead(struct rtnl_tc *tc)
Return per packet overhead of a traffic control object.
struct rtnl_link * rtnl_link_get(struct nl_cache *cache, int ifindex)
Lookup link in cache by interface index.
Current bits/s (rate estimator)
int rtnl_tc_calc_cell_log(int cell_size)
Calculate the binary logarithm for a specific cell size.
Attribute validation policy.
struct nl_cache * nl_cache_mngt_require_safe(const char *name)
Return cache previously provided via nl_cache_mngt_provide()
void nl_object_get(struct nl_object *obj)
Acquire a reference on a object.
void rtnl_tc_set_linktype(struct rtnl_tc *tc, uint32_t type)
Set the linktype of a traffic control object.
uint32_t nla_get_u32(const struct nlattr *nla)
Return payload of 32 bit integer attribute.
Current packet/s (rate estimator)
void rtnl_tc_set_parent(struct rtnl_tc *tc, uint32_t parent)
Set the parent identifier of a traffic control object.
struct nl_data * nl_data_alloc_attr(const struct nlattr *nla)
Allocate abstract data object based on netlink attribute.
int nla_nest_end_keep_empty(struct nl_msg *msg, struct nlattr *start)
Finalize nesting of attributes without stripping off empty attributes.
NUL terminated character string.
Dump all attributes but no statistics.
void * rtnl_tc_data_check(struct rtnl_tc *tc, struct rtnl_tc_ops *ops, int *err)
Check traffic control object type and return private data section.
void rtnl_tc_set_link(struct rtnl_tc *tc, struct rtnl_link *link)
Set link of traffic control object.
int nla_nest_end(struct nl_msg *msg, struct nlattr *start)
Finalize nesting of attributes.
void rtnl_tc_unregister(struct rtnl_tc_ops *ops)
Unregister a traffic control module.
uint32_t rtnl_tc_get_handle(struct rtnl_tc *tc)
Return identifier of a traffic control object.
nl_dump_type
Enumeration of dumping variations (dp_type)
Total number of overlimits.
int rtnl_tc_calc_bufsize(int txtime, int rate)
Calculate buffer size able to transmit in a specific time and rate.
int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, const struct nla_policy *policy)
Create attribute index based on nested attribute.
rtnl_tc_stat
Traffic control statistical identifier.
uint32_t rtnl_tc_get_mtu(struct rtnl_tc *tc)
Return the MTU of traffic control object.
double nl_cancel_down_bytes(unsigned long long l, char **unit)
Cancel down a byte counter.
void rtnl_tc_set_ifindex(struct rtnl_tc *tc, int ifindex)
Set interface index of traffic control object.
#define TC_CAST(ptr)
Macro to cast qdisc/class/classifier to tc object.
uint32_t rtnl_tc_get_parent(struct rtnl_tc *tc)
Return parent identifier of a traffic control object.
void * nla_data(const struct nlattr *nla)
Return pointer to the payload section.
#define NLA_PUT_U32(msg, attrtype, value)
Add 32 bit integer attribute to netlink message.
void rtnl_tc_set_handle(struct rtnl_tc *tc, uint32_t id)
Set identifier of traffic control object.
struct nl_data * nl_data_clone(const struct nl_data *src)
Clone an abstract data object.
uint16_t minlen
Minimal length of payload required.
void * rtnl_tc_data(struct rtnl_tc *tc)
Return pointer to private data of traffic control object.
void rtnl_tc_set_mpu(struct rtnl_tc *tc, uint32_t mpu)
Set the Minimum Packet Unit (MPU) of a traffic control object.
int nlmsg_append(struct nl_msg *n, void *data, size_t len, int pad)
Append data to tail of a netlink message.
struct nl_data * nl_data_alloc(const void *buf, size_t size)
Allocate a new abstract data object.
#define NLA_PUT_STRING(msg, attrtype, value)
Add string attribute to netlink message.
void rtnl_tc_set_chain(struct rtnl_tc *tc, uint32_t chain)
Set the chain index of a traffic control object.
uint16_t type
Type of attribute or NLA_UNSPEC.
struct nl_msg * nlmsg_alloc_simple(int nlmsgtype, int flags)
Allocate a new netlink message.
void rtnl_tc_set_mtu(struct rtnl_tc *tc, uint32_t mtu)
Set the Maximum Transmission Unit (MTU) of traffic control object.
uint32_t nl_us2ticks(uint32_t us)
Convert micro seconds to ticks.
char * rtnl_link_i2name(struct nl_cache *cache, int ifindex, char *dst, size_t len)
Translate interface index to corresponding link name.
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_build_rate_table(struct rtnl_tc *tc, struct rtnl_ratespec *spec, uint32_t *dst)
Compute a transmission time lookup table.
char * rtnl_tc_get_kind(struct rtnl_tc *tc)
Return kind of traffic control object.
Total number of requeues.
void rtnl_tc_set_overhead(struct rtnl_tc *tc, uint32_t overhead)
Set per packet overhead of a traffic control object.
uint32_t rtnl_tc_get_mpu(struct rtnl_tc *tc)
Return the Minimum Packet Unit (MPU) of a traffic control object.
struct rtnl_link * rtnl_tc_get_link(struct rtnl_tc *tc)
Get link of traffic control object.
int rtnl_tc_get_chain(struct rtnl_tc *tc, uint32_t *out_value)
Return chain index of traffic control object.
void nl_dump(struct nl_dump_params *params, const char *fmt,...)
Dump a formatted character string.
void * rtnl_tc_data_peek(struct rtnl_tc *tc)
Returns the private data of the traffic control object.
void rtnl_link_put(struct rtnl_link *link)
Return a link object reference.
int rtnl_tc_get_ifindex(struct rtnl_tc *tc)
Return interface index of traffic control object.
Total number of packets dropped.
size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize)
Copy string attribute payload to a buffer.
struct nlattr * nla_nest_start(struct nl_msg *msg, int attrtype)
Start a new level of nested attributes.
void nl_data_free(struct nl_data *data)
Free an abstract data object.