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