/*
* iplink_bond.c Bonding device support
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
* Authors: Jiri Pirko <jiri@resnulli.us>
* Scott Feldman <sfeldma@cumulusnetworks.com>
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <linux/if_bonding.h>
#include "rt_names.h"
#include "utils.h"
#include "ip_common.h"
#include "json_print.h"
#define BOND_MAX_ARP_TARGETS 16
static unsigned int xstats_print_attr;
static int filter_index;
static const char *mode_tbl[] = {
"balance-rr",
"active-backup",
"balance-xor",
"broadcast",
"802.3ad",
"balance-tlb",
"balance-alb",
NULL,
};
static const char *arp_validate_tbl[] = {
"none",
"active",
"backup",
"all",
NULL,
};
static const char *arp_all_targets_tbl[] = {
"any",
"all",
NULL,
};
static const char *primary_reselect_tbl[] = {
"always",
"better",
"failure",
NULL,
};
static const char *fail_over_mac_tbl[] = {
"none",
"active",
"follow",
NULL,
};
static const char *xmit_hash_policy_tbl[] = {
"layer2",
"layer3+4",
"layer2+3",
"encap2+3",
"encap3+4",
NULL,
};
static const char *lacp_rate_tbl[] = {
"slow",
"fast",
NULL,
};
static const char *ad_select_tbl[] = {
"stable",
"bandwidth",
"count",
NULL,
};
static const char *get_name(const char **tbl, int index)
{
int i;
for (i = 0; tbl[i]; i++)
if (i == index)
return tbl[i];
return "UNKNOWN";
}
static int get_index(const char **tbl, char *name)
{
int i, index;
/* check for integer index passed in instead of name */
if (get_integer(&index, name, 10) == 0)
for (i = 0; tbl[i]; i++)
if (i == index)
return i;
for (i = 0; tbl[i]; i++)
if (strcmp(tbl[i], name) == 0)
return i;
return -1;
}
static void print_explain(FILE *f)
{
fprintf(f,
"Usage: ... bond [ mode BONDMODE ] [ active_slave SLAVE_DEV ]\n"
" [ clear_active_slave ] [ miimon MIIMON ]\n"
" [ updelay UPDELAY ] [ downdelay DOWNDELAY ]\n"
" [ peer_notify_delay DELAY ]\n"
" [ use_carrier USE_CARRIER ]\n"
" [ arp_interval ARP_INTERVAL ]\n"
" [ arp_validate ARP_VALIDATE ]\n"
" [ arp_all_targets ARP_ALL_TARGETS ]\n"
" [ arp_ip_target [ ARP_IP_TARGET, ... ] ]\n"
" [ primary SLAVE_DEV ]\n"
" [ primary_reselect PRIMARY_RESELECT ]\n"
" [ fail_over_mac FAIL_OVER_MAC ]\n"
" [ xmit_hash_policy XMIT_HASH_POLICY ]\n"
" [ resend_igmp RESEND_IGMP ]\n"
" [ num_grat_arp|num_unsol_na NUM_GRAT_ARP|NUM_UNSOL_NA ]\n"
" [ all_slaves_active ALL_SLAVES_ACTIVE ]\n"
" [ min_links MIN_LINKS ]\n"
" [ lp_interval LP_INTERVAL ]\n"
" [ packets_per_slave PACKETS_PER_SLAVE ]\n"
" [ tlb_dynamic_lb TLB_DYNAMIC_LB ]\n"
" [ lacp_rate LACP_RATE ]\n"
" [ ad_select AD_SELECT ]\n"
" [ ad_user_port_key PORTKEY ]\n"
" [ ad_actor_sys_prio SYSPRIO ]\n"
" [ ad_actor_system LLADDR ]\n"
"\n"
"BONDMODE := balance-rr|active-backup|balance-xor|broadcast|802.3ad|balance-tlb|balance-alb\n"
"ARP_VALIDATE := none|active|backup|all\n"
"ARP_ALL_TARGETS := any|all\n"
"PRIMARY_RESELECT := always|better|failure\n"
"FAIL_OVER_MAC := none|active|follow\n"
"XMIT_HASH_POLICY := layer2|layer2+3|layer3+4|encap2+3|encap3+4\n"
"LACP_RATE := slow|fast\n"
"AD_SELECT := stable|bandwidth|count\n"
);
}
static void explain(void)
{
print_explain(stderr);
}
static int bond_parse_opt(struct link_util *lu, int argc, char **argv,
struct nlmsghdr *n)
{
__u8 mode, use_carrier, primary_reselect, fail_over_mac;
__u8 xmit_hash_policy, num_peer_notif, all_slaves_active;
__u8 lacp_rate, ad_select, tlb_dynamic_lb;
__u16 ad_user_port_key, ad_actor_sys_prio;
__u32 miimon, updelay, downdelay, peer_notify_delay, arp_interval, arp_validate;
__u32 arp_all_targets, resend_igmp, min_links, lp_interval;
__u32 packets_per_slave;
unsigned int ifindex;
while (argc > 0) {
if (matches(*argv, "mode") == 0) {
NEXT_ARG();
if (get_index(mode_tbl, *argv) < 0)
invarg("invalid mode", *argv);
mode = get_index(mode_tbl, *argv);
addattr8(n, 1024, IFLA_BOND_MODE, mode);
} else if (matches(*argv, "active_slave") == 0) {
NEXT_ARG();
ifindex = ll_name_to_index(*argv);
if (!ifindex)
return nodev(*argv);
addattr32(n, 1024, IFLA_BOND_ACTIVE_SLAVE, ifindex);
} else if (matches(*argv, "clear_active_slave") == 0) {
addattr32(n, 1024, IFLA_BOND_ACTIVE_SLAVE, 0);
} else if (matches(*argv, "miimon") == 0) {
NEXT_ARG();
if (get_u32(&miimon, *argv, 0))
invarg("invalid miimon", *argv);
addattr32(n, 1024, IFLA_BOND_MIIMON, miimon);
} else if (matches(*argv, "updelay") == 0) {
NEXT_ARG();
if (get_u32(&updelay, *argv, 0))
invarg("invalid updelay", *argv);
addattr32(n, 1024, IFLA_BOND_UPDELAY, updelay);
} else if (matches(*argv, "downdelay") == 0) {
NEXT_ARG();
if (get_u32(&downdelay, *argv, 0))
invarg("invalid downdelay", *argv);
addattr32(n, 1024, IFLA_BOND_DOWNDELAY, downdelay);
} else if (matches(*argv, "peer_notify_delay") == 0) {
NEXT_ARG();
if (get_u32(&peer_notify_delay, *argv, 0))
invarg("invalid peer_notify_delay", *argv);
addattr32(n, 1024, IFLA_BOND_PEER_NOTIF_DELAY, peer_notify_delay);
} else if (matches(*argv, "use_carrier") == 0) {
NEXT_ARG();
if (get_u8(&use_carrier, *argv, 0))
invarg("invalid use_carrier", *argv);
addattr8(n, 1024, IFLA_BOND_USE_CARRIER, use_carrier);
} else if (matches(*argv, "arp_interval") == 0) {
NEXT_ARG();
if (get_u32(&arp_interval, *argv, 0))
invarg("invalid arp_interval", *argv);
addattr32(n, 1024, IFLA_BOND_ARP_INTERVAL, arp_interval);
} else if (matches(*argv, "arp_ip_target") == 0) {
struct rtattr *nest = addattr_nest(n, 1024,
IFLA_BOND_ARP_IP_TARGET);
if (NEXT_ARG_OK()) {
NEXT_ARG();
char *targets = strdupa(*argv);
char *target = strtok(targets, ",");
int i;
for (i = 0; target && i < BOND_MAX_ARP_TARGETS; i++) {
__u32 addr = get_addr32(target);
addattr32(n, 1024, i, addr);
target = strtok(NULL, ",");
}
addattr_nest_end(n, nest);
}
addattr_nest_end(n, nest);
} else if (matches(*argv, "arp_validate") == 0) {
NEXT_ARG();
if (get_index(arp_validate_tbl, *argv) < 0)
invarg("invalid arp_validate", *argv);
arp_validate = get_index(arp_validate_tbl, *argv);
addattr32(n, 1024, IFLA_BOND_ARP_VALIDATE, arp_validate);
} else if (matches(*argv, "arp_all_targets") == 0) {
NEXT_ARG();
if (get_index(arp_all_targets_tbl, *argv) < 0)
invarg("invalid arp_all_targets", *argv);
arp_all_targets = get_index(arp_all_targets_tbl, *argv);
addattr32(n, 1024, IFLA_BOND_ARP_ALL_TARGETS, arp_all_targets);
} else if (matches(*argv, "primary") == 0) {
NEXT_ARG();
ifindex = ll_name_to_index(*argv);
if (!ifindex)
return nodev(*argv);
addattr32(n, 1024, IFLA_BOND_PRIMARY, ifindex);
} else if (matches(*argv, "primary_reselect") == 0) {
NEXT_ARG();
if (get_index(primary_reselect_tbl, *argv) < 0)
invarg("invalid primary_reselect", *argv);
primary_reselect = get_index(primary_reselect_tbl, *argv);
addattr8(n, 1024, IFLA_BOND_PRIMARY_RESELECT,
primary_reselect);
} else if (matches(*argv, "fail_over_mac") == 0) {
NEXT_ARG();
if (get_index(fail_over_mac_tbl, *argv) < 0)
invarg("invalid fail_over_mac", *argv);
fail_over_mac = get_index(fail_over_mac_tbl, *argv);
addattr8(n, 1024, IFLA_BOND_FAIL_OVER_MAC,
fail_over_mac);
} else if (matches(*argv, "xmit_hash_policy") == 0) {
NEXT_ARG();
if (get_index(xmit_hash_policy_tbl, *argv) < 0)
invarg("invalid xmit_hash_policy", *argv);
xmit_hash_policy = get_index(xmit_hash_policy_tbl, *argv);
addattr8(n, 1024, IFLA_BOND_XMIT_HASH_POLICY,
xmit_hash_policy);
} else if (matches(*argv, "resend_igmp") == 0) {
NEXT_ARG();
if (get_u32(&resend_igmp, *argv, 0))
invarg("invalid resend_igmp", *argv);
addattr32(n, 1024, IFLA_BOND_RESEND_IGMP, resend_igmp);
} else if (matches(*argv, "num_grat_arp") == 0 ||
matches(*argv, "num_unsol_na") == 0) {
NEXT_ARG();
if (get_u8(&num_peer_notif, *argv, 0))
invarg("invalid num_grat_arp|num_unsol_na",
*argv);
addattr8(n, 1024, IFLA_BOND_NUM_PEER_NOTIF,
num_peer_notif);
} else if (matches(*argv, "all_slaves_active") == 0) {
NEXT_ARG();
if (get_u8(&all_slaves_active, *argv, 0))
invarg("invalid all_slaves_active", *argv);
addattr8(n, 1024, IFLA_BOND_ALL_SLAVES_ACTIVE,
all_slaves_active);
} else if (matches(*argv, "min_links") == 0) {
NEXT_ARG();
if (get_u32(&min_links, *argv, 0))
invarg("invalid min_links", *argv);
addattr32(n, 1024, IFLA_BOND_MIN_LINKS, min_links);
} else if (matches(*argv, "lp_interval") == 0) {
NEXT_ARG();
if (get_u32(&lp_interval, *argv, 0))
invarg("invalid lp_interval", *argv);
addattr32(n, 1024, IFLA_BOND_LP_INTERVAL, lp_interval);
} else if (matches(*argv, "packets_per_slave") == 0) {
NEXT_ARG();
if (get_u32(&packets_per_slave, *argv, 0))
invarg("invalid packets_per_slave", *argv);
addattr32(n, 1024, IFLA_BOND_PACKETS_PER_SLAVE,
packets_per_slave);
} else if (matches(*argv, "lacp_rate") == 0) {
NEXT_ARG();
if (get_index(lacp_rate_tbl, *argv) < 0)
invarg("invalid lacp_rate", *argv);
lacp_rate = get_index(lacp_rate_tbl, *argv);
addattr8(n, 1024, IFLA_BOND_AD_LACP_RATE, lacp_rate);
} else if (matches(*argv, "ad_select") == 0) {
NEXT_ARG();
if (get_index(ad_select_tbl, *argv) < 0)
invarg("invalid ad_select", *argv);
ad_select = get_index(ad_select_tbl, *argv);
addattr8(n, 1024, IFLA_BOND_AD_SELECT, ad_select);
} else if (matches(*argv, "ad_user_port_key") == 0) {
NEXT_ARG();
if (get_u16(&ad_user_port_key, *argv, 0))
invarg("invalid ad_user_port_key", *argv);
addattr16(n, 1024, IFLA_BOND_AD_USER_PORT_KEY,
ad_user_port_key);
} else if (matches(*argv, "ad_actor_sys_prio") == 0) {
NEXT_ARG();
if (get_u16(&ad_actor_sys_prio, *argv, 0))
invarg("invalid ad_actor_sys_prio", *argv);
addattr16(n, 1024, IFLA_BOND_AD_ACTOR_SYS_PRIO,
ad_actor_sys_prio);
} else if (matches(*argv, "ad_actor_system") == 0) {
int len;
char abuf[32];
NEXT_ARG();
len = ll_addr_a2n(abuf, sizeof(abuf), *argv);
if (len < 0)
return -1;
addattr_l(n, 1024, IFLA_BOND_AD_ACTOR_SYSTEM,
abuf, len);
} else if (matches(*argv, "tlb_dynamic_lb") == 0) {
NEXT_ARG();
if (get_u8(&tlb_dynamic_lb, *argv, 0)) {
invarg("invalid tlb_dynamic_lb", *argv);
return -1;
}
addattr8(n, 1024, IFLA_BOND_TLB_DYNAMIC_LB,
tlb_dynamic_lb);
} else if (matches(*argv, "help") == 0) {
explain();
return -1;
} else {
fprintf(stderr, "bond: unknown command \"%s\"?\n", *argv);
explain();
return -1;
}
argc--, argv++;
}
return 0;
}
static void bond_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
{
if (!tb)
return;
if (tb[IFLA_BOND_MODE]) {
const char *mode = get_name(mode_tbl,
rta_getattr_u8(tb[IFLA_BOND_MODE]));
print_string(PRINT_ANY, "mode", "mode %s ", mode);
}
if (tb[IFLA_BOND_ACTIVE_SLAVE]) {
unsigned int ifindex =
rta_getattr_u32(tb[IFLA_BOND_ACTIVE_SLAVE]);
if (ifindex) {
print_string(PRINT_ANY,
"active_slave",
"active_slave %s ",
ll_index_to_name(ifindex));
}
}
if (tb[IFLA_BOND_MIIMON])
print_uint(PRINT_ANY,
"miimon",
"miimon %u ",
rta_getattr_u32(tb[IFLA_BOND_MIIMON]));
if (tb[IFLA_BOND_UPDELAY])
print_uint(PRINT_ANY,
"updelay",
"updelay %u ",
rta_getattr_u32(tb[IFLA_BOND_UPDELAY]));
if (tb[IFLA_BOND_DOWNDELAY])
print_uint(PRINT_ANY,
"downdelay",
"downdelay %u ",
rta_getattr_u32(tb[IFLA_BOND_DOWNDELAY]));
if (tb[IFLA_BOND_PEER_NOTIF_DELAY])
print_uint(PRINT_ANY,
"peer_notify_delay",
"peer_notify_delay %u ",
rta_getattr_u32(tb[IFLA_BOND_PEER_NOTIF_DELAY]));
if (tb[IFLA_BOND_USE_CARRIER])
print_uint(PRINT_ANY,
"use_carrier",
"use_carrier %u ",
rta_getattr_u8(tb[IFLA_BOND_USE_CARRIER]));
if (tb[IFLA_BOND_ARP_INTERVAL])
print_uint(PRINT_ANY,
"arp_interval",
"arp_interval %u ",
rta_getattr_u32(tb[IFLA_BOND_ARP_INTERVAL]));
if (tb[IFLA_BOND_ARP_IP_TARGET]) {
struct rtattr *iptb[BOND_MAX_ARP_TARGETS + 1];
int i;
parse_rtattr_nested(iptb, BOND_MAX_ARP_TARGETS,
tb[IFLA_BOND_ARP_IP_TARGET]);
if (iptb[0]) {
open_json_array(PRINT_JSON, "arp_ip_target");
print_string(PRINT_FP, NULL, "arp_ip_target ", NULL);
}
for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
if (iptb[i])
print_string(PRINT_ANY,
NULL,
"%s",
rt_addr_n2a_rta(AF_INET, iptb[i]));
if (!is_json_context()
&& i < BOND_MAX_ARP_TARGETS-1
&& iptb[i+1])
fprintf(f, ",");
}
if (iptb[0]) {
print_string(PRINT_FP, NULL, " ", NULL);
close_json_array(PRINT_JSON, NULL);
}
}
if (tb[IFLA_BOND_ARP_VALIDATE]) {
__u32 arp_v = rta_getattr_u32(tb[IFLA_BOND_ARP_VALIDATE]);
const char *arp_validate = get_name(arp_validate_tbl, arp_v);
if (!arp_v && is_json_context())
print_null(PRINT_JSON, "arp_validate", NULL, NULL);
else
print_string(PRINT_ANY,
"arp_validate",
"arp_validate %s ",
arp_validate);
}
if (tb[IFLA_BOND_ARP_ALL_TARGETS]) {
const char *arp_all_targets = get_name(arp_all_targets_tbl,
rta_getattr_u32(tb[IFLA_BOND_ARP_ALL_TARGETS]));
print_string(PRINT_ANY,
"arp_all_targets",
"arp_all_targets %s ",
arp_all_targets);
}
if (tb[IFLA_BOND_PRIMARY]) {
unsigned int ifindex = rta_getattr_u32(tb[IFLA_BOND_PRIMARY]);
if (ifindex) {
print_string(PRINT_ANY,
"primary",
"primary %s ",
ll_index_to_name(ifindex));
}
}
if (tb[IFLA_BOND_PRIMARY_RESELECT]) {
const char *primary_reselect = get_name(primary_reselect_tbl,
rta_getattr_u8(tb[IFLA_BOND_PRIMARY_RESELECT]));
print_string(PRINT_ANY,
"primary_reselect",
"primary_reselect %s ",
primary_reselect);
}
if (tb[IFLA_BOND_FAIL_OVER_MAC]) {
const char *fail_over_mac = get_name(fail_over_mac_tbl,
rta_getattr_u8(tb[IFLA_BOND_FAIL_OVER_MAC]));
print_string(PRINT_ANY,
"fail_over_mac",
"fail_over_mac %s ",
fail_over_mac);
}
if (tb[IFLA_BOND_XMIT_HASH_POLICY]) {
const char *xmit_hash_policy = get_name(xmit_hash_policy_tbl,
rta_getattr_u8(tb[IFLA_BOND_XMIT_HASH_POLICY]));
print_string(PRINT_ANY,
"xmit_hash_policy",
"xmit_hash_policy %s ",
xmit_hash_policy);
}
if (tb[IFLA_BOND_RESEND_IGMP])
print_uint(PRINT_ANY,
"resend_igmp",
"resend_igmp %u ",
rta_getattr_u32(tb[IFLA_BOND_RESEND_IGMP]));
if (tb[IFLA_BOND_NUM_PEER_NOTIF])
print_uint(PRINT_ANY,
"num_peer_notif",
"num_grat_arp %u ",
rta_getattr_u8(tb[IFLA_BOND_NUM_PEER_NOTIF]));
if (tb[IFLA_BOND_ALL_SLAVES_ACTIVE])
print_uint(PRINT_ANY,
"all_slaves_active",
"all_slaves_active %u ",
rta_getattr_u8(tb[IFLA_BOND_ALL_SLAVES_ACTIVE]));
if (tb[IFLA_BOND_MIN_LINKS])
print_uint(PRINT_ANY,
"min_links",
"min_links %u ",
rta_getattr_u32(tb[IFLA_BOND_MIN_LINKS]));
if (tb[IFLA_BOND_LP_INTERVAL])
print_uint(PRINT_ANY,
"lp_interval",
"lp_interval %u ",
rta_getattr_u32(tb[IFLA_BOND_LP_INTERVAL]));
if (tb[IFLA_BOND_PACKETS_PER_SLAVE])
print_uint(PRINT_ANY,
"packets_per_slave",
"packets_per_slave %u ",
rta_getattr_u32(tb[IFLA_BOND_PACKETS_PER_SLAVE]));
if (tb[IFLA_BOND_AD_LACP_RATE]) {
const char *lacp_rate = get_name(lacp_rate_tbl,
rta_getattr_u8(tb[IFLA_BOND_AD_LACP_RATE]));
print_string(PRINT_ANY,
"ad_lacp_rate",
"lacp_rate %s ",
lacp_rate);
}
if (tb[IFLA_BOND_AD_SELECT]) {
const char *ad_select = get_name(ad_select_tbl,
rta_getattr_u8(tb[IFLA_BOND_AD_SELECT]));
print_string(PRINT_ANY,
"ad_select",
"ad_select %s ",
ad_select);
}
if (tb[IFLA_BOND_AD_INFO]) {
struct rtattr *adtb[IFLA_BOND_AD_INFO_MAX + 1];
parse_rtattr_nested(adtb, IFLA_BOND_AD_INFO_MAX,
tb[IFLA_BOND_AD_INFO]);
open_json_object("ad_info");
if (adtb[IFLA_BOND_AD_INFO_AGGREGATOR])
print_int(PRINT_ANY,
"aggregator",
"ad_aggregator %d ",
rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_AGGREGATOR]));
if (adtb[IFLA_BOND_AD_INFO_NUM_PORTS])
print_int(PRINT_ANY,
"num_ports",
"ad_num_ports %d ",
rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_NUM_PORTS]));
if (adtb[IFLA_BOND_AD_INFO_ACTOR_KEY])
print_int(PRINT_ANY,
"actor_key",
"ad_actor_key %d ",
rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_ACTOR_KEY]));
if (adtb[IFLA_BOND_AD_INFO_PARTNER_KEY])
print_int(PRINT_ANY,
"partner_key",
"ad_partner_key %d ",
rta_getattr_u16(adtb[IFLA_BOND_AD_INFO_PARTNER_KEY]));
if (adtb[IFLA_BOND_AD_INFO_PARTNER_MAC]) {
unsigned char *p =
RTA_DATA(adtb[IFLA_BOND_AD_INFO_PARTNER_MAC]);
SPRINT_BUF(b);
print_string(PRINT_ANY,
"partner_mac",
"ad_partner_mac %s ",
ll_addr_n2a(p, ETH_ALEN, 0, b, sizeof(b)));
}
close_json_object();
}
if (tb[IFLA_BOND_AD_ACTOR_SYS_PRIO]) {
print_uint(PRINT_ANY,
"ad_actor_sys_prio",
"ad_actor_sys_prio %u ",
rta_getattr_u16(tb[IFLA_BOND_AD_ACTOR_SYS_PRIO]));
}
if (tb[IFLA_BOND_AD_USER_PORT_KEY]) {
print_uint(PRINT_ANY,
"ad_user_port_key",
"ad_user_port_key %u ",
rta_getattr_u16(tb[IFLA_BOND_AD_USER_PORT_KEY]));
}
if (tb[IFLA_BOND_AD_ACTOR_SYSTEM]) {
/* We assume the l2 address is an Ethernet MAC address */
SPRINT_BUF(b1);
print_string(PRINT_ANY,
"ad_actor_system",
"ad_actor_system %s ",
ll_addr_n2a(RTA_DATA(tb[IFLA_BOND_AD_ACTOR_SYSTEM]),
RTA_PAYLOAD(tb[IFLA_BOND_AD_ACTOR_SYSTEM]),
1 /*ARPHDR_ETHER*/, b1, sizeof(b1)));
}
if (tb[IFLA_BOND_TLB_DYNAMIC_LB]) {
print_uint(PRINT_ANY,
"tlb_dynamic_lb",
"tlb_dynamic_lb %u ",
rta_getattr_u8(tb[IFLA_BOND_TLB_DYNAMIC_LB]));
}
}
static void bond_print_help(struct link_util *lu, int argc, char **argv,
FILE *f)
{
print_explain(f);
}
static void bond_print_xstats_help(struct link_util *lu, FILE *f)
{
fprintf(f, "Usage: ... %s [ 802.3ad ] [ dev DEVICE ]\n", lu->id);
}
static void bond_print_3ad_stats(struct rtattr *lacpattr)
{
struct rtattr *lacptb[BOND_3AD_STAT_MAX+1];
__u64 val;
parse_rtattr(lacptb, BOND_3AD_STAT_MAX, RTA_DATA(lacpattr),
RTA_PAYLOAD(lacpattr));
open_json_object("802.3ad");
if (lacptb[BOND_3AD_STAT_LACPDU_RX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
print_u64(PRINT_ANY, "lacpdu_rx", "LACPDU Rx %llu\n",
rta_getattr_u64(lacptb[BOND_3AD_STAT_LACPDU_RX]));
}
if (lacptb[BOND_3AD_STAT_LACPDU_TX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
print_u64(PRINT_ANY, "lacpdu_tx", "LACPDU Tx %llu\n",
rta_getattr_u64(lacptb[BOND_3AD_STAT_LACPDU_TX]));
}
if (lacptb[BOND_3AD_STAT_LACPDU_UNKNOWN_RX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
val = rta_getattr_u64(lacptb[BOND_3AD_STAT_LACPDU_UNKNOWN_RX]);
print_u64(PRINT_ANY,
"lacpdu_unknown_rx",
"LACPDU Unknown type Rx %llu\n",
val);
}
if (lacptb[BOND_3AD_STAT_LACPDU_ILLEGAL_RX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
val = rta_getattr_u64(lacptb[BOND_3AD_STAT_LACPDU_ILLEGAL_RX]);
print_u64(PRINT_ANY,
"lacpdu_illegal_rx",
"LACPDU Illegal Rx %llu\n",
val);
}
if (lacptb[BOND_3AD_STAT_MARKER_RX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
print_u64(PRINT_ANY, "marker_rx", "Marker Rx %llu\n",
rta_getattr_u64(lacptb[BOND_3AD_STAT_MARKER_RX]));
}
if (lacptb[BOND_3AD_STAT_MARKER_TX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
print_u64(PRINT_ANY, "marker_tx", "Marker Tx %llu\n",
rta_getattr_u64(lacptb[BOND_3AD_STAT_MARKER_TX]));
}
if (lacptb[BOND_3AD_STAT_MARKER_RESP_RX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
val = rta_getattr_u64(lacptb[BOND_3AD_STAT_MARKER_RESP_RX]);
print_u64(PRINT_ANY,
"marker_response_rx",
"Marker response Rx %llu\n",
val);
}
if (lacptb[BOND_3AD_STAT_MARKER_RESP_TX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
val = rta_getattr_u64(lacptb[BOND_3AD_STAT_MARKER_RESP_TX]);
print_u64(PRINT_ANY,
"marker_response_tx",
"Marker response Tx %llu\n",
val);
}
if (lacptb[BOND_3AD_STAT_MARKER_UNKNOWN_RX]) {
print_string(PRINT_FP, NULL, "%-16s ", "");
val = rta_getattr_u64(lacptb[BOND_3AD_STAT_MARKER_UNKNOWN_RX]);
print_u64(PRINT_ANY,
"marker_unknown_rx",
"Marker unknown type Rx %llu\n",
val);
}
close_json_object();
}
static void bond_print_stats_attr(struct rtattr *attr, int ifindex)
{
struct rtattr *bondtb[LINK_XSTATS_TYPE_MAX+1];
struct rtattr *i, *list;
const char *ifname = "";
int rem;
parse_rtattr(bondtb, LINK_XSTATS_TYPE_MAX+1, RTA_DATA(attr),
RTA_PAYLOAD(attr));
if (!bondtb[LINK_XSTATS_TYPE_BOND])
return;
list = bondtb[LINK_XSTATS_TYPE_BOND];
rem = RTA_PAYLOAD(list);
open_json_object(NULL);
ifname = ll_index_to_name(ifindex);
print_string(PRINT_ANY, "ifname", "%-16s\n", ifname);
for (i = RTA_DATA(list); RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {
if (xstats_print_attr && i->rta_type != xstats_print_attr)
continue;
switch (i->rta_type) {
case BOND_XSTATS_3AD:
bond_print_3ad_stats(i);
break;
}
break;
}
close_json_object();
}
int bond_print_xstats(struct nlmsghdr *n, void *arg)
{
struct if_stats_msg *ifsm = NLMSG_DATA(n);
struct rtattr *tb[IFLA_STATS_MAX+1];
int len = n->nlmsg_len;
len -= NLMSG_LENGTH(sizeof(*ifsm));
if (len < 0) {
fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
return -1;
}
if (filter_index && filter_index != ifsm->ifindex)
return 0;
parse_rtattr(tb, IFLA_STATS_MAX, IFLA_STATS_RTA(ifsm), len);
if (tb[IFLA_STATS_LINK_XSTATS])
bond_print_stats_attr(tb[IFLA_STATS_LINK_XSTATS],
ifsm->ifindex);
if (tb[IFLA_STATS_LINK_XSTATS_SLAVE])
bond_print_stats_attr(tb[IFLA_STATS_LINK_XSTATS_SLAVE],
ifsm->ifindex);
return 0;
}
int bond_parse_xstats(struct link_util *lu, int argc, char **argv)
{
while (argc > 0) {
if (strcmp(*argv, "lacp") == 0 ||
strcmp(*argv, "802.3ad") == 0) {
xstats_print_attr = BOND_XSTATS_3AD;
} else if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
filter_index = ll_name_to_index(*argv);
if (!filter_index)
return nodev(*argv);
} else if (strcmp(*argv, "help") == 0) {
bond_print_xstats_help(lu, stdout);
exit(0);
} else {
invarg("unknown attribute", *argv);
}
argc--; argv++;
}
return 0;
}
struct link_util bond_link_util = {
.id = "bond",
.maxattr = IFLA_BOND_MAX,
.parse_opt = bond_parse_opt,
.print_opt = bond_print_opt,
.print_help = bond_print_help,
.parse_ifla_xstats = bond_parse_xstats,
.print_ifla_xstats = bond_print_xstats,
};