tc.rar_Loaded

/* * lib/route/tc.c Traffic Control * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation version 2.1 * of the License. * * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch> */ /** * @ingroup rtnl * @defgroup tc Traffic Control * @brief * @{ */ #include <netlink-local.h> #include <netlink-tc.h> #include <netlink/netlink.h> #include <netlink/utils.h> #include <netlink/route/rtnl.h> #include <netlink/route/link.h> #include <netlink/route/tc.h> /** @cond SKIP */ static struct nla_policy tc_policy[TCA_MAX+1] = { [TCA_KIND] = { .type = NLA_STRING, .maxlen = TCKINDSIZ }, [TCA_STATS] = { .minlen = sizeof(struct tc_stats) }, [TCA_STATS2] = { .type = NLA_NESTED }, }; int tca_parse(struct nlattr **tb, int maxattr, struct rtnl_tca *g, struct nla_policy *policy) { if (g->ce_mask & TCA_ATTR_OPTS) return nla_parse(tb, maxattr, (struct nlattr *) g->tc_opts->d_data, g->tc_opts->d_size, policy); else { /* Ugly but tb[] must be in a defined state even if no * attributes can be found. */ memset(tb, 0, sizeof(struct nlattr *) * (maxattr + 1)); return 0; } } static struct nla_policy tc_stats2_policy[TCA_STATS_MAX+1] = { [TCA_STATS_BASIC] = { .minlen = sizeof(struct gnet_stats_basic) }, [TCA_STATS_RATE_EST] = { .minlen = sizeof(struct gnet_stats_rate_est) }, [TCA_STATS_QUEUE] = { .minlen = sizeof(struct gnet_stats_queue) }, }; int tca_msg_parser(struct nlmsghdr *n, struct rtnl_tca *g) { struct nlattr *tb[TCA_MAX + 1]; struct tcmsg *tm; int err; err = nlmsg_parse(n, sizeof(*tm), tb, TCA_MAX, tc_policy); if (err < 0) return err; if (tb[TCA_KIND] == NULL) return -NLE_MISSING_ATTR; nla_strlcpy(g->tc_kind, tb[TCA_KIND], TCKINDSIZ); tm = nlmsg_data(n); g->tc_family = tm->tcm_family; g->tc_ifindex = tm->tcm_ifindex; g->tc_handle = tm->tcm_handle; g->tc_parent = tm->tcm_parent; g->tc_info = tm->tcm_info; g->ce_mask = (TCA_ATTR_FAMILY | TCA_ATTR_IFINDEX | TCA_ATTR_HANDLE | TCA_ATTR_PARENT | TCA_ATTR_INFO | TCA_ATTR_KIND); if (tb[TCA_OPTIONS]) { g->tc_opts = nl_data_alloc_attr(tb[TCA_OPTIONS]); if (!g->tc_opts) return -NLE_NOMEM; g->ce_mask |= TCA_ATTR_OPTS; } if (tb[TCA_STATS2]) { struct nlattr *tbs[TCA_STATS_MAX + 1]; err = nla_parse_nested(tbs, TCA_STATS_MAX, tb[TCA_STATS2], tc_stats2_policy); if (err < 0) return err; if (tbs[TCA_STATS_BASIC]) { struct gnet_stats_basic *bs; bs = nla_data(tbs[TCA_STATS_BASIC]); g->tc_stats[RTNL_TC_BYTES] = bs->bytes; g->tc_stats[RTNL_TC_PACKETS] = bs->packets; } if (tbs[TCA_STATS_RATE_EST]) { struct gnet_stats_rate_est *re; re = nla_data(tbs[TCA_STATS_RATE_EST]); g->tc_stats[RTNL_TC_RATE_BPS] = re->bps; g->tc_stats[RTNL_TC_RATE_PPS] = re->pps; } if (tbs[TCA_STATS_QUEUE]) { struct gnet_stats_queue *q; q = nla_data(tbs[TCA_STATS_QUEUE]); g->tc_stats[RTNL_TC_QLEN] = q->qlen; g->tc_stats[RTNL_TC_BACKLOG] = q->backlog; g->tc_stats[RTNL_TC_DROPS] = q->drops; g->tc_stats[RTNL_TC_REQUEUES] = q->requeues; g->tc_stats[RTNL_TC_OVERLIMITS] = q->overlimits; } g->ce_mask |= TCA_ATTR_STATS; if (tbs[TCA_STATS_APP]) { g->tc_xstats = nl_data_alloc_attr(tbs[TCA_STATS_APP]); if (g->tc_xstats == NULL) return -NLE_NOMEM; } else goto compat_xstats; } else { if (tb[TCA_STATS]) { struct tc_stats *st = nla_data(tb[TCA_STATS]); g->tc_stats[RTNL_TC_BYTES] = st->bytes; g->tc_stats[RTNL_TC_PACKETS] = st->packets; g->tc_stats[RTNL_TC_RATE_BPS] = st->bps; g->tc_stats[RTNL_TC_RATE_PPS] = st->pps; g->tc_stats[RTNL_TC_QLEN] = st->qlen; g->tc_stats[RTNL_TC_BACKLOG] = st->backlog; g->tc_stats[RTNL_TC_DROPS] = st->drops; g->tc_stats[RTNL_TC_OVERLIMITS] = st->overlimits; g->ce_mask |= TCA_ATTR_STATS; } compat_xstats: if (tb[TCA_XSTATS]) { g->tc_xstats = nl_data_alloc_attr(tb[TCA_XSTATS]); if (g->tc_xstats == NULL) return -NLE_NOMEM; g->ce_mask |= TCA_ATTR_XSTATS; } } return 0; } void tca_free_data(struct rtnl_tca *tca) { nl_data_free(tca->tc_opts); nl_data_free(tca->tc_xstats); } int tca_clone(struct rtnl_tca *dst, struct rtnl_tca *src) { if (src->tc_opts) { dst->tc_opts = nl_data_clone(src->tc_opts); if (!dst->tc_opts) return -NLE_NOMEM; } if (src->tc_xstats) { dst->tc_xstats = nl_data_clone(src->tc_xstats); if (!dst->tc_xstats) return -NLE_NOMEM; } return 0; } void tca_dump_line(struct rtnl_tca *g, const char *type, struct nl_dump_params *p) { char handle[32], parent[32]; struct nl_cache *link_cache; link_cache = nl_cache_mngt_require("route/link"); nl_dump_line(p, "%s %s ", g->tc_kind, type); if (link_cache) { char buf[32]; nl_dump(p, "dev %s ", rtnl_link_i2name(link_cache, g->tc_ifindex, buf, sizeof(buf))); } else nl_dump(p, "dev %u ", g->tc_ifindex); nl_dump(p, "handle %s parent %s", rtnl_tc_handle2str(g->tc_handle, handle, sizeof(handle)), rtnl_tc_handle2str(g->tc_parent, parent, sizeof(parent))); } void tca_dump_details(struct rtnl_tca *g, struct nl_dump_params *p) { nl_dump_line(p, " "); } void tca_dump_stats(struct rtnl_tca *g, struct nl_dump_params *p) { char *unit, fmt[64]; float res; strcpy(fmt, " %7.2f %s %10u %10u %10u %10u %10u\n"); nl_dump_line(p, " Stats: bytes packets drops overlimits" \ " qlen backlog\n"); res = nl_cancel_down_bytes(g->tc_stats[RTNL_TC_BYTES], &unit); if (*unit == 'B') fmt[11] = '9'; nl_dump_line(p, fmt, res, unit, g->tc_stats[RTNL_TC_PACKETS], g->tc_stats[RTNL_TC_DROPS], g->tc_stats[RTNL_TC_OVERLIMITS], g->tc_stats[RTNL_TC_QLEN], g->tc_stats[RTNL_TC_BACKLOG]); res = nl_cancel_down_bytes(g->tc_stats[RTNL_TC_RATE_BPS], &unit); strcpy(fmt, " %7.2f %s/s%9u pps"); if (*unit == 'B') fmt[11] = '9'; nl_dump_line(p, fmt, res, unit, g->tc_stats[RTNL_TC_RATE_PPS]); } int tca_compare(struct nl_object *_a, struct nl_object *_b, uint32_t attrs, int flags) { struct rtnl_tca *a = (struct rtnl_tca *) _a; struct rtnl_tca *b = (struct rtnl_tca *) _b; int diff = 0; #define TC_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, TCA_ATTR_##ATTR, a, b, EXPR) diff |= TC_DIFF(HANDLE, a->tc_handle != b->tc_handle); diff |= TC_DIFF(PARENT, a->tc_parent != b->tc_parent); diff |= TC_DIFF(IFINDEX, a->tc_ifindex != b->tc_ifindex); diff |= TC_DIFF(KIND, strcmp(a->tc_kind, b->tc_kind)); #undef TC_DIFF return diff; } void tca_set_ifindex(struct rtnl_tca *t, int ifindex) { t->tc_ifindex = ifindex; t->ce_mask |= TCA_ATTR_IFINDEX; } int tca_get_ifindex(struct rtnl_tca *t) { return t->tc_ifindex; } void tca_set_handle(struct rtnl_tca *t, uint32_t handle) { t->tc_handle = handle; t->ce_mask |= TCA_ATTR_HANDLE; } uint32_t tca_get_handle(struct rtnl_tca *t) { if (t->ce_mask & TCA_ATTR_HANDLE) return t->tc_handle; else return 0; } void tca_set_parent(struct rtnl_tca *t, uint32_t parent) { t->tc_parent = parent; t->ce_mask |= TCA_ATTR_PARENT; } uint32_t tca_get_parent(struct rtnl_tca *t) { if (t->ce_mask & TCA_ATTR_PARENT) return t->tc_parent; else return 0; } void tca_set_kind(struct rtnl_tca *t, const char *kind) { strncpy(t->tc_kind, kind, sizeof(t->tc_kind) - 1); t->ce_mask |= TCA_ATTR_KIND; } char *tca_get_kind(struct rtnl_tca *t) { if (t->ce_mask & TCA_ATTR_KIND) return t->tc_kind; else return NULL; } uint64_t tca_get_stat(struct rtnl_tca *t, int id) { if (id < 0 || id > RTNL_TC_STATS_MAX) return 0; return t->tc_stats[id]; } int tca_build_msg(struct rtnl_tca *tca, int type, int flags, struct nl_msg **result) { struct nl_msg *msg; struct tcmsg tchdr = { .tcm_family = AF_UNSPEC, .tcm_ifindex = tca->tc_ifindex, .tcm_handle = tca->tc_handle, .tcm_parent = tca->tc_parent, }; msg = nlmsg_alloc_simple(type, flags); if (!msg) return -NLE_NOMEM; if (nlmsg_append(msg, &tc