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 *);
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);
* 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.
*
* // 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 = {
*
* 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
/**
* 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
/**
* 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
*/
/** 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. */
/**
* 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
* @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 */
};
#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
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;
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,
.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,
};
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[] = {
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) {
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,
.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,
};
}
/* 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)));
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 ",
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,
.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,
};
* 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
*/
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;
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);
-
- dp_dump(p, "\n");
+ nl_dump(p, "SEQGLOBAL=%d ", msg->log_msg_seq_global);
- return 1;
+ nl_dump(p, "\n");
}
/**
.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,
+ },
};
/** @} */
* 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>
/** @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);
-
- dp_dump(p, "\n");
+ nl_dump(p, "queue_threshold=%u ", log->log_queue_threshold);
- return 1;
+ nl_dump(p, "\n");
}
static struct trans_tbl copy_modes[] = {
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,
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;
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");
}
/**
.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,
};
/** @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);
-
- dp_dump(p, "\n");
+ nl_dump(p, "copy_range=%u ", queue->queue_copy_range);
- return 1;
+ nl_dump(p, "\n");
}
static struct trans_tbl copy_modes[] = {
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,
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;
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,
.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 |
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)");
-
- dp_dump(p, "\n");
+ nl_dump(p, "noop (no leaf qdisc)");
- 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);
}
/**
.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),
};
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)
.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)
* 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
*/
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;
* 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);
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);
-
- line = print_selector(p, s, cls, u, line);
- dp_dump(p, "\n");
+ nl_dump(p, "indev %s ", u->cu_indev);
-ignore:
- return line;
+ print_selector(p, s, cls, u);
+ nl_dump(p, "\n");
#if 0
#define U32_ATTR_ACTION 0x040
#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)
.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)
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);
}
/**
.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),
};
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);
-
- dp_dump(p, "\n");
+ 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);
- 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],
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],
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],
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);
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) {
*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
.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,
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)
.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,
}
-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;
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) {
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);
}
/**
.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),
}
-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;
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,
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,
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;
}
/**
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,
};
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];
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:
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);
}
/**
.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),
};
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;
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)
}
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;
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)
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;
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;
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)
rtnl_route_nh_dump(nh, p);
}
}
-
- return 0;
}
static int route_compare(struct nl_object *_a, struct nl_object *_b,
.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 |
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,
.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,
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;
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];
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),
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 = {
.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 = {
.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)
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)
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,
};
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);
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)
.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,
};
.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,
};
* 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
*/
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;
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) {
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) {
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)
.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,
};
.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,
};
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)
.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
};
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)
.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,
};
.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,
};
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)
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,
};
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)
.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,
};
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;
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);
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)
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,
};
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");
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],
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,
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)
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);
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,
};
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,
};
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;
{
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;
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,
};
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;
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,
};
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;
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;
{
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;
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,
};
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,
};
{
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;
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,
};
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;
{
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;
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;
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();
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"))
projects / thirdparty / libnl.git / commitdiff
