cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

bond_options.c (47821B)


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