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