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