So far all common tc atttributes were accessed via specific functions, i.e.
rtnl_class_set_parent(), rtnl_qdisc_set_parent(), rtnl_cls_set_parent()
which implied a lot of code duplication. Since all tc objects are derived
from struct rtnl_tc and these common attributes are already stored in there
this patch removes all type specific functions and makes rtnl_tc_* attribute
functions public.
rtnl_qdisc_set_parent(qdisc, 10);
becomes:
rtnl_tc_set_parent((struct rtnl_tc *) qdisc, 10);
This patch also adds the following new attributes to tc objects therefore
removing them as tc specific attributes:
- mtu
- mpu
- overhead
This allows for the rate table calculations to be unified as well taking into
account the new kernel behavior to take care of overhead automatically.
#include <linux/pkt_cls.h>
#include <linux/gen_stats.h>
#include <linux/ip_mp_alg.h>
+#include <linux/atm.h>
#include <netlink/netlink.h>
#include <netlink/handlers.h>
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
#ifndef NETLINK_TC_PRIV_H_
extern "C" {
#endif
-#define TCA_ATTR_HANDLE 0x001
-#define TCA_ATTR_PARENT 0x002
-#define TCA_ATTR_IFINDEX 0x004
-#define TCA_ATTR_KIND 0x008
-#define TCA_ATTR_FAMILY 0x010
-#define TCA_ATTR_INFO 0x020
-#define TCA_ATTR_OPTS 0x040
-#define TCA_ATTR_STATS 0x080
-#define TCA_ATTR_XSTATS 0x100
-#define TCA_ATTR_MAX TCA_ATTR_XSTATS
+#define TCA_ATTR_HANDLE 0x0001
+#define TCA_ATTR_PARENT 0x0002
+#define TCA_ATTR_IFINDEX 0x0004
+#define TCA_ATTR_KIND 0x0008
+#define TCA_ATTR_FAMILY 0x0010
+#define TCA_ATTR_INFO 0x0020
+#define TCA_ATTR_OPTS 0x0040
+#define TCA_ATTR_STATS 0x0080
+#define TCA_ATTR_XSTATS 0x0100
+#define TCA_ATTR_LINK 0x0200
+#define TCA_ATTR_MTU 0x0400
+#define TCA_ATTR_MPU 0x0800
+#define TCA_ATTR_OVERHEAD 0x1000
+#define TCA_ATTR_LINKTYPE 0x2000
+#define TCA_ATTR_MAX TCA_ATTR_LINKTYPE
-extern int tca_parse(struct nlattr **, int, struct rtnl_tca *,
+extern int tca_parse(struct nlattr **, int, struct rtnl_tc *,
struct nla_policy *);
-extern int tca_msg_parser(struct nlmsghdr *, struct rtnl_tca *);
-extern void tca_free_data(struct rtnl_tca *);
-extern int tca_clone(struct rtnl_tca *, struct rtnl_tca *);
-extern void tca_dump_line(struct rtnl_tca *, const char *,
+extern int tca_msg_parser(struct nlmsghdr *, struct rtnl_tc *);
+extern void tca_free_data(struct rtnl_tc *);
+extern int tca_clone(struct rtnl_tc *, struct rtnl_tc *);
+extern void tca_dump_line(struct rtnl_tc *, const char *,
struct nl_dump_params *);
-extern void tca_dump_details(struct rtnl_tca *, struct nl_dump_params *);
-extern void tca_dump_stats(struct rtnl_tca *, struct nl_dump_params *);
+extern void tca_dump_details(struct rtnl_tc *, struct nl_dump_params *);
+extern void tca_dump_stats(struct rtnl_tc *, struct nl_dump_params *);
extern int tca_compare(struct nl_object *, struct nl_object *, uint32_t, int);
-extern void tca_set_ifindex(struct rtnl_tca *, int);
-extern int tca_get_ifindex(struct rtnl_tca *);
-extern void tca_set_handle(struct rtnl_tca *, uint32_t);
-extern uint32_t tca_get_handle(struct rtnl_tca *);
-extern void tca_set_parent(struct rtnl_tca *, uint32_t);
-extern uint32_t tca_get_parent(struct rtnl_tca *);
-extern void tca_set_kind(struct rtnl_tca *, const char *);
-extern char *tca_get_kind(struct rtnl_tca *);
-extern uint64_t tca_get_stat(struct rtnl_tca *, int );
+extern void tca_set_kind(struct rtnl_tc *, const char *);
-extern int tca_build_msg(struct rtnl_tca *, int, int, struct nl_msg **);
+extern int tca_build_msg(struct rtnl_tc *, int, int, struct nl_msg **);
-static inline void *tca_priv(struct rtnl_tca *tca)
+#define RTNL_TC_RTABLE_SIZE 256
+
+extern int rtnl_tc_build_rate_table(struct rtnl_tc *tc, struct rtnl_ratespec *,
+ uint32_t *);
+
+
+static inline void *tca_priv(struct rtnl_tc *tca)
{
return tca->tc_subdata;
}
-static inline void *tca_xstats(struct rtnl_tca *tca)
+static inline void *tca_xstats(struct rtnl_tc *tca)
{
return tca->tc_xstats->d_data;
}
uint32_t pre ##_handle; \
uint32_t pre ##_parent; \
uint32_t pre ##_info; \
+ uint32_t pre ##_mtu; \
+ uint32_t pre ##_mpu; \
+ uint32_t pre ##_overhead; \
+ uint32_t pre ##_linktype; \
char pre ##_kind[TCKINDSIZ]; \
struct nl_data * pre ##_opts; \
uint64_t pre ##_stats[RTNL_TC_STATS_MAX+1]; \
struct nl_data * pre ##_xstats; \
struct nl_data * pre ##_subdata; \
+ struct rtnl_link * pre ##_link
-
-struct rtnl_tca
+struct rtnl_tc
{
NL_TCA_GENERIC(tc);
};
struct rtnl_tbf
{
uint32_t qt_limit;
- uint32_t qt_mpu;
struct rtnl_ratespec qt_rate;
uint32_t qt_rate_bucket;
uint32_t qt_rate_txtime;
struct rtnl_htb_class
{
uint32_t ch_prio;
- uint32_t ch_mtu;
struct rtnl_ratespec ch_rate;
struct rtnl_ratespec ch_ceil;
uint32_t ch_rbuffer;
#include <netlink/route/class.h>
#include <netlink/route/class-modules.h>
+#include <netlink/cli/tc.h>
extern struct rtnl_class *nl_cli_class_alloc(void);
extern struct nl_cache *nl_cli_class_alloc_cache(struct nl_sock *, int);
-extern void nl_cli_class_parse_dev(struct rtnl_class *, struct nl_cache *, char *);
-extern void nl_cli_class_parse_parent(struct rtnl_class *, char *);
-extern void nl_cli_class_parse_handle(struct rtnl_class *, char *);
extern void nl_cli_class_parse_kind(struct rtnl_class *, char *);
#endif
extern struct rtnl_qdisc *nl_cli_qdisc_alloc(void);
-extern void nl_cli_qdisc_parse_dev(struct rtnl_qdisc *, struct nl_cache *, char *);
-extern void nl_cli_qdisc_parse_parent(struct rtnl_qdisc *, char *);
-extern void nl_cli_qdisc_parse_handle(struct rtnl_qdisc *, char *);
extern void nl_cli_qdisc_parse_kind(struct rtnl_qdisc *, char *);
#endif
--- /dev/null
+/*
+ * netlink/cli/tc.h CLI Traffic Control Helpers
+ *
+ * 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) 2010 Thomas Graf <tgraf@suug.ch>
+ */
+
+#ifndef __NETLINK_CLI_TC_H_
+#define __NETLINK_CLI_TC_H_
+
+#include <netlink/route/tc.h>
+
+extern void nl_cli_tc_parse_dev(struct rtnl_tc *, struct nl_cache *, char *);
+extern void nl_cli_tc_parse_parent(struct rtnl_tc *, char *);
+extern void nl_cli_tc_parse_handle(struct rtnl_tc *, char *);
+extern void nl_cli_tc_parse_mtu(struct rtnl_tc *, char *);
+extern void nl_cli_tc_parse_mpu(struct rtnl_tc *, char *);
+extern void nl_cli_tc_parse_overhead(struct rtnl_tc *, char *);
+extern void nl_cli_tc_parse_linktype(struct rtnl_tc *, char *);
+
+#endif
struct nl_msg **);
extern int rtnl_class_delete(struct nl_sock *, struct rtnl_class *);
-extern void rtnl_class_set_ifindex(struct rtnl_class *, int);
-extern int rtnl_class_get_ifindex(struct rtnl_class *);
-extern void rtnl_class_set_handle(struct rtnl_class *, uint32_t);
-extern uint32_t rtnl_class_get_handle(struct rtnl_class *);
-extern void rtnl_class_set_parent(struct rtnl_class *, uint32_t);
-extern uint32_t rtnl_class_get_parent(struct rtnl_class *);
extern void rtnl_class_set_kind(struct rtnl_class *, const char *);
-extern char * rtnl_class_get_kind(struct rtnl_class *);
-extern uint64_t rtnl_class_get_stat(struct rtnl_class *,
- enum rtnl_tc_stats_id);
/* iterators */
extern void rtnl_class_foreach_child(struct rtnl_class *,
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2009 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
#ifndef NETLINK_CLASSIFIER_H_
struct nl_msg **);
extern int rtnl_cls_delete(struct nl_sock *, struct rtnl_cls *, int);
-extern void rtnl_cls_set_ifindex(struct rtnl_cls *, int);
-extern int rtnl_cls_get_ifindex(struct rtnl_cls *);
-extern void rtnl_cls_set_handle(struct rtnl_cls *, uint32_t);
-extern void rtnl_cls_set_parent(struct rtnl_cls *, uint32_t);
-extern uint32_t rtnl_cls_get_parent(struct rtnl_cls *);
extern int rtnl_cls_set_kind(struct rtnl_cls *, const char *);
extern struct rtnl_cls_ops *rtnl_cls_get_ops(struct rtnl_cls *);
struct nl_msg **);
extern int rtnl_qdisc_delete(struct nl_sock *, struct rtnl_qdisc *);
-extern void rtnl_qdisc_set_ifindex(struct rtnl_qdisc *, int);
-extern int rtnl_qdisc_get_ifindex(struct rtnl_qdisc *);
-extern void rtnl_qdisc_set_handle(struct rtnl_qdisc *, uint32_t);
-extern uint32_t rtnl_qdisc_get_handle(struct rtnl_qdisc *);
-extern void rtnl_qdisc_set_parent(struct rtnl_qdisc *, uint32_t);
-extern uint32_t rtnl_qdisc_get_parent(struct rtnl_qdisc *);
extern void rtnl_qdisc_set_kind(struct rtnl_qdisc *, const char *);
-extern char * rtnl_qdisc_get_kind(struct rtnl_qdisc *);
-extern uint64_t rtnl_qdisc_get_stat(struct rtnl_qdisc *, enum rtnl_tc_stats_id);
extern void rtnl_qdisc_foreach_child(struct rtnl_qdisc *, struct nl_cache *,
void (*cb)(struct nl_object *, void *),
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2006 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
* Copyright (c) 2005 Petr Gotthard <petr.gotthard@siemens.com>
* Copyright (c) 2005 Siemens AG Oesterreich
*/
extern void rtnl_htb_set_defcls(struct rtnl_qdisc *, uint32_t);
extern void rtnl_htb_set_prio(struct rtnl_class *, uint32_t);
-extern void rtnl_htb_set_mtu(struct rtnl_class *, uint32_t);
extern void rtnl_htb_set_rate(struct rtnl_class *, uint32_t);
extern void rtnl_htb_set_ceil(struct rtnl_class *, uint32_t);
extern void rtnl_htb_set_rbuffer(struct rtnl_class *, uint32_t);
extern void rtnl_htb_set_cbuffer(struct rtnl_class *, uint32_t);
extern void rtnl_htb_set_quantum(struct rtnl_class *, uint32_t quantum);
-extern void rtnl_htb_set_overhead(struct rtnl_class *, uint8_t overhead);
-extern void rtnl_htb_set_mpu(struct rtnl_class *, uint8_t mpu);
#ifdef __cplusplus
}
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2006 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
#ifndef NETLINK_TBF_H_
extern int rtnl_qdisc_tbf_set_limit_by_latency(struct rtnl_qdisc *, int);
extern int rtnl_qdisc_tbf_get_limit(struct rtnl_qdisc *);
-extern int rtnl_qdisc_tbf_set_mpu(struct rtnl_qdisc *, int);
-extern int rtnl_qdisc_tbf_get_mpu(struct rtnl_qdisc *);
-
extern int rtnl_qdisc_tbf_set_rate(struct rtnl_qdisc *, int, int, int);
extern int rtnl_qdisc_tbf_get_rate(struct rtnl_qdisc *);
extern int rtnl_qdisc_tbf_get_rate_bucket(struct rtnl_qdisc *);
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2006 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
#ifndef NETLINK_TC_H_
#include <netlink/netlink.h>
#include <netlink/cache.h>
#include <netlink/data.h>
+#include <netlink/route/link.h>
#ifdef __cplusplus
extern "C" {
#endif
+struct rtnl_tc;
+
/**
- * TC statistics identifiers
* @ingroup tc
*/
enum rtnl_tc_stats_id {
- RTNL_TC_PACKETS, /**< Packets seen */
- RTNL_TC_BYTES, /**< Bytes seen */
+ RTNL_TC_PACKETS, /**< Number of packets seen */
+ RTNL_TC_BYTES, /**< Total 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_QLEN, /**< Current queue length */
+ RTNL_TC_BACKLOG, /**< Current backlog length */
+ RTNL_TC_DROPS, /**< Total number of packets dropped */
+ RTNL_TC_REQUEUES, /**< Total number of requeues */
+ RTNL_TC_OVERLIMITS, /**< Total number of overlimits */
__RTNL_TC_STATS_MAX,
};
#define RTNL_TC_STATS_MAX (__RTNL_TC_STATS_MAX - 1)
-extern int rtnl_tc_calc_txtime(int, int);
-extern int rtnl_tc_calc_bufsize(int, int);
-extern int rtnl_tc_calc_cell_log(int);
-
-/**
- * Number of entries in a transmission time lookup table
- * @ingroup tc
- */
-#define RTNL_TC_RTABLE_SIZE 256
-
-extern int rtnl_tc_build_rate_table(uint32_t *, uint8_t, int, int);
+extern void rtnl_tc_set_ifindex(struct rtnl_tc *, int);
+extern int rtnl_tc_get_ifindex(struct rtnl_tc *);
+extern void rtnl_tc_set_link(struct rtnl_tc *, struct rtnl_link *);
+extern void rtnl_tc_set_mtu(struct rtnl_tc *, uint32_t);
+extern uint32_t rtnl_tc_get_mtu(struct rtnl_tc *);
+extern void rtnl_tc_set_mpu(struct rtnl_tc *, uint32_t);
+extern uint32_t rtnl_tc_get_mpu(struct rtnl_tc *);
+extern void rtnl_tc_set_overhead(struct rtnl_tc *, uint32_t);
+extern uint32_t rtnl_tc_get_overhead(struct rtnl_tc *);
+extern void rtnl_tc_set_linktype(struct rtnl_tc *, uint32_t);
+extern uint32_t rtnl_tc_get_linktype(struct rtnl_tc *);
+extern void rtnl_tc_set_handle(struct rtnl_tc *, uint32_t);
+extern uint32_t rtnl_tc_get_handle(struct rtnl_tc *);
+extern void rtnl_tc_set_parent(struct rtnl_tc *, uint32_t);
+extern uint32_t rtnl_tc_get_parent(struct rtnl_tc *);
+extern char * rtnl_tc_get_kind(struct rtnl_tc *);
+extern uint64_t rtnl_tc_get_stat(struct rtnl_tc *, int );
+extern int rtnl_tc_calc_txtime(int, int);
+extern int rtnl_tc_calc_bufsize(int, int);
+extern int rtnl_tc_calc_cell_log(int);
-/* TC Handle Translations */
extern int rtnl_tc_read_classid_file(void);
extern char * rtnl_tc_handle2str(uint32_t, char *, size_t);
extern int rtnl_tc_str2handle(const char *, uint32_t *);
" --rate=RATE Rate limit.\n"
" --ceil=RATE Rate limit while borrowing (default: equal to --rate).\n"
" --prio=PRIO Priority, lower is served first (default: 0).\n"
-" --mtu=MTU Maximum packet size on the link (default: 1600).\n"
-" --mpu=MPU Minimum packet size on the link (default: 0).\n"
-" --overhead=OVERHEAD Overhead in bytes per packet (default: 0).\n"
" --quantum=SIZE Amount of bytes to serve at once (default: rate/r2q).\n"
" --burst=SIZE Max charge size of rate burst buffer (default: auto).\n"
" --cburst=SIZE Max charge size of ceil rate burst buffer (default: auto)\n"
ARG_QUANTUM = 258,
ARG_CEIL,
ARG_PRIO,
- ARG_MTU,
- ARG_MPU,
- ARG_OVERHEAD,
ARG_BURST,
ARG_CBURST,
};
{ "quantum", 1, 0, ARG_QUANTUM },
{ "ceil", 1, 0, ARG_CEIL },
{ "prio", 1, 0, ARG_PRIO },
- { "mtu", 1, 0, ARG_MTU },
- { "mpu", 1, 0, ARG_MPU },
- { "overhead", 1, 0, ARG_OVERHEAD },
{ "burst", 1, 0, ARG_BURST },
{ "cburst", 1, 0, ARG_CBURST },
{ 0, 0, 0, 0 }
rtnl_htb_set_ceil(class, rate);
break;
- case ARG_MTU:
- rtnl_htb_set_mtu(class, nl_cli_parse_u32(optarg));
- break;
-
- case ARG_MPU:
- rtnl_htb_set_mpu(class, nl_cli_parse_u32(optarg));
- break;
-
- case ARG_OVERHEAD:
- rtnl_htb_set_overhead(class, nl_cli_parse_u32(optarg));
- break;
-
case ARG_PRIO:
rtnl_htb_set_prio(class, nl_cli_parse_u32(optarg));
break;
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
/**
}
class->ce_msgtype = n->nlmsg_type;
- err = tca_msg_parser(n, (struct rtnl_tca *) class);
+ err = tca_msg_parser(n, (struct rtnl_tc *) class);
if (err < 0)
goto errout_free;
struct rtnl_class_ops *cops;
int err;
- err = tca_build_msg((struct rtnl_tca *) class, type, flags, result);
+ err = tca_build_msg((struct rtnl_tc *) class, type, flags, result);
if (err < 0)
return err;
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2006 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
/**
struct rtnl_class *class = (struct rtnl_class *) obj;
struct rtnl_class_ops *cops;
- tca_free_data((struct rtnl_tca *) class);
+ tca_free_data((struct rtnl_tc *) class);
cops = rtnl_class_lookup_ops(class);
if (cops && cops->co_free_data)
struct rtnl_class_ops *cops;
int err;
- err = tca_clone((struct rtnl_tca *) dst, (struct rtnl_tca *) src);
+ err = tca_clone((struct rtnl_tc *) dst, (struct rtnl_tc *) src);
if (err < 0)
goto errout;
struct rtnl_class *class = (struct rtnl_class *) obj;
struct rtnl_class_ops *cops;
- tca_dump_line((struct rtnl_tca *) class, "class", p);
+ tca_dump_line((struct rtnl_tc *) class, "class", p);
cops = rtnl_class_lookup_ops(class);
if (cops && cops->co_dump[NL_DUMP_LINE])
struct rtnl_class_ops *cops;
class_dump_line(obj, p);
- tca_dump_details((struct rtnl_tca *) class, p);
+ tca_dump_details((struct rtnl_tc *) class, p);
if (class->c_info) {
char buf[32];
struct rtnl_class_ops *cops;
class_dump_details(obj, p);
- tca_dump_stats((struct rtnl_tca *) class, p);
+ tca_dump_stats((struct rtnl_tc *) class, p);
nl_dump(p, "\n");
cops = rtnl_class_lookup_ops(class);
if (!filter)
return;
- rtnl_class_set_parent(filter, class->c_handle);
- rtnl_class_set_ifindex(filter, class->c_ifindex);
+ rtnl_tc_set_parent((struct rtnl_tc *) filter, class->c_handle);
+ rtnl_tc_set_ifindex((struct rtnl_tc *) filter, class->c_ifindex);
rtnl_class_set_kind(filter, class->c_kind);
nl_cache_foreach_filter(cache, (struct nl_object *) filter, cb, arg);
if (!filter)
return;
- rtnl_cls_set_ifindex(filter, class->c_ifindex);
- rtnl_cls_set_parent(filter, class->c_parent);
+ rtnl_tc_set_ifindex((struct rtnl_tc *) filter, class->c_ifindex);
+ rtnl_tc_set_parent((struct rtnl_tc *) filter, class->c_parent);
nl_cache_foreach_filter(cache, (struct nl_object *) filter, cb, arg);
rtnl_cls_put(filter);
* @{
*/
-void rtnl_class_set_ifindex(struct rtnl_class *class, int ifindex)
-{
- tca_set_ifindex((struct rtnl_tca *) class, ifindex);
-}
-
-int rtnl_class_get_ifindex(struct rtnl_class *class)
-{
- return tca_get_ifindex((struct rtnl_tca *) class);
-}
-
-void rtnl_class_set_handle(struct rtnl_class *class, uint32_t handle)
-{
- tca_set_handle((struct rtnl_tca *) class, handle);
-}
-
-uint32_t rtnl_class_get_handle(struct rtnl_class *class)
-{
- return tca_get_handle((struct rtnl_tca *) class);
-}
-
-void rtnl_class_set_parent(struct rtnl_class *class, uint32_t parent)
-{
- tca_set_parent((struct rtnl_tca *) class, parent);
-}
-
-uint32_t rtnl_class_get_parent(struct rtnl_class *class)
-{
- return tca_get_parent((struct rtnl_tca *) class);
-}
-
void rtnl_class_set_kind(struct rtnl_class *class, const char *name)
{
- tca_set_kind((struct rtnl_tca *) class, name);
+ tca_set_kind((struct rtnl_tc *) class, name);
class->c_ops = __rtnl_class_lookup_ops(name);
}
-char *rtnl_class_get_kind(struct rtnl_class *class)
-{
- return tca_get_kind((struct rtnl_tca *) class);
-}
-
-uint64_t rtnl_class_get_stat(struct rtnl_class *class,
- enum rtnl_tc_stats_id id)
-{
- return tca_get_stat((struct rtnl_tca *) class, id);
-}
-
/** @} */
struct nl_object_ops class_obj_ops = {
}
cls->ce_msgtype = nlh->nlmsg_type;
- err = tca_msg_parser(nlh, (struct rtnl_tca *) cls);
+ err = tca_msg_parser(nlh, (struct rtnl_tc *) cls);
if (err < 0)
goto errout_free;
int err, prio, proto;
struct tcmsg *tchdr;
- err = tca_build_msg((struct rtnl_tca *) cls, type, flags, result);
+ err = tca_build_msg((struct rtnl_tc *) cls, type, flags, result);
if (err < 0)
return err;
struct rtnl_basic *basic = rtnl_cls_data(cls);
int err;
- err = tca_parse(tb, TCA_BASIC_MAX, (struct rtnl_tca *) cls, basic_policy);
+ err = tca_parse(tb, TCA_BASIC_MAX, (struct rtnl_tc *) cls, basic_policy);
if (err < 0)
return err;
struct nlattr *tb[TCA_CGROUP_MAX + 1];
int err;
- err = tca_parse(tb, TCA_CGROUP_MAX, (struct rtnl_tca *) cls,
+ err = tca_parse(tb, TCA_CGROUP_MAX, (struct rtnl_tc *) cls,
cgroup_policy);
if (err < 0)
return err;
struct nlattr *tb[TCA_FW_MAX + 1];
int err;
- err = tca_parse(tb, TCA_FW_MAX, (struct rtnl_tca *) cls, fw_policy);
+ err = tca_parse(tb, TCA_FW_MAX, (struct rtnl_tc *) cls, fw_policy);
if (err < 0)
return err;
struct nlattr *tb[TCA_U32_MAX + 1];
int err;
- err = tca_parse(tb, TCA_U32_MAX, (struct rtnl_tca *) cls, u32_policy);
+ err = tca_parse(tb, TCA_U32_MAX, (struct rtnl_tc *) cls, u32_policy);
if (err < 0)
return err;
{
uint32_t handle = (htid << 20) | (hash << 12) | nodeid;
- tca_set_handle((struct rtnl_tca *) cls, handle );
+ rtnl_tc_set_handle((struct rtnl_tc *) cls, handle );
}
int rtnl_u32_set_classid(struct rtnl_cls *cls, uint32_t classid)
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2006 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
/**
struct rtnl_cls *cls = (struct rtnl_cls *) obj;
struct rtnl_cls_ops *cops;
- tca_free_data((struct rtnl_tca *) cls);
+ tca_free_data((struct rtnl_tc *) cls);
cops = rtnl_cls_lookup_ops(cls);
if (cops && cops->co_free_data)
struct rtnl_cls_ops *cops;
int err;
- err = tca_clone((struct rtnl_tca *) dst, (struct rtnl_tca *) src);
+ err = tca_clone((struct rtnl_tc *) dst, (struct rtnl_tc *) src);
if (err < 0)
goto errout;
struct rtnl_cls *cls = (struct rtnl_cls *) obj;
struct rtnl_cls_ops *cops;
- tca_dump_line((struct rtnl_tca *) cls, "cls", p);
+ tca_dump_line((struct rtnl_tc *) cls, "cls", p);
nl_dump(p, " prio %u protocol %s", cls->c_prio,
nl_ether_proto2str(cls->c_protocol, buf, sizeof(buf)));
struct rtnl_cls_ops *cops;
cls_dump_line(obj, p);
- tca_dump_details((struct rtnl_tca *) cls, p);
+ tca_dump_details((struct rtnl_tc *) cls, p);
cops = rtnl_cls_lookup_ops(cls);
if (cops && cops->co_dump[NL_DUMP_DETAILS])
struct rtnl_cls_ops *cops;
cls_dump_details(obj, p);
- tca_dump_stats((struct rtnl_tca *) cls, p);
+ tca_dump_stats((struct rtnl_tc *) cls, p);
nl_dump(p, "\n");
cops = rtnl_cls_lookup_ops(cls);
* @{
*/
-void rtnl_cls_set_ifindex(struct rtnl_cls *f, int ifindex)
-{
- tca_set_ifindex((struct rtnl_tca *) f, ifindex);
-}
-
-int rtnl_cls_get_ifindex(struct rtnl_cls *cls)
-{
- return cls->c_ifindex;
-}
-
-void rtnl_cls_set_handle(struct rtnl_cls *f, uint32_t handle)
-{
- tca_set_handle((struct rtnl_tca *) f, handle);
-}
-
-void rtnl_cls_set_parent(struct rtnl_cls *f, uint32_t parent)
-{
- tca_set_parent((struct rtnl_tca *) f, parent);
-}
-
-uint32_t rtnl_cls_get_parent(struct rtnl_cls *cls)
-{
- return cls->c_parent;
-}
-
int rtnl_cls_set_kind(struct rtnl_cls *cls, const char *kind)
{
if (cls->ce_mask & TCA_ATTR_KIND)
return -NLE_EXIST;
- tca_set_kind((struct rtnl_tca *) cls, kind);
+ tca_set_kind((struct rtnl_tc *) cls, kind);
/* Force allocation of data */
rtnl_cls_data(cls);
qdisc->ce_msgtype = n->nlmsg_type;
- err = tca_msg_parser(n, (struct rtnl_tca *) qdisc);
+ err = tca_msg_parser(n, (struct rtnl_tc *) qdisc);
if (err < 0)
goto errout_free;
struct rtnl_qdisc_ops *qops;
int err;
- err = tca_build_msg((struct rtnl_tca *) qdisc, type, flags, result);
+ err = tca_build_msg((struct rtnl_tc *) qdisc, type, flags, result);
if (err < 0)
return err;
struct rtnl_qdisc *qdisc = (struct rtnl_qdisc *) obj;
struct rtnl_qdisc_ops *qops;
- tca_free_data((struct rtnl_tca *) qdisc);
+ tca_free_data((struct rtnl_tc *) qdisc);
qops = rtnl_qdisc_lookup_ops(qdisc);
if (qops && qops->qo_free_data)
struct rtnl_qdisc_ops *qops;
int err;
- err = tca_clone((struct rtnl_tca *) dst, (struct rtnl_tca *) src);
+ err = tca_clone((struct rtnl_tc *) dst, (struct rtnl_tc *) src);
if (err < 0)
goto errout;
struct rtnl_qdisc *qdisc = (struct rtnl_qdisc *) obj;
struct rtnl_qdisc_ops *qops;
- tca_dump_line((struct rtnl_tca *) qdisc, "qdisc", p);
+ tca_dump_line((struct rtnl_tc *) qdisc, "qdisc", p);
qops = rtnl_qdisc_lookup_ops(qdisc);
if (qops && qops->qo_dump[NL_DUMP_LINE])
qdisc_dump_line(arg, p);
- tca_dump_details((struct rtnl_tca *) qdisc, p);
+ tca_dump_details((struct rtnl_tc *) qdisc, p);
nl_dump(p, "refcnt %u ", qdisc->q_info);
qops = rtnl_qdisc_lookup_ops(qdisc);
struct rtnl_qdisc_ops *qops;
qdisc_dump_details(arg, p);
- tca_dump_stats((struct rtnl_tca *) qdisc, p);
+ tca_dump_stats((struct rtnl_tc *) qdisc, p);
nl_dump(p, "\n");
qops = rtnl_qdisc_lookup_ops(qdisc);
if (!filter)
return;
- rtnl_class_set_parent(filter, qdisc->q_handle);
- rtnl_class_set_ifindex(filter, qdisc->q_ifindex);
+ rtnl_tc_set_parent((struct rtnl_tc *) filter, qdisc->q_handle);
+ rtnl_tc_set_ifindex((struct rtnl_tc *) filter, qdisc->q_ifindex);
rtnl_class_set_kind(filter, qdisc->q_kind);
nl_cache_foreach_filter(cache, (struct nl_object *) filter, cb, arg);
if (!filter)
return;
- rtnl_cls_set_ifindex(filter, qdisc->q_ifindex);
- rtnl_cls_set_parent(filter, qdisc->q_parent);
+ rtnl_tc_set_ifindex((struct rtnl_tc *) filter, qdisc->q_ifindex);
+ rtnl_tc_set_parent((struct rtnl_tc *) filter, qdisc->q_parent);
nl_cache_foreach_filter(cache, (struct nl_object *) filter, cb, arg);
rtnl_cls_put(filter);
* @{
*/
-void rtnl_qdisc_set_ifindex(struct rtnl_qdisc *qdisc, int ifindex)
-{
- tca_set_ifindex((struct rtnl_tca *) qdisc, ifindex);
-}
-
-int rtnl_qdisc_get_ifindex(struct rtnl_qdisc *qdisc)
-{
- return tca_get_ifindex((struct rtnl_tca *) qdisc);
-}
-
-void rtnl_qdisc_set_handle(struct rtnl_qdisc *qdisc, uint32_t handle)
-{
- tca_set_handle((struct rtnl_tca *) qdisc, handle);
-}
-
-uint32_t rtnl_qdisc_get_handle(struct rtnl_qdisc *qdisc)
-{
- return tca_get_handle((struct rtnl_tca *) qdisc);
-}
-
-void rtnl_qdisc_set_parent(struct rtnl_qdisc *qdisc, uint32_t parent)
-{
- tca_set_parent((struct rtnl_tca *) qdisc, parent);
-}
-
-uint32_t rtnl_qdisc_get_parent(struct rtnl_qdisc *qdisc)
-{
- return tca_get_parent((struct rtnl_tca *) qdisc);
-}
-
void rtnl_qdisc_set_kind(struct rtnl_qdisc *qdisc, const char *name)
{
- tca_set_kind((struct rtnl_tca *) qdisc, name);
+ tca_set_kind((struct rtnl_tc *) qdisc, name);
qdisc->q_ops = __rtnl_qdisc_lookup_ops(name);
}
-char *rtnl_qdisc_get_kind(struct rtnl_qdisc *qdisc)
-{
- return tca_get_kind((struct rtnl_tca *) qdisc);
-}
-
-uint64_t rtnl_qdisc_get_stat(struct rtnl_qdisc *qdisc,
- enum rtnl_tc_stats_id id)
-{
- return tca_get_stat((struct rtnl_tca *) qdisc, id);
-}
-
/** @} */
/**
[TCA_CBQ_POLICE] = { .minlen = sizeof(struct tc_cbq_police) },
};
-static inline struct rtnl_cbq *cbq_qdisc(struct rtnl_tca *tca)
+static inline struct rtnl_cbq *cbq_qdisc(struct rtnl_tc *tca)
{
return (struct rtnl_cbq *) tca->tc_subdata;
}
-static inline struct rtnl_cbq *cbq_alloc(struct rtnl_tca *tca)
+static inline struct rtnl_cbq *cbq_alloc(struct rtnl_tc *tca)
{
if (!tca->tc_subdata)
tca->tc_subdata = calloc(1, sizeof(struct rtnl_qdisc));
}
-static int cbq_msg_parser(struct rtnl_tca *tca)
+static int cbq_msg_parser(struct rtnl_tc *tca)
{
struct nlattr *tb[TCA_CBQ_MAX + 1];
struct rtnl_cbq *cbq;
static int cbq_qdisc_msg_parser(struct rtnl_qdisc *qdisc)
{
- return cbq_msg_parser((struct rtnl_tca *) qdisc);
+ return cbq_msg_parser((struct rtnl_tc *) qdisc);
}
static int cbq_class_msg_parser(struct rtnl_class *class)
{
- return cbq_msg_parser((struct rtnl_tca *) class);
+ return cbq_msg_parser((struct rtnl_tc *) class);
}
static void cbq_qdisc_free_data(struct rtnl_qdisc *qdisc)
free(qdisc->q_subdata);
}
-static int cbq_clone(struct rtnl_tca *_dst, struct rtnl_tca *_src)
+static int cbq_clone(struct rtnl_tc *_dst, struct rtnl_tc *_src)
{
struct rtnl_cbq *src = cbq_qdisc(_src);
static int cbq_qdisc_clone(struct rtnl_qdisc *dst, struct rtnl_qdisc *src)
{
- return cbq_clone((struct rtnl_tca *) dst, (struct rtnl_tca *) src);
+ return cbq_clone((struct rtnl_tc *) dst, (struct rtnl_tc *) src);
}
static void cbq_class_free_data(struct rtnl_class *class)
static int cbq_class_clone(struct rtnl_class *dst, struct rtnl_class *src)
{
- return cbq_clone((struct rtnl_tca *) dst, (struct rtnl_tca *) src);
+ return cbq_clone((struct rtnl_tc *) dst, (struct rtnl_tc *) src);
}
-static void cbq_dump_line(struct rtnl_tca *tca, struct nl_dump_params *p)
+static void cbq_dump_line(struct rtnl_tc *tca, struct nl_dump_params *p)
{
struct rtnl_cbq *cbq;
double r, rbit;
static void cbq_qdisc_dump_line(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
- cbq_dump_line((struct rtnl_tca *) qdisc, p);
+ cbq_dump_line((struct rtnl_tc *) qdisc, p);
}
static void cbq_class_dump_line(struct rtnl_class *class,
struct nl_dump_params *p)
{
- cbq_dump_line((struct rtnl_tca *) class, p);
+ cbq_dump_line((struct rtnl_tc *) class, p);
}
-static void cbq_dump_details(struct rtnl_tca *tca, struct nl_dump_params *p)
+static void cbq_dump_details(struct rtnl_tc *tca, struct nl_dump_params *p)
{
struct rtnl_cbq *cbq;
char *unit, buf[32];
static void cbq_qdisc_dump_details(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
- cbq_dump_details((struct rtnl_tca *) qdisc, p);
+ cbq_dump_details((struct rtnl_tc *) qdisc, p);
}
static void cbq_class_dump_details(struct rtnl_class *class,
struct nl_dump_params *p)
{
- cbq_dump_details((struct rtnl_tca *) class, p);
+ cbq_dump_details((struct rtnl_tc *) class, p);
}
-static void cbq_dump_stats(struct rtnl_tca *tca, struct nl_dump_params *p)
+static void cbq_dump_stats(struct rtnl_tc *tca, struct nl_dump_params *p)
{
struct tc_cbq_xstats *x = tca_xstats(tca);
static void cbq_qdisc_dump_stats(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
- cbq_dump_stats((struct rtnl_tca *) qdisc, p);
+ cbq_dump_stats((struct rtnl_tc *) qdisc, p);
}
static void cbq_class_dump_stats(struct rtnl_class *class,
struct nl_dump_params *p)
{
- cbq_dump_stats((struct rtnl_tca *) class, p);
+ cbq_dump_stats((struct rtnl_tc *) class, p);
}
static struct rtnl_qdisc_ops cbq_qdisc_ops = {
struct nlattr *tb[TCA_DSMARK_MAX + 1];
struct rtnl_dsmark_qdisc *dsmark;
- err = tca_parse(tb, TCA_DSMARK_MAX, (struct rtnl_tca *) qdisc,
+ err = tca_parse(tb, TCA_DSMARK_MAX, (struct rtnl_tc *) qdisc,
dsmark_policy);
if (err < 0)
return err;
struct nlattr *tb[TCA_DSMARK_MAX + 1];
struct rtnl_dsmark_class *dsmark;
- err = tca_parse(tb, TCA_DSMARK_MAX, (struct rtnl_tca *) class,
+ err = tca_parse(tb, TCA_DSMARK_MAX, (struct rtnl_tc *) class,
dsmark_policy);
if (err < 0)
return err;
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
* Copyright (c) 2005-2006 Petr Gotthard <petr.gotthard@siemens.com>
* Copyright (c) 2005-2006 Siemens AG Oesterreich
*/
#define SCH_HTB_HAS_DEFCLS 0x02
#define SCH_HTB_HAS_PRIO 0x001
-#define SCH_HTB_HAS_MTU 0x002
-#define SCH_HTB_HAS_RATE 0x004
-#define SCH_HTB_HAS_CEIL 0x008
-#define SCH_HTB_HAS_RBUFFER 0x010
-#define SCH_HTB_HAS_CBUFFER 0x020
-#define SCH_HTB_HAS_QUANTUM 0x040
-#define SCH_HTB_HAS_OVERHEAD 0x080
-#define SCH_HTB_HAS_MPU 0x100
+#define SCH_HTB_HAS_RATE 0x002
+#define SCH_HTB_HAS_CEIL 0x004
+#define SCH_HTB_HAS_RBUFFER 0x008
+#define SCH_HTB_HAS_CBUFFER 0x010
+#define SCH_HTB_HAS_QUANTUM 0x020
/** @endcond */
static inline struct rtnl_htb_qdisc *htb_qdisc(struct rtnl_qdisc *qdisc)
struct nlattr *tb[TCA_HTB_MAX + 1];
struct rtnl_htb_qdisc *d;
- err = tca_parse(tb, TCA_HTB_MAX, (struct rtnl_tca *) qdisc, htb_policy);
+ err = tca_parse(tb, TCA_HTB_MAX, (struct rtnl_tc *) qdisc, htb_policy);
if (err < 0)
return err;
int err;
struct nlattr *tb[TCA_HTB_MAX + 1];
struct rtnl_htb_class *d;
+ struct rtnl_tc *tc = (struct rtnl_tc *) class;
- err = tca_parse(tb, TCA_HTB_MAX, (struct rtnl_tca *) class, htb_policy);
+ err = tca_parse(tb, TCA_HTB_MAX, (struct rtnl_tc *) class, htb_policy);
if (err < 0)
return err;
d->ch_cbuffer = rtnl_tc_calc_bufsize(opts.cbuffer, opts.ceil.rate);
d->ch_quantum = opts.quantum;
+ rtnl_tc_set_mpu(tc, d->ch_rate.rs_mpu);
+ rtnl_tc_set_overhead(tc, d->ch_rate.rs_overhead);
+
d->ch_mask = (SCH_HTB_HAS_PRIO | SCH_HTB_HAS_RATE |
SCH_HTB_HAS_CEIL | SCH_HTB_HAS_RBUFFER |
- SCH_HTB_HAS_CBUFFER | SCH_HTB_HAS_QUANTUM |
- SCH_HTB_HAS_OVERHEAD | SCH_HTB_HAS_MPU);
+ SCH_HTB_HAS_CBUFFER | SCH_HTB_HAS_QUANTUM);
}
return 0;
if (d->ch_mask & SCH_HTB_HAS_PRIO)
nl_dump(p, " prio %u", d->ch_prio);
- if (d->ch_mask & SCH_HTB_HAS_MTU)
- nl_dump(p, " mtu %u", d->ch_mtu);
-
if (d->ch_mask & SCH_HTB_HAS_RBUFFER) {
double b;
char *bu;
if (d->ch_mask & SCH_HTB_HAS_QUANTUM)
nl_dump(p, " quantum %u", d->ch_quantum);
-
- if (d->ch_mask & SCH_HTB_HAS_OVERHEAD)
- nl_dump(p, " overhead %u", d->ch_rate.rs_overhead);
-
- if (d->ch_mask & SCH_HTB_HAS_MPU)
- nl_dump(p, " mpu %u", d->ch_rate.rs_mpu);
}
static struct nl_msg *htb_qdisc_get_opts(struct rtnl_qdisc *qdisc)
return msg;
}
-static uint8_t compute_cell(uint32_t rate, uint32_t mtu)
-{
- uint8_t cell_log = 0;
- while (mtu > 255) {
- mtu >>= 1;
- cell_log++;
- }
-
- return cell_log;
-}
-
static struct nl_msg *htb_class_get_opts(struct rtnl_class *class)
{
struct rtnl_htb_class *d = (struct rtnl_htb_class *) class->c_subdata;
if (d == NULL)
return NULL;
+ if (!(d->ch_mask & SCH_HTB_HAS_RATE))
+ BUG();
+
msg = nlmsg_alloc();
+ if (!msg)
+ return NULL;
+
memset(&opts, 0, sizeof(opts));
/* if not set, zero (0) is used as priority */
if (d->ch_mask & SCH_HTB_HAS_PRIO)
opts.prio = d->ch_prio;
- if (d->ch_mask & SCH_HTB_HAS_MTU)
- mtu = d->ch_mtu;
- else
- mtu = 1600; /* eth packet len */
-
- if (!(d->ch_mask & SCH_HTB_HAS_RATE))
- BUG();
+ mtu = rtnl_tc_get_mtu((struct rtnl_tc *) class);
+ rtnl_tc_build_rate_table((struct rtnl_tc *) class, &d->ch_rate, rtable);
rtnl_rcopy_ratespec(&opts.rate, &d->ch_rate);
- /* if cell_log not set, compute default value */
- if (opts.rate.cell_log == UINT8_MAX)
- opts.rate.cell_log = compute_cell(opts.rate.rate, mtu);
- /* if not set, configured rate is used as ceil, which implies no borrowing */
- if (d->ch_mask & SCH_HTB_HAS_CEIL)
+ if (d->ch_mask & SCH_HTB_HAS_CEIL) {
+ rtnl_tc_build_rate_table((struct rtnl_tc *) class, &d->ch_ceil, ctable);
rtnl_rcopy_ratespec(&opts.ceil, &d->ch_ceil);
- else
+ } else {
+ /*
+ * If not set, configured rate is used as ceil, which implies
+ * no borrowing.
+ */
memcpy(&opts.ceil, &opts.rate, sizeof(struct tc_ratespec));
- /* if cell_log not set, compute default value */
- if (opts.ceil.cell_log == UINT8_MAX)
- opts.ceil.cell_log = compute_cell(opts.ceil.rate, mtu);
+ }
if (d->ch_mask & SCH_HTB_HAS_RBUFFER)
buffer = d->ch_rbuffer;
opts.quantum = d->ch_quantum;
nla_put(msg, TCA_HTB_PARMS, sizeof(opts), &opts);
-
- rtnl_tc_build_rate_table(rtable, d->ch_rate.rs_mpu,
- 1 << opts.rate.cell_log,
- opts.rate.rate);
nla_put(msg, TCA_HTB_RTAB, sizeof(rtable), &rtable);
-
- rtnl_tc_build_rate_table(ctable, d->ch_ceil.rs_mpu,
- 1 << opts.ceil.cell_log,
- opts.ceil.rate);
nla_put(msg, TCA_HTB_CTAB, sizeof(ctable), &ctable);
return msg;
d->ch_mask |= SCH_HTB_HAS_PRIO;
}
-/**
- * Set MTU of the data link.
- * @arg class HTB class to be modified.
- * @arg mtu New MTU in bytes.
- *
- * Sets MTU of the data link controlled by the HTB class.
- * If not set, the Ethernet MTU (1600) is used.
- */
-void rtnl_htb_set_mtu(struct rtnl_class *class, uint32_t mtu)
-{
- struct rtnl_htb_class *d = htb_class(class);
- if (d == NULL)
- return;
-
- d->ch_mtu = mtu;
- d->ch_mask |= SCH_HTB_HAS_MTU;
-}
-
/**
* Set rate of HTB class.
* @arg class HTB class to be modified.
d->ch_mask |= SCH_HTB_HAS_QUANTUM;
}
-/**
- * Set per-packet size overhead used in rate computations of HTB class.
- * @arg class HTB class to be modified.
- * @arg overhead Size in bytes.
- */
-void rtnl_htb_set_overhead(struct rtnl_class *class, uint8_t overhead)
-{
- struct rtnl_htb_class *d = htb_class(class);
- if (d == NULL)
- return;
-
- d->ch_rate.rs_overhead = overhead;
- d->ch_ceil.rs_overhead = overhead;
- d->ch_mask |= SCH_HTB_HAS_OVERHEAD;
-}
-
-/**
- * Set the minimum packet size used in rate computations of HTB class.
- * @arg class HTB class to be modified.
- * @arg mpu Size in bytes.
- */
-void rtnl_htb_set_mpu(struct rtnl_class *class, uint8_t mpu)
-{
- struct rtnl_htb_class *d = htb_class(class);
- if (d == NULL)
- return;
-
- d->ch_rate.rs_mpu = mpu;
- d->ch_ceil.rs_mpu = mpu;
- d->ch_mask |= SCH_HTB_HAS_MPU;
-}
-
/** @} */
static struct rtnl_qdisc_ops htb_qdisc_ops = {
if (!(qdisc->ce_mask & TCA_ATTR_OPTS))
return 0;
- err = tca_parse(tb, TCA_RED_MAX, (struct rtnl_tca *) qdisc, red_policy);
+ err = tca_parse(tb, TCA_RED_MAX, (struct rtnl_tc *) qdisc, red_policy);
if (err < 0)
return err;
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
/**
#define TBF_ATTR_LIMIT 0x01
#define TBF_ATTR_RATE 0x02
#define TBF_ATTR_PEAKRATE 0x10
-#define TBF_ATTR_MPU 0x80
/** @endcond */
static inline struct rtnl_tbf *tbf_qdisc(struct rtnl_qdisc *qdisc)
struct nlattr *tb[TCA_TBF_MAX + 1];
struct rtnl_tbf *tbf;
- err = tca_parse(tb, TCA_TBF_MAX, (struct rtnl_tca *) q, tbf_policy);
+ err = tca_parse(tb, TCA_TBF_MAX, (struct rtnl_tc *) q, tbf_policy);
if (err < 0)
return err;
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;
opts.peakrate.rate);
tbf->qt_peakrate_bucket = bufsize;
- tbf->qt_mask = (TBF_ATTR_LIMIT | TBF_ATTR_MPU | TBF_ATTR_RATE |
- TBF_ATTR_PEAKRATE);
+ rtnl_tc_set_mpu((struct rtnl_tc *) q, tbf->qt_rate.rs_mpu);
+ rtnl_tc_set_overhead((struct rtnl_tc *) q, tbf->qt_rate.rs_overhead);
+
+ tbf->qt_mask = (TBF_ATTR_LIMIT | TBF_ATTR_RATE | TBF_ATTR_PEAKRATE);
}
return 0;
double cl = nl_cancel_down_bytes(1 << tbf->qt_rate.rs_cell_log,
&cu);
- nl_dump(p, "mpu %u rate-bucket-size %1.f%s "
+ nl_dump(p, "rate-bucket-size %1.f%s "
"rate-cell-size %.1f%s\n",
- tbf->qt_mpu, bs, bu, cl, cu);
+ bs, bu, cl, cu);
}
struct tc_tbf_qopt opts;
struct rtnl_tbf *tbf;
struct nl_msg *msg;
- uint32_t rtab[RTNL_TC_RTABLE_SIZE];
- uint32_t ptab[RTNL_TC_RTABLE_SIZE];
+ uint32_t rtab[RTNL_TC_RTABLE_SIZE], ptab[RTNL_TC_RTABLE_SIZE];
int required = TBF_ATTR_RATE | TBF_ATTR_LIMIT;
memset(&opts, 0, sizeof(opts));
opts.limit = tbf->qt_limit;
opts.buffer = tbf->qt_rate_txtime;
- tbf->qt_rate.rs_mpu = tbf->qt_mpu;
- rtnl_rcopy_ratespec(&opts.rate, &tbf->qt_rate);
- rtnl_tc_build_rate_table(rtab, tbf->qt_mpu & 0xff,
- 1 << tbf->qt_rate.rs_cell_log,
- tbf->qt_rate.rs_rate);
+ rtnl_tc_build_rate_table((struct rtnl_tc *) qdisc, &tbf->qt_rate, rtab);
+ rtnl_rcopy_ratespec(&opts.rate, &tbf->qt_rate);
if (tbf->qt_mask & TBF_ATTR_PEAKRATE) {
opts.mtu = tbf->qt_peakrate_txtime;
- tbf->qt_peakrate.rs_mpu = tbf->qt_mpu;
+ rtnl_tc_build_rate_table((struct rtnl_tc *) qdisc, &tbf->qt_peakrate, ptab);
rtnl_rcopy_ratespec(&opts.peakrate, &tbf->qt_peakrate);
- rtnl_tc_build_rate_table(ptab, tbf->qt_mpu & 0xff,
- 1 << tbf->qt_peakrate.rs_cell_log,
- tbf->qt_peakrate.rs_rate);
}
msg = nlmsg_alloc();
return -NLE_NOATTR;
}
-/**
- * Set MPU of TBF qdisc.
- * @arg qdisc TBF qdisc to be modified.
- * @arg mpu New MPU in bytes.
- * @return 0 on success or a negative error code.
- */
-int rtnl_qdisc_tbf_set_mpu(struct rtnl_qdisc *qdisc, int mpu)
-{
- struct rtnl_tbf *tbf;
-
- tbf = tbf_alloc(qdisc);
- if (!tbf)
- return -NLE_NOMEM;
-
- tbf->qt_mpu = mpu;
- tbf->qt_mask |= TBF_ATTR_MPU;
-
- return 0;
-}
-
-/**
- * Get MPU of TBF qdisc.
- * @arg qdisc TBF qdisc.
- * @return MPU in bytes or a negative error code.
- */
-int rtnl_qdisc_tbf_get_mpu(struct rtnl_qdisc *qdisc)
-{
- struct rtnl_tbf *tbf;
-
- tbf = tbf_qdisc(qdisc);
- if (tbf && (tbf->qt_mask & TBF_ATTR_MPU))
- return tbf->qt_mpu;
- else
- return -NLE_NOATTR;
-}
-
static inline int calc_cell_log(int cell, int bucket)
{
- if (cell > 0)
cell = rtnl_tc_calc_cell_log(cell);
- else {
- cell = 0;
-
- if (!bucket)
- bucket = 2047; /* defaults to cell_log=3 */
-
- while ((bucket >> cell) > 255)
- cell++;
- }
-
return cell;
}
if (!tbf)
return -NLE_NOMEM;
- cell_log = calc_cell_log(cell, bucket);
- if (cell_log < 0)
- return cell_log;
+ if (!cell)
+ cell_log = UINT8_MAX;
+ else
+ cell_log = rtnl_tc_calc_cell_log(cell);
tbf->qt_rate.rs_rate = rate;
tbf->qt_rate_bucket = bucket;
* License as published by the Free Software Foundation version 2.1
* of the License.
*
- * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2003-2010 Thomas Graf <tgraf@suug.ch>
*/
/**
* @ingroup rtnl
* @defgroup tc Traffic Control
- * @brief
* @{
*/
[TCA_STATS2] = { .type = NLA_NESTED },
};
-int tca_parse(struct nlattr **tb, int maxattr, struct rtnl_tca *g,
+int tca_parse(struct nlattr **tb, int maxattr, struct rtnl_tc *g,
struct nla_policy *policy)
{
[TCA_STATS_QUEUE] = { .minlen = sizeof(struct gnet_stats_queue) },
};
-int tca_msg_parser(struct nlmsghdr *n, struct rtnl_tca *g)
+int tca_msg_parser(struct nlmsghdr *n, struct rtnl_tc *g)
{
struct nlattr *tb[TCA_MAX + 1];
struct tcmsg *tm;
return 0;
}
-void tca_free_data(struct rtnl_tca *tca)
+void tca_free_data(struct rtnl_tc *tca)
{
+ rtnl_link_put(tca->tc_link);
nl_data_free(tca->tc_opts);
nl_data_free(tca->tc_xstats);
}
-int tca_clone(struct rtnl_tca *dst, struct rtnl_tca *src)
+int tca_clone(struct rtnl_tc *dst, struct rtnl_tc *src)
{
+ if (src->tc_link) {
+ dst->tc_link = (struct rtnl_link *)
+ nl_object_clone(OBJ_CAST(src->tc_link));
+ if (!dst->tc_link)
+ return -NLE_NOMEM;
+ }
+
if (src->tc_opts) {
dst->tc_opts = nl_data_clone(src->tc_opts);
if (!dst->tc_opts)
return 0;
}
-void tca_dump_line(struct rtnl_tca *g, const char *type,
+void tca_dump_line(struct rtnl_tc *g, const char *type,
struct nl_dump_params *p)
{
char handle[32], parent[32];
rtnl_tc_handle2str(g->tc_parent, parent, sizeof(parent)));
}
-void tca_dump_details(struct rtnl_tca *g, struct nl_dump_params *p)
+void tca_dump_details(struct rtnl_tc *tc, struct nl_dump_params *p)
{
nl_dump_line(p, " ");
+
+ if (tc->ce_mask & TCA_ATTR_MTU)
+ nl_dump(p, " mtu %u", tc->tc_mtu);
+
+ if (tc->ce_mask & TCA_ATTR_MPU)
+ nl_dump(p, " mput %u", tc->tc_mpu);
+
+ if (tc->ce_mask & TCA_ATTR_OVERHEAD)
+ nl_dump(p, " overhead %u", tc->tc_overhead);
}
-void tca_dump_stats(struct rtnl_tca *g, struct nl_dump_params *p)
+void tca_dump_stats(struct rtnl_tc *g, struct nl_dump_params *p)
{
char *unit, fmt[64];
float res;
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;
+ struct rtnl_tc *a = (struct rtnl_tc *) _a;
+ struct rtnl_tc *b = (struct rtnl_tc *) _b;
int diff = 0;
#define TC_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, TCA_ATTR_##ATTR, a, b, EXPR)
return diff;
}
-void tca_set_ifindex(struct rtnl_tca *t, int ifindex)
+int tca_build_msg(struct rtnl_tc *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, &tchdr, sizeof(tchdr), NLMSG_ALIGNTO) < 0)
+ goto nla_put_failure;
+
+ if (tca->ce_mask & TCA_ATTR_KIND)
+ NLA_PUT_STRING(msg, TCA_KIND, tca->tc_kind);
+
+ *result = msg;
+ return 0;
+
+nla_put_failure:
+ nlmsg_free(msg);
+ return -NLE_MSGSIZE;
+}
+
+void tca_set_kind(struct rtnl_tc *t, const char *kind)
{
- t->tc_ifindex = ifindex;
- t->ce_mask |= TCA_ATTR_IFINDEX;
+ strncpy(t->tc_kind, kind, sizeof(t->tc_kind) - 1);
+ t->ce_mask |= TCA_ATTR_KIND;
}
-int tca_get_ifindex(struct rtnl_tca *t)
+
+/** @endcond */
+
+/**
+ * @name Attributes
+ * @{
+ */
+
+/**
+ * Set interface index of traffic control object
+ * @arg tc traffic control object
+ * @arg ifindex interface index.
+ *
+ * Sets the interface index of a traffic control object. The interface
+ * index defines the network device which this tc object is attached to.
+ * This function will overwrite any network device assigned with previous
+ * calls to rtnl_tc_set_ifindex() or rtnl_tc_set_link().
+ */
+void rtnl_tc_set_ifindex(struct rtnl_tc *tc, int ifindex)
{
- return t->tc_ifindex;
+ /* Obsolete possible old link reference */
+ rtnl_link_put(tc->tc_link);
+ tc->tc_link = NULL;
+ tc->ce_mask &= ~TCA_ATTR_LINK;
+
+ tc->tc_ifindex = ifindex;
+ tc->ce_mask |= TCA_ATTR_IFINDEX;
}
-void tca_set_handle(struct rtnl_tca *t, uint32_t handle)
+/**
+ * Return interface index of traffic control object
+ * @arg tc traffic control object
+ */
+int rtnl_tc_get_ifindex(struct rtnl_tc *tc)
{
- t->tc_handle = handle;
- t->ce_mask |= TCA_ATTR_HANDLE;
+ return tc->tc_ifindex;
}
-uint32_t tca_get_handle(struct rtnl_tca *t)
+/**
+ * Set link of traffic control object
+ * @arg tc traffic control object
+ * @arg link link object
+ *
+ * Sets the link of a traffic control object. This function serves
+ * the same purpose as rtnl_tc_set_ifindex() but due to the continued
+ * allowed access to the link object it gives it the possibility to
+ * retrieve sane default values for the the MTU and the linktype.
+ * Always prefer this function over rtnl_tc_set_ifindex() if you can
+ * spare to have an additional link object around.
+ */
+void rtnl_tc_set_link(struct rtnl_tc *tc, struct rtnl_link *link)
{
- if (t->ce_mask & TCA_ATTR_HANDLE)
- return t->tc_handle;
- else
- return 0;
+ rtnl_link_put(tc->tc_link);
+
+ if (!link)
+ return;
+
+ nl_object_get(OBJ_CAST(link));
+ tc->tc_link = link;
+ tc->tc_ifindex = link->l_index;
+ tc->ce_mask |= TCA_ATTR_LINK | TCA_ATTR_IFINDEX;
}
-void tca_set_parent(struct rtnl_tca *t, uint32_t parent)
+/**
+ * Set the Maximum Transmission Unit (MTU) of traffic control object
+ * @arg tc traffic control object
+ * @arg mtu largest packet size expected
+ *
+ * Sets the MTU of a traffic control object. Not all traffic control
+ * objects will make use of this but it helps while calculating rate
+ * tables. This value is typically derived directly from the link
+ * the tc object is attached to if the link has been assigned via
+ * rtnl_tc_set_link(). It is usually not necessary to set the MTU
+ * manually, this function is provided to allow overwriting the derived
+ * value.
+ */
+void rtnl_tc_set_mtu(struct rtnl_tc *tc, uint32_t mtu)
{
- t->tc_parent = parent;
- t->ce_mask |= TCA_ATTR_PARENT;
+ tc->tc_mtu = mtu;
+ tc->ce_mask |= TCA_ATTR_MTU;
}
-uint32_t tca_get_parent(struct rtnl_tca *t)
+/**
+ * Return the MTU of traffic control object
+ * @arg tc traffic control object
+ *
+ * Returns the MTU of a traffic control object which has been set via:
+ * -# User specified value set via rtnl_tc_set_mtu()
+ * -# Dervied from link set via rtnl_tc_set_link()
+ * -# Fall back to default: ethernet = 1600
+ */
+uint32_t rtnl_tc_get_mtu(struct rtnl_tc *tc)
{
- if (t->ce_mask & TCA_ATTR_PARENT)
- return t->tc_parent;
+ if (tc->ce_mask & TCA_ATTR_MTU)
+ return tc->tc_mtu;
+ else if (tc->ce_mask & TCA_ATTR_LINK)
+ return tc->tc_link->l_mtu;
else
- return 0;
+ return 1600; /* default to ethernet */
}
-void tca_set_kind(struct rtnl_tca *t, const char *kind)
+/**
+ * Set the Minimum Packet Unit (MPU) of a traffic control object
+ * @arg tc traffic control object
+ * @arg mpu minimum packet size expected
+ *
+ * Sets the MPU of a traffic contorl object. It specifies the minimum
+ * packet size to ever hit this traffic control object. Not all traffic
+ * control objects will make use of this but it helps while calculating
+ * rate tables.
+ */
+void rtnl_tc_set_mpu(struct rtnl_tc *tc, uint32_t mpu)
{
- strncpy(t->tc_kind, kind, sizeof(t->tc_kind) - 1);
- t->ce_mask |= TCA_ATTR_KIND;
+ tc->tc_mpu = mpu;
+ tc->ce_mask |= TCA_ATTR_MPU;
}
-char *tca_get_kind(struct rtnl_tca *t)
+/**
+ * Return the Minimum Packet Unit (MPU) of a traffic control object
+ * @arg tc traffic control object
+ *
+ * @return The MPU previously set via rtnl_tc_set_mpu() or 0.
+ */
+uint32_t rtnl_tc_get_mpu(struct rtnl_tc *tc)
{
- if (t->ce_mask & TCA_ATTR_KIND)
- return t->tc_kind;
- else
- return NULL;
+ return tc->tc_mpu;
}
-uint64_t tca_get_stat(struct rtnl_tca *t, int id)
+/**
+ * Set per packet overhead of a traffic control object
+ * @arg tc traffic control object
+ * @arg overhead overhead per packet in bytes
+ *
+ * Sets the per packet overhead in bytes occuring on the link not seen
+ * by the kernel. This value can be used to correct size calculations
+ * if the packet size on the wire does not match the packet sizes seen
+ * in the network stack. Not all traffic control objects will make use
+ * this but it helps while calculating accurate packet sizes in the
+ * kernel.
+ */
+void rtnl_tc_set_overhead(struct rtnl_tc *tc, uint32_t overhead)
{
- if (id < 0 || id > RTNL_TC_STATS_MAX)
- return 0;
+ tc->tc_overhead = overhead;
+ tc->ce_mask |= TCA_ATTR_OVERHEAD;
+}
- return t->tc_stats[id];
+/**
+ * Return per packet overhead of a traffic control object
+ * @arg tc traffic control object
+ *
+ * @return The overhead previously set by rtnl_tc_set_overhead() or 0.
+ */
+uint32_t rtnl_tc_get_overhead(struct rtnl_tc *tc)
+{
+ return tc->tc_overhead;
}
-int tca_build_msg(struct rtnl_tca *tca, int type, int flags,
- struct nl_msg **result)
+/**
+ * Set the linktype of a traffic control object
+ * @arg tc traffic control object
+ * @arg type type of link (e.g. ARPHRD_ATM, ARPHRD_ETHER)
+ *
+ * Overwrites the type of link this traffic control object is attached to.
+ * This value is typically derived from the link this tc object is attached
+ * if the link has been assigned via rtnl_tc_set_link(). It is usually not
+ * necessary to set the linktype manually. This function is provided to
+ * allow overwriting the linktype.
+ */
+void rtnl_tc_set_linktype(struct rtnl_tc *tc, uint32_t type)
{
- 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,
- };
+ tc->tc_linktype = type;
+ tc->ce_mask |= TCA_ATTR_LINKTYPE;
+}
- msg = nlmsg_alloc_simple(type, flags);
- if (!msg)
- return -NLE_NOMEM;
+/**
+ * Return the linktype of a traffic control object
+ * @arg tc traffic control object
+ *
+ * Returns the linktype of the link the traffic control object is attached to:
+ * -# User specified value via rtnl_tc_set_linktype()
+ * -# Value derived from link set via rtnl_tc_set_link()
+ * -# Default fall-back: ARPHRD_ETHER
+ */
+uint32_t rtnl_tc_get_linktype(struct rtnl_tc *tc)
+{
+ if (tc->ce_mask & TCA_ATTR_LINKTYPE)
+ return tc->tc_linktype;
+ else if (tc->ce_mask & TCA_ATTR_LINK)
+ return tc->tc_link->l_arptype;
+ else
+ return ARPHRD_ETHER; /* default to ethernet */
+}
- if (nlmsg_append(msg, &tchdr, sizeof(tchdr), NLMSG_ALIGNTO) < 0)
- goto nla_put_failure;
+/**
+ * Set identifier of traffic control object
+ * @arg tc traffic control object
+ * @arg id unique identifier
+ */
+void rtnl_tc_set_handle(struct rtnl_tc *tc, uint32_t id)
+{
+ tc->tc_handle = id;
+ tc->ce_mask |= TCA_ATTR_HANDLE;
+}
- if (tca->ce_mask & TCA_ATTR_KIND)
- NLA_PUT_STRING(msg, TCA_KIND, tca->tc_kind);
+/**
+ * Return identifier of a traffic control object
+ * @arg tc traffic control object
+ */
+uint32_t rtnl_tc_get_handle(struct rtnl_tc *tc)
+{
+ return tc->tc_handle;
+}
- *result = msg;
- return 0;
+/**
+ * Set the parent identifier of a traffic control object
+ * @arg tc traffic control object
+ * @arg parent identifier of parent traffif control object
+ *
+ */
+void rtnl_tc_set_parent(struct rtnl_tc *tc, uint32_t parent)
+{
+ tc->tc_parent = parent;
+ tc->ce_mask |= TCA_ATTR_PARENT;
+}
-nla_put_failure:
- nlmsg_free(msg);
- return -NLE_MSGSIZE;
+/**
+ * Return parent identifier of a traffic control object
+ * @arg tc traffic control object
+ */
+uint32_t rtnl_tc_get_parent(struct rtnl_tc *tc)
+{
+ return tc->tc_parent;
}
-/** @endcond */
+/**
+ * Return kind of traffic control object
+ * @arg tc traffic control object
+ *
+ * @return Kind of traffic control object or NULL if not set.
+ */
+char *rtnl_tc_get_kind(struct rtnl_tc *tc)
+{
+ if (tc->ce_mask & TCA_ATTR_KIND)
+ return tc->tc_kind;
+ else
+ return NULL;
+}
+
+/**
+ * Return value of a statistical counter of a traffic control object
+ * @arg tc traffic control object
+ * @arg id identifier of statistical counter
+ *
+ * @return Value of requested statistic counter or 0.
+ */
+uint64_t rtnl_tc_get_stat(struct rtnl_tc *tc, int id)
+{
+ if (id < 0 || id > RTNL_TC_STATS_MAX)
+ return 0;
+
+ return tc->tc_stats[id];
+}
+
+/** @} */
/**
* @name Utilities
* @{
*/
+/*
+ * COPYRIGHT NOTE:
+ * align_to_atm() and adjust_size() derived/coped from iproute2 source.
+ */
+
+/*
+ * The align to ATM cells is used for determining the (ATM) SAR
+ * alignment overhead at the ATM layer. (SAR = Segmentation And
+ * Reassembly). This is for example needed when scheduling packet on
+ * an ADSL connection. Note that the extra ATM-AAL overhead is _not_
+ * included in this calculation. This overhead is added in the kernel
+ * before doing the rate table lookup, as this gives better precision
+ * (as the table will always be aligned for 48 bytes).
+ * --Hawk, d.7/11-2004. <hawk@diku.dk>
+ */
+static unsigned int align_to_atm(unsigned int size)
+{
+ int linksize, cells;
+ cells = size / ATM_CELL_PAYLOAD;
+ if ((size % ATM_CELL_PAYLOAD) > 0)
+ cells++;
+
+ linksize = cells * ATM_CELL_SIZE; /* Use full cell size to add ATM tax */
+ return linksize;
+}
+
+static unsigned int adjust_size(unsigned int size, unsigned int mpu,
+ uint32_t linktype)
+{
+ if (size < mpu)
+ size = mpu;
+
+ switch (linktype) {
+ case ARPHRD_ATM:
+ return align_to_atm(size);
+
+ case ARPHRD_ETHER:
+ default:
+ return size;
+ }
+}
+
/**
* Compute a transmission time lookup table
- * @arg dst Destination buffer of RTNL_TC_RTABLE_SIZE uint32_t[].
- * @arg mpu Minimal size of a packet at all times.
- * @arg cell Size of cell, i.e. size of step between entries in bytes.
- * @arg rate Rate in bytes per second.
+ * @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(cell)];
+ * txtime = table[pktsize >> log2(mtu)];
* @endcode
*/
-int rtnl_tc_build_rate_table(uint32_t *dst, uint8_t mpu, int cell, int rate)
+int rtnl_tc_build_rate_table(struct rtnl_tc *tc, struct rtnl_ratespec *spec,
+ uint32_t *dst)
{
- int i, size, cell_log;
-
- cell_log = rtnl_tc_calc_cell_log(cell);
- if (cell_log < 0)
- return cell_log;
+ 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++;
+ }
for (i = 0; i < RTNL_TC_RTABLE_SIZE; i++) {
- size = (i << cell_log);
- if (size < mpu)
- size = mpu;
-
- dst[i] = rtnl_tc_calc_txtime(size, rate);
+ size = adjust_size((i + 1) << cell_log, spec->rs_mpu, linktype);
+ dst[i] = rtnl_tc_calc_txtime(size, spec->rs_rate);
}
+ spec->rs_cell_align = -1;
+ spec->rs_cell_log = cell_log;
+
return 0;
}
${top_builddir}/lib/libnl-genl.la
libnl_cli_la_SOURCES = \
- utils.c addr.c ct.c link.c neigh.c qdisc.c class.c rule.c route.c
+ utils.c addr.c ct.c link.c neigh.c tc.c qdisc.c class.c rule.c route.c
# cls/ematch_syntax.c cls/ematch_grammar.c cls/ematch.c
# cls/pktloc_syntax.c cls/pktloc_grammar.c cls/utils.c
return cache;
}
-void nl_cli_class_parse_dev(struct rtnl_class *class, struct nl_cache *link_cache, char *arg)
-{
- int ival;
-
- if (!(ival = rtnl_link_name2i(link_cache, arg)))
- nl_cli_fatal(ENOENT, "Link \"%s\" does not exist", arg);
-
- rtnl_class_set_ifindex(class, ival);
-}
-
-void nl_cli_class_parse_parent(struct rtnl_class *class, char *arg)
-{
- uint32_t parent;
- int err;
-
- if ((err = rtnl_tc_str2handle(arg, &parent)) < 0)
- nl_cli_fatal(err, "Unable to parse handle \"%s\": %s",
- arg, nl_geterror(err));
-
- rtnl_class_set_parent(class, parent);
-}
-
-void nl_cli_class_parse_handle(struct rtnl_class *class, char *arg)
-{
- uint32_t handle;
- int err;
-
- if ((err = rtnl_tc_str2handle(arg, &handle)) < 0)
- nl_cli_fatal(err, "Unable to parse classid \"%s\": %s",
- arg, nl_geterror(err));
-
- rtnl_class_set_handle(class, handle);
-}
-
void nl_cli_class_parse_kind(struct rtnl_class *class, char *arg)
{
rtnl_class_set_kind(class, arg);
return qdisc;
}
-void nl_cli_qdisc_parse_dev(struct rtnl_qdisc *qdisc, struct nl_cache *link_cache, char *arg)
-{
- int ival;
-
- if (!(ival = rtnl_link_name2i(link_cache, arg)))
- nl_cli_fatal(ENOENT, "Link \"%s\" does not exist", arg);
-
- rtnl_qdisc_set_ifindex(qdisc, ival);
-}
-
-void nl_cli_qdisc_parse_parent(struct rtnl_qdisc *qdisc, char *arg)
-{
- uint32_t parent;
- int err;
-
- if ((err = rtnl_tc_str2handle(arg, &parent)) < 0)
- nl_cli_fatal(err, "Unable to parse handle \"%s\": %s",
- arg, nl_geterror(err));
-
- rtnl_qdisc_set_parent(qdisc, parent);
-}
-
-void nl_cli_qdisc_parse_handle(struct rtnl_qdisc *qdisc, char *arg)
-{
- uint32_t handle;
- int err;
-
- if ((err = rtnl_tc_str2handle(arg, &handle)) < 0)
- nl_cli_fatal(err, "Unable to parse handle \"%s\": %s",
- arg, nl_geterror(err));
-
- rtnl_qdisc_set_handle(qdisc, handle);
-}
-
void nl_cli_qdisc_parse_kind(struct rtnl_qdisc *qdisc, char *arg)
{
rtnl_qdisc_set_kind(qdisc, arg);
--- /dev/null
+/*
+ * src/lib/tc.c CLI Traffic Control Helpers
+ *
+ * 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) 2010 Thomas Graf <tgraf@suug.ch>
+ */
+
+#include <netlink/cli/utils.h>
+#include <netlink/cli/tc.h>
+#include <netlink/route/tc.h>
+
+/**
+ * @ingroup cli
+ * @defgroup cli_tc Queueing Disciplines
+ * @{
+ */
+void nl_cli_tc_parse_dev(struct rtnl_tc *tc, struct nl_cache *link_cache, char *name)
+{
+ struct rtnl_link *link;
+
+ link = rtnl_link_get_by_name(link_cache, name);
+ if (!link)
+ nl_cli_fatal(ENOENT, "Link \"%s\" does not exist.", name);
+
+ rtnl_tc_set_link(tc, link);
+ rtnl_link_put(link);
+}
+
+void nl_cli_tc_parse_parent(struct rtnl_tc *tc, char *arg)
+{
+ uint32_t parent;
+ int err;
+
+ if ((err = rtnl_tc_str2handle(arg, &parent)) < 0)
+ nl_cli_fatal(err, "Unable to parse handle \"%s\": %s",
+ arg, nl_geterror(err));
+
+ rtnl_tc_set_parent(tc, parent);
+}
+
+void nl_cli_tc_parse_handle(struct rtnl_tc *tc, char *arg)
+{
+ uint32_t handle;
+ int err;
+
+ if ((err = rtnl_tc_str2handle(arg, &handle)) < 0)
+ nl_cli_fatal(err, "Unable to parse handle \"%s\": %s",
+ arg, nl_geterror(err));
+
+ rtnl_tc_set_handle(tc, handle);
+}
+
+void nl_cli_tc_parse_mtu(struct rtnl_tc *tc, char *arg)
+{
+ rtnl_tc_set_mtu(tc, nl_cli_parse_u32(arg));
+}
+
+void nl_cli_tc_parse_mpu(struct rtnl_tc *tc, char *arg)
+{
+ rtnl_tc_set_mpu(tc, nl_cli_parse_u32(arg));
+}
+
+void nl_cli_tc_parse_overhead(struct rtnl_tc *tc, char *arg)
+{
+ rtnl_tc_set_overhead(tc, nl_cli_parse_u32(arg));
+}
+
+void nl_cli_tc_parse_linktype(struct rtnl_tc *tc, char *arg)
+{
+ int type;
+
+ if ((type = nl_str2llproto(arg)) < 0)
+ nl_cli_fatal(type, "Unable to parse linktype \"%s\": %s",
+ arg, nl_geterror(type));
+
+ rtnl_tc_set_linktype(tc, type);
+}
+
+/** @} */
*/
#include <netlink/cli/utils.h>
+#include <netlink/cli/tc.h>
#include <netlink/cli/qdisc.h>
#include <netlink/cli/class.h>
#include <netlink/cli/link.h>
" --update Update class if it exists.\n"
" --update-only Only update class, never create it.\n"
" -d, --dev=DEV Network device the class should be attached to.\n"
-" -i, --id=ID ID of new class (default: auto-generated)r\n"
+" -i, --id=ID ID of new class (default: auto-generated)\n"
" -p, --parent=ID ID of parent { root | ingress | class-ID }\n"
+" --mtu=SIZE Overwrite MTU (default: MTU of network device)\n"
+" --mpu=SIZE Minimum packet size on the link (default: 0).\n"
+" --overhead=SIZE Overhead in bytes per packet (default: 0).\n"
+" --linktype=TYPE Overwrite linktype (default: type of network device)\n"
"\n"
"CONFIGURATION\n"
" -h, --help Show help text of class specific options.\n"
{
struct nl_sock *sock;
struct rtnl_class *class;
+ struct rtnl_tc *tc;
struct nl_cache *link_cache;
struct nl_dump_params dp = {
.dp_type = NL_DUMP_DETAILS,
link_cache = nl_cli_link_alloc_cache(sock);
class = nl_cli_class_alloc();
+ tc = (struct rtnl_tc *) class;
for (;;) {
int c, optidx = 0;
enum {
ARG_UPDATE = 257,
ARG_UPDATE_ONLY = 258,
+ ARG_MTU,
+ ARG_MPU,
+ ARG_OVERHEAD,
+ ARG_LINKTYPE,
};
static struct option long_opts[] = {
{ "quiet", 0, 0, 'q' },
{ "id", 1, 0, 'i' },
{ "update", 0, 0, ARG_UPDATE },
{ "update-only", 0, 0, ARG_UPDATE_ONLY },
+ { "mtu", 1, 0, ARG_MTU },
+ { "mpu", 1, 0, ARG_MPU },
+ { "overhead", 1, 0, ARG_OVERHEAD },
+ { "linktype", 1, 0, ARG_LINKTYPE },
{ 0, 0, 0, 0 }
};
case 'q': quiet = 1; break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
- case 'd': nl_cli_class_parse_dev(class, link_cache, optarg); break;
- case 'p': nl_cli_class_parse_parent(class, optarg); break;
- case 'i': nl_cli_class_parse_handle(class, optarg); break;
+ case 'd': nl_cli_tc_parse_dev(tc, link_cache, optarg); break;
+ case 'p': nl_cli_tc_parse_parent(tc, optarg); break;
+ case 'i': nl_cli_tc_parse_handle(tc, optarg); break;
case ARG_UPDATE: flags = NLM_F_CREATE; break;
case ARG_UPDATE_ONLY: flags = 0; break;
+ case ARG_MTU: nl_cli_tc_parse_mtu(tc, optarg); break;
+ case ARG_MPU: nl_cli_tc_parse_mpu(tc, optarg); break;
+ case ARG_OVERHEAD: nl_cli_tc_parse_overhead(tc, optarg); break;
+ case ARG_LINKTYPE: nl_cli_tc_parse_linktype(tc, optarg); break;
}
}
if (optind >= argc)
print_usage();
- if (!rtnl_class_get_ifindex(class))
+ if (!rtnl_tc_get_ifindex(tc))
nl_cli_fatal(EINVAL, "You must specify a network device (--dev=XXX)");
- if (!rtnl_class_get_parent(class))
+ if (!rtnl_tc_get_parent(tc))
nl_cli_fatal(EINVAL, "You must specify a parent (--parent=XXX)");
kind = argv[optind++];
int main(int argc, char *argv[])
{
struct rtnl_class *class;
+ struct rtnl_tc *tc;
struct nl_cache *link_cache, *class_cache;
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
class = nl_cli_class_alloc();
+ tc = (struct rtnl_tc *) class;
for (;;) {
int c, optidx = 0;
case 'q': quiet = 1; break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
- case 'd':
- nl_cli_class_parse_dev(class, link_cache, optarg);
- break;
- case 'p':
- nl_cli_class_parse_parent(class, optarg);
- break;
- case 'i':
- nl_cli_class_parse_handle(class, optarg);
- break;
- case 'k':
- nl_cli_class_parse_kind(class, optarg);
- break;
+ case 'd': nl_cli_tc_parse_dev(tc, link_cache, optarg); break;
+ case 'p': nl_cli_tc_parse_parent(tc, optarg); break;
+ case 'i': nl_cli_tc_parse_handle(tc, optarg); break;
+ case 'k': nl_cli_class_parse_kind(class, optarg); break;
}
}
- if (!rtnl_class_get_ifindex(class))
+ if (!rtnl_tc_get_ifindex(tc))
nl_cli_fatal(EINVAL, "You must specify a network device (--dev=XXX)");
- class_cache = nl_cli_class_alloc_cache(sock, rtnl_class_get_ifindex(class));
+ class_cache = nl_cli_class_alloc_cache(sock, rtnl_tc_get_ifindex(tc));
nl_cache_foreach_filter(class_cache, OBJ_CAST(class), delete_cb, NULL);
*/
#include <netlink/cli/utils.h>
+#include <netlink/cli/tc.h>
#include <netlink/cli/class.h>
#include <netlink/cli/link.h>
int main(int argc, char *argv[])
{
struct rtnl_class *class;
+ struct rtnl_tc *tc;
struct nl_cache *link_cache;
int ifindex;
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
class = nl_cli_class_alloc();
+ tc = (struct rtnl_tc *) class;
params.dp_fd = stdout;
case ARG_STATS: params.dp_type = NL_DUMP_STATS; break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
- case 'd': nl_cli_class_parse_dev(class, link_cache, optarg); break;
- case 'p': nl_cli_class_parse_parent(class, optarg); break;
- case 'i': nl_cli_class_parse_handle(class, optarg); break;
+ case 'd': nl_cli_tc_parse_dev(tc, link_cache, optarg); break;
+ case 'p': nl_cli_tc_parse_parent(tc, optarg); break;
+ case 'i': nl_cli_tc_parse_handle(tc, optarg); break;
case 'k': nl_cli_class_parse_kind(class, optarg); break;
}
}
- if ((ifindex = rtnl_class_get_ifindex(class)))
+ if ((ifindex = rtnl_tc_get_ifindex(tc)))
__dump_class(ifindex, class);
else
nl_cache_foreach(link_cache, dump_class, class);
*/
#include <netlink/cli/utils.h>
+#include <netlink/cli/tc.h>
#include <netlink/cli/qdisc.h>
#include <netlink/cli/link.h>
{
struct nl_sock *sock;
struct rtnl_qdisc *qdisc;
+ struct rtnl_tc *tc;
struct nl_cache *link_cache;
struct nl_dump_params dp = {
.dp_type = NL_DUMP_DETAILS,
link_cache = nl_cli_link_alloc_cache(sock);
qdisc = nl_cli_qdisc_alloc();
+ tc = (struct rtnl_tc *) qdisc;
for (;;) {
int c, optidx = 0;
case 'q': quiet = 1; break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
- case 'd': nl_cli_qdisc_parse_dev(qdisc, link_cache, optarg); break;
- case 'p': nl_cli_qdisc_parse_parent(qdisc, optarg); break;
- case 'i': nl_cli_qdisc_parse_handle(qdisc, optarg); break;
+ case 'd': nl_cli_tc_parse_dev(tc, link_cache, optarg); break;
+ case 'p': nl_cli_tc_parse_parent(tc, optarg); break;
+ case 'i': nl_cli_tc_parse_handle(tc, optarg); break;
case ARG_UPDATE: flags = NLM_F_CREATE; break;
case ARG_REPLACE: flags = NLM_F_CREATE | NLM_F_REPLACE; break;
case ARG_UPDATE_ONLY: flags = 0; break;
if (optind >= argc)
print_usage();
- if (!rtnl_qdisc_get_ifindex(qdisc))
+ if (!rtnl_tc_get_ifindex(tc))
nl_cli_fatal(EINVAL, "You must specify a network device (--dev=XXX)");
- if (!rtnl_qdisc_get_parent(qdisc))
+ if (!rtnl_tc_get_parent(tc))
nl_cli_fatal(EINVAL, "You must specify a parent");
kind = argv[optind++];
*/
#include <netlink/cli/utils.h>
+#include <netlink/cli/tc.h>
#include <netlink/cli/qdisc.h>
#include <netlink/cli/link.h>
int main(int argc, char *argv[])
{
struct rtnl_qdisc *qdisc;
+ struct rtnl_tc *tc;
struct nl_cache *link_cache, *qdisc_cache;
int nfilter = 0;
link_cache = nl_cli_link_alloc_cache(sock);
qdisc_cache = nl_cli_qdisc_alloc_cache(sock);
qdisc = nl_cli_qdisc_alloc();
+ tc = (struct rtnl_tc *) qdisc;
for (;;) {
int c, optidx = 0;
case 'v': nl_cli_print_version(); break;
case 'd':
nfilter++;
- nl_cli_qdisc_parse_dev(qdisc, link_cache, optarg);
+ nl_cli_tc_parse_dev(tc, link_cache, optarg);
break;
case 'p':
nfilter++;
- nl_cli_qdisc_parse_parent(qdisc, optarg);
+ nl_cli_tc_parse_parent(tc, optarg);
break;
case 'i':
nfilter++;
- nl_cli_qdisc_parse_handle(qdisc, optarg);
+ nl_cli_tc_parse_handle(tc, optarg);
break;
case 'k':
nfilter++;
*/
#include <netlink/cli/utils.h>
+#include <netlink/cli/tc.h>
#include <netlink/cli/qdisc.h>
#include <netlink/cli/link.h>
{
struct nl_sock *sock;
struct rtnl_qdisc *qdisc;
+ struct rtnl_tc *tc;
struct nl_cache *link_cache, *qdisc_cache;
struct nl_dump_params params = {
.dp_type = NL_DUMP_LINE,
link_cache = nl_cli_link_alloc_cache(sock);
qdisc_cache = nl_cli_qdisc_alloc_cache(sock);
qdisc = nl_cli_qdisc_alloc();
+ tc = (struct rtnl_tc *) qdisc;
for (;;) {
int c, optidx = 0;
case ARG_STATS: params.dp_type = NL_DUMP_STATS; break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
- case 'd': nl_cli_qdisc_parse_dev(qdisc, link_cache, optarg); break;
- case 'p': nl_cli_qdisc_parse_parent(qdisc, optarg); break;
- case 'i': nl_cli_qdisc_parse_handle(qdisc, optarg); break;
+ case 'd': nl_cli_tc_parse_dev(tc, link_cache, optarg); break;
+ case 'p': nl_cli_tc_parse_parent(tc, optarg); break;
+ case 'i': nl_cli_tc_parse_handle(tc, optarg); break;
case 'k': nl_cli_qdisc_parse_kind(qdisc, optarg); break;
}
}
struct rtnl_qdisc *leaf;
struct rtnl_class *class = (struct rtnl_class *) obj;
struct nl_cache *cls_cache;
- uint32_t parent = rtnl_class_get_handle(class);
+ uint32_t parent = rtnl_tc_get_handle((struct rtnl_tc *) class);
params.dp_prefix = (int)(long) arg;
nl_object_dump(obj, ¶ms);
{
struct rtnl_qdisc *qdisc = (struct rtnl_qdisc *) obj;
struct nl_cache *cls_cache;
- uint32_t parent = rtnl_qdisc_get_handle(qdisc);
+ uint32_t parent = rtnl_tc_get_handle((struct rtnl_tc *) qdisc);
params.dp_prefix = (int)(long) arg;
nl_object_dump(obj, ¶ms);
projects / thirdparty / libnl.git / commitdiff
