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 
19 static int bond_option_active_slave_set(struct bonding *bond,
20 					const struct bond_opt_value *newval);
21 static int bond_option_miimon_set(struct bonding *bond,
22 				  const struct bond_opt_value *newval);
23 static int bond_option_updelay_set(struct bonding *bond,
24 				   const struct bond_opt_value *newval);
25 static int bond_option_downdelay_set(struct bonding *bond,
26 				     const struct bond_opt_value *newval);
27 static int bond_option_peer_notif_delay_set(struct bonding *bond,
28 					    const struct bond_opt_value *newval);
29 static int bond_option_use_carrier_set(struct bonding *bond,
30 				       const struct bond_opt_value *newval);
31 static int bond_option_arp_interval_set(struct bonding *bond,
32 					const struct bond_opt_value *newval);
33 static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target);
34 static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target);
35 static int bond_option_arp_ip_targets_set(struct bonding *bond,
36 					  const struct bond_opt_value *newval);
37 static int bond_option_ns_ip6_targets_set(struct bonding *bond,
38 					  const struct bond_opt_value *newval);
39 static int bond_option_arp_validate_set(struct bonding *bond,
40 					const struct bond_opt_value *newval);
41 static int bond_option_arp_all_targets_set(struct bonding *bond,
42 					   const struct bond_opt_value *newval);
43 static int bond_option_prio_set(struct bonding *bond,
44 				const struct bond_opt_value *newval);
45 static int bond_option_primary_set(struct bonding *bond,
46 				   const struct bond_opt_value *newval);
47 static int bond_option_primary_reselect_set(struct bonding *bond,
48 					    const struct bond_opt_value *newval);
49 static int bond_option_fail_over_mac_set(struct bonding *bond,
50 					 const struct bond_opt_value *newval);
51 static int bond_option_xmit_hash_policy_set(struct bonding *bond,
52 					    const struct bond_opt_value *newval);
53 static int bond_option_resend_igmp_set(struct bonding *bond,
54 				       const struct bond_opt_value *newval);
55 static int bond_option_num_peer_notif_set(struct bonding *bond,
56 					  const struct bond_opt_value *newval);
57 static int bond_option_all_slaves_active_set(struct bonding *bond,
58 					     const struct bond_opt_value *newval);
59 static int bond_option_min_links_set(struct bonding *bond,
60 				     const struct bond_opt_value *newval);
61 static int bond_option_lp_interval_set(struct bonding *bond,
62 				       const struct bond_opt_value *newval);
63 static int bond_option_pps_set(struct bonding *bond,
64 			       const struct bond_opt_value *newval);
65 static int bond_option_lacp_active_set(struct bonding *bond,
66 				       const struct bond_opt_value *newval);
67 static int bond_option_lacp_rate_set(struct bonding *bond,
68 				     const struct bond_opt_value *newval);
69 static int bond_option_ad_select_set(struct bonding *bond,
70 				     const struct bond_opt_value *newval);
71 static int bond_option_queue_id_set(struct bonding *bond,
72 				    const struct bond_opt_value *newval);
73 static int bond_option_mode_set(struct bonding *bond,
74 				const struct bond_opt_value *newval);
75 static int bond_option_slaves_set(struct bonding *bond,
76 				  const struct bond_opt_value *newval);
77 static int bond_option_tlb_dynamic_lb_set(struct bonding *bond,
78 				  const struct bond_opt_value *newval);
79 static int bond_option_ad_actor_sys_prio_set(struct bonding *bond,
80 					     const struct bond_opt_value *newval);
81 static int bond_option_ad_actor_system_set(struct bonding *bond,
82 					   const struct bond_opt_value *newval);
83 static int bond_option_ad_user_port_key_set(struct bonding *bond,
84 					    const struct bond_opt_value *newval);
85 static int bond_option_missed_max_set(struct bonding *bond,
86 				      const struct bond_opt_value *newval);
87 
88 
89 static 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 
100 static 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 
106 static 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 
116 static 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 
127 static 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 
133 static 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 
140 static 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 
146 static const struct bond_opt_value bond_lacp_active[] = {
147 	{ "off", 0,  0},
148 	{ "on",  1,  BOND_VALFLAG_DEFAULT},
149 	{ NULL,  -1, 0}
150 };
151 
152 static 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 
158 static 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 
165 static 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 
172 static 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 
178 static 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 
185 static 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 
191 static 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 
197 static 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 
204 static 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 
210 static 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 
216 static 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 
222 static 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 
228 static 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 
235 static 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 */
503 const 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 */
518 const 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 */
534 static 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  */
549 static 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  */
571 const 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;
632 out:
633 	return ret;
634 }
635 
636 /* Check opt's dependencies against bond mode and currently set options */
637 static 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 
652 static 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 
670 static 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  */
746 int __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);
768 out:
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  */
785 int __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  */
809 int 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  */
830 const 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 
838 static 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 
851 static 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 
891 static 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  */
955 static 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  */
997 static 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 
1025 static 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 
1032 static 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 
1039 static 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 
1048 static 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  */
1062 static 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 
1097 static 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 
1112 static 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 
1142 static 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 
1147 static 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 
1186 void 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 
1194 static 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)
1221 static 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 
1236 void 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 
1245 static 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
1278 static 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 
1285 static 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 
1295 static 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 
1305 static 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 
1315 static 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 
1336 static 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 
1378 out:
1379 	unblock_netpoll_tx();
1380 
1381 	return 0;
1382 }
1383 
1384 static 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 
1398 static 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 
1408 static 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 
1418 static 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 
1428 static 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 
1436 static 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 
1457 static 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 
1468 static 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 
1476 static 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 
1496 static 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 
1506 static 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 
1517 static 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 
1527 static 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 
1578 out:
1579 	return ret;
1580 
1581 err_no_cmd:
1582 	netdev_dbg(bond->dev, "invalid input for queue_id set\n");
1583 	ret = -EPERM;
1584 	goto out;
1585 
1586 }
1587 
1588 static 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 
1627 out:
1628 	return ret;
1629 
1630 err_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 
1636 static 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 
1646 static 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 
1658 static 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 
1681 err:
1682 	netdev_err(bond->dev, "Invalid ad_actor_system MAC address.\n");
1683 	return -EINVAL;
1684 }
1685 
1686 static 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 }
1695