dect
/
libnl
Archived
13
0
Fork 0
Code Releases Activity

Remove old line counting while dumping

This commit is contained in:
Thomas Graf 2008-05-23 23:45:14 +02:00
parent 10cf5a586c
commit d844307024
59 changed files with 758 additions and 966 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/netlink-local.h
View File

@ -84,10 +84,6 @@ struct trans_list {
extern int __nl_read_num_str_file(const char *path,
int (*cb)(long, const char *));
/* backwards compat */
#define dp_new_line(params, line) nl_new_line(params)
#define dp_dump(params, fmt, arg...) nl_dump(params, fmt, ##arg)
extern int __trans_list_add(int, const char *, struct nl_list_head *);
extern void __trans_list_clear(struct nl_list_head *);

9
include/netlink-tc.h
View File

@ -34,11 +34,10 @@ extern int tca_parse(struct nlattr **, int, struct rtnl_tca *,
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 int tca_dump_brief(struct rtnl_tca *, const char *,
struct nl_dump_params *, int);
extern int tca_dump_full(struct rtnl_tca *, struct nl_dump_params *, int);
extern int tca_dump_stats(struct rtnl_tca *,
struct nl_dump_params *, int);
extern void tca_dump_line(struct rtnl_tca *, 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 int tca_compare(struct nl_object *, struct nl_object *, uint32_t, int);
extern void tca_set_ifindex(struct rtnl_tca *, int);

10
include/netlink/object-api.h
View File

@ -94,7 +94,6 @@ extern "C" {
* struct nl_dump_params *params)
* {
* struct my_obj *my_obj = nl_object_priv(obj);
* int line = 1; // We will print at least one line for sure
*
* // It is absolutely essential to use nl_dump() when printing
* // any text to make sure the dumping parameters are respected.
@ -102,14 +101,11 @@ extern "C" {
*
* // Before we can dump the next line, make sure to prefix
* // this line correctly.
* nl_new_line(params, line++);
* nl_new_line(params);
*
* // You may also split a line into multiple nl_dump() calls.
* nl_dump(params, "String: %s ", my_obj->my_string);
* nl_dump(params, "String-2: %s\n", my_obj->another_string);
*
* // Return the number of lines dumped
* return line;
* }
*
* struct nl_object_ops my_ops = {
@ -304,8 +300,8 @@ struct nl_object_ops
*
* The functions must return the number of lines printed.
*/
int (*oo_dump[NL_DUMP_MAX+1])(struct nl_object *,
struct nl_dump_params *);
void (*oo_dump[NL_DUMP_MAX+1])(struct nl_object *,
struct nl_dump_params *);
/**
* Comparison function

4
include/netlink/route/class-modules.h
View File

@ -32,8 +32,8 @@ struct rtnl_class_ops
/**
* Dump callbacks
*/
int (*co_dump[NL_DUMP_MAX+1])(struct rtnl_class *,
struct nl_dump_params *, int);
void (*co_dump[NL_DUMP_MAX+1])(struct rtnl_class *,
struct nl_dump_params *);
/**
* Must return the contents supposed to be in TCA_OPTIONS

4
include/netlink/route/classifier-modules.h
View File

@ -32,8 +32,8 @@ struct rtnl_cls_ops
/**
* Dump callbacks
*/
int (*co_dump[NL_DUMP_MAX+1])(struct rtnl_cls *,
struct nl_dump_params *, int);
void (*co_dump[NL_DUMP_MAX+1])(struct rtnl_cls *,
struct nl_dump_params *);
/**
* Must return the contents supposed to be in TCA_OPTIONS
*/

4
include/netlink/route/link/info-api.h
View File

@ -45,8 +45,8 @@ struct rtnl_link_info_ops
/** Called when the link object is dumped.
* Must dump the info type specific attributes. */
int (*io_dump[NL_DUMP_MAX+1])(struct rtnl_link *,
struct nl_dump_params *, int);
void (*io_dump[NL_DUMP_MAX+1])(struct rtnl_link *,
struct nl_dump_params *);
/** Called when a link object is cloned.
* Must clone all info type specific attributes. */

4
include/netlink/route/qdisc-modules.h
View File

@ -32,8 +32,8 @@ struct rtnl_qdisc_ops
/**
* Dump callbacks
*/
int (*qo_dump[NL_DUMP_MAX+1])(struct rtnl_qdisc *,
struct nl_dump_params *, int);
void (*qo_dump[NL_DUMP_MAX+1])(struct rtnl_qdisc *,
struct nl_dump_params *);
/**
* Must return the contents supposed to be in TCA_OPTIONS

6
include/netlink/types.h
View File

@ -19,7 +19,7 @@
* @ingroup utils
*/
enum nl_dump_type {
NL_DUMP_ONELINE, /**< Dump object briefly on one line */
NL_DUMP_LINE, /**< Dump object briefly on one line */
NL_DUMP_DETAILS, /**< Dump all attributes but no statistics */
NL_DUMP_STATS, /**< Dump all attributes including statistics */
NL_DUMP_XML, /**< Dump all attribtes in XML format */
@ -28,10 +28,6 @@ enum nl_dump_type {
};
#define NL_DUMP_MAX (__NL_DUMP_MAX - 1)
/* backards compat */
#define NL_DUMP_BRIEF NL_DUMP_ONELINE
#define NL_DUMP_FULL NL_DUMP_DETAILS
/**
* Dumping parameters
* @ingroup utils

2
lib/cache.c
View File

@ -746,7 +746,7 @@ void nl_cache_dump_filter(struct nl_cache *cache,
struct nl_dump_params *params,
struct nl_object *filter)
{
int type = params ? params->dp_type : NL_DUMP_FULL;
int type = params ? params->dp_type : NL_DUMP_DETAILS;
struct nl_object_ops *ops;
struct nl_object *obj;

21
lib/fib_lookup/lookup.c
View File

@ -121,27 +121,24 @@ errout:
return err;
}
static int result_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
static void result_dump_line(struct nl_object *obj, struct nl_dump_params *p)
{
struct flnl_result *res = (struct flnl_result *) obj;
char buf[128];
int line = 1;
dp_dump(p, "table %s prefixlen %u next-hop-selector %u\n",
nl_dump_line(p, "table %s prefixlen %u next-hop-selector %u\n",
rtnl_route_table2str(res->fr_table_id, buf, sizeof(buf)),
res->fr_prefixlen, res->fr_nh_sel);
dp_dump_line(p, line++, "type %s ",
nl_dump_line(p, "type %s ",
nl_rtntype2str(res->fr_type, buf, sizeof(buf)));
dp_dump(p, "scope %s error %s (%d)\n",
nl_dump(p, "scope %s error %s (%d)\n",
rtnl_scope2str(res->fr_scope, buf, sizeof(buf)),
strerror(-res->fr_error), res->fr_error);
return line;
}
static int result_dump_full(struct nl_object *obj, struct nl_dump_params *p)
static void result_dump_details(struct nl_object *obj, struct nl_dump_params *p)
{
return result_dump_brief(obj, p);
result_dump_line(obj, p);
}
static int result_compare(struct nl_object *_a, struct nl_object *_b,
@ -321,8 +318,10 @@ static struct nl_object_ops result_obj_ops = {
.oo_size = sizeof(struct flnl_result),
.oo_free_data = result_free_data,
.oo_clone = result_clone,
.oo_dump[NL_DUMP_BRIEF] = result_dump_brief,
.oo_dump[NL_DUMP_FULL] = result_dump_full,
.oo_dump = {
[NL_DUMP_LINE] = result_dump_line,
[NL_DUMP_DETAILS] = result_dump_details,
},
.oo_compare = result_compare,
};

34
lib/genl/family.c
View File

@ -71,14 +71,12 @@ static int family_clone(struct nl_object *_dst, struct nl_object *_src)
return 0;
}
static int family_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
static void family_dump_line(struct nl_object *obj, struct nl_dump_params *p)
{
struct genl_family *family = (struct genl_family *) obj;
dp_dump(p, "0x%04x %s version %u\n",
nl_dump(p, "0x%04x %s version %u\n",
family->gf_id, family->gf_name, family->gf_version);
return 1;
}
static struct trans_tbl ops_flags[] = {
@ -93,13 +91,12 @@ static char *ops_flags2str(int flags, char *buf, size_t len)
return __flags2str(flags, buf, len, ops_flags, ARRAY_SIZE(ops_flags));
}
static int family_dump_full(struct nl_object *obj, struct nl_dump_params *p)
static void family_dump_details(struct nl_object *obj, struct nl_dump_params *p)
{
struct genl_family *family = (struct genl_family *) obj;
int line;
line = family_dump_brief(obj, p);
dp_dump_line(p, line++, " hdrsize %u maxattr %u\n",
family_dump_line(obj, p);
nl_dump_line(p, " hdrsize %u maxattr %u\n",
family->gf_hdrsize, family->gf_maxattr);
if (family->ce_mask & FAMILY_ATTR_OPS) {
@ -111,24 +108,21 @@ static int family_dump_full(struct nl_object *obj, struct nl_dump_params *p)
genl_op2name(family->gf_id, op->o_id, buf, sizeof(buf));
dp_dump_line(p, line++, " op %s (0x%02x)",
buf, op->o_id);
nl_dump_line(p, " op %s (0x%02x)", buf, op->o_id);
if (op->o_flags)
dp_dump(p, " <%s>",
nl_dump(p, " <%s>",
ops_flags2str(op->o_flags, buf,
sizeof(buf)));
dp_dump(p, "\n");
nl_dump(p, "\n");
}
}
return line;
}
static int family_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
static void family_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
return family_dump_full(obj, p);
family_dump_details(obj, p);
}
static int family_compare(struct nl_object *_a, struct nl_object *_b,
@ -270,13 +264,15 @@ struct nl_object_ops genl_family_ops = {
.oo_constructor = family_constructor,
.oo_free_data = family_free_data,
.oo_clone = family_clone,
.oo_dump[NL_DUMP_BRIEF] = family_dump_brief,
.oo_dump[NL_DUMP_FULL] = family_dump_full,
.oo_dump[NL_DUMP_STATS] = family_dump_stats,
.oo_dump = {
[NL_DUMP_LINE] = family_dump_line,
[NL_DUMP_DETAILS] = family_dump_details,
[NL_DUMP_STATS] = family_dump_stats,
#if 0
.oo_dump[NL_DUMP_XML] = addr_dump_xml,
.oo_dump[NL_DUMP_ENV] = addr_dump_env,
#endif
},
.oo_compare = family_compare,
.oo_id_attrs = FAMILY_ATTR_ID,
};

33
lib/netfilter/ct_obj.c
View File

@ -171,11 +171,13 @@ static void ct_dump_tuples(struct nfnl_ct *ct, struct nl_dump_params *p)
}
/* Compatible with /proc/net/nf_conntrack */
static int ct_dump(struct nl_object *a, struct nl_dump_params *p)
static void ct_dump_line(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_ct *ct = (struct nfnl_ct *) a;
char buf[64];
nl_new_line(p);
if (nfnl_ct_test_proto(ct))
nl_dump(p, "%s ",
nl_ip_proto2str(nfnl_ct_get_proto(ct), buf, sizeof(buf)));
@ -191,17 +193,15 @@ static int ct_dump(struct nl_object *a, struct nl_dump_params *p)
nl_dump(p, "mark %u ", nfnl_ct_get_mark(ct));
nl_dump(p, "\n");
return 1;
}
static int ct_dump_details(struct nl_object *a, struct nl_dump_params *p)
static void ct_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_ct *ct = (struct nfnl_ct *) a;
char buf[64];
int fp = 0;
ct_dump(a, p);
ct_dump_line(a, p);
nl_dump(p, " id 0x%x ", ct->ct_id);
nl_dump_line(p, "family %s ",
@ -249,28 +249,25 @@ static int ct_dump_details(struct nl_object *a, struct nl_dump_params *p)
if (ct->ct_status)
nl_dump(p, ">");
nl_dump(p, "\n");
return 0;
}
static int ct_dump_stats(struct nl_object *a, struct nl_dump_params *p)
static void ct_dump_stats(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_ct *ct = (struct nfnl_ct *) a;
int line = ct_dump_details(a, p);
double res;
char *unit;
dp_dump_line(p, line++, " # packets volume\n");
ct_dump_details(a, p);
nl_dump_line(p, " # packets volume\n");
res = nl_cancel_down_bytes(nfnl_ct_get_bytes(ct, 1), &unit);
dp_dump_line(p, line++, " rx %10llu %7.2f %s\n",
nl_dump_line(p, " rx %10llu %7.2f %s\n",
nfnl_ct_get_packets(ct, 1), res, unit);
res = nl_cancel_down_bytes(nfnl_ct_get_bytes(ct, 0), &unit);
dp_dump_line(p, line++, " tx %10llu %7.2f %s\n",
nl_dump_line(p, " tx %10llu %7.2f %s\n",
nfnl_ct_get_packets(ct, 0), res, unit);
return line;
}
static int ct_compare(struct nl_object *_a, struct nl_object *_b,
@ -776,9 +773,11 @@ struct nl_object_ops ct_obj_ops = {
.oo_size = sizeof(struct nfnl_ct),
.oo_free_data = ct_free_data,
.oo_clone = ct_clone,
.oo_dump[NL_DUMP_BRIEF] = ct_dump,
.oo_dump[NL_DUMP_FULL] = ct_dump_details,
.oo_dump[NL_DUMP_STATS] = ct_dump_stats,
.oo_dump = {
[NL_DUMP_LINE] = ct_dump_line,
[NL_DUMP_DETAILS] = ct_dump_details,
[NL_DUMP_STATS] = ct_dump_stats,
},
.oo_compare = ct_compare,
.oo_attrs2str = ct_attrs2str,
};

60
lib/netfilter/log_msg_obj.c
View File

@ -6,7 +6,7 @@
* 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-2008 Thomas Graf <tgraf@suug.ch>
* Copyright (c) 2007 Philip Craig <philipc@snapgear.com>
* Copyright (c) 2007 Secure Computing Corporation
*/
@ -70,7 +70,7 @@ errout:
return err;
}
static int log_msg_dump(struct nl_object *a, struct nl_dump_params *p)
static void log_msg_dump(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_log_msg *msg = (struct nfnl_log_msg *) a;
struct nl_cache *link_cache;
@ -78,95 +78,95 @@ static int log_msg_dump(struct nl_object *a, struct nl_dump_params *p)
link_cache = nl_cache_mngt_require("route/link");
nl_new_line(p);
if (msg->ce_mask & LOG_MSG_ATTR_PREFIX)
dp_dump(p, "%s", msg->log_msg_prefix);
nl_dump(p, "%s", msg->log_msg_prefix);
if (msg->ce_mask & LOG_MSG_ATTR_INDEV) {
if (link_cache)
dp_dump(p, "IN=%s ",
nl_dump(p, "IN=%s ",
rtnl_link_i2name(link_cache,
msg->log_msg_indev,
buf, sizeof(buf)));
else
dp_dump(p, "IN=%d ", msg->log_msg_indev);
nl_dump(p, "IN=%d ", msg->log_msg_indev);
}
if (msg->ce_mask & LOG_MSG_ATTR_PHYSINDEV) {
if (link_cache)
dp_dump(p, "PHYSIN=%s ",
nl_dump(p, "PHYSIN=%s ",
rtnl_link_i2name(link_cache,
msg->log_msg_physindev,
buf, sizeof(buf)));
else
dp_dump(p, "IN=%d ", msg->log_msg_physindev);
nl_dump(p, "IN=%d ", msg->log_msg_physindev);
}
if (msg->ce_mask & LOG_MSG_ATTR_OUTDEV) {
if (link_cache)
dp_dump(p, "OUT=%s ",
nl_dump(p, "OUT=%s ",
rtnl_link_i2name(link_cache,
msg->log_msg_outdev,
buf, sizeof(buf)));
else
dp_dump(p, "OUT=%d ", msg->log_msg_outdev);
nl_dump(p, "OUT=%d ", msg->log_msg_outdev);
}
if (msg->ce_mask & LOG_MSG_ATTR_PHYSOUTDEV) {
if (link_cache)
dp_dump(p, "PHYSOUT=%s ",
nl_dump(p, "PHYSOUT=%s ",
rtnl_link_i2name(link_cache,
msg->log_msg_physoutdev,
buf, sizeof(buf)));
else
dp_dump(p, "PHYSOUT=%d ", msg->log_msg_physoutdev);
nl_dump(p, "PHYSOUT=%d ", msg->log_msg_physoutdev);
}
if (msg->ce_mask & LOG_MSG_ATTR_HWADDR) {
int i;
dp_dump(p, "MAC");
nl_dump(p, "MAC");
for (i = 0; i < msg->log_msg_hwaddr_len; i++)
dp_dump(p, "%c%02x", i?':':'=', msg->log_msg_hwaddr[i]);
dp_dump(p, " ");
nl_dump(p, "%c%02x", i?':':'=', msg->log_msg_hwaddr[i]);
nl_dump(p, " ");
}
/* FIXME: parse the payload to get iptables LOG compatible format */
if (msg->ce_mask & LOG_MSG_ATTR_FAMILY)
dp_dump(p, "FAMILY=%s ",
nl_dump(p, "FAMILY=%s ",
nl_af2str(msg->log_msg_family, buf, sizeof(buf)));
if (msg->ce_mask & LOG_MSG_ATTR_HWPROTO)
dp_dump(p, "HWPROTO=%s ",
nl_dump(p, "HWPROTO=%s ",
nl_ether_proto2str(ntohs(msg->log_msg_hwproto),
buf, sizeof(buf)));
if (msg->ce_mask & LOG_MSG_ATTR_HOOK)
dp_dump(p, "HOOK=%s ",
nl_dump(p, "HOOK=%s ",
nfnl_inet_hook2str(msg->log_msg_hook,
buf, sizeof(buf)));
if (msg->ce_mask & LOG_MSG_ATTR_MARK)
dp_dump(p, "MARK=%u ", msg->log_msg_mark);
nl_dump(p, "MARK=%u ", msg->log_msg_mark);
if (msg->ce_mask & LOG_MSG_ATTR_PAYLOAD)
dp_dump(p, "PAYLOADLEN=%d ", msg->log_msg_payload_len);
nl_dump(p, "PAYLOADLEN=%d ", msg->log_msg_payload_len);
if (msg->ce_mask & LOG_MSG_ATTR_UID)
dp_dump(p, "UID=%u ", msg->log_msg_uid);
nl_dump(p, "UID=%u ", msg->log_msg_uid);
if (msg->ce_mask & LOG_MSG_ATTR_GID)
dp_dump(p, "GID=%u ", msg->log_msg_gid);
nl_dump(p, "GID=%u ", msg->log_msg_gid);
if (msg->ce_mask & LOG_MSG_ATTR_SEQ)
dp_dump(p, "SEQ=%d ", msg->log_msg_seq);
nl_dump(p, "SEQ=%d ", msg->log_msg_seq);
if (msg->ce_mask & LOG_MSG_ATTR_SEQ_GLOBAL)
dp_dump(p, "SEQGLOBAL=%d ", msg->log_msg_seq_global);
nl_dump(p, "SEQGLOBAL=%d ", msg->log_msg_seq_global);
dp_dump(p, "\n");
return 1;
nl_dump(p, "\n");
}
/**
@ -448,9 +448,11 @@ struct nl_object_ops log_msg_obj_ops = {
.oo_size = sizeof(struct nfnl_log_msg),
.oo_free_data = log_msg_free_data,
.oo_clone = log_msg_clone,
.oo_dump[NL_DUMP_BRIEF] = log_msg_dump,
.oo_dump[NL_DUMP_FULL] = log_msg_dump,
.oo_dump[NL_DUMP_STATS] = log_msg_dump,
.oo_dump = {
[NL_DUMP_LINE] = log_msg_dump,
[NL_DUMP_DETAILS] = log_msg_dump,
[NL_DUMP_STATS] = log_msg_dump,
},
};
/** @} */

30
lib/netfilter/log_obj.c
View File

@ -6,7 +6,7 @@
* 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-2008 Thomas Graf <tgraf@suug.ch>
* Copyright (c) 2007 Philip Craig <philipc@snapgear.com>
* Copyright (c) 2007 Secure Computing Corporation
* Copyright (c) 2008 Patrick McHardy <kaber@trash.net>
@ -26,34 +26,34 @@
/** @endcond */
static int nfnl_log_dump(struct nl_object *a, struct nl_dump_params *p)
static void nfnl_log_dump(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_log *log = (struct nfnl_log *) a;
char buf[64];
nl_new_line(p);
if (log->ce_mask & LOG_ATTR_GROUP)
dp_dump(p, "group=%u ", log->log_group);
nl_dump(p, "group=%u ", log->log_group);
if (log->ce_mask & LOG_ATTR_COPY_MODE)
dp_dump(p, "copy_mode=%s ",
nl_dump(p, "copy_mode=%s ",
nfnl_log_copy_mode2str(log->log_copy_mode,
buf, sizeof(buf)));
if (log->ce_mask & LOG_ATTR_COPY_RANGE)
dp_dump(p, "copy_range=%u ", log->log_copy_range);
nl_dump(p, "copy_range=%u ", log->log_copy_range);
if (log->ce_mask & LOG_ATTR_FLUSH_TIMEOUT)
dp_dump(p, "flush_timeout=%u ", log->log_flush_timeout);
nl_dump(p, "flush_timeout=%u ", log->log_flush_timeout);
if (log->ce_mask & LOG_ATTR_ALLOC_SIZE)
dp_dump(p, "alloc_size=%u ", log->log_alloc_size);
nl_dump(p, "alloc_size=%u ", log->log_alloc_size);
if (log->ce_mask & LOG_ATTR_QUEUE_THRESHOLD)
dp_dump(p, "queue_threshold=%u ", log->log_queue_threshold);
nl_dump(p, "queue_threshold=%u ", log->log_queue_threshold);
dp_dump(p, "\n");
return 1;
nl_dump(p, "\n");
}
static struct trans_tbl copy_modes[] = {
@ -274,9 +274,11 @@ static char *nfnl_log_attrs2str(int attrs, char *buf, size_t len)
struct nl_object_ops log_obj_ops = {
.oo_name = "netfilter/log",
.oo_size = sizeof(struct nfnl_log),
.oo_dump[NL_DUMP_BRIEF] = nfnl_log_dump,
.oo_dump[NL_DUMP_FULL] = nfnl_log_dump,
.oo_dump[NL_DUMP_STATS] = nfnl_log_dump,
.oo_dump = {
[NL_DUMP_LINE] = nfnl_log_dump,
[NL_DUMP_DETAILS] = nfnl_log_dump,
[NL_DUMP_STATS] = nfnl_log_dump,
},
.oo_compare = nfnl_log_compare,
.oo_attrs2str = nfnl_log_attrs2str,
.oo_id_attrs = LOG_ATTR_GROUP,

54
lib/netfilter/queue_msg_obj.c
View File

@ -60,7 +60,7 @@ errout:
return err;
}
static int nfnl_queue_msg_dump(struct nl_object *a, struct nl_dump_params *p)
static void nfnl_queue_msg_dump(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_queue_msg *msg = (struct nfnl_queue_msg *) a;
struct nl_cache *link_cache;
@ -68,90 +68,90 @@ static int nfnl_queue_msg_dump(struct nl_object *a, struct nl_dump_params *p)
link_cache = nl_cache_mngt_require("route/link");
nl_new_line(p);
if (msg->ce_mask & QUEUE_MSG_ATTR_GROUP)
dp_dump(p, "GROUP=%u ", msg->queue_msg_group);
nl_dump(p, "GROUP=%u ", msg->queue_msg_group);
if (msg->ce_mask & QUEUE_MSG_ATTR_INDEV) {
if (link_cache)
dp_dump(p, "IN=%s ",
nl_dump(p, "IN=%s ",
rtnl_link_i2name(link_cache,
msg->queue_msg_indev,
buf, sizeof(buf)));
else
dp_dump(p, "IN=%d ", msg->queue_msg_indev);
nl_dump(p, "IN=%d ", msg->queue_msg_indev);
}
if (msg->ce_mask & QUEUE_MSG_ATTR_PHYSINDEV) {
if (link_cache)
dp_dump(p, "PHYSIN=%s ",
nl_dump(p, "PHYSIN=%s ",
rtnl_link_i2name(link_cache,
msg->queue_msg_physindev,
buf, sizeof(buf)));
else
dp_dump(p, "IN=%d ", msg->queue_msg_physindev);
nl_dump(p, "IN=%d ", msg->queue_msg_physindev);
}
if (msg->ce_mask & QUEUE_MSG_ATTR_OUTDEV) {
if (link_cache)
dp_dump(p, "OUT=%s ",
nl_dump(p, "OUT=%s ",
rtnl_link_i2name(link_cache,
msg->queue_msg_outdev,
buf, sizeof(buf)));
else
dp_dump(p, "OUT=%d ", msg->queue_msg_outdev);
nl_dump(p, "OUT=%d ", msg->queue_msg_outdev);
}
if (msg->ce_mask & QUEUE_MSG_ATTR_PHYSOUTDEV) {
if (link_cache)
dp_dump(p, "PHYSOUT=%s ",
nl_dump(p, "PHYSOUT=%s ",
rtnl_link_i2name(link_cache,
msg->queue_msg_physoutdev,
buf, sizeof(buf)));
else
dp_dump(p, "PHYSOUT=%d ", msg->queue_msg_physoutdev);
nl_dump(p, "PHYSOUT=%d ", msg->queue_msg_physoutdev);
}
if (msg->ce_mask & QUEUE_MSG_ATTR_HWADDR) {
int i;
dp_dump(p, "MAC");
nl_dump(p, "MAC");
for (i = 0; i < msg->queue_msg_hwaddr_len; i++)
dp_dump(p, "%c%02x", i?':':'=',
nl_dump(p, "%c%02x", i?':':'=',
msg->queue_msg_hwaddr[i]);
dp_dump(p, " ");
nl_dump(p, " ");
}
if (msg->ce_mask & QUEUE_MSG_ATTR_FAMILY)
dp_dump(p, "FAMILY=%s ",
nl_dump(p, "FAMILY=%s ",
nl_af2str(msg->queue_msg_family, buf, sizeof(buf)));
if (msg->ce_mask & QUEUE_MSG_ATTR_HWPROTO)
dp_dump(p, "HWPROTO=%s ",
nl_dump(p, "HWPROTO=%s ",
nl_ether_proto2str(ntohs(msg->queue_msg_hwproto),
buf, sizeof(buf)));
if (msg->ce_mask & QUEUE_MSG_ATTR_HOOK)
dp_dump(p, "HOOK=%s ",
nl_dump(p, "HOOK=%s ",
nfnl_inet_hook2str(msg->queue_msg_hook,
buf, sizeof(buf)));
if (msg->ce_mask & QUEUE_MSG_ATTR_MARK)
dp_dump(p, "MARK=%d ", msg->queue_msg_mark);
nl_dump(p, "MARK=%d ", msg->queue_msg_mark);
if (msg->ce_mask & QUEUE_MSG_ATTR_PAYLOAD)
dp_dump(p, "PAYLOADLEN=%d ", msg->queue_msg_payload_len);
nl_dump(p, "PAYLOADLEN=%d ", msg->queue_msg_payload_len);
if (msg->ce_mask & QUEUE_MSG_ATTR_PACKETID)
dp_dump(p, "PACKETID=%u ", msg->queue_msg_packetid);
nl_dump(p, "PACKETID=%u ", msg->queue_msg_packetid);
if (msg->ce_mask & QUEUE_MSG_ATTR_VERDICT)
dp_dump(p, "VERDICT=%s ",
nl_dump(p, "VERDICT=%s ",
nfnl_verdict2str(msg->queue_msg_verdict,
buf, sizeof(buf)));
dp_dump(p, "\n");
return 1;
nl_dump(p, "\n");
}
/**
@ -471,9 +471,11 @@ struct nl_object_ops queue_msg_obj_ops = {
.oo_size = sizeof(struct nfnl_queue_msg),
.oo_free_data = nfnl_queue_msg_free_data,
.oo_clone = nfnl_queue_msg_clone,
.oo_dump[NL_DUMP_BRIEF] = nfnl_queue_msg_dump,
.oo_dump[NL_DUMP_FULL] = nfnl_queue_msg_dump,
.oo_dump[NL_DUMP_STATS] = nfnl_queue_msg_dump,
.oo_dump = {
[NL_DUMP_LINE] = nfnl_queue_msg_dump,
[NL_DUMP_DETAILS] = nfnl_queue_msg_dump,
[NL_DUMP_STATS] = nfnl_queue_msg_dump,
},
.oo_attrs2str = nfnl_queue_msg_attrs2str,
};

24
lib/netfilter/queue_obj.c
View File

@ -28,28 +28,28 @@
/** @endcond */
static int nfnl_queue_dump(struct nl_object *a, struct nl_dump_params *p)
static void nfnl_queue_dump(struct nl_object *a, struct nl_dump_params *p)
{
struct nfnl_queue *queue = (struct nfnl_queue *) a;
char buf[64];
nl_new_line(p);
if (queue->ce_mask & QUEUE_ATTR_GROUP)
dp_dump(p, "group=%u ", queue->queue_group);
nl_dump(p, "group=%u ", queue->queue_group);
if (queue->ce_mask & QUEUE_ATTR_MAXLEN)
dp_dump(p, "maxlen=%u ", queue->queue_maxlen);
nl_dump(p, "maxlen=%u ", queue->queue_maxlen);
if (queue->ce_mask & QUEUE_ATTR_COPY_MODE)
dp_dump(p, "copy_mode=%s ",
nl_dump(p, "copy_mode=%s ",
nfnl_queue_copy_mode2str(queue->queue_copy_mode,
buf, sizeof(buf)));
if (queue->ce_mask & QUEUE_ATTR_COPY_RANGE)
dp_dump(p, "copy_range=%u ", queue->queue_copy_range);
nl_dump(p, "copy_range=%u ", queue->queue_copy_range);
dp_dump(p, "\n");
return 1;
nl_dump(p, "\n");
}
static struct trans_tbl copy_modes[] = {
@ -202,9 +202,11 @@ static char *nfnl_queue_attrs2str(int attrs, char *buf, size_t len)
struct nl_object_ops queue_obj_ops = {
.oo_name = "netfilter/queue",
.oo_size = sizeof(struct nfnl_queue),
.oo_dump[NL_DUMP_BRIEF] = nfnl_queue_dump,
.oo_dump[NL_DUMP_FULL] = nfnl_queue_dump,
.oo_dump[NL_DUMP_STATS] = nfnl_queue_dump,
.oo_dump = {
[NL_DUMP_LINE] = nfnl_queue_dump,
[NL_DUMP_DETAILS] = nfnl_queue_dump,
[NL_DUMP_STATS] = nfnl_queue_dump,
},
.oo_compare = nfnl_queue_compare,
.oo_attrs2str = nfnl_queue_attrs2str,
.oo_id_attrs = QUEUE_ATTR_GROUP,

143
lib/route/addr.c
View File

@ -282,7 +282,7 @@ static int addr_request_update(struct nl_cache *cache, struct nl_sock *sk)
return nl_rtgen_request(sk, RTM_GETADDR, AF_UNSPEC, NLM_F_DUMP);
}
static int addr_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
static void addr_dump_line(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_addr *addr = (struct rtnl_addr *) obj;
struct nl_cache *link_cache;
@ -291,246 +291,235 @@ static int addr_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
link_cache = nl_cache_mngt_require("route/link");
if (addr->ce_mask & ADDR_ATTR_LOCAL)
dp_dump(p, "%s",
nl_dump_line(p, "%s",
nl_addr2str(addr->a_local, buf, sizeof(buf)));
else
dp_dump(p, "none");
nl_dump_line(p, "none");
if (addr->ce_mask & ADDR_ATTR_PEER)
dp_dump(p, " peer %s",
nl_dump(p, " peer %s",
nl_addr2str(addr->a_peer, buf, sizeof(buf)));
dp_dump(p, " %s ", nl_af2str(addr->a_family, buf, sizeof(buf)));
nl_dump(p, " %s ", nl_af2str(addr->a_family, buf, sizeof(buf)));
if (link_cache)
dp_dump(p, "dev %s ",
nl_dump(p, "dev %s ",
rtnl_link_i2name(link_cache, addr->a_ifindex,
buf, sizeof(buf)));
else
dp_dump(p, "dev %d ", addr->a_ifindex);
nl_dump(p, "dev %d ", addr->a_ifindex);
dp_dump(p, "scope %s",
nl_dump(p, "scope %s",
rtnl_scope2str(addr->a_scope, buf, sizeof(buf)));
rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf));
if (buf[0])
dp_dump(p, " <%s>", buf);
nl_dump(p, " <%s>", buf);
dp_dump(p, "\n");
return 1;
nl_dump(p, "\n");
}
static int addr_dump_full(struct nl_object *obj, struct nl_dump_params *p)
static void addr_dump_details(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_addr *addr = (struct rtnl_addr *) obj;
int line = addr_dump_brief(obj, p);
char buf[128];
addr_dump_line(obj, p);
if (addr->ce_mask & (ADDR_ATTR_LABEL | ADDR_ATTR_BROADCAST |
ADDR_ATTR_MULTICAST)) {
dp_dump_line(p, line++, " ");
nl_dump_line(p, " ");
if (addr->ce_mask & ADDR_ATTR_LABEL)
dp_dump(p, " label %s", addr->a_label);
nl_dump(p, " label %s", addr->a_label);
if (addr->ce_mask & ADDR_ATTR_BROADCAST)
dp_dump(p, " broadcast %s",
nl_dump(p, " broadcast %s",
nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_MULTICAST)
dp_dump(p, " multicast %s",
nl_dump(p, " multicast %s",
nl_addr2str(addr->a_multicast, buf,
sizeof(buf)));
dp_dump(p, "\n");
nl_dump(p, "\n");
}
if (addr->ce_mask & ADDR_ATTR_CACHEINFO) {
struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
dp_dump_line(p, line++, " valid-lifetime %s",
nl_dump_line(p, " valid-lifetime %s",
ci->aci_valid == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_valid * 1000,
buf, sizeof(buf)));
dp_dump(p, " preferred-lifetime %s\n",
nl_dump(p, " preferred-lifetime %s\n",
ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_prefered * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, " created boot-time+%s ",
nl_dump_line(p, " created boot-time+%s ",
nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
buf, sizeof(buf)));
dp_dump(p, "last-updated boot-time+%s\n",
nl_dump(p, "last-updated boot-time+%s\n",
nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
buf, sizeof(buf)));
}
return line;
}
static int addr_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
static void addr_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
return addr_dump_full(obj, p);
addr_dump_details(obj, p);
}
static int addr_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
static void addr_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_addr *addr = (struct rtnl_addr *) obj;
struct nl_cache *link_cache;
char buf[128];
int line = 0;
dp_dump_line(p, line++, "<address>\n");
dp_dump_line(p, line++, " <family>%s</family>\n",
nl_dump_line(p, "<address>\n");
nl_dump_line(p, " <family>%s</family>\n",
nl_af2str(addr->a_family, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_LOCAL)
dp_dump_line(p, line++, " <local>%s</local>\n",
nl_dump_line(p, " <local>%s</local>\n",
nl_addr2str(addr->a_local, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_PEER)
dp_dump_line(p, line++, " <peer>%s</peer>\n",
nl_dump_line(p, " <peer>%s</peer>\n",
nl_addr2str(addr->a_peer, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_BROADCAST)
dp_dump_line(p, line++, " <broadcast>%s</broadcast>\n",
nl_dump_line(p, " <broadcast>%s</broadcast>\n",
nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_MULTICAST)
dp_dump_line(p, line++, " <multicast>%s</multicast>\n",
nl_dump_line(p, " <multicast>%s</multicast>\n",
nl_addr2str(addr->a_multicast, buf,
sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_PREFIXLEN)
dp_dump_line(p, line++, " <prefixlen>%u</prefixlen>\n",
nl_dump_line(p, " <prefixlen>%u</prefixlen>\n",
addr->a_prefixlen);
link_cache = nl_cache_mngt_require("route/link");
if (link_cache)
dp_dump_line(p, line++, " <device>%s</device>\n",
nl_dump_line(p, " <device>%s</device>\n",
rtnl_link_i2name(link_cache, addr->a_ifindex,
buf, sizeof(buf)));
else
dp_dump_line(p, line++, " <device>%u</device>\n",
addr->a_ifindex);
nl_dump_line(p, " <device>%u</device>\n", addr->a_ifindex);
if (addr->ce_mask & ADDR_ATTR_SCOPE)
dp_dump_line(p, line++, " <scope>%s</scope>\n",
nl_dump_line(p, " <scope>%s</scope>\n",
rtnl_scope2str(addr->a_scope, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_LABEL)
dp_dump_line(p, line++, " <label>%s</label>\n", addr->a_label);
nl_dump_line(p, " <label>%s</label>\n", addr->a_label);
rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, " <flags>%s</flags>\n", buf);
nl_dump_line(p, " <flags>%s</flags>\n", buf);
if (addr->ce_mask & ADDR_ATTR_CACHEINFO) {
struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
dp_dump_line(p, line++, " <cacheinfo>\n");
dp_dump_line(p, line++, " <valid>%s</valid>\n",
nl_dump_line(p, " <cacheinfo>\n");
nl_dump_line(p, " <valid>%s</valid>\n",
ci->aci_valid == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_valid * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, " <prefered>%s</prefered>\n",
nl_dump_line(p, " <prefered>%s</prefered>\n",
ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_prefered * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, " <created>%s</created>\n",
nl_dump_line(p, " <created>%s</created>\n",
nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
buf, sizeof(buf)));
dp_dump_line(p, line++, " <last-update>%s</last-update>\n",
nl_dump_line(p, " <last-update>%s</last-update>\n",
nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
buf, sizeof(buf)));
dp_dump_line(p, line++, " </cacheinfo>\n");
nl_dump_line(p, " </cacheinfo>\n");
}
dp_dump_line(p, line++, "</address>\n");
return line;
nl_dump_line(p, "</address>\n");
}
static int addr_dump_env(struct nl_object *obj, struct nl_dump_params *p)
static void addr_dump_env(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_addr *addr = (struct rtnl_addr *) obj;
struct nl_cache *link_cache;
char buf[128];
int line = 0;
dp_dump_line(p, line++, "ADDR_FAMILY=%s\n",
nl_dump_line(p, "ADDR_FAMILY=%s\n",
nl_af2str(addr->a_family, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_LOCAL)
dp_dump_line(p, line++, "ADDR_LOCAL=%s\n",
nl_dump_line(p, "ADDR_LOCAL=%s\n",
nl_addr2str(addr->a_local, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_PEER)
dp_dump_line(p, line++, "ADDR_PEER=%s\n",
nl_dump_line(p, "ADDR_PEER=%s\n",
nl_addr2str(addr->a_peer, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_BROADCAST)
dp_dump_line(p, line++, "ADDR_BROADCAST=%s\n",
nl_dump_line(p, "ADDR_BROADCAST=%s\n",
nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_MULTICAST)
dp_dump_line(p, line++, "ADDR_MULTICAST=%s\n",
nl_dump_line(p, "ADDR_MULTICAST=%s\n",
nl_addr2str(addr->a_multicast, buf,
sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_PREFIXLEN)
dp_dump_line(p, line++, "ADDR_PREFIXLEN=%u\n",
nl_dump_line(p, "ADDR_PREFIXLEN=%u\n",
addr->a_prefixlen);
link_cache = nl_cache_mngt_require("route/link");
dp_dump_line(p, line++, "ADDR_IFINDEX=%u\n", addr->a_ifindex);
nl_dump_line(p, "ADDR_IFINDEX=%u\n", addr->a_ifindex);
if (link_cache)
dp_dump_line(p, line++, "ADDR_IFNAME=%s\n",
nl_dump_line(p, "ADDR_IFNAME=%s\n",
rtnl_link_i2name(link_cache, addr->a_ifindex,
buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_SCOPE)
dp_dump_line(p, line++, "ADDR_SCOPE=%s\n",
nl_dump_line(p, "ADDR_SCOPE=%s\n",
rtnl_scope2str(addr->a_scope, buf, sizeof(buf)));
if (addr->ce_mask & ADDR_ATTR_LABEL)
dp_dump_line(p, line++, "ADDR_LABEL=%s\n", addr->a_label);
nl_dump_line(p, "ADDR_LABEL=%s\n", addr->a_label);
rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, "ADDR_FLAGS=%s\n", buf);
nl_dump_line(p, "ADDR_FLAGS=%s\n", buf);
if (addr->ce_mask & ADDR_ATTR_CACHEINFO) {
struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
dp_dump_line(p, line++, "ADDR_CACHEINFO_VALID=%s\n",
nl_dump_line(p, "ADDR_CACHEINFO_VALID=%s\n",
ci->aci_valid == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_valid * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, "ADDR_CACHEINFO_PREFERED=%s\n",
nl_dump_line(p, "ADDR_CACHEINFO_PREFERED=%s\n",
ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
nl_msec2str(ci->aci_prefered * 1000,
buf, sizeof(buf)));
dp_dump_line(p, line++, "ADDR_CACHEINFO_CREATED=%s\n",
nl_dump_line(p, "ADDR_CACHEINFO_CREATED=%s\n",
nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
buf, sizeof(buf)));
dp_dump_line(p, line++, "ADDR_CACHEINFO_LASTUPDATE=%s\n",
nl_dump_line(p, "ADDR_CACHEINFO_LASTUPDATE=%s\n",
nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
buf, sizeof(buf)));
}
return line;
}
static int addr_compare(struct nl_object *_a, struct nl_object *_b,
@ -1018,11 +1007,13 @@ static struct nl_object_ops addr_obj_ops = {
.oo_size = sizeof(struct rtnl_addr),
.oo_free_data = addr_free_data,
.oo_clone = addr_clone,
.oo_dump[NL_DUMP_BRIEF] = addr_dump_brief,
.oo_dump[NL_DUMP_FULL] = addr_dump_full,
.oo_dump[NL_DUMP_STATS] = addr_dump_stats,
.oo_dump[NL_DUMP_XML] = addr_dump_xml,
.oo_dump[NL_DUMP_ENV] = addr_dump_env,
.oo_dump = {
[NL_DUMP_LINE] = addr_dump_line,
[NL_DUMP_DETAILS] = addr_dump_details,
[NL_DUMP_STATS] = addr_dump_stats,
[NL_DUMP_XML] = addr_dump_xml,
[NL_DUMP_ENV] = addr_dump_env,
},
.oo_compare = addr_compare,
.oo_attrs2str = addr_attrs2str,
.oo_id_attrs = (ADDR_ATTR_FAMILY | ADDR_ATTR_IFINDEX |

52
lib/route/class_obj.c
View File

@ -55,62 +55,54 @@ errout:
return err;
}
static int class_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
static void class_dump_line(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_class *class = (struct rtnl_class *) obj;
struct rtnl_class_ops *cops;
int line = tca_dump_brief((struct rtnl_tca *) class, "class", p, 0);
tca_dump_line((struct rtnl_tca *) class, "class", p);
cops = rtnl_class_lookup_ops(class);
if (cops && cops->co_dump[NL_DUMP_BRIEF])
line = cops->co_dump[NL_DUMP_BRIEF](class, p, line);
dp_dump(p, "\n");
return line;
if (cops && cops->co_dump[NL_DUMP_LINE])
cops->co_dump[NL_DUMP_LINE](class, p);
nl_dump(p, "\n");
}
static int class_dump_full(struct nl_object *obj, struct nl_dump_params *p)
static void class_dump_details(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_class *class = (struct rtnl_class *) obj;
struct rtnl_class_ops *cops;
int line;
line = class_dump_brief(obj, p);
line = tca_dump_full((struct rtnl_tca *) class, p, line);
class_dump_line(obj, p);
tca_dump_details((struct rtnl_tca *) class, p);
if (class->c_info) {
char buf[32];
dp_dump(p, "child-qdisc %s ",
nl_dump(p, "child-qdisc %s ",
rtnl_tc_handle2str(class->c_info, buf, sizeof(buf)));
}
cops = rtnl_class_lookup_ops(class);
if (cops && cops->co_dump[NL_DUMP_FULL])
line = cops->co_dump[NL_DUMP_FULL](class, p, line);
if (cops && cops->co_dump[NL_DUMP_DETAILS])
cops->co_dump[NL_DUMP_DETAILS](class, p);
else if (!class->c_info)
dp_dump(p, "noop (no leaf qdisc)");
nl_dump(p, "noop (no leaf qdisc)");
dp_dump(p, "\n");
return line;
nl_dump(p, "\n");
}
static int class_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
static void class_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_class *class = (struct rtnl_class *) obj;
struct rtnl_class_ops *cops;
int line;
line = class_dump_full(obj, p);
line = tca_dump_stats((struct rtnl_tca *) class, p, line);
dp_dump(p, "\n");
class_dump_details(obj, p);
tca_dump_stats((struct rtnl_tca *) class, p);
nl_dump(p, "\n");
cops = rtnl_class_lookup_ops(class);
if (cops && cops->co_dump[NL_DUMP_STATS])
line = cops->co_dump[NL_DUMP_STATS](class, p, line);
return line;
cops->co_dump[NL_DUMP_STATS](class, p);
}
/**
@ -277,9 +269,11 @@ struct nl_object_ops class_obj_ops = {
.oo_size = sizeof(struct rtnl_class),
.oo_free_data = class_free_data,
.oo_clone = class_clone,
.oo_dump[NL_DUMP_BRIEF] = class_dump_brief,
.oo_dump[NL_DUMP_FULL] = class_dump_full,
.oo_dump[NL_DUMP_STATS] = class_dump_stats,
.oo_dump = {
[NL_DUMP_LINE] = class_dump_line,
[NL_DUMP_DETAILS] = class_dump_details,
[NL_DUMP_STATS] = class_dump_stats,
},
.oo_compare = tca_compare,
.oo_id_attrs = (TCA_ATTR_IFINDEX | TCA_ATTR_HANDLE),
};

38
lib/route/cls/fw.c
View File

@ -127,48 +127,32 @@ static int fw_clone(struct rtnl_cls *_dst, struct rtnl_cls *_src)
return 0;
}
static int fw_dump_brief(struct rtnl_cls *cls, struct nl_dump_params *p,
int line)
static void fw_dump_line(struct rtnl_cls *cls, struct nl_dump_params *p)
{
struct rtnl_fw *f = fw_cls(cls);
char buf[32];
if (!f)
goto ignore;
return;
if (f->cf_mask & FW_ATTR_CLASSID)
dp_dump(p, " target %s",
nl_dump(p, " target %s",
rtnl_tc_handle2str(f->cf_classid, buf, sizeof(buf)));
ignore:
return line;
}
static int fw_dump_full(struct rtnl_cls *cls, struct nl_dump_params *p,
int line)
static void fw_dump_details(struct rtnl_cls *cls, struct nl_dump_params *p)
{
struct rtnl_fw *f = fw_cls(cls);
if (!f)
goto ignore;
return;
if (f->cf_mask & FW_ATTR_INDEV)
dp_dump(p, "indev %s ", f->cf_indev);
ignore:
return line;
nl_dump(p, "indev %s ", f->cf_indev);
}
static int fw_dump_stats(struct rtnl_cls *cls, struct nl_dump_params *p,
int line)
static void fw_dump_stats(struct rtnl_cls *cls, struct nl_dump_params *p)
{
struct rtnl_fw *f = fw_cls(cls);
if (!f)
goto ignore;
ignore:
return line;
}
static struct nl_msg *fw_get_opts(struct rtnl_cls *cls)
@ -226,9 +210,11 @@ static struct rtnl_cls_ops fw_ops = {
.co_free_data = fw_free_data,
.co_clone = fw_clone,
.co_get_opts = fw_get_opts,
.co_dump[NL_DUMP_BRIEF] = fw_dump_brief,
.co_dump[NL_DUMP_FULL] = fw_dump_full,
.co_dump[NL_DUMP_STATS] = fw_dump_stats,
.co_dump = {
[NL_DUMP_LINE] = fw_dump_line,
[NL_DUMP_DETAILS] = fw_dump_details,
[NL_DUMP_STATS] = fw_dump_stats,
},
};
static void __init fw_init(void)

91
lib/route/cls/u32.c
View File

@ -6,7 +6,7 @@
* 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-2008 Thomas Graf <tgraf@suug.ch>
* Copyright (c) 2005-2006 Petr Gotthard <petr.gotthard@siemens.com>
* Copyright (c) 2005-2006 Siemens AG Oesterreich
*/
@ -213,27 +213,23 @@ static int u32_clone(struct rtnl_cls *_dst, struct rtnl_cls *_src)
return 0;
}
static int u32_dump_brief(struct rtnl_cls *cls, struct nl_dump_params *p,
int line)
static void u32_dump_line(struct rtnl_cls *cls, struct nl_dump_params *p)
{
struct rtnl_u32 *u = u32_cls(cls);
char buf[32];
if (!u)
goto ignore;
return;
if (u->cu_mask & U32_ATTR_DIVISOR)
dp_dump(p, " divisor %u", u->cu_divisor);
nl_dump(p, " divisor %u", u->cu_divisor);
else if (u->cu_mask & U32_ATTR_CLASSID)
dp_dump(p, " target %s",
nl_dump(p, " target %s",
rtnl_tc_handle2str(u->cu_classid, buf, sizeof(buf)));
ignore:
return line;
}
static int print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
struct rtnl_cls *cls, struct rtnl_u32 *u, int line)
static void print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
struct rtnl_cls *cls, struct rtnl_u32 *u)
{
int i;
struct tc_u32_key *key;
@ -243,23 +239,23 @@ static int print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
* exports the selector if no divisor is set but hash offset
* and hash mask make only sense in hash filters with divisor
* set */
dp_dump(p, " hash at %u & 0x%x", sel->hoff, sel->hmask);
nl_dump(p, " hash at %u & 0x%x", sel->hoff, sel->hmask);
}
if (sel->flags & (TC_U32_OFFSET | TC_U32_VAROFFSET)) {
dp_dump(p, " offset at %u", sel->off);
nl_dump(p, " offset at %u", sel->off);
if (sel->flags & TC_U32_VAROFFSET)
dp_dump(p, " variable (at %u & 0x%x) >> %u",
nl_dump(p, " variable (at %u & 0x%x) >> %u",
sel->offoff, ntohs(sel->offmask), sel->offshift);
}
if (sel->flags) {
int flags = sel->flags;
dp_dump(p, " <");
nl_dump(p, " <");
#define PRINT_FLAG(f) if (flags & TC_U32_##f) { \
flags &= ~TC_U32_##f; dp_dump(p, #f "%s", flags ? "," : ""); }
flags &= ~TC_U32_##f; nl_dump(p, #f "%s", flags ? "," : ""); }
PRINT_FLAG(TERMINAL);
PRINT_FLAG(OFFSET);
@ -267,66 +263,59 @@ static int print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
PRINT_FLAG(EAT);
#undef PRINT_FLAG
dp_dump(p, ">");
nl_dump(p, ">");
}
for (i = 0; i < sel->nkeys; i++) {
key = (struct tc_u32_key *) ((char *) sel + sizeof(*sel)) + i;
dp_dump(p, "\n");
dp_dump_line(p, line++, " match key at %s%u ",
key->offmask ? "nexthdr+" : "", key->off);
nl_dump(p, "\n");
nl_dump_line(p, " match key at %s%u ",
key->offmask ? "nexthdr+" : "", key->off);
if (key->offmask)
dp_dump(p, "[0x%u] ", key->offmask);
nl_dump(p, "[0x%u] ", key->offmask);
dp_dump(p, "& 0x%08x == 0x%08x", ntohl(key->mask), ntohl(key->val));
nl_dump(p, "& 0x%08x == 0x%08x", ntohl(key->mask), ntohl(key->val));
if (p->dp_type == NL_DUMP_STATS &&
(u->cu_mask & U32_ATTR_PCNT)) {
struct tc_u32_pcnt *pcnt = u->cu_pcnt->d_data;
dp_dump(p, " successful %" PRIu64, pcnt->kcnts[i]);
nl_dump(p, " successful %" PRIu64, pcnt->kcnts[i]);
}
}
return line;
}
static int u32_dump_full(struct rtnl_cls *cls, struct nl_dump_params *p,
int line)
static void u32_dump_details(struct rtnl_cls *cls, struct nl_dump_params *p)
{
struct rtnl_u32 *u = u32_cls(cls);
struct tc_u32_sel *s;
if (!u)
goto ignore;
return;
if (!(u->cu_mask & U32_ATTR_SELECTOR)) {
dp_dump(p, "no-selector\n");
return line;
nl_dump(p, "no-selector\n");
return;
}
s = u->cu_selector->d_data;
dp_dump(p, "nkeys %u ", s->nkeys);
nl_dump(p, "nkeys %u ", s->nkeys);
if (u->cu_mask & U32_ATTR_HASH)
dp_dump(p, "ht key 0x%x hash 0x%u",
nl_dump(p, "ht key 0x%x hash 0x%u",
TC_U32_USERHTID(u->cu_hash), TC_U32_HASH(u->cu_hash));
if (u->cu_mask & U32_ATTR_LINK)
dp_dump(p, "link %u ", u->cu_link);
nl_dump(p, "link %u ", u->cu_link);
if (u->cu_mask & U32_ATTR_INDEV)
dp_dump(p, "indev %s ", u->cu_indev);
nl_dump(p, "indev %s ", u->cu_indev);
line = print_selector(p, s, cls, u, line);
dp_dump(p, "\n");
ignore:
return line;
print_selector(p, s, cls, u);
nl_dump(p, "\n");
#if 0
#define U32_ATTR_ACTION 0x040
@ -337,24 +326,20 @@ ignore:
#endif
}
static int u32_dump_stats(struct rtnl_cls *cls, struct nl_dump_params *p,
int line)
static void u32_dump_stats(struct rtnl_cls *cls, struct nl_dump_params *p)
{
struct rtnl_u32 *u = u32_cls(cls);
if (!u)
goto ignore;
return;
if (u->cu_mask & U32_ATTR_PCNT) {
struct tc_u32_pcnt *pc = u->cu_pcnt->d_data;
dp_dump(p, "\n");
dp_dump_line(p, line++, "%s successful hits\n");
dp_dump_line(p, line++, "%s %8llu %8llu\n",
nl_dump(p, "\n");
nl_dump_line(p, "%s successful hits\n");
nl_dump_line(p, "%s %8llu %8llu\n",
pc->rhit, pc->rcnt);
}
ignore:
return line;
}
static struct nl_msg *u32_get_opts(struct rtnl_cls *cls)
@ -581,9 +566,11 @@ static struct rtnl_cls_ops u32_ops = {
.co_free_data = u32_free_data,
.co_clone = u32_clone,
.co_get_opts = u32_get_opts,
.co_dump[NL_DUMP_BRIEF] = u32_dump_brief,
.co_dump[NL_DUMP_FULL] = u32_dump_full,
.co_dump[NL_DUMP_STATS] = u32_dump_stats,
.co_dump = {
[NL_DUMP_LINE] = u32_dump_line,
[NL_DUMP_DETAILS] = u32_dump_details,
[NL_DUMP_STATS] = u32_dump_stats,
},
};
static void __init u32_init(void)

51
lib/route/cls_obj.c
View File

@ -59,59 +59,50 @@ errout:
return err;
}
static int cls_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
static void cls_dump_line(struct nl_object *obj, struct nl_dump_params *p)
{
char buf[32];
struct rtnl_cls *cls = (struct rtnl_cls *) obj;
struct rtnl_cls_ops *cops;
int line;
line = tca_dump_brief((struct rtnl_tca *) cls, "cls", p, 0);
tca_dump_line((struct rtnl_tca *) cls, "cls", p);
dp_dump(p, " prio %u protocol %s", cls->c_prio,
nl_dump(p, " prio %u protocol %s", cls->c_prio,
nl_ether_proto2str(cls->c_protocol, buf, sizeof(buf)));
cops = rtnl_cls_lookup_ops(cls);
if (cops && cops->co_dump[NL_DUMP_BRIEF])
line = cops->co_dump[NL_DUMP_BRIEF](cls, p, line);
dp_dump(p, "\n");
return line;
if (cops && cops->co_dump[NL_DUMP_LINE])
cops->co_dump[NL_DUMP_LINE](cls, p);
nl_dump(p, "\n");
}
static int cls_dump_full(struct nl_object *obj, struct nl_dump_params *p)
static void cls_dump_details(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_cls *cls = (struct rtnl_cls *) obj;
struct rtnl_cls_ops *cops;
int line;
line = cls_dump_brief(obj, p);
line = tca_dump_full((struct rtnl_tca *) cls, p, line);
cls_dump_line(obj, p);
tca_dump_details((struct rtnl_tca *) cls, p);
cops = rtnl_cls_lookup_ops(cls);
if (cops && cops->co_dump[NL_DUMP_FULL])
line = cops->co_dump[NL_DUMP_FULL](cls, p, line);
if (cops && cops->co_dump[NL_DUMP_DETAILS])
cops->co_dump[NL_DUMP_DETAILS](cls, p);
else
dp_dump(p, "no options\n");
return line;
nl_dump(p, "no options\n");
}
static int cls_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
static void cls_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_cls *cls = (struct rtnl_cls *) obj;
struct rtnl_cls_ops *cops;
int line;
line = cls_dump_full(obj, p);
line = tca_dump_stats((struct rtnl_tca *) cls, p, line);
dp_dump(p, "\n");
cls_dump_details(obj, p);
tca_dump_stats((struct rtnl_tca *) cls, p);
nl_dump(p, "\n");
cops = rtnl_cls_lookup_ops(cls);
if (cops && cops->co_dump[NL_DUMP_STATS])
line = cops->co_dump[NL_DUMP_STATS](cls, p, line);
return line;
cops->co_dump[NL_DUMP_STATS](cls, p);
}
/**
@ -193,9 +184,11 @@ struct nl_object_ops cls_obj_ops = {
.oo_size = sizeof(struct rtnl_cls),
.oo_free_data = cls_free_data,
.oo_clone = cls_clone,
.oo_dump[NL_DUMP_BRIEF] = cls_dump_brief,
.oo_dump[NL_DUMP_FULL] = cls_dump_full,
.oo_dump[NL_DUMP_STATS] = cls_dump_stats,
.oo_dump = {
[NL_DUMP_LINE] = cls_dump_line,
[NL_DUMP_DETAILS] = cls_dump_details,
[NL_DUMP_STATS] = cls_dump_stats,
},
.oo_compare = tca_compare,
.oo_id_attrs = (TCA_ATTR_IFINDEX | TCA_ATTR_HANDLE),
};

187
lib/route/link.c
View File

@ -427,110 +427,99 @@ static int link_request_update(struct nl_cache *cache, struct nl_sock *sk)
return nl_rtgen_request(sk, RTM_GETLINK, AF_UNSPEC, NLM_F_DUMP);
}
static int link_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
static void link_dump_line(struct nl_object *obj, struct nl_dump_params *p)
{
char buf[128];
struct nl_cache *cache = dp_cache(obj);
struct rtnl_link *link = (struct rtnl_link *) obj;
int line = 1;
dp_dump(p, "%s %s ", link->l_name,
nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
nl_dump_line(p, "%s %s ", link->l_name,
nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
if (link->l_addr && !nl_addr_iszero(link->l_addr))
dp_dump(p, "%s ", nl_addr2str(link->l_addr, buf, sizeof(buf)));
nl_dump(p, "%s ", nl_addr2str(link->l_addr, buf, sizeof(buf)));
if (link->ce_mask & LINK_ATTR_MASTER) {
struct rtnl_link *master = rtnl_link_get(cache, link->l_master);
dp_dump(p, "master %s ", master ? master->l_name : "inv");
nl_dump(p, "master %s ", master ? master->l_name : "inv");
if (master)
rtnl_link_put(master);
}
rtnl_link_flags2str(link->l_flags, buf, sizeof(buf));
if (buf[0])
dp_dump(p, "<%s> ", buf);
nl_dump(p, "<%s> ", buf);
if (link->ce_mask & LINK_ATTR_LINK) {
struct rtnl_link *ll = rtnl_link_get(cache, link->l_link);
dp_dump(p, "slave-of %s ", ll ? ll->l_name : "NONE");
nl_dump(p, "slave-of %s ", ll ? ll->l_name : "NONE");
if (ll)
rtnl_link_put(ll);
}
if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_BRIEF])
line = link->l_info_ops->io_dump[NL_DUMP_BRIEF](link, p, line);
if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_LINE])
link->l_info_ops->io_dump[NL_DUMP_LINE](link, p);
dp_dump(p, "\n");
return line;
nl_dump(p, "\n");
}
static int link_dump_full(struct nl_object *obj, struct nl_dump_params *p)
static void link_dump_details(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_link *link = (struct rtnl_link *) obj;
char buf[64];
int line;
line = link_dump_brief(obj, p);
dp_new_line(p, line++);
link_dump_line(obj, p);
dp_dump(p, " mtu %u ", link->l_mtu);
dp_dump(p, "txqlen %u weight %u ", link->l_txqlen, link->l_weight);
nl_dump_line(p, " mtu %u ", link->l_mtu);
nl_dump(p, "txqlen %u weight %u ", link->l_txqlen, link->l_weight);
if (link->ce_mask & LINK_ATTR_QDISC)
dp_dump(p, "qdisc %s ", link->l_qdisc);
nl_dump(p, "qdisc %s ", link->l_qdisc);
if (link->ce_mask & LINK_ATTR_MAP && link->l_map.lm_irq)
dp_dump(p, "irq %u ", link->l_map.lm_irq);
nl_dump(p, "irq %u ", link->l_map.lm_irq);
if (link->ce_mask & LINK_ATTR_IFINDEX)
dp_dump(p, "index %u ", link->l_index);
nl_dump(p, "index %u ", link->l_index);
dp_dump(p, "\n");
dp_new_line(p, line++);
dp_dump(p, " ");
nl_dump(p, "\n");
nl_dump_line(p, " ");
if (link->ce_mask & LINK_ATTR_BRD)
dp_dump(p, "brd %s ", nl_addr2str(link->l_bcast, buf,
nl_dump(p, "brd %s ", nl_addr2str(link->l_bcast, buf,
sizeof(buf)));
if ((link->ce_mask & LINK_ATTR_OPERSTATE) &&
link->l_operstate != IF_OPER_UNKNOWN) {
rtnl_link_operstate2str(link->l_operstate, buf, sizeof(buf));
dp_dump(p, "state %s ", buf);
nl_dump(p, "state %s ", buf);
}
dp_dump(p, "mode %s\n",
nl_dump(p, "mode %s\n",
rtnl_link_mode2str(link->l_linkmode, buf, sizeof(buf)));
if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_FULL])
line = link->l_info_ops->io_dump[NL_DUMP_FULL](link, p, line);
return line;
if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_DETAILS])
link->l_info_ops->io_dump[NL_DUMP_DETAILS](link, p);
}
static int link_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
static void link_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_link *link = (struct rtnl_link *) obj;
char *unit, fmt[64];
float res;
int line;
line = link_dump_full(obj, p);
link_dump_details(obj, p);
dp_dump_line(p, line++, " Stats: bytes packets errors "
" dropped fifo-err compressed\n");
nl_dump_line(p, " Stats: bytes packets errors "
" dropped fifo-err compressed\n");
res = nl_cancel_down_bytes(link->l_stats[RTNL_LINK_RX_BYTES], &unit);
strcpy(fmt, " RX %X.2f %s %10llu %10llu %10llu %10llu %10llu\n");
fmt[9] = *unit == 'B' ? '9' : '7';
dp_dump_line(p, line++, fmt,
res, unit,
nl_dump_line(p, fmt, res, unit,
link->l_stats[RTNL_LINK_RX_PACKETS],
link->l_stats[RTNL_LINK_RX_ERRORS],
link->l_stats[RTNL_LINK_RX_DROPPED],
@ -542,18 +531,17 @@ static int link_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
strcpy(fmt, " TX %X.2f %s %10llu %10llu %10llu %10llu %10llu\n");
fmt[9] = *unit == 'B' ? '9' : '7';
dp_dump_line(p, line++, fmt,
res, unit,
nl_dump_line(p, fmt, res, unit,
link->l_stats[RTNL_LINK_TX_PACKETS],
link->l_stats[RTNL_LINK_TX_ERRORS],
link->l_stats[RTNL_LINK_TX_DROPPED],
link->l_stats[RTNL_LINK_TX_FIFO_ERR],
link->l_stats[RTNL_LINK_TX_COMPRESSED]);
dp_dump_line(p, line++, " Errors: length over crc "
" frame missed multicast\n");
nl_dump_line(p, " Errors: length over crc "
" frame missed multicast\n");
dp_dump_line(p, line++, " RX %10" PRIu64 " %10" PRIu64 " %10"
nl_dump_line(p, " RX %10" PRIu64 " %10" PRIu64 " %10"
PRIu64 " %10" PRIu64 " %10" PRIu64 " %10"
PRIu64 "\n",
link->l_stats[RTNL_LINK_RX_LEN_ERR],
@ -563,11 +551,11 @@ static int link_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
link->l_stats[RTNL_LINK_RX_MISSED_ERR],
link->l_stats[RTNL_LINK_MULTICAST]);
dp_dump_line(p, line++, " aborted carrier heartbeat "
" window collision\n");
nl_dump_line(p, " aborted carrier heartbeat "
" window collision\n");
dp_dump_line(p, line++, " TX %10" PRIu64 " %10" PRIu64 " %10"
PRIu64 " %10" PRIu64 " %10" PRIu64 "\n",
nl_dump_line(p, " TX %10" PRIu64 " %10" PRIu64 " %10"
PRIu64 " %10" PRIu64 " %10" PRIu64 "\n",
link->l_stats[RTNL_LINK_TX_ABORT_ERR],
link->l_stats[RTNL_LINK_TX_CARRIER_ERR],
link->l_stats[RTNL_LINK_TX_HBEAT_ERR],
@ -575,40 +563,38 @@ static int link_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
link->l_stats[RTNL_LINK_TX_COLLISIONS]);
if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_STATS])
line = link->l_info_ops->io_dump[NL_DUMP_STATS](link, p, line);
return line;
link->l_info_ops->io_dump[NL_DUMP_STATS](link, p);
}
static int link_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
static void link_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_link *link = (struct rtnl_link *) obj;
struct nl_cache *cache = dp_cache(obj);
char buf[128];
int i, line = 0;
int i;
dp_dump_line(p, line++, "<link name=\"%s\" index=\"%u\">\n",
nl_dump_line(p, "<link name=\"%s\" index=\"%u\">\n",
link->l_name, link->l_index);
dp_dump_line(p, line++, " <family>%s</family>\n",
nl_dump_line(p, " <family>%s</family>\n",
nl_af2str(link->l_family, buf, sizeof(buf)));
dp_dump_line(p, line++, " <arptype>%s</arptype>\n",
nl_dump_line(p, " <arptype>%s</arptype>\n",
nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
dp_dump_line(p, line++, " <address>%s</address>\n",
nl_dump_line(p, " <address>%s</address>\n",
nl_addr2str(link->l_addr, buf, sizeof(buf)));
dp_dump_line(p, line++, " <mtu>%u</mtu>\n", link->l_mtu);
dp_dump_line(p, line++, " <txqlen>%u</txqlen>\n", link->l_txqlen);
dp_dump_line(p, line++, " <weight>%u</weight>\n", link->l_weight);
nl_dump_line(p, " <mtu>%u</mtu>\n", link->l_mtu);
nl_dump_line(p, " <txqlen>%u</txqlen>\n", link->l_txqlen);
nl_dump_line(p, " <weight>%u</weight>\n", link->l_weight);
rtnl_link_flags2str(link->l_flags, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, " <flags>%s</flags>\n", buf);
nl_dump_line(p, " <flags>%s</flags>\n", buf);
if (link->ce_mask & LINK_ATTR_QDISC)
dp_dump_line(p, line++, " <qdisc>%s</qdisc>\n", link->l_qdisc);
nl_dump_line(p, " <qdisc>%s</qdisc>\n", link->l_qdisc);
if (link->ce_mask & LINK_ATTR_LINK) {
struct rtnl_link *ll = rtnl_link_get(cache, link->l_link);
dp_dump_line(p, line++, " <link>%s</link>\n",
nl_dump_line(p, " <link>%s</link>\n",
ll ? ll->l_name : "none");
if (ll)
rtnl_link_put(ll);
@ -616,91 +602,87 @@ static int link_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
if (link->ce_mask & LINK_ATTR_MASTER) {
struct rtnl_link *master = rtnl_link_get(cache, link->l_master);
dp_dump_line(p, line++, " <master>%s</master>\n",
nl_dump_line(p, " <master>%s</master>\n",
master ? master->l_name : "none");
if (master)
rtnl_link_put(master);
}
if (link->ce_mask & LINK_ATTR_BRD)
dp_dump_line(p, line++, " <broadcast>%s</broadcast>\n",
nl_dump_line(p, " <broadcast>%s</broadcast>\n",
nl_addr2str(link->l_bcast, buf, sizeof(buf)));
if (link->ce_mask & LINK_ATTR_STATS) {
dp_dump_line(p, line++, " <stats>\n");
nl_dump_line(p, " <stats>\n");
for (i = 0; i <= RTNL_LINK_STATS_MAX; i++) {
rtnl_link_stat2str(i, buf, sizeof(buf));
dp_dump_line(p, line++,
" <%s>%" PRIu64 "</%s>\n",
nl_dump_line(p, " <%s>%" PRIu64 "</%s>\n",
buf, link->l_stats[i], buf);
}
dp_dump_line(p, line++, " </stats>\n");
nl_dump_line(p, " </stats>\n");
}
if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_XML]) {
dp_dump_line(p, line++, " <info>\n");
line = link->l_info_ops->io_dump[NL_DUMP_XML](link, p, line);
dp_dump_line(p, line++, " </info>\n");
nl_dump_line(p, " <info>\n");
link->l_info_ops->io_dump[NL_DUMP_XML](link, p);
nl_dump_line(p, " </info>\n");
}
dp_dump_line(p, line++, "</link>\n");
nl_dump_line(p, "</link>\n");
#if 0
uint32_t l_change; /**< Change mask */
struct rtnl_lifmap l_map; /**< Interface device mapping */
#endif
return line;
}
static int link_dump_env(struct nl_object *obj, struct nl_dump_params *p)
static void link_dump_env(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_link *link = (struct rtnl_link *) obj;
struct nl_cache *cache = dp_cache(obj);
char buf[128];
int i, line = 0;
int i;
dp_dump_line(p, line++, "LINK_NAME=%s\n", link->l_name);
dp_dump_line(p, line++, "LINK_IFINDEX=%u\n", link->l_index);
dp_dump_line(p, line++, "LINK_FAMILY=%s\n",
nl_dump_line(p, "LINK_NAME=%s\n", link->l_name);
nl_dump_line(p, "LINK_IFINDEX=%u\n", link->l_index);
nl_dump_line(p, "LINK_FAMILY=%s\n",
nl_af2str(link->l_family, buf, sizeof(buf)));
dp_dump_line(p, line++, "LINK_TYPE=%s\n",
nl_dump_line(p, "LINK_TYPE=%s\n",
nl_llproto2str(link->l_arptype, buf, sizeof(buf)));
if (link->ce_mask & LINK_ATTR_ADDR)
dp_dump_line(p, line++, "LINK_ADDRESS=%s\n",
nl_dump_line(p, "LINK_ADDRESS=%s\n",
nl_addr2str(link->l_addr, buf, sizeof(buf)));
dp_dump_line(p, line++, "LINK_MTU=%u\n", link->l_mtu);
dp_dump_line(p, line++, "LINK_TXQUEUELEN=%u\n", link->l_txqlen);
dp_dump_line(p, line++, "LINK_WEIGHT=%u\n", link->l_weight);
nl_dump_line(p, "LINK_MTU=%u\n", link->l_mtu);
nl_dump_line(p, "LINK_TXQUEUELEN=%u\n", link->l_txqlen);
nl_dump_line(p, "LINK_WEIGHT=%u\n", link->l_weight);
rtnl_link_flags2str(link->l_flags & ~IFF_RUNNING, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, "LINK_FLAGS=%s\n", buf);
nl_dump_line(p, "LINK_FLAGS=%s\n", buf);
if (link->ce_mask & LINK_ATTR_QDISC)
dp_dump_line(p, line++, "LINK_QDISC=%s\n", link->l_qdisc);
nl_dump_line(p, "LINK_QDISC=%s\n", link->l_qdisc);
if (link->ce_mask & LINK_ATTR_LINK) {
struct rtnl_link *ll = rtnl_link_get(cache, link->l_link);
dp_dump_line(p, line++, "LINK_LINK_IFINDEX=%d\n", link->l_link);
nl_dump_line(p, "LINK_LINK_IFINDEX=%d\n", link->l_link);
if (ll) {
dp_dump_line(p, line++, "LINK_LINK_IFNAME=%s\n",
ll->l_name);
nl_dump_line(p, "LINK_LINK_IFNAME=%s\n", ll->l_name);
rtnl_link_put(ll);
}
}
if (link->ce_mask & LINK_ATTR_MASTER) {
struct rtnl_link *master = rtnl_link_get(cache, link->l_master);
dp_dump_line(p, line++, "LINK_MASTER=%s\n",
nl_dump_line(p, "LINK_MASTER=%s\n",
master ? master->l_name : "none");
if (master)
rtnl_link_put(master);
}
if (link->ce_mask & LINK_ATTR_BRD)
dp_dump_line(p, line++, "LINK_BROADCAST=%s\n",
nl_dump_line(p, "LINK_BROADCAST=%s\n",
nl_addr2str(link->l_bcast, buf, sizeof(buf)));
if (link->ce_mask & LINK_ATTR_STATS) {
@ -713,15 +695,12 @@ static int link_dump_env(struct nl_object *obj, struct nl_dump_params *p)
*c = toupper(*c);
c++;
}
dp_dump_line(p, line++,
"%s=%" PRIu64 "\n", buf, link->l_stats[i]);
nl_dump_line(p, "%s=%" PRIu64 "\n", buf, link->l_stats[i]);
}
}
if (link->l_info_ops && link->l_info_ops->io_dump[NL_DUMP_ENV])
line = link->l_info_ops->io_dump[NL_DUMP_ENV](link, p, line);
return line;
link->l_info_ops->io_dump[NL_DUMP_ENV](link, p);
}
#if 0
@ -1517,11 +1496,13 @@ static struct nl_object_ops link_obj_ops = {
.oo_size = sizeof(struct rtnl_link),
.oo_free_data = link_free_data,
.oo_clone = link_clone,
.oo_dump[NL_DUMP_BRIEF] = link_dump_brief,
.oo_dump[NL_DUMP_FULL] = link_dump_full,
.oo_dump[NL_DUMP_STATS] = link_dump_stats,
.oo_dump[NL_DUMP_XML] = link_dump_xml,
.oo_dump[NL_DUMP_ENV] = link_dump_env,
.oo_dump = {
[NL_DUMP_LINE] = link_dump_line,
[NL_DUMP_DETAILS] = link_dump_details,
[NL_DUMP_STATS] = link_dump_stats,
[NL_DUMP_XML] = link_dump_xml,
[NL_DUMP_ENV] = link_dump_env,
},
.oo_compare = link_compare,
.oo_attrs2str = link_attrs2str,
.oo_id_attrs = LINK_ATTR_IFINDEX,

49
lib/route/link/vlan.c
View File

@ -179,71 +179,60 @@ static void vlan_free(struct rtnl_link *link)
link->l_info = NULL;
}
static int vlan_dump_brief(struct rtnl_link *link, struct nl_dump_params *p,
int line)
static void vlan_dump_line(struct rtnl_link *link, struct nl_dump_params *p)
{
struct vlan_info *vi = link->l_info;
dp_dump(p, "vlan-id %d", vi->vi_vlan_id);
return line;
nl_dump(p, "vlan-id %d", vi->vi_vlan_id);
}
static int vlan_dump_full(struct rtnl_link *link, struct nl_dump_params *p,
int line)
static void vlan_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
{
struct vlan_info *vi = link->l_info;
int i, printed;
char buf[64];
rtnl_link_vlan_flags2str(vi->vi_flags, buf, sizeof(buf));
dp_dump_line(p, line++, " vlan-info id %d <%s>\n",
vi->vi_vlan_id, buf);
nl_dump_line(p, " vlan-info id %d <%s>\n", vi->vi_vlan_id, buf);
if (vi->vi_mask & VLAN_HAS_INGRESS_QOS) {
dp_dump_line(p, line++,
nl_dump_line(p,
" ingress vlan prio -> qos/socket prio mapping:\n");
for (i = 0, printed = 0; i <= VLAN_PRIO_MAX; i++) {
if (vi->vi_ingress_qos[i]) {
if (printed == 0) {
dp_new_line(p, line);
dp_dump(p, " ");
}
dp_dump(p, "%x -> %#08x, ",
if (printed == 0)
nl_dump_line(p, " ");
nl_dump(p, "%x -> %#08x, ",
i, vi->vi_ingress_qos[i]);
if (printed++ == 3) {
dp_dump(p, "\n");
nl_dump(p, "\n");
printed = 0;
}
}
}
if (printed > 0 && printed != 4)
dp_dump(p, "\n");
nl_dump(p, "\n");
}
if (vi->vi_mask & VLAN_HAS_EGRESS_QOS) {
dp_dump_line(p, line++,
nl_dump_line(p,
" egress qos/socket prio -> vlan prio mapping:\n");
for (i = 0, printed = 0; i < vi->vi_negress; i++) {
if (printed == 0) {
dp_new_line(p, line);
dp_dump(p, " ");
}
dp_dump(p, "%#08x -> %x, ",
if (printed == 0)
nl_dump_line(p, " ");
nl_dump(p, "%#08x -> %x, ",
vi->vi_egress_qos[i].vm_from,
vi->vi_egress_qos[i].vm_to);
if (printed++ == 3) {
dp_dump(p, "\n");
nl_dump(p, "\n");
printed = 0;
}
}
if (printed > 0 && printed != 4)
dp_dump(p, "\n");
nl_dump(p, "\n");
}
return line;
}
static int vlan_clone(struct rtnl_link *dst, struct rtnl_link *src)
@ -336,8 +325,10 @@ static struct rtnl_link_info_ops vlan_info_ops = {
.io_name = "vlan",
.io_alloc = vlan_alloc,
.io_parse = vlan_parse,
.io_dump[NL_DUMP_BRIEF] = vlan_dump_brief,
.io_dump[NL_DUMP_FULL] = vlan_dump_full,
.io_dump = {
[NL_DUMP_LINE] = vlan_dump_line,
[NL_DUMP_DETAILS] = vlan_dump_details,
},
.io_clone = vlan_clone,
.io_put_attrs = vlan_put_attrs,
.io_free = vlan_free,

97
lib/route/neigh.c
View File

@ -328,7 +328,7 @@ static int neigh_request_update(struct nl_cache *c, struct nl_sock *h)
}
static int neigh_dump_brief(struct nl_object *a, struct nl_dump_params *p)
static void neigh_dump_line(struct nl_object *a, struct nl_dump_params *p)
{
char dst[INET6_ADDRSTRLEN+5], lladdr[INET6_ADDRSTRLEN+5];
struct rtnl_neigh *n = (struct rtnl_neigh *) a;
@ -337,72 +337,67 @@ static int neigh_dump_brief(struct nl_object *a, struct nl_dump_params *p)
link_cache = nl_cache_mngt_require("route/link");
dp_dump(p, "%s ", nl_addr2str(n->n_dst, dst, sizeof(dst)));
nl_dump_line(p, "%s ", nl_addr2str(n->n_dst, dst, sizeof(dst)));
if (link_cache)
dp_dump(p, "dev %s ",
nl_dump(p, "dev %s ",
rtnl_link_i2name(link_cache, n->n_ifindex,
state, sizeof(state)));
else
dp_dump(p, "dev %d ", n->n_ifindex);
nl_dump(p, "dev %d ", n->n_ifindex);
if (n->ce_mask & NEIGH_ATTR_LLADDR)
dp_dump(p, "lladdr %s ",
nl_dump(p, "lladdr %s ",
nl_addr2str(n->n_lladdr, lladdr, sizeof(lladdr)));
rtnl_neigh_state2str(n->n_state, state, sizeof(state));
rtnl_neigh_flags2str(n->n_flags, flags, sizeof(flags));
if (state[0])
dp_dump(p, "<%s", state);
nl_dump(p, "<%s", state);
if (flags[0])
dp_dump(p, "%s%s", state[0] ? "," : "<", flags);
nl_dump(p, "%s%s", state[0] ? "," : "<", flags);
if (state[0] || flags[0])
dp_dump(p, ">");
dp_dump(p, "\n");
return 1;
nl_dump(p, ">");
nl_dump(p, "\n");
}
static int neigh_dump_full(struct nl_object *a, struct nl_dump_params *p)
static void neigh_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
char rtn_type[32];
struct rtnl_neigh *n = (struct rtnl_neigh *) a;
int hz = nl_get_hz();
int line = neigh_dump_brief(a, p);
neigh_dump_line(a, p);
dp_dump_line(p, line++, " refcnt %u type %s confirmed %u used "
nl_dump_line(p, " refcnt %u type %s confirmed %u used "
"%u updated %u\n",
n->n_cacheinfo.nci_refcnt,
nl_rtntype2str(n->n_type, rtn_type, sizeof(rtn_type)),
n->n_cacheinfo.nci_confirmed/hz,
n->n_cacheinfo.nci_used/hz, n->n_cacheinfo.nci_updated/hz);
return line;
}
static int neigh_dump_stats(struct nl_object *a, struct nl_dump_params *p)
static void neigh_dump_stats(struct nl_object *a, struct nl_dump_params *p)
{
return neigh_dump_full(a, p);
neigh_dump_details(a, p);
}
static int neigh_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
static void neigh_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_neigh *neigh = (struct rtnl_neigh *) obj;
char buf[128];
int line = 0;
dp_dump_line(p, line++, "<neighbour>\n");
dp_dump_line(p, line++, " <family>%s</family>\n",
nl_dump_line(p, "<neighbour>\n");
nl_dump_line(p, " <family>%s</family>\n",
nl_af2str(neigh->n_family, buf, sizeof(buf)));
if (neigh->ce_mask & NEIGH_ATTR_LLADDR)
dp_dump_line(p, line++, " <lladdr>%s</lladdr>\n",
nl_dump_line(p, " <lladdr>%s</lladdr>\n",
nl_addr2str(neigh->n_lladdr, buf, sizeof(buf)));
if (neigh->ce_mask & NEIGH_ATTR_DST)
dp_dump_line(p, line++, " <dst>%s</dst>\n",
nl_dump_line(p, " <dst>%s</dst>\n",
nl_addr2str(neigh->n_dst, buf, sizeof(buf)));
if (neigh->ce_mask & NEIGH_ATTR_IFINDEX) {
@ -411,88 +406,80 @@ static int neigh_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
link_cache = nl_cache_mngt_require("route/link");
if (link_cache)
dp_dump_line(p, line++, " <device>%s</device>\n",
nl_dump_line(p, " <device>%s</device>\n",
rtnl_link_i2name(link_cache,
neigh->n_ifindex,
buf, sizeof(buf)));
else
dp_dump_line(p, line++, " <device>%u</device>\n",
nl_dump_line(p, " <device>%u</device>\n",
neigh->n_ifindex);
}
if (neigh->ce_mask & NEIGH_ATTR_PROBES)
dp_dump_line(p, line++, " <probes>%u</probes>\n",
neigh->n_probes);
nl_dump_line(p, " <probes>%u</probes>\n", neigh->n_probes);
if (neigh->ce_mask & NEIGH_ATTR_TYPE)
dp_dump_line(p, line++, " <type>%s</type>\n",
nl_dump_line(p, " <type>%s</type>\n",
nl_rtntype2str(neigh->n_type, buf, sizeof(buf)));
rtnl_neigh_flags2str(neigh->n_flags, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, " <flags>%s</flags>\n", buf);
nl_dump_line(p, " <flags>%s</flags>\n", buf);
rtnl_neigh_state2str(neigh->n_state, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, " <state>%s</state>\n", buf);
nl_dump_line(p, " <state>%s</state>\n", buf);
dp_dump_line(p, line++, "</neighbour>\n");
nl_dump_line(p, "</neighbour>\n");
#if 0
struct rtnl_ncacheinfo n_cacheinfo;
#endif
return line;
}
static int neigh_dump_env(struct nl_object *obj, struct nl_dump_params *p)
static void neigh_dump_env(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_neigh *neigh = (struct rtnl_neigh *) obj;
char buf[128];
int line = 0;
dp_dump_line(p, line++, "NEIGH_FAMILY=%s\n",
nl_dump_line(p, "NEIGH_FAMILY=%s\n",
nl_af2str(neigh->n_family, buf, sizeof(buf)));
if (neigh->ce_mask & NEIGH_ATTR_LLADDR)
dp_dump_line(p, line++, "NEIGHT_LLADDR=%s\n",
nl_dump_line(p, "NEIGHT_LLADDR=%s\n",
nl_addr2str(neigh->n_lladdr, buf, sizeof(buf)));
if (neigh->ce_mask & NEIGH_ATTR_DST)
dp_dump_line(p, line++, "NEIGH_DST=%s\n",
nl_dump_line(p, "NEIGH_DST=%s\n",
nl_addr2str(neigh->n_dst, buf, sizeof(buf)));
if (neigh->ce_mask & NEIGH_ATTR_IFINDEX) {
struct nl_cache *link_cache;
dp_dump_line(p, line++, "NEIGH_IFINDEX=%u\n",
neigh->n_ifindex);
nl_dump_line(p, "NEIGH_IFINDEX=%u\n", neigh->n_ifindex);
link_cache = nl_cache_mngt_require("route/link");
if (link_cache)
dp_dump_line(p, line++, "NEIGH_IFNAME=%s\n",
nl_dump_line(p, "NEIGH_IFNAME=%s\n",
rtnl_link_i2name(link_cache,
neigh->n_ifindex,
buf, sizeof(buf)));
}
if (neigh->ce_mask & NEIGH_ATTR_PROBES)
dp_dump_line(p, line++, "NEIGH_PROBES=%u\n",
neigh->n_probes);
nl_dump_line(p, "NEIGH_PROBES=%u\n", neigh->n_probes);
if (neigh->ce_mask & NEIGH_ATTR_TYPE)
dp_dump_line(p, line++, "NEIGH_TYPE=%s\n",
nl_dump_line(p, "NEIGH_TYPE=%s\n",
nl_rtntype2str(neigh->n_type, buf, sizeof(buf)));
rtnl_neigh_flags2str(neigh->n_flags, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, "NEIGH_FLAGS=%s\n", buf);
nl_dump_line(p, "NEIGH_FLAGS=%s\n", buf);
rtnl_neigh_state2str(neigh->n_state, buf, sizeof(buf));
if (buf[0])
dp_dump_line(p, line++, "NEIGH_STATE=%s\n", buf);
return line;
nl_dump_line(p, "NEIGH_STATE=%s\n", buf);
}
/**
@ -909,11 +896,13 @@ static struct nl_object_ops neigh_obj_ops = {
.oo_size = sizeof(struct rtnl_neigh),
.oo_free_data = neigh_free_data,
.oo_clone = neigh_clone,
.oo_dump[NL_DUMP_BRIEF] = neigh_dump_brief,
.oo_dump[NL_DUMP_FULL] = neigh_dump_full,
.oo_dump[NL_DUMP_STATS] = neigh_dump_stats,
.oo_dump[NL_DUMP_XML] = neigh_dump_xml,
.oo_dump[NL_DUMP_ENV] = neigh_dump_env,
.oo_dump = {
[NL_DUMP_LINE] = neigh_dump_line,
[NL_DUMP_DETAILS] = neigh_dump_details,
[NL_DUMP_STATS] = neigh_dump_stats,
[NL_DUMP_XML] = neigh_dump_xml,
[NL_DUMP_ENV] = neigh_dump_env,
},
.oo_compare = neigh_compare,
.oo_attrs2str = neigh_attrs2str,
.oo_id_attrs = (NEIGH_ATTR_DST | NEIGH_ATTR_FAMILY),

71
lib/route/neightbl.c
View File

@ -228,12 +228,11 @@ static int neightbl_request_update(struct nl_cache *c, struct nl_sock *h)
}
static int neightbl_dump_brief(struct nl_object *arg, struct nl_dump_params *p)
static void neightbl_dump_line(struct nl_object *arg, struct nl_dump_params *p)
{
int line = 1;
struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg;
dp_dump(p, "%s", ntbl->nt_name);
nl_dump_line(p, "%s", ntbl->nt_name);
if (ntbl->nt_parms.ntp_mask & NEIGHTBLPARM_ATTR_IFINDEX) {
struct nl_cache *link_cache;
@ -242,57 +241,52 @@ static int neightbl_dump_brief(struct nl_object *arg, struct nl_dump_params *p)
if (link_cache) {
char buf[32];
dp_dump(p, "<%s> ",
nl_dump(p, "<%s> ",
rtnl_link_i2name(link_cache,
ntbl->nt_parms.ntp_ifindex,
buf, sizeof(buf)));
} else
dp_dump(p, "<%u> ", ntbl->nt_parms.ntp_ifindex);
nl_dump(p, "<%u> ", ntbl->nt_parms.ntp_ifindex);
} else
dp_dump(p, " ");
nl_dump(p, " ");
if (ntbl->ce_mask & NEIGHTBL_ATTR_CONFIG)
dp_dump(p, "entries %u ", ntbl->nt_config.ndtc_entries);
nl_dump(p, "entries %u ", ntbl->nt_config.ndtc_entries);
if (ntbl->ce_mask & NEIGHTBL_ATTR_PARMS) {
char rt[32], rt2[32];
struct rtnl_neightbl_parms *pa = &ntbl->nt_parms;
dp_dump(p, "reachable-time %s retransmit-time %s",
nl_dump(p, "reachable-time %s retransmit-time %s",
nl_msec2str(pa->ntp_reachable_time, rt, sizeof(rt)),
nl_msec2str(pa->ntp_retrans_time, rt2, sizeof(rt2)));
}
dp_dump(p, "\n");
return line;
nl_dump(p, "\n");
}
static int neightbl_dump_full(struct nl_object *arg, struct nl_dump_params *p)
static void neightbl_dump_details(struct nl_object *arg, struct nl_dump_params *p)
{
char x[32], y[32], z[32];
struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg;
int line = neightbl_dump_brief(arg, p);
neightbl_dump_line(arg, p);
if (ntbl->ce_mask & NEIGHTBL_ATTR_CONFIG) {
dp_new_line(p, line++);
dp_dump(p, " key-len %u entry-size %u last-flush %s\n",
nl_dump_line(p, " key-len %u entry-size %u last-flush %s\n",
ntbl->nt_config.ndtc_key_len,
ntbl->nt_config.ndtc_entry_size,
nl_msec2str(ntbl->nt_config.ndtc_last_flush,
x, sizeof(x)));
dp_new_line(p, line++);
dp_dump(p, " gc threshold %u/%u/%u interval %s " \
nl_dump_line(p, " gc threshold %u/%u/%u interval %s " \
"chain-position %u\n",
ntbl->nt_gc_thresh1, ntbl->nt_gc_thresh2,
ntbl->nt_gc_thresh3,
nl_msec2str(ntbl->nt_gc_interval, x, sizeof(x)),
ntbl->nt_config.ndtc_hash_chain_gc);
dp_new_line(p, line++);
dp_dump(p, " hash-rand 0x%08X/0x%08X last-rand %s\n",
nl_dump_line(p, " hash-rand 0x%08X/0x%08X last-rand %s\n",
ntbl->nt_config.ndtc_hash_rnd,
ntbl->nt_config.ndtc_hash_mask,
nl_msec2str(ntbl->nt_config.ndtc_last_rand,
@ -302,49 +296,43 @@ static int neightbl_dump_full(struct nl_object *arg, struct nl_dump_params *p)
if (ntbl->ce_mask & NEIGHTBL_ATTR_PARMS) {
struct rtnl_neightbl_parms *pa = &ntbl->nt_parms;
dp_new_line(p, line++);
dp_dump(p, " refcnt %u pending-queue-limit %u " \
nl_dump_line(p, " refcnt %u pending-queue-limit %u " \
"proxy-delayed-queue-limit %u\n",
pa->ntp_refcnt,
pa->ntp_queue_len,
pa->ntp_proxy_qlen);
dp_new_line(p, line++);
dp_dump(p, " num-userspace-probes %u num-unicast-probes " \
nl_dump_line(p, " num-userspace-probes %u num-unicast-probes " \
"%u num-multicast-probes %u\n",
pa->ntp_app_probes,
pa->ntp_ucast_probes,
pa->ntp_mcast_probes);
dp_new_line(p, line++);
dp_dump(p, " min-age %s base-reachable-time %s " \
nl_dump_line(p, " min-age %s base-reachable-time %s " \
"stale-check-interval %s\n",
nl_msec2str(pa->ntp_locktime, x, sizeof(x)),
nl_msec2str(pa->ntp_base_reachable_time,
y, sizeof(y)),
nl_msec2str(pa->ntp_gc_stale_time, z, sizeof(z)));
dp_new_line(p, line++);
dp_dump(p, " initial-probe-delay %s answer-delay %s " \
nl_dump_line(p, " initial-probe-delay %s answer-delay %s " \
"proxy-answer-delay %s\n",
nl_msec2str(pa->ntp_probe_delay, x, sizeof(x)),
nl_msec2str(pa->ntp_anycast_delay, y, sizeof(y)),
nl_msec2str(pa->ntp_proxy_delay, z, sizeof(z)));
}
return line;
}
static int neightbl_dump_stats(struct nl_object *arg, struct nl_dump_params *p)
static void neightbl_dump_stats(struct nl_object *arg, struct nl_dump_params *p)
{
struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg;
int line = neightbl_dump_full(arg, p);
neightbl_dump_details(arg, p);
if (!(ntbl->ce_mask & NEIGHTBL_ATTR_STATS))
return line;
return;
dp_new_line(p, line++);
dp_dump(p, " lookups %lld hits %lld failed %lld " \
nl_dump_line(p, " lookups %lld hits %lld failed %lld " \
"allocations %lld destroys %lld\n",
ntbl->nt_stats.ndts_lookups,
ntbl->nt_stats.ndts_hits,
@ -352,18 +340,15 @@ static int neightbl_dump_stats(struct nl_object *arg, struct nl_dump_params *p)
ntbl->nt_stats.ndts_allocs,
ntbl->nt_stats.ndts_destroys);
dp_new_line(p, line++);
dp_dump(p, " hash-grows %lld forced-gc-runs %lld " \
nl_dump_line(p, " hash-grows %lld forced-gc-runs %lld " \
"periodic-gc-runs %lld\n",
ntbl->nt_stats.ndts_hash_grows,
ntbl->nt_stats.ndts_forced_gc_runs,
ntbl->nt_stats.ndts_periodic_gc_runs);
dp_dump(p, " rcv-unicast-probes %lld rcv-multicast-probes %lld\n",
nl_dump_line(p, " rcv-unicast-probes %lld rcv-multicast-probes %lld\n",
ntbl->nt_stats.ndts_rcv_probes_ucast,
ntbl->nt_stats.ndts_rcv_probes_mcast);
return line;
}
/**
@ -794,9 +779,11 @@ void rtnl_neightbl_set_locktime(struct rtnl_neightbl *ntbl, uint64_t ms)
static struct nl_object_ops neightbl_obj_ops = {
.oo_name = "route/neightbl",
.oo_size = sizeof(struct rtnl_neightbl),
.oo_dump[NL_DUMP_BRIEF] = neightbl_dump_brief,
.oo_dump[NL_DUMP_FULL] = neightbl_dump_full,
.oo_dump[NL_DUMP_STATS] = neightbl_dump_stats,
.oo_dump = {
[NL_DUMP_LINE] = neightbl_dump_line,
[NL_DUMP_DETAILS] = neightbl_dump_details,
[NL_DUMP_STATS] = neightbl_dump_stats,
},
.oo_compare = neightbl_compare,
};

6
lib/route/nexthop.c
View File

@ -104,7 +104,7 @@ int rtnl_route_nh_compare(struct rtnl_nexthop *a, struct rtnl_nexthop *b,
return diff;
}
static void nh_dump_oneline(struct rtnl_nexthop *nh, struct nl_dump_params *dp)
static void nh_dump_line(struct rtnl_nexthop *nh, struct nl_dump_params *dp)
{
struct nl_cache *link_cache;
char buf[128];
@ -205,8 +205,8 @@ static void nh_dump_env(struct rtnl_nexthop *nh, struct nl_dump_params *dp)
void rtnl_route_nh_dump(struct rtnl_nexthop *nh, struct nl_dump_params *dp)
{
switch (dp->dp_type) {
case NL_DUMP_ONELINE:
nh_dump_oneline(nh, dp);
case NL_DUMP_LINE:
nh_dump_line(nh, dp);
break;
case NL_DUMP_DETAILS:

49
lib/route/qdisc_obj.c
View File

@ -56,54 +56,49 @@ errout:
return err;
}
static int qdisc_dump_brief(struct nl_object *obj, struct nl_dump_params *p)
static void qdisc_dump_line(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_qdisc *qdisc = (struct rtnl_qdisc *) obj;
struct rtnl_qdisc_ops *qops;
int line = tca_dump_brief((struct rtnl_tca *) qdisc, "qdisc", p, 0);
tca_dump_line((struct rtnl_tca *) qdisc, "qdisc", p);
qops = rtnl_qdisc_lookup_ops(qdisc);
if (qops && qops->qo_dump[NL_DUMP_BRIEF])
line = qops->qo_dump[NL_DUMP_BRIEF](qdisc, p, line);
if (qops && qops->qo_dump[NL_DUMP_LINE])
qops->qo_dump[NL_DUMP_LINE](qdisc, p);
dp_dump(p, "\n");
return line;
nl_dump(p, "\n");
}
static int qdisc_dump_full(struct nl_object *arg, struct nl_dump_params *p)
static void qdisc_dump_details(struct nl_object *arg, struct nl_dump_params *p)
{
struct rtnl_qdisc *qdisc = (struct rtnl_qdisc *) arg;
struct rtnl_qdisc_ops *qops;
int line = qdisc_dump_brief(arg, p);
qdisc_dump_line(arg, p);
line = tca_dump_full((struct rtnl_tca *) qdisc, p, line);
dp_dump(p, "refcnt %u ", qdisc->q_info);
tca_dump_details((struct rtnl_tca *) qdisc, p);
nl_dump(p, "refcnt %u ", qdisc->q_info);
qops = rtnl_qdisc_lookup_ops(qdisc);
if (qops && qops->qo_dump[NL_DUMP_FULL])
line = qops->qo_dump[NL_DUMP_FULL](qdisc, p, line);
if (qops && qops->qo_dump[NL_DUMP_DETAILS])
qops->qo_dump[NL_DUMP_DETAILS](qdisc, p);
dp_dump(p, "\n");
return line;
nl_dump(p, "\n");
}
static int qdisc_dump_stats(struct nl_object *arg, struct nl_dump_params *p)
static void qdisc_dump_stats(struct nl_object *arg, struct nl_dump_params *p)
{
struct rtnl_qdisc *qdisc = (struct rtnl_qdisc *) arg;
struct rtnl_qdisc_ops *qops;
int line = qdisc_dump_full(arg, p);
line = tca_dump_stats((struct rtnl_tca *) qdisc, p, line );
dp_dump(p, "\n");
qdisc_dump_details(arg, p);
tca_dump_stats((struct rtnl_tca *) qdisc, p);
nl_dump(p, "\n");
qops = rtnl_qdisc_lookup_ops(qdisc);
if (qops && qops->qo_dump[NL_DUMP_STATS])
line = qops->qo_dump[NL_DUMP_STATS](qdisc, p, line);
return line;
qops->qo_dump[NL_DUMP_STATS](qdisc, p);
}
/**
@ -263,9 +258,11 @@ struct nl_object_ops qdisc_obj_ops = {
.oo_size = sizeof(struct rtnl_qdisc),
.oo_free_data = qdisc_free_data,
.oo_clone = qdisc_clone,
.oo_dump[NL_DUMP_BRIEF] = qdisc_dump_brief,
.oo_dump[NL_DUMP_FULL] = qdisc_dump_full,
.oo_dump[NL_DUMP_STATS] = qdisc_dump_stats,
.oo_dump = {
[NL_DUMP_LINE] = qdisc_dump_line,
[NL_DUMP_DETAILS] = qdisc_dump_details,
[NL_DUMP_STATS] = qdisc_dump_stats,
},
.oo_compare = tca_compare,
.oo_id_attrs = (TCA_ATTR_IFINDEX | TCA_ATTR_HANDLE),
};

32
lib/route/route_obj.c
View File

@ -122,7 +122,7 @@ static int route_clone(struct nl_object *_dst, struct nl_object *_src)
return 0;
}
static int route_dump_oneline(struct nl_object *a, struct nl_dump_params *p)
static void route_dump_line(struct nl_object *a, struct nl_dump_params *p)
{
struct rtnl_route *r = (struct rtnl_route *) a;
struct nl_cache *link_cache;
@ -130,7 +130,7 @@ static int route_dump_oneline(struct nl_object *a, struct nl_dump_params *p)
link_cache = nl_cache_mngt_require("route/link");
nl_dump(p, "%s ", nl_af2str(r->rt_family, buf, sizeof(buf)));
nl_dump_line(p, "%s ", nl_af2str(r->rt_family, buf, sizeof(buf)));
if (!(r->ce_mask & ROUTE_ATTR_DST) ||
nl_addr_get_len(r->rt_dst) == 0)
@ -182,11 +182,9 @@ static int route_dump_oneline(struct nl_object *a, struct nl_dump_params *p)
}
nl_dump(p, "\n");
return 1;
}
static int route_dump_details(struct nl_object *a, struct nl_dump_params *p)
static void route_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
struct rtnl_route *r = (struct rtnl_route *) a;
struct nl_cache *link_cache;
@ -195,7 +193,7 @@ static int route_dump_details(struct nl_object *a, struct nl_dump_params *p)
link_cache = nl_cache_mngt_require("route/link");
route_dump_oneline(a, p);
route_dump_line(a, p);
nl_dump_line(p, " ");
if (r->ce_mask & ROUTE_ATTR_PREF_SRC)
@ -254,11 +252,9 @@ static int route_dump_details(struct nl_object *a, struct nl_dump_params *p)
r->rt_metrics[i]);
nl_dump(p, "]\n");
}
return 0;
}
static int route_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
static void route_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_route *route = (struct rtnl_route *) obj;
@ -273,11 +269,9 @@ static int route_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
ci->rtci_last_use / nl_get_hz(),
ci->rtci_expires / nl_get_hz());
}
return 0;
}
static int route_dump_env(struct nl_object *obj, struct nl_dump_params *p)
static void route_dump_env(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_route *route = (struct rtnl_route *) obj;
struct nl_cache *link_cache;
@ -285,7 +279,7 @@ static int route_dump_env(struct nl_object *obj, struct nl_dump_params *p)
link_cache = nl_cache_mngt_require("route/link");
nl_dump(p, "ROUTE_FAMILY=%s\n",
nl_dump_line(p, "ROUTE_FAMILY=%s\n",
nl_af2str(route->rt_family, buf, sizeof(buf)));
if (route->ce_mask & ROUTE_ATTR_DST)
@ -340,8 +334,6 @@ static int route_dump_env(struct nl_object *obj, struct nl_dump_params *p)
rtnl_route_nh_dump(nh, p);
}
}
return 0;
}
static int route_compare(struct nl_object *_a, struct nl_object *_b,
@ -1170,10 +1162,12 @@ struct nl_object_ops route_obj_ops = {
.oo_constructor = route_constructor,
.oo_free_data = route_free_data,
.oo_clone = route_clone,
.oo_dump[NL_DUMP_ONELINE] = route_dump_oneline,
.oo_dump[NL_DUMP_DETAILS] = route_dump_details,
.oo_dump[NL_DUMP_STATS] = route_dump_stats,
.oo_dump[NL_DUMP_ENV] = route_dump_env,
.oo_dump = {
[NL_DUMP_LINE] = route_dump_line,
[NL_DUMP_DETAILS] = route_dump_details,
[NL_DUMP_STATS] = route_dump_stats,
[NL_DUMP_ENV] = route_dump_env,
},
.oo_compare = route_compare,
.oo_attrs2str = route_attrs2str,
.oo_id_attrs = (ROUTE_ATTR_FAMILY | ROUTE_ATTR_TOS |

133
lib/route/rule.c
View File

@ -169,185 +169,160 @@ static int rule_request_update(struct nl_cache *c, struct nl_sock *h)
return nl_rtgen_request(h, RTM_GETRULE, AF_UNSPEC, NLM_F_DUMP);
}
static int rule_dump_brief(struct nl_object *o, struct nl_dump_params *p)
static void rule_dump_line(struct nl_object *o, struct nl_dump_params *p)
{
struct rtnl_rule *r = (struct rtnl_rule *) o;
char buf[128];
dp_dump(p, "%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
dp_dump(p, "%s ", nl_af2str(r->r_family, buf, sizeof(buf)));
nl_dump_line(p, "%8d ", (r->ce_mask & RULE_ATTR_PRIO) ? r->r_prio : 0);
nl_dump(p, "%s ", nl_af2str(r->r_family, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_SRC)
dp_dump(p, "from %s ",
nl_dump(p, "from %s ",
nl_addr2str(r->r_src, buf, sizeof(buf)));
else if (r->ce_mask & RULE_ATTR_SRC_LEN && r->r_src_len)
dp_dump(p, "from 0/%d ", r->r_src_len);
nl_dump(p, "from 0/%d ", r->r_src_len);
if (r->ce_mask & RULE_ATTR_DST)
dp_dump(p, "to %s ",
nl_dump(p, "to %s ",
nl_addr2str(r->r_dst, buf, sizeof(buf)));
else if (r->ce_mask & RULE_ATTR_DST_LEN && r->r_dst_len)
dp_dump(p, "to 0/%d ", r->r_dst_len);
nl_dump(p, "to 0/%d ", r->r_dst_len);
if (r->ce_mask & RULE_ATTR_DSFIELD && r->r_dsfield)
dp_dump(p, "tos %d ", r->r_dsfield);
nl_dump(p, "tos %d ", r->r_dsfield);
if (r->ce_mask & RULE_ATTR_MARK)
dp_dump(p, "mark %" PRIx64 , r->r_mark);
nl_dump(p, "mark %" PRIx64 , r->r_mark);
if (r->ce_mask & RULE_ATTR_IIF)
dp_dump(p, "iif %s ", r->r_iif);
nl_dump(p, "iif %s ", r->r_iif);
if (r->ce_mask & RULE_ATTR_TABLE)
dp_dump(p, "lookup %s ",
nl_dump(p, "lookup %s ",
rtnl_route_table2str(r->r_table, buf, sizeof(buf)));
if (r->ce_mask & RULE_ATTR_REALMS)
dp_dump(p, "realms %s ",
nl_dump(p, "realms %s ",
rtnl_realms2str(r->r_realms, buf, sizeof(buf)));
dp_dump(p, "action %s\n",
nl_dump(p, "action %s\n",
nl_rtntype2str(r->r_type, buf, sizeof(buf)));
return 1;
}
static int rule_dump_full(struct nl_object *obj, struct nl_dump_params *p)
static void rule_dump_details(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_rule *rule = (struct rtnl_rule *) obj;
char buf[128];
int line;
line = rule_dump_brief(obj, p);
rule_dump_line(obj, p);
if (rule->ce_mask & RULE_ATTR_SRCMAP)
dp_dump_line(p, line++, " srcmap %s\n",
nl_dump_line(p, " srcmap %s\n",
nl_addr2str(rule->r_srcmap, buf, sizeof(buf)));
return line;
}
static int rule_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
static void rule_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
return rule_dump_full(obj, p);
rule_dump_details(obj, p);
}
static int rule_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
static void rule_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_rule *rule = (struct rtnl_rule *) obj;
char buf[128];
int line = 0;
dp_dump_line(p, line++, "<rule>\n");
nl_dump_line(p, "<rule>\n");
dp_dump_line(p, line++, " <priority>%u</priority>\n",
rule->r_prio);
dp_dump_line(p, line++, " <family>%s</family>\n",
nl_dump_line(p, " <priority>%u</priority>\n", rule->r_prio);
nl_dump_line(p, " <family>%s</family>\n",
nl_af2str(rule->r_family, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_DST)
dp_dump_line(p, line++, " <dst>%s</dst>\n",
nl_dump_line(p, " <dst>%s</dst>\n",
nl_addr2str(rule->r_dst, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_DST_LEN)
dp_dump_line(p, line++, " <dstlen>%u</dstlen>\n",
rule->r_dst_len);
nl_dump_line(p, " <dstlen>%u</dstlen>\n", rule->r_dst_len);
if (rule->ce_mask & RULE_ATTR_SRC)
dp_dump_line(p, line++, " <src>%s</src>\n",
nl_dump_line(p, " <src>%s</src>\n",
nl_addr2str(rule->r_src, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_SRC_LEN)
dp_dump_line(p, line++, " <srclen>%u</srclen>\n",
rule->r_src_len);
nl_dump_line(p, " <srclen>%u</srclen>\n", rule->r_src_len);
if (rule->ce_mask & RULE_ATTR_IIF)
dp_dump_line(p, line++, " <iif>%s</iif>\n", rule->r_iif);
nl_dump_line(p, " <iif>%s</iif>\n", rule->r_iif);
if (rule->ce_mask & RULE_ATTR_TABLE)
dp_dump_line(p, line++, " <table>%u</table>\n",
rule->r_table);
nl_dump_line(p, " <table>%u</table>\n", rule->r_table);
if (rule->ce_mask & RULE_ATTR_REALMS)
dp_dump_line(p, line++, " <realms>%u</realms>\n",
rule->r_realms);
nl_dump_line(p, " <realms>%u</realms>\n", rule->r_realms);
if (rule->ce_mask & RULE_ATTR_MARK)
dp_dump_line(p, line++, " <mark>%" PRIx64 "</mark>\n",
rule->r_mark);
nl_dump_line(p, " <mark>%" PRIx64 "</mark>\n", rule->r_mark);
if (rule->ce_mask & RULE_ATTR_DSFIELD)
dp_dump_line(p, line++, " <dsfield>%u</dsfield>\n",
rule->r_dsfield);
nl_dump_line(p, " <dsfield>%u</dsfield>\n", rule->r_dsfield);
if (rule->ce_mask & RULE_ATTR_TYPE)
dp_dump_line(p, line++, "<type>%s</type>\n",
nl_dump_line(p, "<type>%s</type>\n",
nl_rtntype2str(rule->r_type, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_SRCMAP)
dp_dump_line(p, line++, "<srcmap>%s</srcmap>\n",
nl_dump_line(p, "<srcmap>%s</srcmap>\n",
nl_addr2str(rule->r_srcmap, buf, sizeof(buf)));
dp_dump_line(p, line++, "</rule>\n");
return line;
nl_dump_line(p, "</rule>\n");
}
static int rule_dump_env(struct nl_object *obj, struct nl_dump_params *p)
static void rule_dump_env(struct nl_object *obj, struct nl_dump_params *p)
{
struct rtnl_rule *rule = (struct rtnl_rule *) obj;
char buf[128];
int line = 0;
dp_dump_line(p, line++, "RULE_PRIORITY=%u\n",
rule->r_prio);
dp_dump_line(p, line++, "RULE_FAMILY=%s\n",
nl_dump_line(p, "RULE_PRIORITY=%u\n", rule->r_prio);
nl_dump_line(p, "RULE_FAMILY=%s\n",
nl_af2str(rule->r_family, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_DST)
dp_dump_line(p, line++, "RULE_DST=%s\n",
nl_dump_line(p, "RULE_DST=%s\n",
nl_addr2str(rule->r_dst, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_DST_LEN)
dp_dump_line(p, line++, "RULE_DSTLEN=%u\n",
rule->r_dst_len);
nl_dump_line(p, "RULE_DSTLEN=%u\n", rule->r_dst_len);
if (rule->ce_mask & RULE_ATTR_SRC)
dp_dump_line(p, line++, "RULE_SRC=%s\n",
nl_dump_line(p, "RULE_SRC=%s\n",
nl_addr2str(rule->r_src, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_SRC_LEN)
dp_dump_line(p, line++, "RULE_SRCLEN=%u\n",
rule->r_src_len);
nl_dump_line(p, "RULE_SRCLEN=%u\n", rule->r_src_len);
if (rule->ce_mask & RULE_ATTR_IIF)
dp_dump_line(p, line++, "RULE_IIF=%s\n", rule->r_iif);
nl_dump_line(p, "RULE_IIF=%s\n", rule->r_iif);
if (rule->ce_mask & RULE_ATTR_TABLE)
dp_dump_line(p, line++, "RULE_TABLE=%u\n",
rule->r_table);
nl_dump_line(p, "RULE_TABLE=%u\n", rule->r_table);
if (rule->ce_mask & RULE_ATTR_REALMS)
dp_dump_line(p, line++, "RULE_REALM=%u\n",
rule->r_realms);
nl_dump_line(p, "RULE_REALM=%u\n", rule->r_realms);
if (rule->ce_mask & RULE_ATTR_MARK)
dp_dump_line(p, line++, "RULE_MARK=0x%" PRIx64 "\n",
rule->r_mark);
nl_dump_line(p, "RULE_MARK=0x%" PRIx64 "\n", rule->r_mark);
if (rule->ce_mask & RULE_ATTR_DSFIELD)
dp_dump_line(p, line++, "RULE_DSFIELD=%u\n",
rule->r_dsfield);
nl_dump_line(p, "RULE_DSFIELD=%u\n", rule->r_dsfield);
if (rule->ce_mask & RULE_ATTR_TYPE)
dp_dump_line(p, line++, "RULE_TYPE=%s\n",
nl_dump_line(p, "RULE_TYPE=%s\n",
nl_rtntype2str(rule->r_type, buf, sizeof(buf)));
if (rule->ce_mask & RULE_ATTR_SRCMAP)
dp_dump_line(p, line++, "RULE_SRCMAP=%s\n",
nl_dump_line(p, "RULE_SRCMAP=%s\n",
nl_addr2str(rule->r_srcmap, buf, sizeof(buf)));
return line;
}
static int rule_compare(struct nl_object *_a, struct nl_object *_b,
@ -834,11 +809,13 @@ static struct nl_object_ops rule_obj_ops = {
.oo_size = sizeof(struct rtnl_rule),
.oo_free_data = rule_free_data,
.oo_clone = rule_clone,
.oo_dump[NL_DUMP_BRIEF] = rule_dump_brief,
.oo_dump[NL_DUMP_FULL] = rule_dump_full,
.oo_dump[NL_DUMP_STATS] = rule_dump_stats,
.oo_dump[NL_DUMP_XML] = rule_dump_xml,
.oo_dump[NL_DUMP_ENV] = rule_dump_env,
.oo_dump = {
[NL_DUMP_LINE] = rule_dump_line,
[NL_DUMP_DETAILS] = rule_dump_details,
[NL_DUMP_STATS] = rule_dump_stats,
[NL_DUMP_XML] = rule_dump_xml,
[NL_DUMP_ENV] = rule_dump_env,
},
.oo_compare = rule_compare,
.oo_attrs2str = rule_attrs2str,
.oo_id_attrs = ~0,

94
lib/route/sch/cbq.c
View File

@ -153,8 +153,7 @@ static int cbq_class_clone(struct rtnl_class *dst, struct rtnl_class *src)
return cbq_clone((struct rtnl_tca *) dst, (struct rtnl_tca *) src);
}
static int cbq_dump_brief(struct rtnl_tca *tca, struct nl_dump_params *p,
int line)
static void cbq_dump_line(struct rtnl_tca *tca, struct nl_dump_params *p)
{
struct rtnl_cbq *cbq;
double r, rbit;
@ -162,32 +161,28 @@ static int cbq_dump_brief(struct rtnl_tca *tca, struct nl_dump_params *p,
cbq = cbq_qdisc(tca);
if (!cbq)
goto ignore;
return;
r = nl_cancel_down_bytes(cbq->cbq_rate.rate, &ru);
rbit = nl_cancel_down_bits(cbq->cbq_rate.rate * 8, &rubit);
dp_dump(p, " rate %.2f%s/s (%.0f%s) prio %u",
nl_dump(p, " rate %.2f%s/s (%.0f%s) prio %u",
r, ru, rbit, rubit, cbq->cbq_wrr.priority);
ignore:
return line;
}
static int cbq_qdisc_dump_brief(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void cbq_qdisc_dump_line(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
return cbq_dump_brief((struct rtnl_tca *) qdisc, p, line);
cbq_dump_line((struct rtnl_tca *) qdisc, p);
}
static int cbq_class_dump_brief(struct rtnl_class *class,
struct nl_dump_params *p, int line)
static void cbq_class_dump_line(struct rtnl_class *class,
struct nl_dump_params *p)
{
return cbq_dump_brief((struct rtnl_tca *) class, p, line);
cbq_dump_line((struct rtnl_tca *) class, p);
}
static int cbq_dump_full(struct rtnl_tca *tca, struct nl_dump_params *p,
int line)
static void cbq_dump_details(struct rtnl_tca *tca, struct nl_dump_params *p)
{
struct rtnl_cbq *cbq;
char *unit, buf[32];
@ -196,18 +191,18 @@ static int cbq_dump_full(struct rtnl_tca *tca, struct nl_dump_params *p,
cbq = cbq_qdisc(tca);
if (!cbq)
goto ignore;
return;
w = nl_cancel_down_bits(cbq->cbq_wrr.weight * 8, &unit);
dp_dump(p, "avgpkt %u mpu %u cell %u allot %u weight %.0f%s\n",
nl_dump(p, "avgpkt %u mpu %u cell %u allot %u weight %.0f%s\n",
cbq->cbq_lss.avpkt,
cbq->cbq_rate.mpu,
1 << cbq->cbq_rate.cell_log,
cbq->cbq_wrr.allot, w, unit);
el = cbq->cbq_lss.ewma_log;
dp_dump_line(p, line++, " minidle %uus maxidle %uus offtime "
nl_dump_line(p, " minidle %uus maxidle %uus offtime "
"%uus level %u ewma_log %u\n",
nl_ticks2us(cbq->cbq_lss.minidle >> el),
nl_ticks2us(cbq->cbq_lss.maxidle >> el),
@ -215,60 +210,53 @@ static int cbq_dump_full(struct rtnl_tca *tca, struct nl_dump_params *p,
cbq->cbq_lss.level,
cbq->cbq_lss.ewma_log);
dp_dump_line(p, line++, " penalty %uus strategy %s ",
nl_dump_line(p, " penalty %uus strategy %s ",
nl_ticks2us(cbq->cbq_ovl.penalty),
nl_ovl_strategy2str(cbq->cbq_ovl.strategy, buf, sizeof(buf)));
dp_dump(p, "split %s defmap 0x%08x ",
nl_dump(p, "split %s defmap 0x%08x ",
rtnl_tc_handle2str(cbq->cbq_fopt.split, buf, sizeof(buf)),
cbq->cbq_fopt.defmap);
dp_dump(p, "police %s",
nl_dump(p, "police %s",
nl_police2str(cbq->cbq_police.police, buf, sizeof(buf)));
ignore:
return line;
}
static int cbq_qdisc_dump_full(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void cbq_qdisc_dump_details(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
return cbq_dump_full((struct rtnl_tca *) qdisc, p, line);
cbq_dump_details((struct rtnl_tca *) qdisc, p);
}
static int cbq_class_dump_full(struct rtnl_class *class,
struct nl_dump_params *p, int line)
static void cbq_class_dump_details(struct rtnl_class *class,
struct nl_dump_params *p)
{
return cbq_dump_full((struct rtnl_tca *) class, p, line);
cbq_dump_details((struct rtnl_tca *) class, p);
}
static int cbq_dump_with_stats(struct rtnl_tca *tca, struct nl_dump_params *p,
int line)
static void cbq_dump_stats(struct rtnl_tca *tca, struct nl_dump_params *p)
{
struct tc_cbq_xstats *x = tca_xstats(tca);
if (!x)
goto ignore;
return;
dp_dump_line(p, line++, " borrows overact "
" avgidle undertime\n");
dp_dump_line(p, line++, " %10u %10u %10u %10u\n",
nl_dump_line(p, " borrows overact "
" avgidle undertime\n");
nl_dump_line(p, " %10u %10u %10u %10u\n",
x->borrows, x->overactions, x->avgidle, x->undertime);
ignore:
return line;
}
static int cbq_qdisc_dump_with_stats(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void cbq_qdisc_dump_stats(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
return cbq_dump_with_stats((struct rtnl_tca *) qdisc, p, line);
cbq_dump_stats((struct rtnl_tca *) qdisc, p);
}
static int cbq_class_dump_with_stats(struct rtnl_class *class,
struct nl_dump_params *p, int line)
static void cbq_class_dump_stats(struct rtnl_class *class,
struct nl_dump_params *p)
{
return cbq_dump_with_stats((struct rtnl_tca *) class, p, line);
cbq_dump_stats((struct rtnl_tca *) class, p);
}
static struct rtnl_qdisc_ops cbq_qdisc_ops = {
@ -276,9 +264,11 @@ static struct rtnl_qdisc_ops cbq_qdisc_ops = {
.qo_msg_parser = cbq_qdisc_msg_parser,
.qo_free_data = cbq_qdisc_free_data,
.qo_clone = cbq_qdisc_clone,
.qo_dump[NL_DUMP_BRIEF] = cbq_qdisc_dump_brief,
.qo_dump[NL_DUMP_FULL] = cbq_qdisc_dump_full,
.qo_dump[NL_DUMP_STATS] = cbq_qdisc_dump_with_stats,
.qo_dump = {
[NL_DUMP_LINE] = cbq_qdisc_dump_line,
[NL_DUMP_DETAILS] = cbq_qdisc_dump_details,
[NL_DUMP_STATS] = cbq_qdisc_dump_stats,
},
};
static struct rtnl_class_ops cbq_class_ops = {
@ -286,9 +276,11 @@ static struct rtnl_class_ops cbq_class_ops = {
.co_msg_parser = cbq_class_msg_parser,
.co_free_data = cbq_class_free_data,
.co_clone = cbq_class_clone,
.co_dump[NL_DUMP_BRIEF] = cbq_class_dump_brief,
.co_dump[NL_DUMP_FULL] = cbq_class_dump_full,
.co_dump[NL_DUMP_STATS] = cbq_class_dump_with_stats,
.co_dump = {
[NL_DUMP_LINE] = cbq_class_dump_line,
[NL_DUMP_DETAILS] = cbq_class_dump_details,
[NL_DUMP_STATS] = cbq_class_dump_stats,
},
};
static void __init cbq_init(void)

42
lib/route/sch/dsmark.c
View File

@ -133,51 +133,43 @@ static int dsmark_class_msg_parser(struct rtnl_class *class)
return 0;
}
static int dsmark_qdisc_dump_brief(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void dsmark_qdisc_dump_line(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
struct rtnl_dsmark_qdisc *dsmark = dsmark_qdisc(qdisc);
if (dsmark && (dsmark->qdm_mask & SCH_DSMARK_ATTR_INDICES))
dp_dump(p, " indices 0x%04x", dsmark->qdm_indices);
return line;
nl_dump(p, " indices 0x%04x", dsmark->qdm_indices);
}
static int dsmark_qdisc_dump_full(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void dsmark_qdisc_dump_details(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
struct rtnl_dsmark_qdisc *dsmark = dsmark_qdisc(qdisc);
if (!dsmark)
goto ignore;
return;
if (dsmark->qdm_mask & SCH_DSMARK_ATTR_DEFAULT_INDEX)
dp_dump(p, " default index 0x%04x", dsmark->qdm_default_index);
nl_dump(p, " default index 0x%04x", dsmark->qdm_default_index);
if (dsmark->qdm_mask & SCH_DSMARK_ATTR_SET_TC_INDEX)
dp_dump(p, " set-tc-index");
ignore:
return line;
nl_dump(p, " set-tc-index");
}
static int dsmark_class_dump_brief(struct rtnl_class *class,
struct nl_dump_params *p, int line)
static void dsmark_class_dump_line(struct rtnl_class *class,
struct nl_dump_params *p)
{
struct rtnl_dsmark_class *dsmark = dsmark_class(class);
if (!dsmark)
goto ignore;
return;
if (dsmark->cdm_mask & SCH_DSMARK_ATTR_VALUE)
dp_dump(p, " value 0x%02x", dsmark->cdm_value);
nl_dump(p, " value 0x%02x", dsmark->cdm_value);
if (dsmark->cdm_mask & SCH_DSMARK_ATTR_MASK)
dp_dump(p, " mask 0x%02x", dsmark->cdm_bmask);
ignore:
return line;
nl_dump(p, " mask 0x%02x", dsmark->cdm_bmask);
}
static struct nl_msg *dsmark_qdisc_get_opts(struct rtnl_qdisc *qdisc)
@ -432,15 +424,17 @@ int rtnl_qdisc_dsmark_get_set_tc_index(struct rtnl_qdisc *qdisc)
static struct rtnl_qdisc_ops dsmark_qdisc_ops = {
.qo_kind = "dsmark",
.qo_msg_parser = dsmark_qdisc_msg_parser,
.qo_dump[NL_DUMP_BRIEF] = dsmark_qdisc_dump_brief,
.qo_dump[NL_DUMP_FULL] = dsmark_qdisc_dump_full,
.qo_dump = {
[NL_DUMP_LINE] = dsmark_qdisc_dump_line,
[NL_DUMP_DETAILS] = dsmark_qdisc_dump_details,
},
.qo_get_opts = dsmark_qdisc_get_opts,
};
static struct rtnl_class_ops dsmark_class_ops = {
.co_kind = "dsmark",
.co_msg_parser = dsmark_class_msg_parser,
.co_dump[NL_DUMP_BRIEF] = dsmark_class_dump_brief,
.co_dump[NL_DUMP_LINE] = dsmark_class_dump_line,
.co_get_opts = dsmark_class_get_opts,
};

18
lib/route/sch/fifo.c
View File

@ -78,19 +78,15 @@ static void fifo_free_data(struct rtnl_qdisc *qdisc)
free(qdisc->q_subdata);
}
static int pfifo_dump_brief(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void pfifo_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_fifo *fifo = fifo_qdisc(qdisc);
if (fifo)
dp_dump(p, " limit %u packets", fifo->qf_limit);
return line;
nl_dump(p, " limit %u packets", fifo->qf_limit);
}
static int bfifo_dump_brief(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void bfifo_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_fifo *fifo = fifo_qdisc(qdisc);
@ -99,10 +95,8 @@ static int bfifo_dump_brief(struct rtnl_qdisc *qdisc,
double r;
r = nl_cancel_down_bytes(fifo->qf_limit, &unit);
dp_dump(p, " limit %.1f%s", r, unit);
nl_dump(p, " limit %.1f%s", r, unit);
}
return line;
}
static struct nl_msg *fifo_get_opts(struct rtnl_qdisc *qdisc)
@ -178,7 +172,7 @@ static struct rtnl_qdisc_ops pfifo_ops = {
.qo_kind = "pfifo",
.qo_msg_parser = fifo_msg_parser,
.qo_free_data = fifo_free_data,
.qo_dump[NL_DUMP_BRIEF] = pfifo_dump_brief,
.qo_dump[NL_DUMP_LINE] = pfifo_dump_line,
.qo_get_opts = fifo_get_opts,
};
@ -186,7 +180,7 @@ static struct rtnl_qdisc_ops bfifo_ops = {
.qo_kind = "bfifo",
.qo_msg_parser = fifo_msg_parser,
.qo_free_data = fifo_free_data,
.qo_dump[NL_DUMP_BRIEF] = bfifo_dump_brief,
.qo_dump[NL_DUMP_LINE] = bfifo_dump_line,
.qo_get_opts = fifo_get_opts,
};

59
lib/route/sch/htb.c
View File

@ -6,7 +6,7 @@
* 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-2008 Thomas Graf <tgraf@suug.ch>
* Copyright (c) 2005-2006 Petr Gotthard <petr.gotthard@siemens.com>
* Copyright (c) 2005-2006 Siemens AG Oesterreich
*/
@ -136,34 +136,31 @@ static void htb_class_free_data(struct rtnl_class *class)
free(class->c_subdata);
}
static int htb_qdisc_dump_brief(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void htb_qdisc_dump_line(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p)
{
struct rtnl_htb_qdisc *d = (struct rtnl_htb_qdisc *) qdisc->q_subdata;
if (d == NULL)
goto ignore;
return;
if (d->qh_mask & SCH_HTB_HAS_RATE2QUANTUM)
dp_dump(p, " r2q %u", d->qh_rate2quantum);
nl_dump(p, " r2q %u", d->qh_rate2quantum);
if (d->qh_mask & SCH_HTB_HAS_DEFCLS) {
char buf[32];
dp_dump(p, " default %s",
nl_dump(p, " default %s",
rtnl_tc_handle2str(d->qh_defcls, buf, sizeof(buf)));
}
ignore:
return line;
}
static int htb_class_dump_brief(struct rtnl_class *class,
struct nl_dump_params *p, int line)
static void htb_class_dump_line(struct rtnl_class *class,
struct nl_dump_params *p)
{
struct rtnl_htb_class *d = (struct rtnl_htb_class *) class->c_subdata;
if (d == NULL)
goto ignore;
return;
if (d->ch_mask & SCH_HTB_HAS_RATE) {
double r, rbit;
@ -172,21 +169,18 @@ static int htb_class_dump_brief(struct rtnl_class *class,
r = nl_cancel_down_bytes(d->ch_rate.rs_rate, &ru);
rbit = nl_cancel_down_bits(d->ch_rate.rs_rate*8, &rubit);
dp_dump(p, " rate %.2f%s/s (%.0f%s) log %u",
nl_dump(p, " rate %.2f%s/s (%.0f%s) log %u",
r, ru, rbit, rubit, 1<<d->ch_rate.rs_cell_log);
}
ignore:
return line;
}
static int htb_class_dump_full(struct rtnl_class *class,
struct nl_dump_params *p, int line)
static void htb_class_dump_details(struct rtnl_class *class,
struct nl_dump_params *p)
{
struct rtnl_htb_class *d = (struct rtnl_htb_class *) class->c_subdata;
if (d == NULL)
goto ignore;
return;
/* line 1 */
if (d->ch_mask & SCH_HTB_HAS_CEIL) {
@ -196,22 +190,22 @@ static int htb_class_dump_full(struct rtnl_class *class,
r = nl_cancel_down_bytes(d->ch_ceil.rs_rate, &ru);
rbit = nl_cancel_down_bits(d->ch_ceil.rs_rate*8, &rubit);
dp_dump(p, " ceil %.2f%s/s (%.0f%s) log %u",
nl_dump(p, " ceil %.2f%s/s (%.0f%s) log %u",
r, ru, rbit, rubit, 1<<d->ch_ceil.rs_cell_log);
}
if (d->ch_mask & SCH_HTB_HAS_PRIO)
dp_dump(p, " prio %u", d->ch_prio);
nl_dump(p, " prio %u", d->ch_prio);
if (d->ch_mask & SCH_HTB_HAS_MTU)
dp_dump(p, " mtu %u", d->ch_mtu);
nl_dump(p, " mtu %u", d->ch_mtu);
if (d->ch_mask & SCH_HTB_HAS_RBUFFER) {
double b;
char *bu;
b = nl_cancel_down_bytes(d->ch_rbuffer, &bu);
dp_dump(p, " rbuffer %.2f%s", b, bu);
nl_dump(p, " rbuffer %.2f%s", b, bu);
}
if (d->ch_mask & SCH_HTB_HAS_CBUFFER) {
@ -219,20 +213,17 @@ static int htb_class_dump_full(struct rtnl_class *class,
char *bu;
b = nl_cancel_down_bytes(d->ch_cbuffer, &bu);
dp_dump(p, " cbuffer %.2f%s", b, bu);
nl_dump(p, " cbuffer %.2f%s", b, bu);
}
if (d->ch_mask & SCH_HTB_HAS_QUANTUM)
dp_dump(p, " quantum %u", d->ch_quantum);
nl_dump(p, " quantum %u", d->ch_quantum);
if (d->ch_mask & SCH_HTB_HAS_OVERHEAD)
dp_dump(p, " overhead %u", d->ch_overhead);
nl_dump(p, " overhead %u", d->ch_overhead);
if (d->ch_mask & SCH_HTB_HAS_MPU)
dp_dump(p, " mpu %u", d->ch_mpu);
ignore:
return line;
nl_dump(p, " mpu %u", d->ch_mpu);
}
static struct nl_msg *htb_qdisc_get_opts(struct rtnl_qdisc *qdisc)
@ -525,7 +516,7 @@ static struct rtnl_qdisc_ops htb_qdisc_ops = {
.qo_kind = "htb",
.qo_msg_parser = htb_qdisc_msg_parser,
.qo_free_data = htb_qdisc_free_data,
.qo_dump[NL_DUMP_BRIEF] = htb_qdisc_dump_brief,
.qo_dump[NL_DUMP_LINE] = htb_qdisc_dump_line,
.qo_get_opts = htb_qdisc_get_opts,
};
@ -533,8 +524,10 @@ static struct rtnl_class_ops htb_class_ops = {
.co_kind = "htb",
.co_msg_parser = htb_class_msg_parser,
.co_free_data = htb_class_free_data,
.co_dump[NL_DUMP_BRIEF] = htb_class_dump_brief,
.co_dump[NL_DUMP_FULL] = htb_class_dump_full,
.co_dump = {
[NL_DUMP_LINE] = htb_class_dump_line,
[NL_DUMP_DETAILS] = htb_class_dump_details,
},
.co_get_opts = htb_class_get_opts,
};

16
lib/route/sch/netem.c
View File

@ -160,21 +160,12 @@ static void netem_free_data(struct rtnl_qdisc *qdisc)
free (qdisc->q_subdata);
}
static int netem_dump_brief(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
static void netem_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_netem *netem = netem_qdisc(qdisc);
if (netem)
dp_dump(p, "limit %d", netem->qnm_limit);
return line;
}
static int netem_dump_full(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
{
return line;
nl_dump(p, "limit %d", netem->qnm_limit);
}
int netem_build_msg(struct rtnl_qdisc *qdisc, struct nl_msg *msg)
@ -930,8 +921,7 @@ static struct rtnl_qdisc_ops netem_ops = {
.qo_kind = "netem",
.qo_msg_parser = netem_msg_parser,
.qo_free_data = netem_free_data,
.qo_dump[NL_DUMP_BRIEF] = netem_dump_brief,
.qo_dump[NL_DUMP_FULL] = netem_dump_full,
.qo_dump[NL_DUMP_LINE] = netem_dump_line,
.qo_get_opts = 0,
.qo_build_msg = netem_build_msg
};

43
lib/route/sch/prio.c
View File

@ -77,55 +77,48 @@ static void prio_free_data(struct rtnl_qdisc *qdisc)
free(qdisc->q_subdata);
}
static int prio_dump_brief(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void prio_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_prio *prio = prio_qdisc(qdisc);
if (prio)
dp_dump(p, " bands %u", prio->qp_bands);
return line;
nl_dump(p, " bands %u", prio->qp_bands);
}
static int prio_dump_full(struct rtnl_qdisc *qdisc,
struct nl_dump_params *p, int line)
static void prio_dump_details(struct rtnl_qdisc *qdisc,struct nl_dump_params *p)
{
struct rtnl_prio *prio = prio_qdisc(qdisc);
int i, hp;
if (!prio)
goto ignore;
return;
dp_dump(p, "priomap [");
nl_dump(p, "priomap [");
for (i = 0; i <= TC_PRIO_MAX; i++)
dp_dump(p, "%u%s", prio->qp_priomap[i],
nl_dump(p, "%u%s", prio->qp_priomap[i],
i < TC_PRIO_MAX ? " " : "");
dp_dump(p, "]\n");
dp_new_line(p, line++);
nl_dump(p, "]\n");
nl_new_line(p);
hp = (((TC_PRIO_MAX/2) + 1) & ~1);
for (i = 0; i < hp; i++) {
char a[32];
dp_dump(p, " %18s => %u",
nl_dump(p, " %18s => %u",
rtnl_prio2str(i, a, sizeof(a)),
prio->qp_priomap[i]);
if (hp+i <= TC_PRIO_MAX) {
dp_dump(p, " %18s => %u",
nl_dump(p, " %18s => %u",
rtnl_prio2str(hp+i, a, sizeof(a)),
prio->qp_priomap[hp+i]);
if (i < (hp - 1)) {
dp_dump(p, "\n");
dp_new_line(p, line++);
nl_dump(p, "\n");
nl_new_line(p);
}
}
}
ignore:
return line;
}
static struct nl_msg *prio_get_opts(struct rtnl_qdisc *qdisc)
@ -300,8 +293,10 @@ static struct rtnl_qdisc_ops prio_ops = {
.qo_kind = "prio",
.qo_msg_parser = prio_msg_parser,
.qo_free_data = prio_free_data,
.qo_dump[NL_DUMP_BRIEF] = prio_dump_brief,
.qo_dump[NL_DUMP_FULL] = prio_dump_full,
.qo_dump = {
[NL_DUMP_LINE] = prio_dump_line,
[NL_DUMP_DETAILS] = prio_dump_details,
},
.qo_get_opts = prio_get_opts,
};
@ -309,8 +304,10 @@ static struct rtnl_qdisc_ops pfifo_fast_ops = {
.qo_kind = "pfifo_fast",
.qo_msg_parser = prio_msg_parser,
.qo_free_data = prio_free_data,
.qo_dump[NL_DUMP_BRIEF] = prio_dump_brief,
.qo_dump[NL_DUMP_FULL] = prio_dump_full,
.qo_dump = {
[NL_DUMP_LINE] = prio_dump_line,
[NL_DUMP_DETAILS] = prio_dump_details,
},
.qo_get_opts = prio_get_opts,
};

23
lib/route/sch/red.c
View File

@ -89,40 +89,31 @@ static int red_msg_parser(struct rtnl_qdisc *qdisc)
return 0;
}
static int red_dump_brief(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
static void red_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_red *red = red_qdisc(qdisc);
if (red) {
/* XXX: limit, min, max, flags */
}
return line;
}
static int red_dump_full(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
static void red_dump_details(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_red *red = red_qdisc(qdisc);
if (red) {
/* XXX: wlog, plog, scell_log */
}
return line;
}
static int red_dump_stats(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
static void red_dump_stats(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_red *red = red_qdisc(qdisc);
if (red) {
/* XXX: xstats */
}
return line;
}
static struct nl_msg *red_get_opts(struct rtnl_qdisc *qdisc)
@ -200,9 +191,11 @@ int rtnl_red_get_limit(struct rtnl_qdisc *qdisc)
static struct rtnl_qdisc_ops red_ops = {
.qo_kind = "red",
.qo_msg_parser = red_msg_parser,
.qo_dump[NL_DUMP_BRIEF] = red_dump_brief,
.qo_dump[NL_DUMP_FULL] = red_dump_full,
.qo_dump[NL_DUMP_STATS] = red_dump_stats,
.qo_dump = {
[NL_DUMP_LINE] = red_dump_line,
[NL_DUMP_DETAILS] = red_dump_details,
[NL_DUMP_STATS] = red_dump_stats,
},
.qo_get_opts = red_get_opts,
};

21
lib/route/sch/sfq.c
View File

@ -87,29 +87,22 @@ static void sfq_free_data(struct rtnl_qdisc *qdisc)
free(qdisc->q_subdata);
}
static int sfq_dump_brief(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
static void sfq_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_sfq *sfq = sfq_qdisc(qdisc);
if (sfq)
dp_dump(p, " quantum %u perturb %us",
sfq->qs_quantum,
nl_dump(p, " quantum %u perturb %us", sfq->qs_quantum,
nl_ticks2us(sfq->qs_perturb * nl_get_hz()));
return line;
}
static int sfq_dump_full(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
static void sfq_dump_details(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_sfq *sfq = sfq_qdisc(qdisc);
if (sfq)
dp_dump(p, "limit %u divisor %u",
nl_dump(p, "limit %u divisor %u",
sfq->qs_limit, sfq->qs_divisor);
return line;
}
static struct nl_msg *sfq_get_opts(struct rtnl_qdisc *qdisc)
@ -276,8 +269,10 @@ static struct rtnl_qdisc_ops sfq_ops = {
.qo_kind = "sfq",
.qo_msg_parser = sfq_msg_parser,
.qo_free_data = sfq_free_data,
.qo_dump[NL_DUMP_BRIEF] = sfq_dump_brief,
.qo_dump[NL_DUMP_FULL] = sfq_dump_full,
.qo_dump = {
[NL_DUMP_LINE] = sfq_dump_line,
[NL_DUMP_DETAILS] = sfq_dump_details,
},
.qo_get_opts = sfq_get_opts,
};

32
lib/route/sch/tbf.c
View File

@ -93,34 +93,29 @@ static int tbf_msg_parser(struct rtnl_qdisc *q)
return 0;
}
static int tbf_dump_brief(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
static void tbf_dump_line(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
double r, rbit, lim;
char *ru, *rubit, *limu;
struct rtnl_tbf *tbf = tbf_qdisc(qdisc);
if (!tbf)
goto ignore;
return;
r = nl_cancel_down_bytes(tbf->qt_rate.rs_rate, &ru);
rbit = nl_cancel_down_bits(tbf->qt_rate.rs_rate*8, &rubit);
lim = nl_cancel_down_bytes(tbf->qt_limit, &limu);
dp_dump(p, " rate %.2f%s/s (%.0f%s) limit %.2f%s",
nl_dump(p, " rate %.2f%s/s (%.0f%s) limit %.2f%s",
r, ru, rbit, rubit, lim, limu);
ignore:
return line;
}
static int tbf_dump_full(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
int line)
static void tbf_dump_details(struct rtnl_qdisc *qdisc, struct nl_dump_params *p)
{
struct rtnl_tbf *tbf = tbf_qdisc(qdisc);
if (!tbf)
goto ignore;
return;
if (1) {
char *bu, *cu;
@ -128,7 +123,7 @@ static int tbf_dump_full(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
double cl = nl_cancel_down_bytes(1 << tbf->qt_rate.rs_cell_log,
&cu);
dp_dump(p, "mpu %u rate-bucket-size %1.f%s "
nl_dump(p, "mpu %u rate-bucket-size %1.f%s "
"rate-cell-size %.1f%s\n",
tbf->qt_mpu, bs, bu, cl, cu);
@ -144,14 +139,11 @@ static int tbf_dump_full(struct rtnl_qdisc *qdisc, struct nl_dump_params *p,
cl = nl_cancel_down_bits(1 << tbf->qt_peakrate.rs_cell_log,
&clu);
dp_dump_line(p, line++, " peak-rate %.2f%s/s (%.0f%s) "
"bucket-size %.1f%s cell-size %.1f%s",
"latency %.1f%s",
nl_dump_line(p, " peak-rate %.2f%s/s (%.0f%s) "
"bucket-size %.1f%s cell-size %.1f%s",
"latency %.1f%s",
pr, pru, prb, prbu, bs, bsu, cl, clu);
}
ignore:
return line;
}
static struct nl_msg *tbf_get_opts(struct rtnl_qdisc *qdisc)
@ -521,8 +513,10 @@ int rtnl_qdisc_tbf_get_peakrate_cell(struct rtnl_qdisc *qdisc)
static struct rtnl_qdisc_ops tbf_qdisc_ops = {
.qo_kind = "tbf",
.qo_msg_parser = tbf_msg_parser,
.qo_dump[NL_DUMP_BRIEF] = tbf_dump_brief,
.qo_dump[NL_DUMP_FULL] = tbf_dump_full,
.qo_dump = {
[NL_DUMP_LINE] = tbf_dump_line,
[NL_DUMP_DETAILS] = tbf_dump_details,
},
.qo_get_opts = tbf_get_opts,
};

29
lib/route/tc.c
View File

@ -183,44 +183,41 @@ int tca_clone(struct rtnl_tca *dst, struct rtnl_tca *src)
return 0;
}
int tca_dump_brief(struct rtnl_tca *g, const char *type,
struct nl_dump_params *p, int line)
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");
dp_dump(p, "%s %s ", g->tc_kind, type);
nl_dump_line(p, "%s %s ", g->tc_kind, type);
if (link_cache) {
char buf[32];
dp_dump(p, "dev %s ",
nl_dump(p, "dev %s ",
rtnl_link_i2name(link_cache, g->tc_ifindex,
buf, sizeof(buf)));
} else
dp_dump(p, "dev %u ", g->tc_ifindex);
nl_dump(p, "dev %u ", g->tc_ifindex);
dp_dump(p, "handle %s parent %s",
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)));
return 1;
}
int tca_dump_full(struct rtnl_tca *g, struct nl_dump_params *p, int line)
void tca_dump_details(struct rtnl_tca *g, struct nl_dump_params *p)
{
dp_dump_line(p, line++, " ");
return line;
nl_dump_line(p, " ");
}
int tca_dump_stats(struct rtnl_tca *g, struct nl_dump_params *p, int line)
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");
dp_dump_line(p, line++,
nl_dump_line(p,
" Stats: bytes packets drops overlimits" \
" qlen backlog\n");
@ -228,7 +225,7 @@ int tca_dump_stats(struct rtnl_tca *g, struct nl_dump_params *p, int line)
if (*unit == 'B')
fmt[11] = '9';
dp_dump_line(p, line++, fmt, res, unit,
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],
@ -242,9 +239,7 @@ int tca_dump_stats(struct rtnl_tca *g, struct nl_dump_params *p, int line)
if (*unit == 'B')
fmt[11] = '9';
dp_dump_line(p, line++, fmt, res, unit, g->tc_stats[RTNL_TC_RATE_PPS]);
return line;
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,

5
lib/utils.c
View File

@ -25,7 +25,7 @@
int nl_debug = 0;
struct nl_dump_params nl_debug_dp = {
.dp_type = NL_DUMP_FULL,
.dp_type = NL_DUMP_DETAILS,
};
static void __init nl_debug_init(void)
@ -870,8 +870,7 @@ void dump_from_ops(struct nl_object *obj, struct nl_dump_params *params)
buf, sizeof(buf)));
#endif
params->dp_pre_dump = 1;
} else
nl_new_line(params);
}
if (obj->ce_ops->oo_dump[type])
obj->ce_ops->oo_dump[type](obj, params);

2
src/genl-ctrl-list.c
View File

@ -29,7 +29,7 @@ int main(int argc, char *argv[])
struct nl_sock *sock;
struct nl_cache *family_cache;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};

2
src/nf-ct-list.c
View File

@ -50,7 +50,7 @@ int main(int argc, char *argv[])
struct nl_cache *ct_cache;
struct nfnl_ct *ct;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};

2
src/nl-addr-add.c
View File

@ -41,7 +41,7 @@ int main(int argc, char *argv[])
struct rtnl_addr *addr;
struct nl_cache *link_cache;
struct nl_dump_params dp = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
int err;

2
src/nl-addr-delete.c
View File

@ -43,7 +43,7 @@ static void delete_cb(struct nl_object *obj, void *arg)
{
struct rtnl_addr *addr = nl_object_priv(obj);
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
int err;

2
src/nl-addr-list.c
View File

@ -38,7 +38,7 @@ int main(int argc, char *argv[])
struct rtnl_addr *addr;
struct nl_cache *link_cache, *addr_cache;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};

2
src/nl-fib-lookup.c
View File

@ -31,7 +31,7 @@ int main(int argc, char *argv[])
struct nl_addr *addr;
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_FULL,
.dp_type = NL_DUMP_DETAILS,
};
int table = RT_TABLE_UNSPEC, scope = RT_SCOPE_UNIVERSE;
int tos = 0, err = 1;

2
src/nl-link-list.c
View File

@ -52,7 +52,7 @@ int main(int argc, char *argv[])
struct nl_cache *link_cache;
struct rtnl_link *link;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};

2
src/nl-link-set.c
View File

@ -49,7 +49,7 @@ static void set_cb(struct nl_object *obj, void *arg)
struct rtnl_link *link = nl_object_priv(obj);
struct rtnl_link *change = arg;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
int err;

2
src/nl-neigh-add.c
View File

@ -45,7 +45,7 @@ int main(int argc, char *argv[])
struct rtnl_neigh *neigh;
struct nl_cache *link_cache;
struct nl_dump_params dp = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
int err, ok = 0, nlflags = NLM_F_REPLACE | NLM_F_CREATE;

2
src/nl-neigh-delete.c
View File

@ -41,7 +41,7 @@ static void delete_cb(struct nl_object *obj, void *arg)
{
struct rtnl_neigh *neigh = nl_object_priv(obj);
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
int err;

2
src/nl-neigh-list.c
View File

@ -37,7 +37,7 @@ int main(int argc, char *argv[])
struct rtnl_neigh *neigh;
struct nl_cache *link_cache, *neigh_cache;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};

2
src/nl-neightbl-list.c
View File

@ -29,7 +29,7 @@ int main(int argc, char *argv[])
struct nl_sock *sock;
struct nl_cache *link_cache, *neightbl_cache;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};

2
src/nl-qdisc-delete.c
View File

@ -40,7 +40,7 @@ static void delete_cb(struct nl_object *obj, void *arg)
{
struct rtnl_qdisc *qdisc = nl_object_priv(obj);
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
int err;

2
src/nl-qdisc-list.c
View File

@ -38,7 +38,7 @@ int main(int argc, char *argv[])
struct rtnl_qdisc *qdisc;
struct nl_cache *link_cache, *qdisc_cache;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};

2
src/nl-route-add.c
View File

@ -52,7 +52,7 @@ int main(int argc, char *argv[])
struct nl_handle *sock;
struct rtnl_route *route;
struct nl_dump_params dp = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
int err = 1;

2
src/nl-route-delete.c
View File

@ -60,7 +60,7 @@ static void delete_cb(struct nl_object *obj, void *arg)
{
struct rtnl_route *route = (struct rtnl_route *) obj;
struct nl_dump_params params = {
.dp_type = NL_DUMP_ONELINE,
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
int err;

2
src/nl-route-list.c
View File

@ -52,7 +52,7 @@ int main(int argc, char *argv[])
struct rtnl_route *route;
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_BRIEF
.dp_type = NL_DUMP_LINE,
};
int print_cache = 0;

2
src/nl-rule-list.c
View File

@ -35,7 +35,7 @@ int main(int argc, char *argv[])
struct nl_cache *link_cache, *rule_cache;
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_BRIEF
.dp_type = NL_DUMP_LINE,
};
sock = nlt_alloc_socket();

4
src/utils.c
View File

@ -90,9 +90,9 @@ struct nl_addr *nlt_addr_parse(const char *str, int family)
int nlt_parse_dumptype(const char *str)
{
if (!strcasecmp(str, "brief"))
return NL_DUMP_BRIEF;
return NL_DUMP_LINE;
else if (!strcasecmp(str, "details") || !strcasecmp(str, "detailed"))
return NL_DUMP_FULL;
return NL_DUMP_DETAILS;
else if (!strcasecmp(str, "stats"))
return NL_DUMP_STATS;
else if (!strcasecmp(str, "xml"))