| /* SPDX-License-Identifier: LGPL-2.1+ */ |
| |
| #include "alloc-util.h" |
| #include "bond.h" |
| #include "conf-parser.h" |
| #include "ether-addr-util.h" |
| #include "extract-word.h" |
| #include "netlink-util.h" |
| #include "networkd-manager.h" |
| #include "string-table.h" |
| #include "string-util.h" |
| |
| /* |
| * Number of seconds between instances where the bonding |
| * driver sends learning packets to each slaves peer switch |
| */ |
| #define LEARNING_PACKETS_INTERVAL_MIN_SEC (1 * USEC_PER_SEC) |
| #define LEARNING_PACKETS_INTERVAL_MAX_SEC (0x7fffffff * USEC_PER_SEC) |
| |
| /* Number of IGMP membership reports to be issued after |
| * a failover event. |
| */ |
| #define RESEND_IGMP_MIN 0 |
| #define RESEND_IGMP_MAX 255 |
| #define RESEND_IGMP_DEFAULT 1 |
| |
| /* |
| * Number of packets to transmit through a slave before |
| * moving to the next one. |
| */ |
| #define PACKETS_PER_SLAVE_MIN 0 |
| #define PACKETS_PER_SLAVE_MAX 65535 |
| #define PACKETS_PER_SLAVE_DEFAULT 1 |
| |
| /* |
| * Number of peer notifications (gratuitous ARPs and |
| * unsolicited IPv6 Neighbor Advertisements) to be issued after a |
| * failover event. |
| */ |
| #define GRATUITOUS_ARP_MIN 0 |
| #define GRATUITOUS_ARP_MAX 255 |
| #define GRATUITOUS_ARP_DEFAULT 1 |
| |
| static const char* const bond_mode_table[_NETDEV_BOND_MODE_MAX] = { |
| [NETDEV_BOND_MODE_BALANCE_RR] = "balance-rr", |
| [NETDEV_BOND_MODE_ACTIVE_BACKUP] = "active-backup", |
| [NETDEV_BOND_MODE_BALANCE_XOR] = "balance-xor", |
| [NETDEV_BOND_MODE_BROADCAST] = "broadcast", |
| [NETDEV_BOND_MODE_802_3AD] = "802.3ad", |
| [NETDEV_BOND_MODE_BALANCE_TLB] = "balance-tlb", |
| [NETDEV_BOND_MODE_BALANCE_ALB] = "balance-alb", |
| }; |
| |
| DEFINE_STRING_TABLE_LOOKUP(bond_mode, BondMode); |
| DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_mode, bond_mode, BondMode, "Failed to parse bond mode"); |
| |
| static const char* const bond_xmit_hash_policy_table[_NETDEV_BOND_XMIT_HASH_POLICY_MAX] = { |
| [NETDEV_BOND_XMIT_HASH_POLICY_LAYER2] = "layer2", |
| [NETDEV_BOND_XMIT_HASH_POLICY_LAYER34] = "layer3+4", |
| [NETDEV_BOND_XMIT_HASH_POLICY_LAYER23] = "layer2+3", |
| [NETDEV_BOND_XMIT_HASH_POLICY_ENCAP23] = "encap2+3", |
| [NETDEV_BOND_XMIT_HASH_POLICY_ENCAP34] = "encap3+4", |
| }; |
| |
| DEFINE_STRING_TABLE_LOOKUP(bond_xmit_hash_policy, BondXmitHashPolicy); |
| DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_xmit_hash_policy, |
| bond_xmit_hash_policy, |
| BondXmitHashPolicy, |
| "Failed to parse bond transmit hash policy") |
| |
| static const char* const bond_lacp_rate_table[_NETDEV_BOND_LACP_RATE_MAX] = { |
| [NETDEV_BOND_LACP_RATE_SLOW] = "slow", |
| [NETDEV_BOND_LACP_RATE_FAST] = "fast", |
| }; |
| |
| DEFINE_STRING_TABLE_LOOKUP(bond_lacp_rate, BondLacpRate); |
| DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_lacp_rate, bond_lacp_rate, BondLacpRate, "Failed to parse bond lacp rate") |
| |
| static const char* const bond_ad_select_table[_NETDEV_BOND_AD_SELECT_MAX] = { |
| [NETDEV_BOND_AD_SELECT_STABLE] = "stable", |
| [NETDEV_BOND_AD_SELECT_BANDWIDTH] = "bandwidth", |
| [NETDEV_BOND_AD_SELECT_COUNT] = "count", |
| }; |
| |
| DEFINE_STRING_TABLE_LOOKUP(bond_ad_select, BondAdSelect); |
| DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_ad_select, bond_ad_select, BondAdSelect, "Failed to parse bond AD select"); |
| |
| static const char* const bond_fail_over_mac_table[_NETDEV_BOND_FAIL_OVER_MAC_MAX] = { |
| [NETDEV_BOND_FAIL_OVER_MAC_NONE] = "none", |
| [NETDEV_BOND_FAIL_OVER_MAC_ACTIVE] = "active", |
| [NETDEV_BOND_FAIL_OVER_MAC_FOLLOW] = "follow", |
| }; |
| |
| DEFINE_STRING_TABLE_LOOKUP(bond_fail_over_mac, BondFailOverMac); |
| DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_fail_over_mac, bond_fail_over_mac, BondFailOverMac, "Failed to parse bond fail over MAC"); |
| |
| static const char *const bond_arp_validate_table[_NETDEV_BOND_ARP_VALIDATE_MAX] = { |
| [NETDEV_BOND_ARP_VALIDATE_NONE] = "none", |
| [NETDEV_BOND_ARP_VALIDATE_ACTIVE]= "active", |
| [NETDEV_BOND_ARP_VALIDATE_BACKUP]= "backup", |
| [NETDEV_BOND_ARP_VALIDATE_ALL]= "all", |
| }; |
| |
| DEFINE_STRING_TABLE_LOOKUP(bond_arp_validate, BondArpValidate); |
| DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_arp_validate, bond_arp_validate, BondArpValidate, "Failed to parse bond arp validate"); |
| |
| static const char *const bond_arp_all_targets_table[_NETDEV_BOND_ARP_ALL_TARGETS_MAX] = { |
| [NETDEV_BOND_ARP_ALL_TARGETS_ANY] = "any", |
| [NETDEV_BOND_ARP_ALL_TARGETS_ALL] = "all", |
| }; |
| |
| DEFINE_STRING_TABLE_LOOKUP(bond_arp_all_targets, BondArpAllTargets); |
| DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_arp_all_targets, bond_arp_all_targets, BondArpAllTargets, "Failed to parse bond Arp all targets"); |
| |
| static const char *const bond_primary_reselect_table[_NETDEV_BOND_PRIMARY_RESELECT_MAX] = { |
| [NETDEV_BOND_PRIMARY_RESELECT_ALWAYS] = "always", |
| [NETDEV_BOND_PRIMARY_RESELECT_BETTER]= "better", |
| [NETDEV_BOND_PRIMARY_RESELECT_FAILURE]= "failure", |
| }; |
| |
| DEFINE_STRING_TABLE_LOOKUP(bond_primary_reselect, BondPrimaryReselect); |
| DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_primary_reselect, bond_primary_reselect, BondPrimaryReselect, "Failed to parse bond primary reselect"); |
| |
| static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) { |
| Bond *b; |
| int r; |
| |
| assert(netdev); |
| assert(!link); |
| assert(m); |
| |
| b = BOND(netdev); |
| |
| assert(b); |
| |
| if (b->mode != _NETDEV_BOND_MODE_INVALID) { |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_MODE, b->mode); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MODE attribute: %m"); |
| } |
| |
| if (b->xmit_hash_policy != _NETDEV_BOND_XMIT_HASH_POLICY_INVALID) { |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_XMIT_HASH_POLICY, b->xmit_hash_policy); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_XMIT_HASH_POLICY attribute: %m"); |
| } |
| |
| if (b->lacp_rate != _NETDEV_BOND_LACP_RATE_INVALID && |
| b->mode == NETDEV_BOND_MODE_802_3AD) { |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_LACP_RATE, b->lacp_rate); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_LACP_RATE attribute: %m"); |
| } |
| |
| if (b->miimon != 0) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_MIIMON, b->miimon / USEC_PER_MSEC); |
| if (r < 0) |
| log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_BOND_MIIMON attribute: %m"); |
| } |
| |
| if (b->downdelay != 0) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_DOWNDELAY, b->downdelay / USEC_PER_MSEC); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_DOWNDELAY attribute: %m"); |
| } |
| |
| if (b->updelay != 0) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_UPDELAY, b->updelay / USEC_PER_MSEC); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_UPDELAY attribute: %m"); |
| } |
| |
| if (b->arp_interval != 0) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_INTERVAL, b->arp_interval / USEC_PER_MSEC); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_INTERVAL attribute: %m"); |
| |
| if (b->lp_interval >= LEARNING_PACKETS_INTERVAL_MIN_SEC && |
| b->lp_interval <= LEARNING_PACKETS_INTERVAL_MAX_SEC) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_LP_INTERVAL, b->lp_interval / USEC_PER_SEC); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_LP_INTERVAL attribute: %m"); |
| } |
| } |
| |
| if (b->ad_select != _NETDEV_BOND_AD_SELECT_INVALID && |
| b->mode == NETDEV_BOND_MODE_802_3AD) { |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_SELECT, b->ad_select); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_SELECT attribute: %m"); |
| } |
| |
| if (b->fail_over_mac != _NETDEV_BOND_FAIL_OVER_MAC_INVALID && |
| b->mode == NETDEV_BOND_MODE_ACTIVE_BACKUP) { |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_FAIL_OVER_MAC, b->fail_over_mac); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_FAIL_OVER_MAC attribute: %m"); |
| } |
| |
| if (b->arp_validate != _NETDEV_BOND_ARP_VALIDATE_INVALID) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_VALIDATE, b->arp_validate); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_VALIDATE attribute: %m"); |
| } |
| |
| if (b->arp_all_targets != _NETDEV_BOND_ARP_ALL_TARGETS_INVALID) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->arp_all_targets); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m"); |
| } |
| |
| if (b->primary_reselect != _NETDEV_BOND_PRIMARY_RESELECT_INVALID) { |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_PRIMARY_RESELECT, b->primary_reselect); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PRIMARY_RESELECT attribute: %m"); |
| } |
| |
| if (b->resend_igmp <= RESEND_IGMP_MAX) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_RESEND_IGMP, b->resend_igmp); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_RESEND_IGMP attribute: %m"); |
| } |
| |
| if (b->packets_per_slave <= PACKETS_PER_SLAVE_MAX && |
| b->mode == NETDEV_BOND_MODE_BALANCE_RR) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_PACKETS_PER_SLAVE, b->packets_per_slave); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PACKETS_PER_SLAVE attribute: %m"); |
| } |
| |
| if (b->num_grat_arp <= GRATUITOUS_ARP_MAX) { |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_NUM_PEER_NOTIF, b->num_grat_arp); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_NUM_PEER_NOTIF attribute: %m"); |
| } |
| |
| if (b->min_links != 0) { |
| r = sd_netlink_message_append_u32(m, IFLA_BOND_MIN_LINKS, b->min_links); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MIN_LINKS attribute: %m"); |
| } |
| |
| if (b->ad_actor_sys_prio != 0) { |
| r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_ACTOR_SYS_PRIO, b->ad_actor_sys_prio); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_ACTOR_SYS_PRIO attribute: %m"); |
| } |
| |
| if (b->ad_user_port_key != 0) { |
| r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_USER_PORT_KEY, b->ad_user_port_key); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_USER_PORT_KEY attribute: %m"); |
| } |
| |
| if (!ether_addr_is_null(&b->ad_actor_system)) { |
| r = sd_netlink_message_append_ether_addr(m, IFLA_BOND_AD_ACTOR_SYSTEM, &b->ad_actor_system); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_ACTOR_SYSTEM attribute: %m"); |
| } |
| |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_ALL_SLAVES_ACTIVE, b->all_slaves_active); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ALL_SLAVES_ACTIVE attribute: %m"); |
| |
| if (b->tlb_dynamic_lb >= 0) { |
| r = sd_netlink_message_append_u8(m, IFLA_BOND_TLB_DYNAMIC_LB, b->tlb_dynamic_lb); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_TLB_DYNAMIC_LB attribute: %m"); |
| } |
| |
| if (b->arp_interval > 0 && !ordered_set_isempty(b->arp_ip_targets)) { |
| Iterator i; |
| void *val; |
| int n = 0; |
| |
| r = sd_netlink_message_open_container(m, IFLA_BOND_ARP_IP_TARGET); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not open contaniner IFLA_BOND_ARP_IP_TARGET : %m"); |
| |
| ORDERED_SET_FOREACH(val, b->arp_ip_targets, i) { |
| r = sd_netlink_message_append_u32(m, n++, PTR_TO_UINT32(val)); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m"); |
| } |
| |
| r = sd_netlink_message_close_container(m); |
| if (r < 0) |
| return log_netdev_error_errno(netdev, r, "Could not close contaniner IFLA_BOND_ARP_IP_TARGET : %m"); |
| } |
| |
| return 0; |
| } |
| |
| static int link_set_bond_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) { |
| int r; |
| |
| assert(m); |
| assert(link); |
| assert(link->ifname); |
| |
| if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) |
| return 1; |
| |
| r = sd_netlink_message_get_errno(m); |
| if (r < 0) { |
| log_link_warning_errno(link, r, "Could not set bonding interface: %m"); |
| return 1; |
| } |
| |
| return 1; |
| } |
| |
| int link_set_bond(Link *link) { |
| _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL; |
| int r; |
| |
| assert(link); |
| assert(link->network); |
| |
| r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_NEWLINK, link->network->bond->ifindex); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m"); |
| |
| r = sd_netlink_message_set_flags(req, NLM_F_REQUEST | NLM_F_ACK); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not set netlink flags: %m"); |
| |
| r = sd_netlink_message_open_container(req, IFLA_LINKINFO); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not append IFLA_PROTINFO attribute: %m"); |
| |
| r = sd_netlink_message_open_container_union(req, IFLA_INFO_DATA, "bond"); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m"); |
| |
| if (link->network->active_slave) { |
| r = sd_netlink_message_append_u32(req, IFLA_BOND_ACTIVE_SLAVE, link->ifindex); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not append IFLA_BOND_ACTIVE_SLAVE attribute: %m"); |
| } |
| |
| if (link->network->primary_slave) { |
| r = sd_netlink_message_append_u32(req, IFLA_BOND_PRIMARY, link->ifindex); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not append IFLA_BOND_PRIMARY attribute: %m"); |
| } |
| |
| r = sd_netlink_message_close_container(req); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m"); |
| |
| r = sd_netlink_message_close_container(req); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m"); |
| |
| r = netlink_call_async(link->manager->rtnl, NULL, req, link_set_bond_handler, |
| link_netlink_destroy_callback, link); |
| if (r < 0) |
| return log_link_error_errno(link, r, "Could not send rtnetlink message: %m"); |
| |
| link_ref(link); |
| |
| return r; |
| } |
| |
| int config_parse_arp_ip_target_address( |
| const char *unit, |
| const char *filename, |
| unsigned line, |
| const char *section, |
| unsigned section_line, |
| const char *lvalue, |
| int ltype, |
| const char *rvalue, |
| void *data, |
| void *userdata) { |
| |
| Bond *b = userdata; |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(data); |
| |
| if (isempty(rvalue)) { |
| b->arp_ip_targets = ordered_set_free(b->arp_ip_targets); |
| return 0; |
| } |
| |
| for (;;) { |
| _cleanup_free_ char *n = NULL; |
| union in_addr_union ip; |
| |
| r = extract_first_word(&rvalue, &n, NULL, 0); |
| if (r < 0) { |
| log_syntax(unit, LOG_ERR, filename, line, r, |
| "Failed to parse Bond ARP ip target address, ignoring assignment: %s", |
| rvalue); |
| return 0; |
| } |
| if (r == 0) |
| return 0; |
| |
| r = in_addr_from_string(AF_INET, n, &ip); |
| if (r < 0) { |
| log_syntax(unit, LOG_ERR, filename, line, r, |
| "Bond ARP ip target address is invalid, ignoring assignment: %s", n); |
| continue; |
| } |
| |
| r = ordered_set_ensure_allocated(&b->arp_ip_targets, NULL); |
| if (r < 0) |
| return log_oom(); |
| |
| if (ordered_set_size(b->arp_ip_targets) >= NETDEV_BOND_ARP_TARGETS_MAX) { |
| log_syntax(unit, LOG_WARNING, filename, line, 0, |
| "Too many ARP ip targets are specified. The maximum number is %d. Ignoring assignment: %s", |
| NETDEV_BOND_ARP_TARGETS_MAX, n); |
| continue; |
| } |
| |
| r = ordered_set_put(b->arp_ip_targets, UINT32_TO_PTR(ip.in.s_addr)); |
| if (r == -EEXIST) |
| log_syntax(unit, LOG_WARNING, filename, line, r, |
| "Bond ARP ip target address is duplicated, ignoring assignment: %s", n); |
| if (r < 0) |
| log_syntax(unit, LOG_ERR, filename, line, r, |
| "Failed to store bond ARP ip target address '%s', ignoring assignment: %m", n); |
| } |
| } |
| |
| int config_parse_ad_actor_sys_prio( |
| const char *unit, |
| const char *filename, |
| unsigned line, |
| const char *section, |
| unsigned section_line, |
| const char *lvalue, |
| int ltype, |
| const char *rvalue, |
| void *data, |
| void *userdata) { |
| Bond *b = userdata; |
| uint16_t v; |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(data); |
| |
| r = safe_atou16(rvalue, &v); |
| if (r < 0) { |
| log_syntax(unit, LOG_ERR, filename, line, r, |
| "Failed to parse actor system priority '%s', ignoring: %m", rvalue); |
| return 0; |
| } |
| |
| if (v == 0) { |
| log_syntax(unit, LOG_ERR, filename, line, 0, |
| "Failed to parse actor system priority '%s'. Range is [1,65535], ignoring.", |
| rvalue); |
| return 0; |
| } |
| |
| b->ad_actor_sys_prio = v; |
| |
| return 0; |
| } |
| |
| int config_parse_ad_user_port_key( |
| const char *unit, |
| const char *filename, |
| unsigned line, |
| const char *section, |
| unsigned section_line, |
| const char *lvalue, |
| int ltype, |
| const char *rvalue, |
| void *data, |
| void *userdata) { |
| Bond *b = userdata; |
| uint16_t v; |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(data); |
| |
| r = safe_atou16(rvalue, &v); |
| if (r < 0) { |
| log_syntax(unit, LOG_ERR, filename, line, r, |
| "Failed to parse user port key '%s', ignoring: %m", rvalue); |
| return 0; |
| } |
| |
| if (v > 1023) { |
| log_syntax(unit, LOG_ERR, filename, line, 0, |
| "Failed to parse user port key '%s'. Range is [0…1023], ignoring.", rvalue); |
| return 0; |
| } |
| |
| b->ad_user_port_key = v; |
| |
| return 0; |
| } |
| |
| int config_parse_ad_actor_system( |
| const char *unit, |
| const char *filename, |
| unsigned line, |
| const char *section, |
| unsigned section_line, |
| const char *lvalue, |
| int ltype, |
| const char *rvalue, |
| void *data, |
| void *userdata) { |
| Bond *b = userdata; |
| struct ether_addr n; |
| int r; |
| |
| assert(filename); |
| assert(lvalue); |
| assert(rvalue); |
| assert(data); |
| |
| r = ether_addr_from_string(rvalue, &n); |
| if (r < 0) { |
| log_syntax(unit, LOG_ERR, filename, line, r, |
| "Not a valid MAC address %s. Ignoring assignment: %m", |
| rvalue); |
| return 0; |
| } |
| if (ether_addr_is_null(&n) || (n.ether_addr_octet[0] & 0x01)) { |
| log_syntax(unit, LOG_ERR, filename, line, 0, |
| "Not a valid MAC address %s, can not be null or multicast. Ignoring assignment.", |
| rvalue); |
| return 0; |
| } |
| |
| b->ad_actor_system = n; |
| |
| return 0; |
| } |
| |
| static void bond_done(NetDev *netdev) { |
| Bond *b; |
| |
| assert(netdev); |
| b = BOND(netdev); |
| assert(b); |
| |
| ordered_set_free(b->arp_ip_targets); |
| } |
| |
| static void bond_init(NetDev *netdev) { |
| Bond *b; |
| |
| assert(netdev); |
| |
| b = BOND(netdev); |
| |
| assert(b); |
| |
| b->mode = _NETDEV_BOND_MODE_INVALID; |
| b->xmit_hash_policy = _NETDEV_BOND_XMIT_HASH_POLICY_INVALID; |
| b->lacp_rate = _NETDEV_BOND_LACP_RATE_INVALID; |
| b->ad_select = _NETDEV_BOND_AD_SELECT_INVALID; |
| b->fail_over_mac = _NETDEV_BOND_FAIL_OVER_MAC_INVALID; |
| b->arp_validate = _NETDEV_BOND_ARP_VALIDATE_INVALID; |
| b->arp_all_targets = _NETDEV_BOND_ARP_ALL_TARGETS_INVALID; |
| b->primary_reselect = _NETDEV_BOND_PRIMARY_RESELECT_INVALID; |
| |
| b->all_slaves_active = false; |
| b->tlb_dynamic_lb = -1; |
| |
| b->resend_igmp = RESEND_IGMP_DEFAULT; |
| b->packets_per_slave = PACKETS_PER_SLAVE_DEFAULT; |
| b->num_grat_arp = GRATUITOUS_ARP_DEFAULT; |
| b->lp_interval = LEARNING_PACKETS_INTERVAL_MIN_SEC; |
| } |
| |
| const NetDevVTable bond_vtable = { |
| .object_size = sizeof(Bond), |
| .init = bond_init, |
| .done = bond_done, |
| .sections = NETDEV_COMMON_SECTIONS "Bond\0", |
| .fill_message_create = netdev_bond_fill_message_create, |
| .create_type = NETDEV_CREATE_MASTER, |
| .generate_mac = true, |
| }; |