drivers/net/bonding/bond_options.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * drivers/net/bond/bond_options.c - bonding options
   4  * Copyright (c) 2013 Jiri Pirko <[email protected]>
   5  * Copyright (c) 2013 Scott Feldman <[email protected]>
   6  */
   7
   8 #include <linux/errno.h>
   9 #include <linux/if.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/rcupdate.h>
  13 #include <linux/ctype.h>
  14 #include <linux/inet.h>
  15 #include <linux/sched/signal.h>
  16
  17 #include <net/bonding.h>
  18
  19 static int bond_option_active_slave_set(struct bonding *bond,
  20                                         const struct bond_opt_value *newval);
  21 static int bond_option_miimon_set(struct bonding *bond,
  22                                   const struct bond_opt_value *newval);
  23 static int bond_option_updelay_set(struct bonding *bond,
  24                                    const struct bond_opt_value *newval);
  25 static int bond_option_downdelay_set(struct bonding *bond,
  26                                      const struct bond_opt_value *newval);
  27 static int bond_option_peer_notif_delay_set(struct bonding *bond,
  28                                             const struct bond_opt_value *newval);
  29 static int bond_option_use_carrier_set(struct bonding *bond,
  30                                        const struct bond_opt_value *newval);
  31 static int bond_option_arp_interval_set(struct bonding *bond,
  32                                         const struct bond_opt_value *newval);
  33 static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target);
  34 static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target);
  35 static int bond_option_arp_ip_targets_set(struct bonding *bond,
  36                                           const struct bond_opt_value *newval);
  37 static int bond_option_ns_ip6_targets_set(struct bonding *bond,
  38                                           const struct bond_opt_value *newval);
  39 static int bond_option_arp_validate_set(struct bonding *bond,
  40                                         const struct bond_opt_value *newval);
  41 static int bond_option_arp_all_targets_set(struct bonding *bond,
  42                                            const struct bond_opt_value *newval);
  43 static int bond_option_prio_set(struct bonding *bond,
  44                                 const struct bond_opt_value *newval);
  45 static int bond_option_primary_set(struct bonding *bond,
  46                                    const struct bond_opt_value *newval);
  47 static int bond_option_primary_reselect_set(struct bonding *bond,
  48                                             const struct bond_opt_value *newval);
  49 static int bond_option_fail_over_mac_set(struct bonding *bond,
  50                                          const struct bond_opt_value *newval);
  51 static int bond_option_xmit_hash_policy_set(struct bonding *bond,
  52                                             const struct bond_opt_value *newval);
  53 static int bond_option_resend_igmp_set(struct bonding *bond,
  54                                        const struct bond_opt_value *newval);
  55 static int bond_option_num_peer_notif_set(struct bonding *bond,
  56                                           const struct bond_opt_value *newval);
  57 static int bond_option_all_slaves_active_set(struct bonding *bond,
  58                                              const struct bond_opt_value *newval);
  59 static int bond_option_min_links_set(struct bonding *bond,
  60                                      const struct bond_opt_value *newval);
  61 static int bond_option_lp_interval_set(struct bonding *bond,
  62                                        const struct bond_opt_value *newval);
  63 static int bond_option_pps_set(struct bonding *bond,
  64                                const struct bond_opt_value *newval);
  65 static int bond_option_lacp_active_set(struct bonding *bond,
  66                                        const struct bond_opt_value *newval);
  67 static int bond_option_lacp_rate_set(struct bonding *bond,
  68                                      const struct bond_opt_value *newval);
  69 static int bond_option_ad_select_set(struct bonding *bond,
  70                                      const struct bond_opt_value *newval);
  71 static int bond_option_queue_id_set(struct bonding *bond,
  72                                     const struct bond_opt_value *newval);
  73 static int bond_option_mode_set(struct bonding *bond,
  74                                 const struct bond_opt_value *newval);
  75 static int bond_option_slaves_set(struct bonding *bond,
  76                                   const struct bond_opt_value *newval);
  77 static int bond_option_tlb_dynamic_lb_set(struct bonding *bond,
  78                                   const struct bond_opt_value *newval);
  79 static int bond_option_ad_actor_sys_prio_set(struct bonding *bond,
  80                                              const struct bond_opt_value *newval);
  81 static int bond_option_ad_actor_system_set(struct bonding *bond,
  82                                            const struct bond_opt_value *newval);
  83 static int bond_option_ad_user_port_key_set(struct bonding *bond,
  84                                             const struct bond_opt_value *newval);
  85 static int bond_option_missed_max_set(struct bonding *bond,
  86                                       const struct bond_opt_value *newval);
  87 static int bond_option_coupled_control_set(struct bonding *bond,
  88                                            const struct bond_opt_value *newval);
  89
  90 static const struct bond_opt_value bond_mode_tbl[] = {
  91         { "balance-rr",    BOND_MODE_ROUNDROBIN,   BOND_VALFLAG_DEFAULT},
  92         { "active-backup", BOND_MODE_ACTIVEBACKUP, 0},
  93         { "balance-xor",   BOND_MODE_XOR,          0},
  94         { "broadcast",     BOND_MODE_BROADCAST,    0},
  95         { "802.3ad",       BOND_MODE_8023AD,       0},
  96         { "balance-tlb",   BOND_MODE_TLB,          0},
  97         { "balance-alb",   BOND_MODE_ALB,          0},
  98         { NULL,            -1,                     0},
  99 };
 100
 101 static const struct bond_opt_value bond_pps_tbl[] = {
 102         { "default", 1,         BOND_VALFLAG_DEFAULT},
 103         { "maxval",  USHRT_MAX, BOND_VALFLAG_MAX},
 104         { NULL,      -1,        0},
 105 };
 106
 107 static const struct bond_opt_value bond_xmit_hashtype_tbl[] = {
 108         { "layer2",      BOND_XMIT_POLICY_LAYER2,      BOND_VALFLAG_DEFAULT},
 109         { "layer3+4",    BOND_XMIT_POLICY_LAYER34,     0},
 110         { "layer2+3",    BOND_XMIT_POLICY_LAYER23,     0},
 111         { "encap2+3",    BOND_XMIT_POLICY_ENCAP23,     0},
 112         { "encap3+4",    BOND_XMIT_POLICY_ENCAP34,     0},
 113         { "vlan+srcmac", BOND_XMIT_POLICY_VLAN_SRCMAC, 0},
 114         { NULL,          -1,                           0},
 115 };
 116
 117 static const struct bond_opt_value bond_arp_validate_tbl[] = {
 118         { "none",               BOND_ARP_VALIDATE_NONE,         BOND_VALFLAG_DEFAULT},
 119         { "active",             BOND_ARP_VALIDATE_ACTIVE,       0},
 120         { "backup",             BOND_ARP_VALIDATE_BACKUP,       0},
 121         { "all",                BOND_ARP_VALIDATE_ALL,          0},
 122         { "filter",             BOND_ARP_FILTER,                0},
 123         { "filter_active",      BOND_ARP_FILTER_ACTIVE,         0},
 124         { "filter_backup",      BOND_ARP_FILTER_BACKUP,         0},
 125         { NULL,                 -1,                             0},
 126 };
 127
 128 static const struct bond_opt_value bond_arp_all_targets_tbl[] = {
 129         { "any", BOND_ARP_TARGETS_ANY, BOND_VALFLAG_DEFAULT},
 130         { "all", BOND_ARP_TARGETS_ALL, 0},
 131         { NULL,  -1,                   0},
 132 };
 133
 134 static const struct bond_opt_value bond_fail_over_mac_tbl[] = {
 135         { "none",   BOND_FOM_NONE,   BOND_VALFLAG_DEFAULT},
 136         { "active", BOND_FOM_ACTIVE, 0},
 137         { "follow", BOND_FOM_FOLLOW, 0},
 138         { NULL,     -1,              0},
 139 };
 140
 141 static const struct bond_opt_value bond_intmax_tbl[] = {
 142         { "off",     0,       BOND_VALFLAG_DEFAULT},
 143         { "maxval",  INT_MAX, BOND_VALFLAG_MAX},
 144         { NULL,      -1,      0}
 145 };
 146
 147 static const struct bond_opt_value bond_lacp_active[] = {
 148         { "off", 0,  0},
 149         { "on",  1,  BOND_VALFLAG_DEFAULT},
 150         { NULL,  -1, 0}
 151 };
 152
 153 static const struct bond_opt_value bond_lacp_rate_tbl[] = {
 154         { "slow", AD_LACP_SLOW, 0},
 155         { "fast", AD_LACP_FAST, 0},
 156         { NULL,   -1,           0},
 157 };
 158
 159 static const struct bond_opt_value bond_ad_select_tbl[] = {
 160         { "stable",    BOND_AD_STABLE,    BOND_VALFLAG_DEFAULT},
 161         { "bandwidth", BOND_AD_BANDWIDTH, 0},
 162         { "count",     BOND_AD_COUNT,     0},
 163         { NULL,        -1,                0},
 164 };
 165
 166 static const struct bond_opt_value bond_num_peer_notif_tbl[] = {
 167         { "off",     0,   0},
 168         { "maxval",  255, BOND_VALFLAG_MAX},
 169         { "default", 1,   BOND_VALFLAG_DEFAULT},
 170         { NULL,      -1,  0}
 171 };
 172
 173 static const struct bond_opt_value bond_peer_notif_delay_tbl[] = {
 174         { "off",     0,   0},
 175         { "maxval",  300000, BOND_VALFLAG_MAX},
 176         { NULL,      -1,  0}
 177 };
 178
 179 static const struct bond_opt_value bond_primary_reselect_tbl[] = {
 180         { "always",  BOND_PRI_RESELECT_ALWAYS,  BOND_VALFLAG_DEFAULT},
 181         { "better",  BOND_PRI_RESELECT_BETTER,  0},
 182         { "failure", BOND_PRI_RESELECT_FAILURE, 0},
 183         { NULL,      -1},
 184 };
 185
 186 static const struct bond_opt_value bond_use_carrier_tbl[] = {
 187         { "off", 0,  0},
 188         { "on",  1,  BOND_VALFLAG_DEFAULT},
 189         { NULL,  -1, 0}
 190 };
 191
 192 static const struct bond_opt_value bond_all_slaves_active_tbl[] = {
 193         { "off", 0,  BOND_VALFLAG_DEFAULT},
 194         { "on",  1,  0},
 195         { NULL,  -1, 0}
 196 };
 197
 198 static const struct bond_opt_value bond_resend_igmp_tbl[] = {
 199         { "off",     0,   0},
 200         { "maxval",  255, BOND_VALFLAG_MAX},
 201         { "default", 1,   BOND_VALFLAG_DEFAULT},
 202         { NULL,      -1,  0}
 203 };
 204
 205 static const struct bond_opt_value bond_lp_interval_tbl[] = {
 206         { "minval",  1,       BOND_VALFLAG_MIN | BOND_VALFLAG_DEFAULT},
 207         { "maxval",  INT_MAX, BOND_VALFLAG_MAX},
 208         { NULL,      -1,      0},
 209 };
 210
 211 static const struct bond_opt_value bond_tlb_dynamic_lb_tbl[] = {
 212         { "off", 0,  0},
 213         { "on",  1,  BOND_VALFLAG_DEFAULT},
 214         { NULL,  -1, 0}
 215 };
 216
 217 static const struct bond_opt_value bond_ad_actor_sys_prio_tbl[] = {
 218         { "minval",  1,     BOND_VALFLAG_MIN},
 219         { "maxval",  65535, BOND_VALFLAG_MAX | BOND_VALFLAG_DEFAULT},
 220         { NULL,      -1,    0},
 221 };
 222
 223 static const struct bond_opt_value bond_ad_user_port_key_tbl[] = {
 224         { "minval",  0,     BOND_VALFLAG_MIN | BOND_VALFLAG_DEFAULT},
 225         { "maxval",  1023,  BOND_VALFLAG_MAX},
 226         { NULL,      -1,    0},
 227 };
 228
 229 static const struct bond_opt_value bond_missed_max_tbl[] = {
 230         { "minval",     1,      BOND_VALFLAG_MIN},
 231         { "maxval",     255,    BOND_VALFLAG_MAX},
 232         { "default",    2,      BOND_VALFLAG_DEFAULT},
 233         { NULL,         -1,     0},
 234 };
 235
 236 static const struct bond_opt_value bond_coupled_control_tbl[] = {
 237         { "on",  1,  BOND_VALFLAG_DEFAULT},
 238         { "off", 0,  0},
 239         { NULL,  -1, 0},
 240 };
 241
 242 static const struct bond_option bond_opts[BOND_OPT_LAST] = {
 243         [BOND_OPT_MODE] = {
 244                 .id = BOND_OPT_MODE,
 245                 .name = "mode",
 246                 .desc = "bond device mode",
 247                 .flags = BOND_OPTFLAG_NOSLAVES | BOND_OPTFLAG_IFDOWN,
 248                 .values = bond_mode_tbl,
 249                 .set = bond_option_mode_set
 250         },
 251         [BOND_OPT_PACKETS_PER_SLAVE] = {
 252                 .id = BOND_OPT_PACKETS_PER_SLAVE,
 253                 .name = "packets_per_slave",
 254                 .desc = "Packets to send per slave in RR mode",
 255                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ROUNDROBIN)),
 256                 .values = bond_pps_tbl,
 257                 .set = bond_option_pps_set
 258         },
 259         [BOND_OPT_XMIT_HASH] = {
 260                 .id = BOND_OPT_XMIT_HASH,
 261                 .name = "xmit_hash_policy",
 262                 .desc = "balance-xor, 802.3ad, and tlb hashing method",
 263                 .values = bond_xmit_hashtype_tbl,
 264                 .set = bond_option_xmit_hash_policy_set
 265         },
 266         [BOND_OPT_ARP_VALIDATE] = {
 267                 .id = BOND_OPT_ARP_VALIDATE,
 268                 .name = "arp_validate",
 269                 .desc = "validate src/dst of ARP probes",
 270                 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) |
 271                                BIT(BOND_MODE_ALB),
 272                 .values = bond_arp_validate_tbl,
 273                 .set = bond_option_arp_validate_set
 274         },
 275         [BOND_OPT_ARP_ALL_TARGETS] = {
 276                 .id = BOND_OPT_ARP_ALL_TARGETS,
 277                 .name = "arp_all_targets",
 278                 .desc = "fail on any/all arp targets timeout",
 279                 .values = bond_arp_all_targets_tbl,
 280                 .set = bond_option_arp_all_targets_set
 281         },
 282         [BOND_OPT_FAIL_OVER_MAC] = {
 283                 .id = BOND_OPT_FAIL_OVER_MAC,
 284                 .name = "fail_over_mac",
 285                 .desc = "For active-backup, do not set all slaves to the same MAC",
 286                 .flags = BOND_OPTFLAG_NOSLAVES,
 287                 .values = bond_fail_over_mac_tbl,
 288                 .set = bond_option_fail_over_mac_set
 289         },
 290         [BOND_OPT_ARP_INTERVAL] = {
 291                 .id = BOND_OPT_ARP_INTERVAL,
 292                 .name = "arp_interval",
 293                 .desc = "arp interval in milliseconds",
 294                 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) |
 295                                BIT(BOND_MODE_ALB),
 296                 .values = bond_intmax_tbl,
 297                 .set = bond_option_arp_interval_set
 298         },
 299         [BOND_OPT_MISSED_MAX] = {
 300                 .id = BOND_OPT_MISSED_MAX,
 301                 .name = "arp_missed_max",
 302                 .desc = "Maximum number of missed ARP interval",
 303                 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) |
 304                                BIT(BOND_MODE_ALB),
 305                 .values = bond_missed_max_tbl,
 306                 .set = bond_option_missed_max_set
 307         },
 308         [BOND_OPT_ARP_TARGETS] = {
 309                 .id = BOND_OPT_ARP_TARGETS,
 310                 .name = "arp_ip_target",
 311                 .desc = "arp targets in n.n.n.n form",
 312                 .flags = BOND_OPTFLAG_RAWVAL,
 313                 .set = bond_option_arp_ip_targets_set
 314         },
 315         [BOND_OPT_NS_TARGETS] = {
 316                 .id = BOND_OPT_NS_TARGETS,
 317                 .name = "ns_ip6_target",
 318                 .desc = "NS targets in ffff:ffff::ffff:ffff form",
 319                 .flags = BOND_OPTFLAG_RAWVAL,
 320                 .set = bond_option_ns_ip6_targets_set
 321         },
 322         [BOND_OPT_DOWNDELAY] = {
 323                 .id = BOND_OPT_DOWNDELAY,
 324                 .name = "downdelay",
 325                 .desc = "Delay before considering link down, in milliseconds",
 326                 .values = bond_intmax_tbl,
 327                 .set = bond_option_downdelay_set
 328         },
 329         [BOND_OPT_UPDELAY] = {
 330                 .id = BOND_OPT_UPDELAY,
 331                 .name = "updelay",
 332                 .desc = "Delay before considering link up, in milliseconds",
 333                 .values = bond_intmax_tbl,
 334                 .set = bond_option_updelay_set
 335         },
 336         [BOND_OPT_LACP_ACTIVE] = {
 337                 .id = BOND_OPT_LACP_ACTIVE,
 338                 .name = "lacp_active",
 339                 .desc = "Send LACPDU frames with configured lacp rate or acts as speak when spoken to",
 340                 .flags = BOND_OPTFLAG_IFDOWN,
 341                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
 342                 .values = bond_lacp_active,
 343                 .set = bond_option_lacp_active_set
 344         },
 345         [BOND_OPT_LACP_RATE] = {
 346                 .id = BOND_OPT_LACP_RATE,
 347                 .name = "lacp_rate",
 348                 .desc = "LACPDU tx rate to request from 802.3ad partner",
 349                 .flags = BOND_OPTFLAG_IFDOWN,
 350                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
 351                 .values = bond_lacp_rate_tbl,
 352                 .set = bond_option_lacp_rate_set
 353         },
 354         [BOND_OPT_MINLINKS] = {
 355                 .id = BOND_OPT_MINLINKS,
 356                 .name = "min_links",
 357                 .desc = "Minimum number of available links before turning on carrier",
 358                 .values = bond_intmax_tbl,
 359                 .set = bond_option_min_links_set
 360         },
 361         [BOND_OPT_AD_SELECT] = {
 362                 .id = BOND_OPT_AD_SELECT,
 363                 .name = "ad_select",
 364                 .desc = "803.ad aggregation selection logic",
 365                 .flags = BOND_OPTFLAG_IFDOWN,
 366                 .values = bond_ad_select_tbl,
 367                 .set = bond_option_ad_select_set
 368         },
 369         [BOND_OPT_NUM_PEER_NOTIF] = {
 370                 .id = BOND_OPT_NUM_PEER_NOTIF,
 371                 .name = "num_unsol_na",
 372                 .desc = "Number of peer notifications to send on failover event",
 373                 .values = bond_num_peer_notif_tbl,
 374                 .set = bond_option_num_peer_notif_set
 375         },
 376         [BOND_OPT_MIIMON] = {
 377                 .id = BOND_OPT_MIIMON,
 378                 .name = "miimon",
 379                 .desc = "Link check interval in milliseconds",
 380                 .values = bond_intmax_tbl,
 381                 .set = bond_option_miimon_set
 382         },
 383         [BOND_OPT_PRIO] = {
 384                 .id = BOND_OPT_PRIO,
 385                 .name = "prio",
 386                 .desc = "Link priority for failover re-selection",
 387                 .flags = BOND_OPTFLAG_RAWVAL,
 388                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) |
 389                                                 BIT(BOND_MODE_TLB) |
 390                                                 BIT(BOND_MODE_ALB)),
 391                 .set = bond_option_prio_set
 392         },
 393         [BOND_OPT_PRIMARY] = {
 394                 .id = BOND_OPT_PRIMARY,
 395                 .name = "primary",
 396                 .desc = "Primary network device to use",
 397                 .flags = BOND_OPTFLAG_RAWVAL,
 398                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) |
 399                                                 BIT(BOND_MODE_TLB) |
 400                                                 BIT(BOND_MODE_ALB)),
 401                 .set = bond_option_primary_set
 402         },
 403         [BOND_OPT_PRIMARY_RESELECT] = {
 404                 .id = BOND_OPT_PRIMARY_RESELECT,
 405                 .name = "primary_reselect",
 406                 .desc = "Reselect primary slave once it comes up",
 407                 .values = bond_primary_reselect_tbl,
 408                 .set = bond_option_primary_reselect_set
 409         },
 410         [BOND_OPT_USE_CARRIER] = {
 411                 .id = BOND_OPT_USE_CARRIER,
 412                 .name = "use_carrier",
 413                 .desc = "Use netif_carrier_ok (vs MII ioctls) in miimon",
 414                 .values = bond_use_carrier_tbl,
 415                 .set = bond_option_use_carrier_set
 416         },
 417         [BOND_OPT_ACTIVE_SLAVE] = {
 418                 .id = BOND_OPT_ACTIVE_SLAVE,
 419                 .name = "active_slave",
 420                 .desc = "Currently active slave",
 421                 .flags = BOND_OPTFLAG_RAWVAL,
 422                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) |
 423                                                 BIT(BOND_MODE_TLB) |
 424                                                 BIT(BOND_MODE_ALB)),
 425                 .set = bond_option_active_slave_set
 426         },
 427         [BOND_OPT_QUEUE_ID] = {
 428                 .id = BOND_OPT_QUEUE_ID,
 429                 .name = "queue_id",
 430                 .desc = "Set queue id of a slave",
 431                 .flags = BOND_OPTFLAG_RAWVAL,
 432                 .set = bond_option_queue_id_set
 433         },
 434         [BOND_OPT_ALL_SLAVES_ACTIVE] = {
 435                 .id = BOND_OPT_ALL_SLAVES_ACTIVE,
 436                 .name = "all_slaves_active",
 437                 .desc = "Keep all frames received on an interface by setting active flag for all slaves",
 438                 .values = bond_all_slaves_active_tbl,
 439                 .set = bond_option_all_slaves_active_set
 440         },
 441         [BOND_OPT_RESEND_IGMP] = {
 442                 .id = BOND_OPT_RESEND_IGMP,
 443                 .name = "resend_igmp",
 444                 .desc = "Number of IGMP membership reports to send on link failure",
 445                 .values = bond_resend_igmp_tbl,
 446                 .set = bond_option_resend_igmp_set
 447         },
 448         [BOND_OPT_LP_INTERVAL] = {
 449                 .id = BOND_OPT_LP_INTERVAL,
 450                 .name = "lp_interval",
 451                 .desc = "The number of seconds between instances where the bonding driver sends learning packets to each slave's peer switch",
 452                 .values = bond_lp_interval_tbl,
 453                 .set = bond_option_lp_interval_set
 454         },
 455         [BOND_OPT_SLAVES] = {
 456                 .id = BOND_OPT_SLAVES,
 457                 .name = "slaves",
 458                 .desc = "Slave membership management",
 459                 .flags = BOND_OPTFLAG_RAWVAL,
 460                 .set = bond_option_slaves_set
 461         },
 462         [BOND_OPT_TLB_DYNAMIC_LB] = {
 463                 .id = BOND_OPT_TLB_DYNAMIC_LB,
 464                 .name = "tlb_dynamic_lb",
 465                 .desc = "Enable dynamic flow shuffling",
 466                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_TLB) | BIT(BOND_MODE_ALB)),
 467                 .values = bond_tlb_dynamic_lb_tbl,
 468                 .flags = BOND_OPTFLAG_IFDOWN,
 469                 .set = bond_option_tlb_dynamic_lb_set,
 470         },
 471         [BOND_OPT_AD_ACTOR_SYS_PRIO] = {
 472                 .id = BOND_OPT_AD_ACTOR_SYS_PRIO,
 473                 .name = "ad_actor_sys_prio",
 474                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
 475                 .values = bond_ad_actor_sys_prio_tbl,
 476                 .set = bond_option_ad_actor_sys_prio_set,
 477         },
 478         [BOND_OPT_AD_ACTOR_SYSTEM] = {
 479                 .id = BOND_OPT_AD_ACTOR_SYSTEM,
 480                 .name = "ad_actor_system",
 481                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
 482                 .flags = BOND_OPTFLAG_RAWVAL,
 483                 .set = bond_option_ad_actor_system_set,
 484         },
 485         [BOND_OPT_AD_USER_PORT_KEY] = {
 486                 .id = BOND_OPT_AD_USER_PORT_KEY,
 487                 .name = "ad_user_port_key",
 488                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
 489                 .flags = BOND_OPTFLAG_IFDOWN,
 490                 .values = bond_ad_user_port_key_tbl,
 491                 .set = bond_option_ad_user_port_key_set,
 492         },
 493         [BOND_OPT_NUM_PEER_NOTIF_ALIAS] = {
 494                 .id = BOND_OPT_NUM_PEER_NOTIF_ALIAS,
 495                 .name = "num_grat_arp",
 496                 .desc = "Number of peer notifications to send on failover event",
 497                 .values = bond_num_peer_notif_tbl,
 498                 .set = bond_option_num_peer_notif_set
 499         },
 500         [BOND_OPT_PEER_NOTIF_DELAY] = {
 501                 .id = BOND_OPT_PEER_NOTIF_DELAY,
 502                 .name = "peer_notif_delay",
 503                 .desc = "Delay between each peer notification on failover event, in milliseconds",
 504                 .values = bond_peer_notif_delay_tbl,
 505                 .set = bond_option_peer_notif_delay_set
 506         },
 507         [BOND_OPT_COUPLED_CONTROL] = {
 508                 .id = BOND_OPT_COUPLED_CONTROL,
 509                 .name = "coupled_control",
 510                 .desc = "Opt into using coupled control MUX for LACP states",
 511                 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
 512                 .flags = BOND_OPTFLAG_IFDOWN,
 513                 .values = bond_coupled_control_tbl,
 514                 .set = bond_option_coupled_control_set,
 515         }
 516 };
 517
 518 /* Searches for an option by name */
 519 const struct bond_option *bond_opt_get_by_name(const char *name)
 520 {
 521         const struct bond_option *opt;
 522         int option;
 523
 524         for (option = 0; option < BOND_OPT_LAST; option++) {
 525                 opt = bond_opt_get(option);
 526                 if (opt && !strcmp(opt->name, name))
 527                         return opt;
 528         }
 529
 530         return NULL;
 531 }
 532
 533 /* Searches for a value in opt's values[] table */
 534 const struct bond_opt_value *bond_opt_get_val(unsigned int option, u64 val)
 535 {
 536         const struct bond_option *opt;
 537         int i;
 538
 539         opt = bond_opt_get(option);
 540         if (WARN_ON(!opt))
 541                 return NULL;
 542         for (i = 0; opt->values && opt->values[i].string; i++)
 543                 if (opt->values[i].value == val)
 544                         return &opt->values[i];
 545
 546         return NULL;
 547 }
 548
 549 /* Searches for a value in opt's values[] table which matches the flagmask */
 550 static const struct bond_opt_value *bond_opt_get_flags(const struct bond_option *opt,
 551                                                        u32 flagmask)
 552 {
 553         int i;
 554
 555         for (i = 0; opt->values && opt->values[i].string; i++)
 556                 if (opt->values[i].flags & flagmask)
 557                         return &opt->values[i];
 558
 559         return NULL;
 560 }
 561
 562 /* If maxval is missing then there's no range to check. In case minval is
 563  * missing then it's considered to be 0.
 564  */
 565 static bool bond_opt_check_range(const struct bond_option *opt, u64 val)
 566 {
 567         const struct bond_opt_value *minval, *maxval;
 568
 569         minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN);
 570         maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX);
 571         if (!maxval || (minval && val < minval->value) || val > maxval->value)
 572                 return false;
 573
 574         return true;
 575 }
 576
 577 /**
 578  * bond_opt_parse - parse option value
 579  * @opt: the option to parse against
 580  * @val: value to parse
 581  *
 582  * This function tries to extract the value from @val and check if it's
 583  * a possible match for the option and returns NULL if a match isn't found,
 584  * or the struct_opt_value that matched. It also strips the new line from
 585  * @val->string if it's present.
 586  */
 587 const struct bond_opt_value *bond_opt_parse(const struct bond_option *opt,
 588                                             struct bond_opt_value *val)
 589 {
 590         char *p, valstr[BOND_OPT_MAX_NAMELEN + 1] = { 0, };
 591         const struct bond_opt_value *tbl;
 592         const struct bond_opt_value *ret = NULL;
 593         bool checkval;
 594         int i, rv;
 595
 596         /* No parsing if the option wants a raw val */
 597         if (opt->flags & BOND_OPTFLAG_RAWVAL)
 598                 return val;
 599
 600         tbl = opt->values;
 601         if (!tbl)
 602                 goto out;
 603
 604         /* ULLONG_MAX is used to bypass string processing */
 605         checkval = val->value != ULLONG_MAX;
 606         if (!checkval) {
 607                 if (!val->string)
 608                         goto out;
 609                 p = strchr(val->string, '\n');
 610                 if (p)
 611                         *p = '\0';
 612                 for (p = val->string; *p; p++)
 613                         if (!(isdigit(*p) || isspace(*p)))
 614                                 break;
 615                 /* The following code extracts the string to match or the value
 616                  * and sets checkval appropriately
 617                  */
 618                 if (*p) {
 619                         rv = sscanf(val->string, "%32s", valstr);
 620                 } else {
 621                         rv = sscanf(val->string, "%llu", &val->value);
 622                         checkval = true;
 623                 }
 624                 if (!rv)
 625                         goto out;
 626         }
 627
 628         for (i = 0; tbl[i].string; i++) {
 629                 /* Check for exact match */
 630                 if (checkval) {
 631                         if (val->value == tbl[i].value)
 632                                 ret = &tbl[i];
 633                 } else {
 634                         if (!strcmp(valstr, "default") &&
 635                             (tbl[i].flags & BOND_VALFLAG_DEFAULT))
 636                                 ret = &tbl[i];
 637
 638                         if (!strcmp(valstr, tbl[i].string))
 639                                 ret = &tbl[i];
 640                 }
 641                 /* Found an exact match */
 642                 if (ret)
 643                         goto out;
 644         }
 645         /* Possible range match */
 646         if (checkval && bond_opt_check_range(opt, val->value))
 647                 ret = val;
 648 out:
 649         return ret;
 650 }
 651
 652 /* Check opt's dependencies against bond mode and currently set options */
 653 static int bond_opt_check_deps(struct bonding *bond,
 654                                const struct bond_option *opt)
 655 {
 656         struct bond_params *params = &bond->params;
 657
 658         if (test_bit(params->mode, &opt->unsuppmodes))
 659                 return -EACCES;
 660         if ((opt->flags & BOND_OPTFLAG_NOSLAVES) && bond_has_slaves(bond))
 661                 return -ENOTEMPTY;
 662         if ((opt->flags & BOND_OPTFLAG_IFDOWN) && (bond->dev->flags & IFF_UP))
 663                 return -EBUSY;
 664
 665         return 0;
 666 }
 667
 668 static void bond_opt_dep_print(struct bonding *bond,
 669                                const struct bond_option *opt,
 670                                struct nlattr *bad_attr,
 671                                struct netlink_ext_ack *extack)
 672 {
 673         const struct bond_opt_value *modeval;
 674         struct bond_params *params;
 675
 676         params = &bond->params;
 677         modeval = bond_opt_get_val(BOND_OPT_MODE, params->mode);
 678         if (test_bit(params->mode, &opt->unsuppmodes)) {
 679                 netdev_err(bond->dev, "option %s: mode dependency failed, not supported in mode %s(%llu)\n",
 680                            opt->name, modeval->string, modeval->value);
 681                 NL_SET_ERR_MSG_ATTR(extack, bad_attr,
 682                                     "option not supported in mode");
 683         }
 684 }
 685
 686 static void bond_opt_error_interpret(struct bonding *bond,
 687                                      const struct bond_option *opt,
 688                                      int error, const struct bond_opt_value *val,
 689                                      struct nlattr *bad_attr,
 690                                      struct netlink_ext_ack *extack)
 691 {
 692         const struct bond_opt_value *minval, *maxval;
 693         char *p;
 694
 695         switch (error) {
 696         case -EINVAL:
 697                 NL_SET_ERR_MSG_ATTR(extack, bad_attr, "invalid option value");
 698                 if (val) {
 699                         if (val->string) {
 700                                 /* sometimes RAWVAL opts may have new lines */
 701                                 p = strchr(val->string, '\n');
 702                                 if (p)
 703                                         *p = '\0';
 704                                 netdev_err(bond->dev, "option %s: invalid value (%s)\n",
 705                                            opt->name, val->string);
 706                         } else {
 707                                 netdev_err(bond->dev, "option %s: invalid value (%llu)\n",
 708                                            opt->name, val->value);
 709                         }
 710                 }
 711                 minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN);
 712                 maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX);
 713                 if (!maxval)
 714                         break;
 715                 netdev_err(bond->dev, "option %s: allowed values %llu - %llu\n",
 716                            opt->name, minval ? minval->value : 0, maxval->value);
 717                 break;
 718         case -EACCES:
 719                 bond_opt_dep_print(bond, opt, bad_attr, extack);
 720                 break;
 721         case -ENOTEMPTY:
 722                 NL_SET_ERR_MSG_ATTR(extack, bad_attr,
 723                                     "unable to set option because the bond device has slaves");
 724                 netdev_err(bond->dev, "option %s: unable to set because the bond device has slaves\n",
 725                            opt->name);
 726                 break;
 727         case -EBUSY:
 728                 NL_SET_ERR_MSG_ATTR(extack, bad_attr,
 729                                     "unable to set option because the bond is up");
 730                 netdev_err(bond->dev, "option %s: unable to set because the bond device is up\n",
 731                            opt->name);
 732                 break;
 733         case -ENODEV:
 734                 if (val && val->string) {
 735                         p = strchr(val->string, '\n');
 736                         if (p)
 737                                 *p = '\0';
 738                         netdev_err(bond->dev, "option %s: interface %s does not exist!\n",
 739                                    opt->name, val->string);
 740                         NL_SET_ERR_MSG_ATTR(extack, bad_attr,
 741                                             "interface does not exist");
 742                 }
 743                 break;
 744         default:
 745                 break;
 746         }
 747 }
 748
 749 /**
 750  * __bond_opt_set - set a bonding option
 751  * @bond: target bond device
 752  * @option: option to set
 753  * @val: value to set it to
 754  * @bad_attr: netlink attribue that caused the error
 755  * @extack: extended netlink error structure, used when an error message
 756  *          needs to be returned to the caller via netlink
 757  *
 758  * This function is used to change the bond's option value, it can be
 759  * used for both enabling/changing an option and for disabling it. RTNL lock
 760  * must be obtained before calling this function.
 761  */
 762 int __bond_opt_set(struct bonding *bond,
 763                    unsigned int option, struct bond_opt_value *val,
 764                    struct nlattr *bad_attr, struct netlink_ext_ack *extack)
 765 {
 766         const struct bond_opt_value *retval = NULL;
 767         const struct bond_option *opt;
 768         int ret = -ENOENT;
 769
 770         ASSERT_RTNL();
 771
 772         opt = bond_opt_get(option);
 773         if (WARN_ON(!val) || WARN_ON(!opt))
 774                 goto out;
 775         ret = bond_opt_check_deps(bond, opt);
 776         if (ret)
 777                 goto out;
 778         retval = bond_opt_parse(opt, val);
 779         if (!retval) {
 780                 ret = -EINVAL;
 781                 goto out;
 782         }
 783         ret = opt->set(bond, retval);
 784 out:
 785         if (ret)
 786                 bond_opt_error_interpret(bond, opt, ret, val, bad_attr, extack);
 787
 788         return ret;
 789 }
 790 /**
 791  * __bond_opt_set_notify - set a bonding option
 792  * @bond: target bond device
 793  * @option: option to set
 794  * @val: value to set it to
 795  *
 796  * This function is used to change the bond's option value and trigger
 797  * a notification to user sapce. It can be used for both enabling/changing
 798  * an option and for disabling it. RTNL lock must be obtained before calling
 799  * this function.
 800  */
 801 int __bond_opt_set_notify(struct bonding *bond,
 802                           unsigned int option, struct bond_opt_value *val)
 803 {
 804         int ret;
 805
 806         ASSERT_RTNL();
 807
 808         ret = __bond_opt_set(bond, option, val, NULL, NULL);
 809
 810         if (!ret && (bond->dev->reg_state == NETREG_REGISTERED))
 811                 call_netdevice_notifiers(NETDEV_CHANGEINFODATA, bond->dev);
 812
 813         return ret;
 814 }
 815
 816 /**
 817  * bond_opt_tryset_rtnl - try to acquire rtnl and call __bond_opt_set
 818  * @bond: target bond device
 819  * @option: option to set
 820  * @buf: value to set it to
 821  *
 822  * This function tries to acquire RTNL without blocking and if successful
 823  * calls __bond_opt_set. It is mainly used for sysfs option manipulation.
 824  */
 825 int bond_opt_tryset_rtnl(struct bonding *bond, unsigned int option, char *buf)
 826 {
 827         struct bond_opt_value optval;
 828         int ret;
 829
 830         if (!rtnl_trylock())
 831                 return restart_syscall();
 832         bond_opt_initstr(&optval, buf);
 833         ret = __bond_opt_set_notify(bond, option, &optval);
 834         rtnl_unlock();
 835
 836         return ret;
 837 }
 838
 839 /**
 840  * bond_opt_get - get a pointer to an option
 841  * @option: option for which to return a pointer
 842  *
 843  * This function checks if option is valid and if so returns a pointer
 844  * to its entry in the bond_opts[] option array.
 845  */
 846 const struct bond_option *bond_opt_get(unsigned int option)
 847 {
 848         if (!BOND_OPT_VALID(option))
 849                 return NULL;
 850
 851         return &bond_opts[option];
 852 }
 853
 854 static bool bond_set_xfrm_features(struct bonding *bond)
 855 {
 856         if (!IS_ENABLED(CONFIG_XFRM_OFFLOAD))
 857                 return false;
 858
 859         if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP)
 860                 bond->dev->wanted_features |= BOND_XFRM_FEATURES;
 861         else
 862                 bond->dev->wanted_features &= ~BOND_XFRM_FEATURES;
 863
 864         return true;
 865 }
 866
 867 static int bond_option_mode_set(struct bonding *bond,
 868                                 const struct bond_opt_value *newval)
 869 {
 870         if (!bond_mode_uses_arp(newval->value)) {
 871                 if (bond->params.arp_interval) {
 872                         netdev_dbg(bond->dev, "%s mode is incompatible with arp monitoring, start mii monitoring\n",
 873                                    newval->string);
 874                         /* disable arp monitoring */
 875                         bond->params.arp_interval = 0;
 876                 }
 877
 878                 if (!bond->params.miimon) {
 879                         /* set miimon to default value */
 880                         bond->params.miimon = BOND_DEFAULT_MIIMON;
 881                         netdev_dbg(bond->dev, "Setting MII monitoring interval to %d\n",
 882                                    bond->params.miimon);
 883                 }
 884         }
 885
 886         if (newval->value == BOND_MODE_ALB)
 887                 bond->params.tlb_dynamic_lb = 1;
 888
 889         /* don't cache arp_validate between modes */
 890         bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
 891         bond->params.mode = newval->value;
 892
 893         if (bond->dev->reg_state == NETREG_REGISTERED) {
 894                 bool update = false;
 895
 896                 update |= bond_set_xfrm_features(bond);
 897
 898                 if (update)
 899                         netdev_update_features(bond->dev);
 900         }
 901
 902         bond_xdp_set_features(bond->dev);
 903
 904         return 0;
 905 }
 906
 907 static int bond_option_active_slave_set(struct bonding *bond,
 908                                         const struct bond_opt_value *newval)
 909 {
 910         char ifname[IFNAMSIZ] = { 0, };
 911         struct net_device *slave_dev;
 912         int ret = 0;
 913
 914         sscanf(newval->string, "%15s", ifname); /* IFNAMSIZ */
 915         if (!strlen(ifname) || newval->string[0] == '\n') {
 916                 slave_dev = NULL;
 917         } else {
 918                 slave_dev = __dev_get_by_name(dev_net(bond->dev), ifname);
 919                 if (!slave_dev)
 920                         return -ENODEV;
 921         }
 922
 923         if (slave_dev) {
 924                 if (!netif_is_bond_slave(slave_dev)) {
 925                         slave_err(bond->dev, slave_dev, "Device is not bonding slave\n");
 926                         return -EINVAL;
 927                 }
 928
 929                 if (bond->dev != netdev_master_upper_dev_get(slave_dev)) {
 930                         slave_err(bond->dev, slave_dev, "Device is not our slave\n");
 931                         return -EINVAL;
 932                 }
 933         }
 934
 935         block_netpoll_tx();
 936         /* check to see if we are clearing active */
 937         if (!slave_dev) {
 938                 netdev_dbg(bond->dev, "Clearing current active slave\n");
 939                 RCU_INIT_POINTER(bond->curr_active_slave, NULL);
 940                 bond_select_active_slave(bond);
 941         } else {
 942                 struct slave *old_active = rtnl_dereference(bond->curr_active_slave);
 943                 struct slave *new_active = bond_slave_get_rtnl(slave_dev);
 944
 945                 BUG_ON(!new_active);
 946
 947                 if (new_active == old_active) {
 948                         /* do nothing */
 949                         slave_dbg(bond->dev, new_active->dev, "is already the current active slave\n");
 950                 } else {
 951                         if (old_active && (new_active->link == BOND_LINK_UP) &&
 952                             bond_slave_is_up(new_active)) {
 953                                 slave_dbg(bond->dev, new_active->dev, "Setting as active slave\n");
 954                                 bond_change_active_slave(bond, new_active);
 955                         } else {
 956                                 slave_err(bond->dev, new_active->dev, "Could not set as active slave; either %s is down or the link is down\n",
 957                                           new_active->dev->name);
 958                                 ret = -EINVAL;
 959                         }
 960                 }
 961         }
 962         unblock_netpoll_tx();
 963
 964         return ret;
 965 }
 966
 967 /* There are two tricky bits here.  First, if MII monitoring is activated, then
 968  * we must disable ARP monitoring.  Second, if the timer isn't running, we must
 969  * start it.
 970  */
 971 static int bond_option_miimon_set(struct bonding *bond,
 972                                   const struct bond_opt_value *newval)
 973 {
 974         netdev_dbg(bond->dev, "Setting MII monitoring interval to %llu\n",
 975                    newval->value);
 976         bond->params.miimon = newval->value;
 977         if (bond->params.updelay)
 978                 netdev_dbg(bond->dev, "Note: Updating updelay (to %d) since it is a multiple of the miimon value\n",
 979                            bond->params.updelay * bond->params.miimon);
 980         if (bond->params.downdelay)
 981                 netdev_dbg(bond->dev, "Note: Updating downdelay (to %d) since it is a multiple of the miimon value\n",
 982                            bond->params.downdelay * bond->params.miimon);
 983         if (bond->params.peer_notif_delay)
 984                 netdev_dbg(bond->dev, "Note: Updating peer_notif_delay (to %d) since it is a multiple of the miimon value\n",
 985                            bond->params.peer_notif_delay * bond->params.miimon);
 986         if (newval->value && bond->params.arp_interval) {
 987                 netdev_dbg(bond->dev, "MII monitoring cannot be used with ARP monitoring - disabling ARP monitoring...\n");
 988                 bond->params.arp_interval = 0;
 989                 if (bond->params.arp_validate)
 990                         bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
 991         }
 992         if (bond->dev->flags & IFF_UP) {
 993                 /* If the interface is up, we may need to fire off
 994                  * the MII timer. If the interface is down, the
 995                  * timer will get fired off when the open function
 996                  * is called.
 997                  */
 998                 if (!newval->value) {
 999                         cancel_delayed_work_sync(&bond->mii_work);
1000                 } else {
1001                         cancel_delayed_work_sync(&bond->arp_work);
1002                         queue_delayed_work(bond->wq, &bond->mii_work, 0);
1003                 }
1004         }
1005
1006         return 0;
1007 }
1008
1009 /* Set up, down and peer notification delays. These must be multiples
1010  * of the MII monitoring value, and are stored internally as the
1011  * multiplier. Thus, we must translate to MS for the real world.
1012  */
1013 static int _bond_option_delay_set(struct bonding *bond,
1014                                   const struct bond_opt_value *newval,
1015                                   const char *name,
1016                                   int *target)
1017 {
1018         int value = newval->value;
1019
1020         if (!bond->params.miimon) {
1021                 netdev_err(bond->dev, "Unable to set %s as MII monitoring is disabled\n",
1022                            name);
1023                 return -EPERM;
1024         }
1025         if ((value % bond->params.miimon) != 0) {
1026                 netdev_warn(bond->dev,
1027                             "%s (%d) is not a multiple of miimon (%d), value rounded to %d ms\n",
1028                             name,
1029                             value, bond->params.miimon,
1030                             (value / bond->params.miimon) *
1031                             bond->params.miimon);
1032         }
1033         *target = value / bond->params.miimon;
1034         netdev_dbg(bond->dev, "Setting %s to %d\n",
1035                    name,
1036                    *target * bond->params.miimon);
1037
1038         return 0;
1039 }
1040
1041 static int bond_option_updelay_set(struct bonding *bond,
1042                                    const struct bond_opt_value *newval)
1043 {
1044         return _bond_option_delay_set(bond, newval, "up delay",
1045                                       &bond->params.updelay);
1046 }
1047
1048 static int bond_option_downdelay_set(struct bonding *bond,
1049                                      const struct bond_opt_value *newval)
1050 {
1051         return _bond_option_delay_set(bond, newval, "down delay",
1052                                       &bond->params.downdelay);
1053 }
1054
1055 static int bond_option_peer_notif_delay_set(struct bonding *bond,
1056                                             const struct bond_opt_value *newval)
1057 {
1058         int ret = _bond_option_delay_set(bond, newval,
1059                                          "peer notification delay",
1060                                          &bond->params.peer_notif_delay);
1061         return ret;
1062 }
1063
1064 static int bond_option_use_carrier_set(struct bonding *bond,
1065                                        const struct bond_opt_value *newval)
1066 {
1067         netdev_dbg(bond->dev, "Setting use_carrier to %llu\n",
1068                    newval->value);
1069         bond->params.use_carrier = newval->value;
1070
1071         return 0;
1072 }
1073
1074 /* There are two tricky bits here.  First, if ARP monitoring is activated, then
1075  * we must disable MII monitoring.  Second, if the ARP timer isn't running,
1076  * we must start it.
1077  */
1078 static int bond_option_arp_interval_set(struct bonding *bond,
1079                                         const struct bond_opt_value *newval)
1080 {
1081         netdev_dbg(bond->dev, "Setting ARP monitoring interval to %llu\n",
1082                    newval->value);
1083         bond->params.arp_interval = newval->value;
1084         if (newval->value) {
1085                 if (bond->params.miimon) {
1086                         netdev_dbg(bond->dev, "ARP monitoring cannot be used with MII monitoring. Disabling MII monitoring\n");
1087                         bond->params.miimon = 0;
1088                 }
1089                 if (!bond->params.arp_targets[0])
1090                         netdev_dbg(bond->dev, "ARP monitoring has been set up, but no ARP targets have been specified\n");
1091         }
1092         if (bond->dev->flags & IFF_UP) {
1093                 /* If the interface is up, we may need to fire off
1094                  * the ARP timer.  If the interface is down, the
1095                  * timer will get fired off when the open function
1096                  * is called.
1097                  */
1098                 if (!newval->value) {
1099                         if (bond->params.arp_validate)
1100                                 bond->recv_probe = NULL;
1101                         cancel_delayed_work_sync(&bond->arp_work);
1102                 } else {
1103                         /* arp_validate can be set only in active-backup mode */
1104                         bond->recv_probe = bond_rcv_validate;
1105                         cancel_delayed_work_sync(&bond->mii_work);
1106                         queue_delayed_work(bond->wq, &bond->arp_work, 0);
1107                 }
1108         }
1109
1110         return 0;
1111 }
1112
1113 static void _bond_options_arp_ip_target_set(struct bonding *bond, int slot,
1114                                             __be32 target,
1115                                             unsigned long last_rx)
1116 {
1117         __be32 *targets = bond->params.arp_targets;
1118         struct list_head *iter;
1119         struct slave *slave;
1120
1121         if (slot >= 0 && slot < BOND_MAX_ARP_TARGETS) {
1122                 bond_for_each_slave(bond, slave, iter)
1123                         slave->target_last_arp_rx[slot] = last_rx;
1124                 targets[slot] = target;
1125         }
1126 }
1127
1128 static int _bond_option_arp_ip_target_add(struct bonding *bond, __be32 target)
1129 {
1130         __be32 *targets = bond->params.arp_targets;
1131         int ind;
1132
1133         if (!bond_is_ip_target_ok(target)) {
1134                 netdev_err(bond->dev, "invalid ARP target %pI4 specified for addition\n",
1135                            &target);
1136                 return -EINVAL;
1137         }
1138
1139         if (bond_get_targets_ip(targets, target) != -1) { /* dup */
1140                 netdev_err(bond->dev, "ARP target %pI4 is already present\n",
1141                            &target);
1142                 return -EINVAL;
1143         }
1144
1145         ind = bond_get_targets_ip(targets, 0); /* first free slot */
1146         if (ind == -1) {
1147                 netdev_err(bond->dev, "ARP target table is full!\n");
1148                 return -EINVAL;
1149         }
1150
1151         netdev_dbg(bond->dev, "Adding ARP target %pI4\n", &target);
1152
1153         _bond_options_arp_ip_target_set(bond, ind, target, jiffies);
1154
1155         return 0;
1156 }
1157
1158 static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target)
1159 {
1160         return _bond_option_arp_ip_target_add(bond, target);
1161 }
1162
1163 static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target)
1164 {
1165         __be32 *targets = bond->params.arp_targets;
1166         struct list_head *iter;
1167         struct slave *slave;
1168         unsigned long *targets_rx;
1169         int ind, i;
1170
1171         if (!bond_is_ip_target_ok(target)) {
1172                 netdev_err(bond->dev, "invalid ARP target %pI4 specified for removal\n",
1173                            &target);
1174                 return -EINVAL;
1175         }
1176
1177         ind = bond_get_targets_ip(targets, target);
1178         if (ind == -1) {
1179                 netdev_err(bond->dev, "unable to remove nonexistent ARP target %pI4\n",
1180                            &target);
1181                 return -EINVAL;
1182         }
1183
1184         if (ind == 0 && !targets[1] && bond->params.arp_interval)
1185                 netdev_warn(bond->dev, "Removing last arp target with arp_interval on\n");
1186
1187         netdev_dbg(bond->dev, "Removing ARP target %pI4\n", &target);
1188
1189         bond_for_each_slave(bond, slave, iter) {
1190                 targets_rx = slave->target_last_arp_rx;
1191                 for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++)
1192                         targets_rx[i] = targets_rx[i+1];
1193                 targets_rx[i] = 0;
1194         }
1195         for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++)
1196                 targets[i] = targets[i+1];
1197         targets[i] = 0;
1198
1199         return 0;
1200 }
1201
1202 void bond_option_arp_ip_targets_clear(struct bonding *bond)
1203 {
1204         int i;
1205
1206         for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
1207                 _bond_options_arp_ip_target_set(bond, i, 0, 0);
1208 }
1209
1210 static int bond_option_arp_ip_targets_set(struct bonding *bond,
1211                                           const struct bond_opt_value *newval)
1212 {
1213         int ret = -EPERM;
1214         __be32 target;
1215
1216         if (newval->string) {
1217                 if (!in4_pton(newval->string+1, -1, (u8 *)&target, -1, NULL)) {
1218                         netdev_err(bond->dev, "invalid ARP target %pI4 specified\n",
1219                                    &target);
1220                         return ret;
1221                 }
1222                 if (newval->string[0] == '+')
1223                         ret = bond_option_arp_ip_target_add(bond, target);
1224                 else if (newval->string[0] == '-')
1225                         ret = bond_option_arp_ip_target_rem(bond, target);
1226                 else
1227                         netdev_err(bond->dev, "no command found in arp_ip_targets file - use +<addr> or -<addr>\n");
1228         } else {
1229                 target = newval->value;
1230                 ret = bond_option_arp_ip_target_add(bond, target);
1231         }
1232
1233         return ret;
1234 }
1235
1236 #if IS_ENABLED(CONFIG_IPV6)
1237 static void _bond_options_ns_ip6_target_set(struct bonding *bond, int slot,
1238                                             struct in6_addr *target,
1239                                             unsigned long last_rx)
1240 {
1241         struct in6_addr *targets = bond->params.ns_targets;
1242         struct list_head *iter;
1243         struct slave *slave;
1244
1245         if (slot >= 0 && slot < BOND_MAX_NS_TARGETS) {
1246                 bond_for_each_slave(bond, slave, iter)
1247                         slave->target_last_arp_rx[slot] = last_rx;
1248                 targets[slot] = *target;
1249         }
1250 }
1251
1252 void bond_option_ns_ip6_targets_clear(struct bonding *bond)
1253 {
1254         struct in6_addr addr_any = in6addr_any;
1255         int i;
1256
1257         for (i = 0; i < BOND_MAX_NS_TARGETS; i++)
1258                 _bond_options_ns_ip6_target_set(bond, i, &addr_any, 0);
1259 }
1260
1261 static int bond_option_ns_ip6_targets_set(struct bonding *bond,
1262                                           const struct bond_opt_value *newval)
1263 {
1264         struct in6_addr *target = (struct in6_addr *)newval->extra;
1265         struct in6_addr *targets = bond->params.ns_targets;
1266         struct in6_addr addr_any = in6addr_any;
1267         int index;
1268
1269         if (!bond_is_ip6_target_ok(target)) {
1270                 netdev_err(bond->dev, "invalid NS target %pI6c specified for addition\n",
1271                            target);
1272                 return -EINVAL;
1273         }
1274
1275         if (bond_get_targets_ip6(targets, target) != -1) { /* dup */
1276                 netdev_err(bond->dev, "NS target %pI6c is already present\n",
1277                            target);
1278                 return -EINVAL;
1279         }
1280
1281         index = bond_get_targets_ip6(targets, &addr_any); /* first free slot */
1282         if (index == -1) {
1283                 netdev_err(bond->dev, "NS target table is full!\n");
1284                 return -EINVAL;
1285         }
1286
1287         netdev_dbg(bond->dev, "Adding NS target %pI6c\n", target);
1288
1289         _bond_options_ns_ip6_target_set(bond, index, target, jiffies);
1290
1291         return 0;
1292 }
1293 #else
1294 static int bond_option_ns_ip6_targets_set(struct bonding *bond,
1295                                           const struct bond_opt_value *newval)
1296 {
1297         return -EPERM;
1298 }
1299 #endif
1300
1301 static int bond_option_arp_validate_set(struct bonding *bond,
1302                                         const struct bond_opt_value *newval)
1303 {
1304         netdev_dbg(bond->dev, "Setting arp_validate to %s (%llu)\n",
1305                    newval->string, newval->value);
1306         bond->params.arp_validate = newval->value;
1307
1308         return 0;
1309 }
1310
1311 static int bond_option_arp_all_targets_set(struct bonding *bond,
1312                                            const struct bond_opt_value *newval)
1313 {
1314         netdev_dbg(bond->dev, "Setting arp_all_targets to %s (%llu)\n",
1315                    newval->string, newval->value);
1316         bond->params.arp_all_targets = newval->value;
1317
1318         return 0;
1319 }
1320
1321 static int bond_option_missed_max_set(struct bonding *bond,
1322                                       const struct bond_opt_value *newval)
1323 {
1324         netdev_dbg(bond->dev, "Setting missed max to %s (%llu)\n",
1325                    newval->string, newval->value);
1326         bond->params.missed_max = newval->value;
1327
1328         return 0;
1329 }
1330
1331 static int bond_option_prio_set(struct bonding *bond,
1332                                 const struct bond_opt_value *newval)
1333 {
1334         struct slave *slave;
1335
1336         slave = bond_slave_get_rtnl(newval->slave_dev);
1337         if (!slave) {
1338                 netdev_dbg(newval->slave_dev, "%s called on NULL slave\n", __func__);
1339                 return -ENODEV;
1340         }
1341         slave->prio = newval->value;
1342
1343         if (rtnl_dereference(bond->primary_slave))
1344                 slave_warn(bond->dev, slave->dev,
1345                            "prio updated, but will not affect failover re-selection as primary slave have been set\n");
1346         else
1347                 bond_select_active_slave(bond);
1348
1349         return 0;
1350 }
1351
1352 static int bond_option_primary_set(struct bonding *bond,
1353                                    const struct bond_opt_value *newval)
1354 {
1355         char *p, *primary = newval->string;
1356         struct list_head *iter;
1357         struct slave *slave;
1358
1359         block_netpoll_tx();
1360
1361         p = strchr(primary, '\n');
1362         if (p)
1363                 *p = '\0';
1364         /* check to see if we are clearing primary */
1365         if (!strlen(primary)) {
1366                 netdev_dbg(bond->dev, "Setting primary slave to None\n");
1367                 RCU_INIT_POINTER(bond->primary_slave, NULL);
1368                 memset(bond->params.primary, 0, sizeof(bond->params.primary));
1369                 bond_select_active_slave(bond);
1370                 goto out;
1371         }
1372
1373         bond_for_each_slave(bond, slave, iter) {
1374                 if (strncmp(slave->dev->name, primary, IFNAMSIZ) == 0) {
1375                         slave_dbg(bond->dev, slave->dev, "Setting as primary slave\n");
1376                         rcu_assign_pointer(bond->primary_slave, slave);
1377                         strcpy(bond->params.primary, slave->dev->name);
1378                         bond->force_primary = true;
1379                         bond_select_active_slave(bond);
1380                         goto out;
1381                 }
1382         }
1383
1384         if (rtnl_dereference(bond->primary_slave)) {
1385                 netdev_dbg(bond->dev, "Setting primary slave to None\n");
1386                 RCU_INIT_POINTER(bond->primary_slave, NULL);
1387                 bond_select_active_slave(bond);
1388         }
1389         strscpy_pad(bond->params.primary, primary, IFNAMSIZ);
1390
1391         netdev_dbg(bond->dev, "Recording %s as primary, but it has not been enslaved yet\n",
1392                    primary);
1393
1394 out:
1395         unblock_netpoll_tx();
1396
1397         return 0;
1398 }
1399
1400 static int bond_option_primary_reselect_set(struct bonding *bond,
1401                                             const struct bond_opt_value *newval)
1402 {
1403         netdev_dbg(bond->dev, "Setting primary_reselect to %s (%llu)\n",
1404                    newval->string, newval->value);
1405         bond->params.primary_reselect = newval->value;
1406
1407         block_netpoll_tx();
1408         bond_select_active_slave(bond);
1409         unblock_netpoll_tx();
1410
1411         return 0;
1412 }
1413
1414 static int bond_option_fail_over_mac_set(struct bonding *bond,
1415                                          const struct bond_opt_value *newval)
1416 {
1417         netdev_dbg(bond->dev, "Setting fail_over_mac to %s (%llu)\n",
1418                    newval->string, newval->value);
1419         bond->params.fail_over_mac = newval->value;
1420
1421         return 0;
1422 }
1423
1424 static int bond_option_xmit_hash_policy_set(struct bonding *bond,
1425                                             const struct bond_opt_value *newval)
1426 {
1427         netdev_dbg(bond->dev, "Setting xmit hash policy to %s (%llu)\n",
1428                    newval->string, newval->value);
1429         bond->params.xmit_policy = newval->value;
1430
1431         return 0;
1432 }
1433
1434 static int bond_option_resend_igmp_set(struct bonding *bond,
1435                                        const struct bond_opt_value *newval)
1436 {
1437         netdev_dbg(bond->dev, "Setting resend_igmp to %llu\n",
1438                    newval->value);
1439         bond->params.resend_igmp = newval->value;
1440
1441         return 0;
1442 }
1443
1444 static int bond_option_num_peer_notif_set(struct bonding *bond,
1445                                    const struct bond_opt_value *newval)
1446 {
1447         bond->params.num_peer_notif = newval->value;
1448
1449         return 0;
1450 }
1451
1452 static int bond_option_all_slaves_active_set(struct bonding *bond,
1453                                              const struct bond_opt_value *newval)
1454 {
1455         struct list_head *iter;
1456         struct slave *slave;
1457
1458         if (newval->value == bond->params.all_slaves_active)
1459                 return 0;
1460         bond->params.all_slaves_active = newval->value;
1461         bond_for_each_slave(bond, slave, iter) {
1462                 if (!bond_is_active_slave(slave)) {
1463                         if (newval->value)
1464                                 slave->inactive = 0;
1465                         else
1466                                 slave->inactive = 1;
1467                 }
1468         }
1469
1470         return 0;
1471 }
1472
1473 static int bond_option_min_links_set(struct bonding *bond,
1474                                      const struct bond_opt_value *newval)
1475 {
1476         netdev_dbg(bond->dev, "Setting min links value to %llu\n",
1477                    newval->value);
1478         bond->params.min_links = newval->value;
1479         bond_set_carrier(bond);
1480
1481         return 0;
1482 }
1483
1484 static int bond_option_lp_interval_set(struct bonding *bond,
1485                                        const struct bond_opt_value *newval)
1486 {
1487         bond->params.lp_interval = newval->value;
1488
1489         return 0;
1490 }
1491
1492 static int bond_option_pps_set(struct bonding *bond,
1493                                const struct bond_opt_value *newval)
1494 {
1495         netdev_dbg(bond->dev, "Setting packets per slave to %llu\n",
1496                    newval->value);
1497         bond->params.packets_per_slave = newval->value;
1498         if (newval->value > 0) {
1499                 bond->params.reciprocal_packets_per_slave =
1500                         reciprocal_value(newval->value);
1501         } else {
1502                 /* reciprocal_packets_per_slave is unused if
1503                  * packets_per_slave is 0 or 1, just initialize it
1504                  */
1505                 bond->params.reciprocal_packets_per_slave =
1506                         (struct reciprocal_value) { 0 };
1507         }
1508
1509         return 0;
1510 }
1511
1512 static int bond_option_lacp_active_set(struct bonding *bond,
1513                                        const struct bond_opt_value *newval)
1514 {
1515         netdev_dbg(bond->dev, "Setting LACP active to %s (%llu)\n",
1516                    newval->string, newval->value);
1517         bond->params.lacp_active = newval->value;
1518
1519         return 0;
1520 }
1521
1522 static int bond_option_lacp_rate_set(struct bonding *bond,
1523                                      const struct bond_opt_value *newval)
1524 {
1525         netdev_dbg(bond->dev, "Setting LACP rate to %s (%llu)\n",
1526                    newval->string, newval->value);
1527         bond->params.lacp_fast = newval->value;
1528         bond_3ad_update_lacp_rate(bond);
1529
1530         return 0;
1531 }
1532
1533 static int bond_option_ad_select_set(struct bonding *bond,
1534                                      const struct bond_opt_value *newval)
1535 {
1536         netdev_dbg(bond->dev, "Setting ad_select to %s (%llu)\n",
1537                    newval->string, newval->value);
1538         bond->params.ad_select = newval->value;
1539
1540         return 0;
1541 }
1542
1543 static int bond_option_queue_id_set(struct bonding *bond,
1544                                     const struct bond_opt_value *newval)
1545 {
1546         struct slave *slave, *update_slave;
1547         struct net_device *sdev;
1548         struct list_head *iter;
1549         char *delim;
1550         int ret = 0;
1551         u16 qid;
1552
1553         /* delim will point to queue id if successful */
1554         delim = strchr(newval->string, ':');
1555         if (!delim)
1556                 goto err_no_cmd;
1557
1558         /* Terminate string that points to device name and bump it
1559          * up one, so we can read the queue id there.
1560          */
1561         *delim = '\0';
1562         if (sscanf(++delim, "%hd\n", &qid) != 1)
1563                 goto err_no_cmd;
1564
1565         /* Check buffer length, valid ifname and queue id */
1566         if (!dev_valid_name(newval->string) ||
1567             qid > bond->dev->real_num_tx_queues)
1568                 goto err_no_cmd;
1569
1570         /* Get the pointer to that interface if it exists */
1571         sdev = __dev_get_by_name(dev_net(bond->dev), newval->string);
1572         if (!sdev)
1573                 goto err_no_cmd;
1574
1575         /* Search for thes slave and check for duplicate qids */
1576         update_slave = NULL;
1577         bond_for_each_slave(bond, slave, iter) {
1578                 if (sdev == slave->dev)
1579                         /* We don't need to check the matching
1580                          * slave for dups, since we're overwriting it
1581                          */
1582                         update_slave = slave;
1583                 else if (qid && qid == slave->queue_id) {
1584                         goto err_no_cmd;
1585                 }
1586         }
1587
1588         if (!update_slave)
1589                 goto err_no_cmd;
1590
1591         /* Actually set the qids for the slave */
1592         update_slave->queue_id = qid;
1593
1594 out:
1595         return ret;
1596
1597 err_no_cmd:
1598         netdev_dbg(bond->dev, "invalid input for queue_id set\n");
1599         ret = -EPERM;
1600         goto out;
1601
1602 }
1603
1604 static int bond_option_slaves_set(struct bonding *bond,
1605                                   const struct bond_opt_value *newval)
1606 {
1607         char command[IFNAMSIZ + 1] = { 0, };
1608         struct net_device *dev;
1609         char *ifname;
1610         int ret;
1611
1612         sscanf(newval->string, "%16s", command); /* IFNAMSIZ*/
1613         ifname = command + 1;
1614         if ((strlen(command) <= 1) ||
1615             (command[0] != '+' && command[0] != '-') ||
1616             !dev_valid_name(ifname))
1617                 goto err_no_cmd;
1618
1619         dev = __dev_get_by_name(dev_net(bond->dev), ifname);
1620         if (!dev) {
1621                 netdev_dbg(bond->dev, "interface %s does not exist!\n",
1622                            ifname);
1623                 ret = -ENODEV;
1624                 goto out;
1625         }
1626
1627         switch (command[0]) {
1628         case '+':
1629                 slave_dbg(bond->dev, dev, "Enslaving interface\n");
1630                 ret = bond_enslave(bond->dev, dev, NULL);
1631                 break;
1632
1633         case '-':
1634                 slave_dbg(bond->dev, dev, "Releasing interface\n");
1635                 ret = bond_release(bond->dev, dev);
1636                 break;
1637
1638         default:
1639                 /* should not run here. */
1640                 goto err_no_cmd;
1641         }
1642
1643 out:
1644         return ret;
1645
1646 err_no_cmd:
1647         netdev_err(bond->dev, "no command found in slaves file - use +ifname or -ifname\n");
1648         ret = -EPERM;
1649         goto out;
1650 }
1651
1652 static int bond_option_tlb_dynamic_lb_set(struct bonding *bond,
1653                                           const struct bond_opt_value *newval)
1654 {
1655         netdev_dbg(bond->dev, "Setting dynamic-lb to %s (%llu)\n",
1656                    newval->string, newval->value);
1657         bond->params.tlb_dynamic_lb = newval->value;
1658
1659         return 0;
1660 }
1661
1662 static int bond_option_ad_actor_sys_prio_set(struct bonding *bond,
1663                                              const struct bond_opt_value *newval)
1664 {
1665         netdev_dbg(bond->dev, "Setting ad_actor_sys_prio to %llu\n",
1666                    newval->value);
1667
1668         bond->params.ad_actor_sys_prio = newval->value;
1669         bond_3ad_update_ad_actor_settings(bond);
1670
1671         return 0;
1672 }
1673
1674 static int bond_option_ad_actor_system_set(struct bonding *bond,
1675                                            const struct bond_opt_value *newval)
1676 {
1677         u8 macaddr[ETH_ALEN];
1678         u8 *mac;
1679
1680         if (newval->string) {
1681                 if (!mac_pton(newval->string, macaddr))
1682                         goto err;
1683                 mac = macaddr;
1684         } else {
1685                 mac = (u8 *)&newval->value;
1686         }
1687
1688         if (is_multicast_ether_addr(mac))
1689                 goto err;
1690
1691         netdev_dbg(bond->dev, "Setting ad_actor_system to %pM\n", mac);
1692         ether_addr_copy(bond->params.ad_actor_system, mac);
1693         bond_3ad_update_ad_actor_settings(bond);
1694
1695         return 0;
1696
1697 err:
1698         netdev_err(bond->dev, "Invalid ad_actor_system MAC address.\n");
1699         return -EINVAL;
1700 }
1701
1702 static int bond_option_ad_user_port_key_set(struct bonding *bond,
1703                                             const struct bond_opt_value *newval)
1704 {
1705         netdev_dbg(bond->dev, "Setting ad_user_port_key to %llu\n",
1706                    newval->value);
1707
1708         bond->params.ad_user_port_key = newval->value;
1709         return 0;
1710 }
1711
1712 static int bond_option_coupled_control_set(struct bonding *bond,
1713                                            const struct bond_opt_value *newval)
1714 {
1715         netdev_info(bond->dev, "Setting coupled_control to %s (%llu)\n",
1716                     newval->string, newval->value);
1717
1718         bond->params.coupled_control = newval->value;
1719         return 0;
1720 }