src/network/netdev/bond.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <netinet/in.h>
   4 #include <linux/if_arp.h>
   5
   6 #include "alloc-util.h"
   7 #include "bond.h"
   8 #include "bond-util.h"
   9 #include "conf-parser.h"
  10 #include "ether-addr-util.h"
  11 #include "extract-word.h"
  12 #include "netlink-util.h"
  13 #include "networkd-manager.h"
  14 #include "string-table.h"
  15
  16 /*
  17  * Number of seconds between instances where the bonding
  18  * driver sends learning packets to each slaves peer switch
  19  */
  20 #define LEARNING_PACKETS_INTERVAL_MIN_SEC       (1 * USEC_PER_SEC)
  21 #define LEARNING_PACKETS_INTERVAL_MAX_SEC       (0x7fffffff * USEC_PER_SEC)
  22
  23 /* Number of IGMP membership reports to be issued after
  24  * a failover event.
  25  */
  26 #define RESEND_IGMP_MIN           0
  27 #define RESEND_IGMP_MAX           255
  28 #define RESEND_IGMP_DEFAULT       1
  29
  30 /*
  31  * Number of packets to transmit through a slave before
  32  * moving to the next one.
  33  */
  34 #define PACKETS_PER_SLAVE_MIN     0
  35 #define PACKETS_PER_SLAVE_MAX     65535
  36 #define PACKETS_PER_SLAVE_DEFAULT 1
  37
  38 /*
  39  * Number of peer notifications (gratuitous ARPs and
  40  * unsolicited IPv6 Neighbor Advertisements) to be issued after a
  41  * failover event.
  42  */
  43 #define GRATUITOUS_ARP_MIN        0
  44 #define GRATUITOUS_ARP_MAX        255
  45 #define GRATUITOUS_ARP_DEFAULT    1
  46
  47 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_mode, bond_mode, BondMode, "Failed to parse bond mode");
  48 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_xmit_hash_policy,
  49                          bond_xmit_hash_policy,
  50                          BondXmitHashPolicy,
  51                          "Failed to parse bond transmit hash policy");
  52 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_lacp_rate, bond_lacp_rate, BondLacpRate, "Failed to parse bond lacp rate");
  53 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_ad_select, bond_ad_select, BondAdSelect, "Failed to parse bond AD select");
  54 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_fail_over_mac, bond_fail_over_mac, BondFailOverMac, "Failed to parse bond fail over MAC");
  55 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_arp_validate, bond_arp_validate, BondArpValidate, "Failed to parse bond arp validate");
  56 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_arp_all_targets, bond_arp_all_targets, BondArpAllTargets, "Failed to parse bond Arp all targets");
  57 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_primary_reselect, bond_primary_reselect, BondPrimaryReselect, "Failed to parse bond primary reselect");
  58
  59 static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
  60         assert(!link);
  61         assert(m);
  62
  63         Bond *b = BOND(netdev);
  64         int r;
  65
  66         if (b->mode != _NETDEV_BOND_MODE_INVALID) {
  67                 r = sd_netlink_message_append_u8(m, IFLA_BOND_MODE, b->mode);
  68                 if (r < 0)
  69                         return r;
  70         }
  71
  72         if (b->xmit_hash_policy != _NETDEV_BOND_XMIT_HASH_POLICY_INVALID) {
  73                 r = sd_netlink_message_append_u8(m, IFLA_BOND_XMIT_HASH_POLICY, b->xmit_hash_policy);
  74                 if (r < 0)
  75                         return r;
  76         }
  77
  78         if (b->lacp_rate != _NETDEV_BOND_LACP_RATE_INVALID &&
  79             b->mode == NETDEV_BOND_MODE_802_3AD) {
  80                 r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_LACP_RATE, b->lacp_rate);
  81                 if (r < 0)
  82                         return r;
  83         }
  84
  85         if (b->miimon != 0) {
  86                 r = sd_netlink_message_append_u32(m, IFLA_BOND_MIIMON, b->miimon / USEC_PER_MSEC);
  87                 if (r < 0)
  88                         return r;
  89         }
  90
  91         if (b->peer_notify_delay != 0) {
  92                 r = sd_netlink_message_append_u32(m, IFLA_BOND_PEER_NOTIF_DELAY, b->peer_notify_delay / USEC_PER_MSEC);
  93                 if (r < 0)
  94                         return r;
  95         }
  96
  97         if (b->downdelay != 0) {
  98                 r = sd_netlink_message_append_u32(m, IFLA_BOND_DOWNDELAY, b->downdelay / USEC_PER_MSEC);
  99                 if (r < 0)
 100                         return r;
 101         }
 102
 103         if (b->updelay != 0) {
 104                 r = sd_netlink_message_append_u32(m, IFLA_BOND_UPDELAY, b->updelay / USEC_PER_MSEC);
 105                 if (r < 0)
 106                         return r;
 107         }
 108
 109         if (b->arp_interval != 0) {
 110                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_INTERVAL, b->arp_interval / USEC_PER_MSEC);
 111                 if (r < 0)
 112                         return r;
 113
 114                 if (b->lp_interval >= LEARNING_PACKETS_INTERVAL_MIN_SEC &&
 115                     b->lp_interval <= LEARNING_PACKETS_INTERVAL_MAX_SEC) {
 116                         r = sd_netlink_message_append_u32(m, IFLA_BOND_LP_INTERVAL, b->lp_interval / USEC_PER_SEC);
 117                         if (r < 0)
 118                                 return r;
 119                 }
 120         }
 121
 122         if (b->ad_select != _NETDEV_BOND_AD_SELECT_INVALID &&
 123             b->mode == NETDEV_BOND_MODE_802_3AD) {
 124                 r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_SELECT, b->ad_select);
 125                 if (r < 0)
 126                         return r;
 127         }
 128
 129         if (b->fail_over_mac != _NETDEV_BOND_FAIL_OVER_MAC_INVALID &&
 130             b->mode == NETDEV_BOND_MODE_ACTIVE_BACKUP) {
 131                 r = sd_netlink_message_append_u8(m, IFLA_BOND_FAIL_OVER_MAC, b->fail_over_mac);
 132                 if (r < 0)
 133                         return r;
 134         }
 135
 136         if (b->arp_validate != _NETDEV_BOND_ARP_VALIDATE_INVALID) {
 137                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_VALIDATE, b->arp_validate);
 138                 if (r < 0)
 139                         return r;
 140         }
 141
 142         if (b->arp_all_targets != _NETDEV_BOND_ARP_ALL_TARGETS_INVALID) {
 143                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->arp_all_targets);
 144                 if (r < 0)
 145                         return r;
 146         }
 147
 148         if (b->primary_reselect != _NETDEV_BOND_PRIMARY_RESELECT_INVALID) {
 149                 r = sd_netlink_message_append_u8(m, IFLA_BOND_PRIMARY_RESELECT, b->primary_reselect);
 150                 if (r < 0)
 151                         return r;
 152         }
 153
 154         if (b->resend_igmp <= RESEND_IGMP_MAX) {
 155                 r = sd_netlink_message_append_u32(m, IFLA_BOND_RESEND_IGMP, b->resend_igmp);
 156                 if (r < 0)
 157                         return r;
 158         }
 159
 160         if (b->packets_per_slave <= PACKETS_PER_SLAVE_MAX &&
 161             b->mode == NETDEV_BOND_MODE_BALANCE_RR) {
 162                 r = sd_netlink_message_append_u32(m, IFLA_BOND_PACKETS_PER_SLAVE, b->packets_per_slave);
 163                 if (r < 0)
 164                         return r;
 165         }
 166
 167         if (b->num_grat_arp <= GRATUITOUS_ARP_MAX) {
 168                 r = sd_netlink_message_append_u8(m, IFLA_BOND_NUM_PEER_NOTIF, b->num_grat_arp);
 169                 if (r < 0)
 170                         return r;
 171         }
 172
 173         if (b->min_links != 0) {
 174                 r = sd_netlink_message_append_u32(m, IFLA_BOND_MIN_LINKS, b->min_links);
 175                 if (r < 0)
 176                         return r;
 177         }
 178
 179         if (b->ad_actor_sys_prio != 0) {
 180                 r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_ACTOR_SYS_PRIO, b->ad_actor_sys_prio);
 181                 if (r < 0)
 182                         return r;
 183         }
 184
 185         if (b->ad_user_port_key != 0) {
 186                 r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_USER_PORT_KEY, b->ad_user_port_key);
 187                 if (r < 0)
 188                         return r;
 189         }
 190
 191         if (!ether_addr_is_null(&b->ad_actor_system)) {
 192                 r = sd_netlink_message_append_ether_addr(m, IFLA_BOND_AD_ACTOR_SYSTEM, &b->ad_actor_system);
 193                 if (r < 0)
 194                         return r;
 195         }
 196
 197         r = sd_netlink_message_append_u8(m, IFLA_BOND_ALL_SLAVES_ACTIVE, b->all_slaves_active);
 198         if (r < 0)
 199                 return r;
 200
 201         if (b->tlb_dynamic_lb >= 0) {
 202                 r = sd_netlink_message_append_u8(m, IFLA_BOND_TLB_DYNAMIC_LB, b->tlb_dynamic_lb);
 203                 if (r < 0)
 204                         return r;
 205         }
 206
 207         if (b->arp_missed_max > 0) {
 208                 r = sd_netlink_message_append_u8(m, IFLA_BOND_MISSED_MAX, b->arp_missed_max);
 209                 if (r < 0)
 210                         return r;
 211         }
 212
 213         if (b->arp_interval > 0 && !ordered_set_isempty(b->arp_ip_targets)) {
 214                 void *val;
 215                 int n = 0;
 216
 217                 r = sd_netlink_message_open_container(m, IFLA_BOND_ARP_IP_TARGET);
 218                 if (r < 0)
 219                         return r;
 220
 221                 ORDERED_SET_FOREACH(val, b->arp_ip_targets) {
 222                         r = sd_netlink_message_append_u32(m, n++, PTR_TO_UINT32(val));
 223                         if (r < 0)
 224                                 return r;
 225                 }
 226
 227                 r = sd_netlink_message_close_container(m);
 228                 if (r < 0)
 229                         return r;
 230         }
 231
 232         return 0;
 233 }
 234
 235 int config_parse_arp_ip_target_address(
 236                 const char *unit,
 237                 const char *filename,
 238                 unsigned line,
 239                 const char *section,
 240                 unsigned section_line,
 241                 const char *lvalue,
 242                 int ltype,
 243                 const char *rvalue,
 244                 void *data,
 245                 void *userdata) {
 246
 247         assert(filename);
 248         assert(lvalue);
 249         assert(rvalue);
 250         assert(data);
 251
 252         Bond *b = BOND(userdata);
 253         int r;
 254
 255         if (isempty(rvalue)) {
 256                 b->arp_ip_targets = ordered_set_free(b->arp_ip_targets);
 257                 return 0;
 258         }
 259
 260         for (const char *p = rvalue;;) {
 261                 _cleanup_free_ char *n = NULL;
 262                 union in_addr_union ip;
 263
 264                 r = extract_first_word(&p, &n, NULL, 0);
 265                 if (r == -ENOMEM)
 266                         return log_oom();
 267                 if (r < 0) {
 268                         log_syntax(unit, LOG_WARNING, filename, line, r,
 269                                    "Failed to parse Bond ARP IP target address, ignoring assignment: %s",
 270                                    rvalue);
 271                         return 0;
 272                 }
 273                 if (r == 0)
 274                         return 0;
 275
 276                 r = in_addr_from_string(AF_INET, n, &ip);
 277                 if (r < 0) {
 278                         log_syntax(unit, LOG_WARNING, filename, line, r,
 279                                    "Bond ARP IP target address is invalid, ignoring assignment: %s", n);
 280                         continue;
 281                 }
 282
 283                 if (ordered_set_size(b->arp_ip_targets) >= NETDEV_BOND_ARP_TARGETS_MAX) {
 284                         log_syntax(unit, LOG_WARNING, filename, line, 0,
 285                                    "Too many ARP IP targets are specified. The maximum number is %d. Ignoring assignment: %s",
 286                                    NETDEV_BOND_ARP_TARGETS_MAX, n);
 287                         continue;
 288                 }
 289
 290                 r = ordered_set_ensure_put(&b->arp_ip_targets, NULL, UINT32_TO_PTR(ip.in.s_addr));
 291                 if (r == -ENOMEM)
 292                         return log_oom();
 293                 if (r == -EEXIST)
 294                         log_syntax(unit, LOG_WARNING, filename, line, r,
 295                                    "Bond ARP IP target address is duplicated, ignoring assignment: %s", n);
 296                 if (r < 0)
 297                         log_syntax(unit, LOG_WARNING, filename, line, r,
 298                                    "Failed to store bond ARP IP target address '%s', ignoring assignment: %m", n);
 299         }
 300 }
 301
 302 int config_parse_ad_actor_sys_prio(
 303                 const char *unit,
 304                 const char *filename,
 305                 unsigned line,
 306                 const char *section,
 307                 unsigned section_line,
 308                 const char *lvalue,
 309                 int ltype,
 310                 const char *rvalue,
 311                 void *data,
 312                 void *userdata) {
 313
 314         assert(filename);
 315         assert(lvalue);
 316         assert(rvalue);
 317         assert(data);
 318
 319         Bond *b = ASSERT_PTR(userdata);
 320
 321         return config_parse_uint16_bounded(
 322                         unit, filename, line, section, section_line, lvalue, rvalue,
 323                         1, UINT16_MAX, true,
 324                         &b->ad_actor_sys_prio);
 325 }
 326
 327 int config_parse_ad_user_port_key(
 328                 const char *unit,
 329                 const char *filename,
 330                 unsigned line,
 331                 const char *section,
 332                 unsigned section_line,
 333                 const char *lvalue,
 334                 int ltype,
 335                 const char *rvalue,
 336                 void *data,
 337                 void *userdata) {
 338
 339         assert(filename);
 340         assert(lvalue);
 341         assert(rvalue);
 342         assert(data);
 343
 344         Bond *b = ASSERT_PTR(userdata);
 345
 346         return config_parse_uint16_bounded(
 347                         unit, filename, line, section, section_line, lvalue, rvalue,
 348                         0, 1023, /* ignoring= */ true,
 349                         &b->ad_user_port_key);
 350 }
 351
 352 int config_parse_ad_actor_system(
 353                 const char *unit,
 354                 const char *filename,
 355                 unsigned line,
 356                 const char *section,
 357                 unsigned section_line,
 358                 const char *lvalue,
 359                 int ltype,
 360                 const char *rvalue,
 361                 void *data,
 362                 void *userdata) {
 363         Bond *b = userdata;
 364         struct ether_addr n;
 365         int r;
 366
 367         assert(filename);
 368         assert(lvalue);
 369         assert(rvalue);
 370         assert(data);
 371
 372         r = parse_ether_addr(rvalue, &n);
 373         if (r < 0) {
 374                 log_syntax(unit, LOG_WARNING, filename, line, r,
 375                            "Not a valid MAC address %s. Ignoring assignment: %m",
 376                            rvalue);
 377                 return 0;
 378         }
 379         if (ether_addr_is_null(&n) || (n.ether_addr_octet[0] & 0x01)) {
 380                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 381                            "Not an appropriate MAC address %s, cannot be null or multicast. Ignoring assignment.",
 382                            rvalue);
 383                 return 0;
 384         }
 385
 386         b->ad_actor_system = n;
 387
 388         return 0;
 389 }
 390
 391 static void bond_done(NetDev *netdev) {
 392         Bond *b = BOND(netdev);
 393
 394         ordered_set_free(b->arp_ip_targets);
 395 }
 396
 397 static void bond_init(NetDev *netdev) {
 398         Bond *b = BOND(netdev);
 399
 400         b->mode = _NETDEV_BOND_MODE_INVALID;
 401         b->xmit_hash_policy = _NETDEV_BOND_XMIT_HASH_POLICY_INVALID;
 402         b->lacp_rate = _NETDEV_BOND_LACP_RATE_INVALID;
 403         b->ad_select = _NETDEV_BOND_AD_SELECT_INVALID;
 404         b->fail_over_mac = _NETDEV_BOND_FAIL_OVER_MAC_INVALID;
 405         b->arp_validate = _NETDEV_BOND_ARP_VALIDATE_INVALID;
 406         b->arp_all_targets = _NETDEV_BOND_ARP_ALL_TARGETS_INVALID;
 407         b->primary_reselect = _NETDEV_BOND_PRIMARY_RESELECT_INVALID;
 408
 409         b->all_slaves_active = false;
 410         b->tlb_dynamic_lb = -1;
 411
 412         b->resend_igmp = RESEND_IGMP_DEFAULT;
 413         b->packets_per_slave = PACKETS_PER_SLAVE_DEFAULT;
 414         b->num_grat_arp = GRATUITOUS_ARP_DEFAULT;
 415         b->lp_interval = LEARNING_PACKETS_INTERVAL_MIN_SEC;
 416 }
 417
 418 const NetDevVTable bond_vtable = {
 419         .object_size = sizeof(Bond),
 420         .init = bond_init,
 421         .done = bond_done,
 422         .sections = NETDEV_COMMON_SECTIONS "Bond\0",
 423         .fill_message_create = netdev_bond_fill_message_create,
 424         .create_type = NETDEV_CREATE_INDEPENDENT,
 425         .iftype = ARPHRD_ETHER,
 426         .generate_mac = true,
 427 };