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