src/network/netdev/bond.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <netinet/ether.h>
   4 #include <linux/if_bonding.h>
   5
   6 #include "sd-netlink.h"
   7
   8 #include "alloc-util.h"
   9 #include "conf-parser.h"
  10 #include "ether-addr-util.h"
  11 #include "extract-word.h"
  12 #include "missing.h"
  13 #include "netdev/bond.h"
  14 #include "string-table.h"
  15 #include "string-util.h"
  16
  17 /*
  18  * Number of seconds between instances where the bonding
  19  * driver sends learning packets to each slaves peer switch
  20  */
  21 #define LEARNING_PACKETS_INTERVAL_MIN_SEC       (1 * USEC_PER_SEC)
  22 #define LEARNING_PACKETS_INTERVAL_MAX_SEC       (0x7fffffff * USEC_PER_SEC)
  23
  24 /* Number of IGMP membership reports to be issued after
  25  * a failover event.
  26  */
  27 #define RESEND_IGMP_MIN           0
  28 #define RESEND_IGMP_MAX           255
  29 #define RESEND_IGMP_DEFAULT       1
  30
  31 /*
  32  * Number of packets to transmit through a slave before
  33  * moving to the next one.
  34  */
  35 #define PACKETS_PER_SLAVE_MIN     0
  36 #define PACKETS_PER_SLAVE_MAX     65535
  37 #define PACKETS_PER_SLAVE_DEFAULT 1
  38
  39 /*
  40  * Number of peer notifications (gratuitous ARPs and
  41  * unsolicited IPv6 Neighbor Advertisements) to be issued after a
  42  * failover event.
  43  */
  44 #define GRATUITOUS_ARP_MIN        0
  45 #define GRATUITOUS_ARP_MAX        255
  46 #define GRATUITOUS_ARP_DEFAULT    1
  47
  48 static const char* const bond_mode_table[_NETDEV_BOND_MODE_MAX] = {
  49         [NETDEV_BOND_MODE_BALANCE_RR] = "balance-rr",
  50         [NETDEV_BOND_MODE_ACTIVE_BACKUP] = "active-backup",
  51         [NETDEV_BOND_MODE_BALANCE_XOR] = "balance-xor",
  52         [NETDEV_BOND_MODE_BROADCAST] = "broadcast",
  53         [NETDEV_BOND_MODE_802_3AD] = "802.3ad",
  54         [NETDEV_BOND_MODE_BALANCE_TLB] = "balance-tlb",
  55         [NETDEV_BOND_MODE_BALANCE_ALB] = "balance-alb",
  56 };
  57
  58 DEFINE_STRING_TABLE_LOOKUP(bond_mode, BondMode);
  59 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_mode, bond_mode, BondMode, "Failed to parse bond mode");
  60
  61 static const char* const bond_xmit_hash_policy_table[_NETDEV_BOND_XMIT_HASH_POLICY_MAX] = {
  62         [NETDEV_BOND_XMIT_HASH_POLICY_LAYER2] = "layer2",
  63         [NETDEV_BOND_XMIT_HASH_POLICY_LAYER34] = "layer3+4",
  64         [NETDEV_BOND_XMIT_HASH_POLICY_LAYER23] = "layer2+3",
  65         [NETDEV_BOND_XMIT_HASH_POLICY_ENCAP23] = "encap2+3",
  66         [NETDEV_BOND_XMIT_HASH_POLICY_ENCAP34] = "encap3+4",
  67 };
  68
  69 DEFINE_STRING_TABLE_LOOKUP(bond_xmit_hash_policy, BondXmitHashPolicy);
  70 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_xmit_hash_policy,
  71                          bond_xmit_hash_policy,
  72                          BondXmitHashPolicy,
  73                          "Failed to parse bond transmit hash policy")
  74
  75 static const char* const bond_lacp_rate_table[_NETDEV_BOND_LACP_RATE_MAX] = {
  76         [NETDEV_BOND_LACP_RATE_SLOW] = "slow",
  77         [NETDEV_BOND_LACP_RATE_FAST] = "fast",
  78 };
  79
  80 DEFINE_STRING_TABLE_LOOKUP(bond_lacp_rate, BondLacpRate);
  81 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_lacp_rate, bond_lacp_rate, BondLacpRate, "Failed to parse bond lacp rate")
  82
  83 static const char* const bond_ad_select_table[_NETDEV_BOND_AD_SELECT_MAX] = {
  84         [NETDEV_BOND_AD_SELECT_STABLE] = "stable",
  85         [NETDEV_BOND_AD_SELECT_BANDWIDTH] = "bandwidth",
  86         [NETDEV_BOND_AD_SELECT_COUNT] = "count",
  87 };
  88
  89 DEFINE_STRING_TABLE_LOOKUP(bond_ad_select, BondAdSelect);
  90 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_ad_select, bond_ad_select, BondAdSelect, "Failed to parse bond AD select");
  91
  92 static const char* const bond_fail_over_mac_table[_NETDEV_BOND_FAIL_OVER_MAC_MAX] = {
  93         [NETDEV_BOND_FAIL_OVER_MAC_NONE] = "none",
  94         [NETDEV_BOND_FAIL_OVER_MAC_ACTIVE] = "active",
  95         [NETDEV_BOND_FAIL_OVER_MAC_FOLLOW] = "follow",
  96 };
  97
  98 DEFINE_STRING_TABLE_LOOKUP(bond_fail_over_mac, BondFailOverMac);
  99 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_fail_over_mac, bond_fail_over_mac, BondFailOverMac, "Failed to parse bond fail over MAC");
 100
 101 static const char *const bond_arp_validate_table[_NETDEV_BOND_ARP_VALIDATE_MAX] = {
 102         [NETDEV_BOND_ARP_VALIDATE_NONE] = "none",
 103         [NETDEV_BOND_ARP_VALIDATE_ACTIVE]= "active",
 104         [NETDEV_BOND_ARP_VALIDATE_BACKUP]= "backup",
 105         [NETDEV_BOND_ARP_VALIDATE_ALL]= "all",
 106 };
 107
 108 DEFINE_STRING_TABLE_LOOKUP(bond_arp_validate, BondArpValidate);
 109 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_arp_validate, bond_arp_validate, BondArpValidate, "Failed to parse bond arp validate");
 110
 111 static const char *const bond_arp_all_targets_table[_NETDEV_BOND_ARP_ALL_TARGETS_MAX] = {
 112         [NETDEV_BOND_ARP_ALL_TARGETS_ANY] = "any",
 113         [NETDEV_BOND_ARP_ALL_TARGETS_ALL] = "all",
 114 };
 115
 116 DEFINE_STRING_TABLE_LOOKUP(bond_arp_all_targets, BondArpAllTargets);
 117 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_arp_all_targets, bond_arp_all_targets, BondArpAllTargets, "Failed to parse bond Arp all targets");
 118
 119 static const char *bond_primary_reselect_table[_NETDEV_BOND_PRIMARY_RESELECT_MAX] = {
 120         [NETDEV_BOND_PRIMARY_RESELECT_ALWAYS] = "always",
 121         [NETDEV_BOND_PRIMARY_RESELECT_BETTER]= "better",
 122         [NETDEV_BOND_PRIMARY_RESELECT_FAILURE]= "failure",
 123 };
 124
 125 DEFINE_STRING_TABLE_LOOKUP(bond_primary_reselect, BondPrimaryReselect);
 126 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_primary_reselect, bond_primary_reselect, BondPrimaryReselect, "Failed to parse bond primary reselect");
 127
 128 static uint8_t bond_mode_to_kernel(BondMode mode) {
 129         switch (mode) {
 130         case NETDEV_BOND_MODE_BALANCE_RR:
 131                 return BOND_MODE_ROUNDROBIN;
 132         case NETDEV_BOND_MODE_ACTIVE_BACKUP:
 133                 return BOND_MODE_ACTIVEBACKUP;
 134         case NETDEV_BOND_MODE_BALANCE_XOR:
 135                 return BOND_MODE_XOR;
 136         case NETDEV_BOND_MODE_BROADCAST:
 137                 return BOND_MODE_BROADCAST;
 138         case NETDEV_BOND_MODE_802_3AD:
 139                 return BOND_MODE_8023AD;
 140         case NETDEV_BOND_MODE_BALANCE_TLB:
 141                 return BOND_MODE_TLB;
 142         case NETDEV_BOND_MODE_BALANCE_ALB:
 143                 return BOND_MODE_ALB;
 144         default:
 145                 return (uint8_t) -1;
 146         }
 147 }
 148
 149 static uint8_t bond_xmit_hash_policy_to_kernel(BondXmitHashPolicy policy) {
 150         switch (policy) {
 151         case NETDEV_BOND_XMIT_HASH_POLICY_LAYER2:
 152                 return BOND_XMIT_POLICY_LAYER2;
 153         case NETDEV_BOND_XMIT_HASH_POLICY_LAYER34:
 154                 return BOND_XMIT_POLICY_LAYER34;
 155         case NETDEV_BOND_XMIT_HASH_POLICY_LAYER23:
 156                 return BOND_XMIT_POLICY_LAYER23;
 157         case NETDEV_BOND_XMIT_HASH_POLICY_ENCAP23:
 158                 return BOND_XMIT_POLICY_ENCAP23;
 159         case NETDEV_BOND_XMIT_HASH_POLICY_ENCAP34:
 160                 return BOND_XMIT_POLICY_ENCAP34;
 161         default:
 162                 return (uint8_t) -1;
 163         }
 164 }
 165
 166 static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
 167         Bond *b;
 168         ArpIpTarget *target = NULL;
 169         int r, i = 0;
 170
 171         assert(netdev);
 172         assert(!link);
 173         assert(m);
 174
 175         b = BOND(netdev);
 176
 177         assert(b);
 178
 179         if (b->mode != _NETDEV_BOND_MODE_INVALID) {
 180                 r = sd_netlink_message_append_u8(m, IFLA_BOND_MODE,
 181                                               bond_mode_to_kernel(b->mode));
 182                 if (r < 0)
 183                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MODE attribute: %m");
 184         }
 185
 186         if (b->xmit_hash_policy != _NETDEV_BOND_XMIT_HASH_POLICY_INVALID) {
 187                 r = sd_netlink_message_append_u8(m, IFLA_BOND_XMIT_HASH_POLICY,
 188                                               bond_xmit_hash_policy_to_kernel(b->xmit_hash_policy));
 189                 if (r < 0)
 190                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_XMIT_HASH_POLICY attribute: %m");
 191         }
 192
 193         if (b->lacp_rate != _NETDEV_BOND_LACP_RATE_INVALID &&
 194             b->mode == NETDEV_BOND_MODE_802_3AD) {
 195                 r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_LACP_RATE, b->lacp_rate );
 196                 if (r < 0)
 197                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_LACP_RATE attribute: %m");
 198         }
 199
 200         if (b->miimon != 0) {
 201                 r = sd_netlink_message_append_u32(m, IFLA_BOND_MIIMON, b->miimon / USEC_PER_MSEC);
 202                 if (r < 0)
 203                         log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_BOND_MIIMON attribute: %m");
 204         }
 205
 206         if (b->downdelay != 0) {
 207                 r = sd_netlink_message_append_u32(m, IFLA_BOND_DOWNDELAY, b->downdelay / USEC_PER_MSEC);
 208                 if (r < 0)
 209                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_DOWNDELAY attribute: %m");
 210         }
 211
 212         if (b->updelay != 0) {
 213                 r = sd_netlink_message_append_u32(m, IFLA_BOND_UPDELAY, b->updelay / USEC_PER_MSEC);
 214                 if (r < 0)
 215                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_UPDELAY attribute: %m");
 216         }
 217
 218         if (b->arp_interval != 0) {
 219                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_INTERVAL, b->arp_interval / USEC_PER_MSEC);
 220                 if (r < 0)
 221                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_INTERVAL attribute: %m");
 222
 223                 if ((b->lp_interval >= LEARNING_PACKETS_INTERVAL_MIN_SEC) &&
 224                     (b->lp_interval <= LEARNING_PACKETS_INTERVAL_MAX_SEC)) {
 225                         r = sd_netlink_message_append_u32(m, IFLA_BOND_LP_INTERVAL, b->lp_interval / USEC_PER_SEC);
 226                         if (r < 0)
 227                                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_LP_INTERVAL attribute: %m");
 228                 }
 229         }
 230
 231         if (b->ad_select != _NETDEV_BOND_AD_SELECT_INVALID &&
 232             b->mode == NETDEV_BOND_MODE_802_3AD) {
 233                 r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_SELECT, b->ad_select);
 234                 if (r < 0)
 235                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_SELECT attribute: %m");
 236         }
 237
 238         if (b->fail_over_mac != _NETDEV_BOND_FAIL_OVER_MAC_INVALID &&
 239             b->mode == NETDEV_BOND_MODE_ACTIVE_BACKUP) {
 240                 r = sd_netlink_message_append_u8(m, IFLA_BOND_FAIL_OVER_MAC, b->fail_over_mac);
 241                 if (r < 0)
 242                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_FAIL_OVER_MAC attribute: %m");
 243         }
 244
 245         if (b->arp_validate != _NETDEV_BOND_ARP_VALIDATE_INVALID) {
 246                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_VALIDATE, b->arp_validate);
 247                 if (r < 0)
 248                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_VALIDATE attribute: %m");
 249         }
 250
 251         if (b->arp_all_targets != _NETDEV_BOND_ARP_ALL_TARGETS_INVALID) {
 252                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->arp_all_targets);
 253                 if (r < 0)
 254                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
 255         }
 256
 257         if (b->primary_reselect != _NETDEV_BOND_PRIMARY_RESELECT_INVALID) {
 258                 r = sd_netlink_message_append_u8(m, IFLA_BOND_PRIMARY_RESELECT, b->primary_reselect);
 259                 if (r < 0)
 260                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PRIMARY_RESELECT attribute: %m");
 261         }
 262
 263         if (b->resend_igmp <= RESEND_IGMP_MAX) {
 264                 r = sd_netlink_message_append_u32(m, IFLA_BOND_RESEND_IGMP, b->resend_igmp);
 265                 if (r < 0)
 266                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_RESEND_IGMP attribute: %m");
 267         }
 268
 269         if (b->packets_per_slave <= PACKETS_PER_SLAVE_MAX &&
 270             b->mode == NETDEV_BOND_MODE_BALANCE_RR) {
 271                 r = sd_netlink_message_append_u32(m, IFLA_BOND_PACKETS_PER_SLAVE, b->packets_per_slave);
 272                 if (r < 0)
 273                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PACKETS_PER_SLAVE attribute: %m");
 274         }
 275
 276         if (b->num_grat_arp <= GRATUITOUS_ARP_MAX) {
 277                 r = sd_netlink_message_append_u8(m, IFLA_BOND_NUM_PEER_NOTIF, b->num_grat_arp);
 278                 if (r < 0)
 279                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_NUM_PEER_NOTIF attribute: %m");
 280         }
 281
 282         if (b->min_links != 0) {
 283                 r = sd_netlink_message_append_u32(m, IFLA_BOND_MIN_LINKS, b->min_links);
 284                 if (r < 0)
 285                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MIN_LINKS attribute: %m");
 286         }
 287
 288         if (b->ad_actor_sys_prio != 0) {
 289                 r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_ACTOR_SYS_PRIO, b->ad_actor_sys_prio);
 290                 if (r < 0)
 291                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_ACTOR_SYS_PRIO attribute: %m");
 292         }
 293
 294         if (b->ad_user_port_key != 0) {
 295                 r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_USER_PORT_KEY, b->ad_user_port_key);
 296                 if (r < 0)
 297                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_USER_PORT_KEY attribute: %m");
 298         }
 299
 300         if (b->ad_actor_system) {
 301                 r = sd_netlink_message_append_ether_addr(m, IFLA_BOND_AD_ACTOR_SYSTEM, b->ad_actor_system);
 302                 if (r < 0)
 303                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_ACTOR_SYSTEM attribute: %m");
 304         }
 305
 306         r = sd_netlink_message_append_u8(m, IFLA_BOND_ALL_SLAVES_ACTIVE, b->all_slaves_active);
 307         if (r < 0)
 308                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ALL_SLAVES_ACTIVE attribute: %m");
 309
 310         if (b->tlb_dynamic_lb >= 0) {
 311                 r = sd_netlink_message_append_u8(m, IFLA_BOND_TLB_DYNAMIC_LB, b->tlb_dynamic_lb);
 312                 if (r < 0)
 313                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_TLB_DYNAMIC_LB attribute: %m");
 314         }
 315
 316         if (b->arp_interval > 0)  {
 317                 if (b->n_arp_ip_targets > 0) {
 318
 319                         r = sd_netlink_message_open_container(m, IFLA_BOND_ARP_IP_TARGET);
 320                         if (r < 0)
 321                                 return log_netdev_error_errno(netdev, r, "Could not open contaniner IFLA_BOND_ARP_IP_TARGET : %m");
 322
 323                         LIST_FOREACH(arp_ip_target, target, b->arp_ip_targets) {
 324                                 r = sd_netlink_message_append_u32(m, i++, target->ip.in.s_addr);
 325                                 if (r < 0)
 326                                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
 327                         }
 328
 329                         r = sd_netlink_message_close_container(m);
 330                         if (r < 0)
 331                                 return log_netdev_error_errno(netdev, r, "Could not close contaniner IFLA_BOND_ARP_IP_TARGET : %m");
 332                 }
 333         }
 334
 335         return 0;
 336 }
 337
 338 int config_parse_arp_ip_target_address(const char *unit,
 339                                        const char *filename,
 340                                        unsigned line,
 341                                        const char *section,
 342                                        unsigned section_line,
 343                                        const char *lvalue,
 344                                        int ltype,
 345                                        const char *rvalue,
 346                                        void *data,
 347                                        void *userdata) {
 348         Bond *b = userdata;
 349         int r;
 350
 351         assert(filename);
 352         assert(lvalue);
 353         assert(rvalue);
 354         assert(data);
 355
 356         for (;;) {
 357                 _cleanup_free_ ArpIpTarget *buffer = NULL;
 358                 _cleanup_free_ char *n = NULL;
 359                 int f;
 360
 361                 r = extract_first_word(&rvalue, &n, NULL, 0);
 362                 if (r < 0) {
 363                         log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse Bond ARP ip target address, ignoring assignment: %s", rvalue);
 364                         return 0;
 365                 }
 366
 367                 if (r == 0)
 368                         break;
 369
 370                 buffer = new0(ArpIpTarget, 1);
 371                 if (!buffer)
 372                         return -ENOMEM;
 373
 374                 r = in_addr_from_string_auto(n, &f, &buffer->ip);
 375                 if (r < 0) {
 376                         log_syntax(unit, LOG_ERR, filename, line, r, "Bond ARP ip target address is invalid, ignoring assignment: %s", n);
 377                         return 0;
 378                 }
 379
 380                 if (f != AF_INET) {
 381                         log_syntax(unit, LOG_ERR, filename, line, 0, "Bond ARP ip target address is invalid, ignoring assignment: %s", n);
 382                         return 0;
 383                 }
 384
 385                 LIST_PREPEND(arp_ip_target, b->arp_ip_targets, TAKE_PTR(buffer));
 386                 b->n_arp_ip_targets++;
 387         }
 388
 389         if (b->n_arp_ip_targets > NETDEV_BOND_ARP_TARGETS_MAX)
 390                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 391                            "More than the maximum number of kernel-supported ARP ip targets specified: %d > %d",
 392                            b->n_arp_ip_targets, NETDEV_BOND_ARP_TARGETS_MAX);
 393
 394         return 0;
 395 }
 396
 397 int config_parse_ad_actor_sys_prio(const char *unit,
 398                                    const char *filename,
 399                                    unsigned line,
 400                                    const char *section,
 401                                    unsigned section_line,
 402                                    const char *lvalue,
 403                                    int ltype,
 404                                    const char *rvalue,
 405                                    void *data,
 406                                    void *userdata) {
 407         Bond *b = userdata;
 408         uint16_t v;
 409         int r;
 410
 411         assert(filename);
 412         assert(lvalue);
 413         assert(rvalue);
 414         assert(data);
 415
 416         r = safe_atou16(rvalue, &v);
 417         if (r < 0) {
 418                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse actor system priority '%s', ignoring: %m", rvalue);
 419                 return 0;
 420         }
 421
 422         if (v == 0) {
 423                 log_syntax(unit, LOG_ERR, filename, line, 0, "Failed to parse actor system priority '%s'. Range is [1,65535], ignoring.", rvalue);
 424                 return 0;
 425         }
 426
 427         b->ad_actor_sys_prio = v;
 428
 429         return 0;
 430 }
 431
 432 int config_parse_ad_user_port_key(const char *unit,
 433                                   const char *filename,
 434                                   unsigned line,
 435                                   const char *section,
 436                                   unsigned section_line,
 437                                   const char *lvalue,
 438                                   int ltype,
 439                                   const char *rvalue,
 440                                   void *data,
 441                                   void *userdata) {
 442         Bond *b = userdata;
 443         uint16_t v;
 444         int r;
 445
 446         assert(filename);
 447         assert(lvalue);
 448         assert(rvalue);
 449         assert(data);
 450
 451         r = safe_atou16(rvalue, &v);
 452         if (r < 0) {
 453                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse user port key '%s', ignoring: %m", rvalue);
 454                 return 0;
 455         }
 456
 457         if (v > 1023) {
 458                 log_syntax(unit, LOG_ERR, filename, line, 0, "Failed to parse user port key '%s'. Range is [0,1023], ignoring.", rvalue);
 459                 return 0;
 460         }
 461
 462         b->ad_user_port_key = v;
 463
 464         return 0;
 465 }
 466
 467 int config_parse_ad_actor_system(const char *unit,
 468                                  const char *filename,
 469                                  unsigned line,
 470                                  const char *section,
 471                                  unsigned section_line,
 472                                  const char *lvalue,
 473                                  int ltype,
 474                                  const char *rvalue,
 475                                  void *data,
 476                                  void *userdata) {
 477         Bond *b = userdata;
 478         _cleanup_free_ struct ether_addr *n = NULL;
 479         int r;
 480
 481         assert(filename);
 482         assert(lvalue);
 483         assert(rvalue);
 484         assert(data);
 485
 486         n = new0(struct ether_addr, 1);
 487         if (!n)
 488                 return log_oom();
 489
 490         r = ether_addr_from_string(rvalue, n);
 491         if (r < 0) {
 492                 log_syntax(unit, LOG_ERR, filename, line, r, "Not a valid MAC address %s. Ignoring assignment: %m", rvalue);
 493                 return 0;
 494         }
 495
 496         if (ether_addr_is_null(n) || (n->ether_addr_octet[0] & 0x01)) {
 497                 log_syntax(unit, LOG_ERR, filename, line, 0, "Not a valid MAC address %s, can not be null or multicast. Ignoring assignment.", rvalue);
 498                 return 0;
 499         }
 500
 501         free_and_replace(b->ad_actor_system, n);
 502
 503         return 0;
 504 }
 505
 506 static void bond_done(NetDev *netdev) {
 507         ArpIpTarget *t = NULL, *n = NULL;
 508         Bond *b;
 509
 510         assert(netdev);
 511
 512         b = BOND(netdev);
 513
 514         assert(b);
 515
 516         free(b->ad_actor_system);
 517
 518         LIST_FOREACH_SAFE(arp_ip_target, t, n, b->arp_ip_targets)
 519                 free(t);
 520
 521         b->arp_ip_targets = NULL;
 522 }
 523
 524 static void bond_init(NetDev *netdev) {
 525         Bond *b;
 526
 527         assert(netdev);
 528
 529         b = BOND(netdev);
 530
 531         assert(b);
 532
 533         b->mode = _NETDEV_BOND_MODE_INVALID;
 534         b->xmit_hash_policy = _NETDEV_BOND_XMIT_HASH_POLICY_INVALID;
 535         b->lacp_rate = _NETDEV_BOND_LACP_RATE_INVALID;
 536         b->ad_select = _NETDEV_BOND_AD_SELECT_INVALID;
 537         b->fail_over_mac = _NETDEV_BOND_FAIL_OVER_MAC_INVALID;
 538         b->arp_validate = _NETDEV_BOND_ARP_VALIDATE_INVALID;
 539         b->arp_all_targets = _NETDEV_BOND_ARP_ALL_TARGETS_INVALID;
 540         b->primary_reselect = _NETDEV_BOND_PRIMARY_RESELECT_INVALID;
 541
 542         b->all_slaves_active = false;
 543         b->tlb_dynamic_lb = -1;
 544
 545         b->resend_igmp = RESEND_IGMP_DEFAULT;
 546         b->packets_per_slave = PACKETS_PER_SLAVE_DEFAULT;
 547         b->num_grat_arp = GRATUITOUS_ARP_DEFAULT;
 548         b->lp_interval = LEARNING_PACKETS_INTERVAL_MIN_SEC;
 549
 550         LIST_HEAD_INIT(b->arp_ip_targets);
 551         b->n_arp_ip_targets = 0;
 552 }
 553
 554 const NetDevVTable bond_vtable = {
 555         .object_size = sizeof(Bond),
 556         .init = bond_init,
 557         .done = bond_done,
 558         .sections = "Match\0NetDev\0Bond\0",
 559         .fill_message_create = netdev_bond_fill_message_create,
 560         .create_type = NETDEV_CREATE_MASTER,
 561 };