2 * drivers/net/bond/bond_options.c - bonding options
3 * Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us>
4 * Copyright (c) 2013 Scott Feldman <sfeldma@cumulusnetworks.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/errno.h>
16 #include <linux/netdevice.h>
17 #include <linux/spinlock.h>
18 #include <linux/rcupdate.h>
19 #include <linux/ctype.h>
20 #include <linux/inet.h>
23 static int bond_option_active_slave_set(struct bonding
*bond
,
24 const struct bond_opt_value
*newval
);
25 static int bond_option_miimon_set(struct bonding
*bond
,
26 const struct bond_opt_value
*newval
);
27 static int bond_option_updelay_set(struct bonding
*bond
,
28 const struct bond_opt_value
*newval
);
29 static int bond_option_downdelay_set(struct bonding
*bond
,
30 const struct bond_opt_value
*newval
);
31 static int bond_option_use_carrier_set(struct bonding
*bond
,
32 const struct bond_opt_value
*newval
);
33 static int bond_option_arp_interval_set(struct bonding
*bond
,
34 const struct bond_opt_value
*newval
);
35 static int bond_option_arp_ip_target_add(struct bonding
*bond
, __be32 target
);
36 static int bond_option_arp_ip_target_rem(struct bonding
*bond
, __be32 target
);
37 static int bond_option_arp_ip_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_primary_set(struct bonding
*bond
,
44 const struct bond_opt_value
*newval
);
45 static int bond_option_primary_reselect_set(struct bonding
*bond
,
46 const struct bond_opt_value
*newval
);
47 static int bond_option_fail_over_mac_set(struct bonding
*bond
,
48 const struct bond_opt_value
*newval
);
49 static int bond_option_xmit_hash_policy_set(struct bonding
*bond
,
50 const struct bond_opt_value
*newval
);
51 static int bond_option_resend_igmp_set(struct bonding
*bond
,
52 const struct bond_opt_value
*newval
);
53 static int bond_option_num_peer_notif_set(struct bonding
*bond
,
54 const struct bond_opt_value
*newval
);
55 static int bond_option_all_slaves_active_set(struct bonding
*bond
,
56 const struct bond_opt_value
*newval
);
57 static int bond_option_min_links_set(struct bonding
*bond
,
58 const struct bond_opt_value
*newval
);
59 static int bond_option_lp_interval_set(struct bonding
*bond
,
60 const struct bond_opt_value
*newval
);
61 static int bond_option_pps_set(struct bonding
*bond
,
62 const struct bond_opt_value
*newval
);
63 static int bond_option_lacp_rate_set(struct bonding
*bond
,
64 const struct bond_opt_value
*newval
);
65 static int bond_option_ad_select_set(struct bonding
*bond
,
66 const struct bond_opt_value
*newval
);
67 static int bond_option_queue_id_set(struct bonding
*bond
,
68 const struct bond_opt_value
*newval
);
69 static int bond_option_mode_set(struct bonding
*bond
,
70 const struct bond_opt_value
*newval
);
71 static int bond_option_slaves_set(struct bonding
*bond
,
72 const struct bond_opt_value
*newval
);
73 static int bond_option_tlb_dynamic_lb_set(struct bonding
*bond
,
74 const struct bond_opt_value
*newval
);
77 static const struct bond_opt_value bond_mode_tbl
[] = {
78 { "balance-rr", BOND_MODE_ROUNDROBIN
, BOND_VALFLAG_DEFAULT
},
79 { "active-backup", BOND_MODE_ACTIVEBACKUP
, 0},
80 { "balance-xor", BOND_MODE_XOR
, 0},
81 { "broadcast", BOND_MODE_BROADCAST
, 0},
82 { "802.3ad", BOND_MODE_8023AD
, 0},
83 { "balance-tlb", BOND_MODE_TLB
, 0},
84 { "balance-alb", BOND_MODE_ALB
, 0},
88 static const struct bond_opt_value bond_pps_tbl
[] = {
89 { "default", 1, BOND_VALFLAG_DEFAULT
},
90 { "maxval", USHRT_MAX
, BOND_VALFLAG_MAX
},
94 static const struct bond_opt_value bond_xmit_hashtype_tbl
[] = {
95 { "layer2", BOND_XMIT_POLICY_LAYER2
, BOND_VALFLAG_DEFAULT
},
96 { "layer3+4", BOND_XMIT_POLICY_LAYER34
, 0},
97 { "layer2+3", BOND_XMIT_POLICY_LAYER23
, 0},
98 { "encap2+3", BOND_XMIT_POLICY_ENCAP23
, 0},
99 { "encap3+4", BOND_XMIT_POLICY_ENCAP34
, 0},
103 static const struct bond_opt_value bond_arp_validate_tbl
[] = {
104 { "none", BOND_ARP_VALIDATE_NONE
, BOND_VALFLAG_DEFAULT
},
105 { "active", BOND_ARP_VALIDATE_ACTIVE
, 0},
106 { "backup", BOND_ARP_VALIDATE_BACKUP
, 0},
107 { "all", BOND_ARP_VALIDATE_ALL
, 0},
108 { "filter", BOND_ARP_FILTER
, 0},
109 { "filter_active", BOND_ARP_FILTER_ACTIVE
, 0},
110 { "filter_backup", BOND_ARP_FILTER_BACKUP
, 0},
114 static const struct bond_opt_value bond_arp_all_targets_tbl
[] = {
115 { "any", BOND_ARP_TARGETS_ANY
, BOND_VALFLAG_DEFAULT
},
116 { "all", BOND_ARP_TARGETS_ALL
, 0},
120 static const struct bond_opt_value bond_fail_over_mac_tbl
[] = {
121 { "none", BOND_FOM_NONE
, BOND_VALFLAG_DEFAULT
},
122 { "active", BOND_FOM_ACTIVE
, 0},
123 { "follow", BOND_FOM_FOLLOW
, 0},
127 static const struct bond_opt_value bond_intmax_tbl
[] = {
128 { "off", 0, BOND_VALFLAG_DEFAULT
},
129 { "maxval", INT_MAX
, BOND_VALFLAG_MAX
},
132 static const struct bond_opt_value bond_lacp_rate_tbl
[] = {
133 { "slow", AD_LACP_SLOW
, 0},
134 { "fast", AD_LACP_FAST
, 0},
138 static const struct bond_opt_value bond_ad_select_tbl
[] = {
139 { "stable", BOND_AD_STABLE
, BOND_VALFLAG_DEFAULT
},
140 { "bandwidth", BOND_AD_BANDWIDTH
, 0},
141 { "count", BOND_AD_COUNT
, 0},
145 static const struct bond_opt_value bond_num_peer_notif_tbl
[] = {
147 { "maxval", 255, BOND_VALFLAG_MAX
},
148 { "default", 1, BOND_VALFLAG_DEFAULT
},
152 static const struct bond_opt_value bond_primary_reselect_tbl
[] = {
153 { "always", BOND_PRI_RESELECT_ALWAYS
, BOND_VALFLAG_DEFAULT
},
154 { "better", BOND_PRI_RESELECT_BETTER
, 0},
155 { "failure", BOND_PRI_RESELECT_FAILURE
, 0},
159 static const struct bond_opt_value bond_use_carrier_tbl
[] = {
161 { "on", 1, BOND_VALFLAG_DEFAULT
},
165 static const struct bond_opt_value bond_all_slaves_active_tbl
[] = {
166 { "off", 0, BOND_VALFLAG_DEFAULT
},
171 static const struct bond_opt_value bond_resend_igmp_tbl
[] = {
173 { "maxval", 255, BOND_VALFLAG_MAX
},
174 { "default", 1, BOND_VALFLAG_DEFAULT
},
178 static const struct bond_opt_value bond_lp_interval_tbl
[] = {
179 { "minval", 1, BOND_VALFLAG_MIN
| BOND_VALFLAG_DEFAULT
},
180 { "maxval", INT_MAX
, BOND_VALFLAG_MAX
},
184 static const struct bond_opt_value bond_tlb_dynamic_lb_tbl
[] = {
186 { "on", 1, BOND_VALFLAG_DEFAULT
},
190 static const struct bond_option bond_opts
[] = {
194 .desc
= "bond device mode",
195 .flags
= BOND_OPTFLAG_NOSLAVES
| BOND_OPTFLAG_IFDOWN
,
196 .values
= bond_mode_tbl
,
197 .set
= bond_option_mode_set
199 [BOND_OPT_PACKETS_PER_SLAVE
] = {
200 .id
= BOND_OPT_PACKETS_PER_SLAVE
,
201 .name
= "packets_per_slave",
202 .desc
= "Packets to send per slave in RR mode",
203 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_ROUNDROBIN
)),
204 .values
= bond_pps_tbl
,
205 .set
= bond_option_pps_set
207 [BOND_OPT_XMIT_HASH
] = {
208 .id
= BOND_OPT_XMIT_HASH
,
209 .name
= "xmit_hash_policy",
210 .desc
= "balance-xor, 802.3ad, and tlb hashing method",
211 .values
= bond_xmit_hashtype_tbl
,
212 .set
= bond_option_xmit_hash_policy_set
214 [BOND_OPT_ARP_VALIDATE
] = {
215 .id
= BOND_OPT_ARP_VALIDATE
,
216 .name
= "arp_validate",
217 .desc
= "validate src/dst of ARP probes",
218 .unsuppmodes
= BIT(BOND_MODE_8023AD
) | BIT(BOND_MODE_TLB
) |
220 .values
= bond_arp_validate_tbl
,
221 .set
= bond_option_arp_validate_set
223 [BOND_OPT_ARP_ALL_TARGETS
] = {
224 .id
= BOND_OPT_ARP_ALL_TARGETS
,
225 .name
= "arp_all_targets",
226 .desc
= "fail on any/all arp targets timeout",
227 .values
= bond_arp_all_targets_tbl
,
228 .set
= bond_option_arp_all_targets_set
230 [BOND_OPT_FAIL_OVER_MAC
] = {
231 .id
= BOND_OPT_FAIL_OVER_MAC
,
232 .name
= "fail_over_mac",
233 .desc
= "For active-backup, do not set all slaves to the same MAC",
234 .flags
= BOND_OPTFLAG_NOSLAVES
,
235 .values
= bond_fail_over_mac_tbl
,
236 .set
= bond_option_fail_over_mac_set
238 [BOND_OPT_ARP_INTERVAL
] = {
239 .id
= BOND_OPT_ARP_INTERVAL
,
240 .name
= "arp_interval",
241 .desc
= "arp interval in milliseconds",
242 .unsuppmodes
= BIT(BOND_MODE_8023AD
) | BIT(BOND_MODE_TLB
) |
244 .values
= bond_intmax_tbl
,
245 .set
= bond_option_arp_interval_set
247 [BOND_OPT_ARP_TARGETS
] = {
248 .id
= BOND_OPT_ARP_TARGETS
,
249 .name
= "arp_ip_target",
250 .desc
= "arp targets in n.n.n.n form",
251 .flags
= BOND_OPTFLAG_RAWVAL
,
252 .set
= bond_option_arp_ip_targets_set
254 [BOND_OPT_DOWNDELAY
] = {
255 .id
= BOND_OPT_DOWNDELAY
,
257 .desc
= "Delay before considering link down, in milliseconds",
258 .values
= bond_intmax_tbl
,
259 .set
= bond_option_downdelay_set
261 [BOND_OPT_UPDELAY
] = {
262 .id
= BOND_OPT_UPDELAY
,
264 .desc
= "Delay before considering link up, in milliseconds",
265 .values
= bond_intmax_tbl
,
266 .set
= bond_option_updelay_set
268 [BOND_OPT_LACP_RATE
] = {
269 .id
= BOND_OPT_LACP_RATE
,
271 .desc
= "LACPDU tx rate to request from 802.3ad partner",
272 .flags
= BOND_OPTFLAG_IFDOWN
,
273 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD
)),
274 .values
= bond_lacp_rate_tbl
,
275 .set
= bond_option_lacp_rate_set
277 [BOND_OPT_MINLINKS
] = {
278 .id
= BOND_OPT_MINLINKS
,
280 .desc
= "Minimum number of available links before turning on carrier",
281 .values
= bond_intmax_tbl
,
282 .set
= bond_option_min_links_set
284 [BOND_OPT_AD_SELECT
] = {
285 .id
= BOND_OPT_AD_SELECT
,
287 .desc
= "803.ad aggregation selection logic",
288 .flags
= BOND_OPTFLAG_IFDOWN
,
289 .values
= bond_ad_select_tbl
,
290 .set
= bond_option_ad_select_set
292 [BOND_OPT_NUM_PEER_NOTIF
] = {
293 .id
= BOND_OPT_NUM_PEER_NOTIF
,
294 .name
= "num_unsol_na",
295 .desc
= "Number of peer notifications to send on failover event",
296 .values
= bond_num_peer_notif_tbl
,
297 .set
= bond_option_num_peer_notif_set
299 [BOND_OPT_MIIMON
] = {
300 .id
= BOND_OPT_MIIMON
,
302 .desc
= "Link check interval in milliseconds",
303 .values
= bond_intmax_tbl
,
304 .set
= bond_option_miimon_set
306 [BOND_OPT_PRIMARY
] = {
307 .id
= BOND_OPT_PRIMARY
,
309 .desc
= "Primary network device to use",
310 .flags
= BOND_OPTFLAG_RAWVAL
,
311 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP
) |
314 .set
= bond_option_primary_set
316 [BOND_OPT_PRIMARY_RESELECT
] = {
317 .id
= BOND_OPT_PRIMARY_RESELECT
,
318 .name
= "primary_reselect",
319 .desc
= "Reselect primary slave once it comes up",
320 .values
= bond_primary_reselect_tbl
,
321 .set
= bond_option_primary_reselect_set
323 [BOND_OPT_USE_CARRIER
] = {
324 .id
= BOND_OPT_USE_CARRIER
,
325 .name
= "use_carrier",
326 .desc
= "Use netif_carrier_ok (vs MII ioctls) in miimon",
327 .values
= bond_use_carrier_tbl
,
328 .set
= bond_option_use_carrier_set
330 [BOND_OPT_ACTIVE_SLAVE
] = {
331 .id
= BOND_OPT_ACTIVE_SLAVE
,
332 .name
= "active_slave",
333 .desc
= "Currently active slave",
334 .flags
= BOND_OPTFLAG_RAWVAL
,
335 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP
) |
338 .set
= bond_option_active_slave_set
340 [BOND_OPT_QUEUE_ID
] = {
341 .id
= BOND_OPT_QUEUE_ID
,
343 .desc
= "Set queue id of a slave",
344 .flags
= BOND_OPTFLAG_RAWVAL
,
345 .set
= bond_option_queue_id_set
347 [BOND_OPT_ALL_SLAVES_ACTIVE
] = {
348 .id
= BOND_OPT_ALL_SLAVES_ACTIVE
,
349 .name
= "all_slaves_active",
350 .desc
= "Keep all frames received on an interface by setting active flag for all slaves",
351 .values
= bond_all_slaves_active_tbl
,
352 .set
= bond_option_all_slaves_active_set
354 [BOND_OPT_RESEND_IGMP
] = {
355 .id
= BOND_OPT_RESEND_IGMP
,
356 .name
= "resend_igmp",
357 .desc
= "Number of IGMP membership reports to send on link failure",
358 .values
= bond_resend_igmp_tbl
,
359 .set
= bond_option_resend_igmp_set
361 [BOND_OPT_LP_INTERVAL
] = {
362 .id
= BOND_OPT_LP_INTERVAL
,
363 .name
= "lp_interval",
364 .desc
= "The number of seconds between instances where the bonding driver sends learning packets to each slave's peer switch",
365 .values
= bond_lp_interval_tbl
,
366 .set
= bond_option_lp_interval_set
368 [BOND_OPT_SLAVES
] = {
369 .id
= BOND_OPT_SLAVES
,
371 .desc
= "Slave membership management",
372 .flags
= BOND_OPTFLAG_RAWVAL
,
373 .set
= bond_option_slaves_set
375 [BOND_OPT_TLB_DYNAMIC_LB
] = {
376 .id
= BOND_OPT_TLB_DYNAMIC_LB
,
377 .name
= "tlb_dynamic_lb",
378 .desc
= "Enable dynamic flow shuffling",
379 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_TLB
)),
380 .values
= bond_tlb_dynamic_lb_tbl
,
381 .flags
= BOND_OPTFLAG_IFDOWN
,
382 .set
= bond_option_tlb_dynamic_lb_set
,
387 /* Searches for an option by name */
388 const struct bond_option
*bond_opt_get_by_name(const char *name
)
390 const struct bond_option
*opt
;
393 for (option
= 0; option
< BOND_OPT_LAST
; option
++) {
394 opt
= bond_opt_get(option
);
395 if (opt
&& !strcmp(opt
->name
, name
))
402 /* Searches for a value in opt's values[] table */
403 const struct bond_opt_value
*bond_opt_get_val(unsigned int option
, u64 val
)
405 const struct bond_option
*opt
;
408 opt
= bond_opt_get(option
);
411 for (i
= 0; opt
->values
&& opt
->values
[i
].string
; i
++)
412 if (opt
->values
[i
].value
== val
)
413 return &opt
->values
[i
];
418 /* Searches for a value in opt's values[] table which matches the flagmask */
419 static const struct bond_opt_value
*bond_opt_get_flags(const struct bond_option
*opt
,
424 for (i
= 0; opt
->values
&& opt
->values
[i
].string
; i
++)
425 if (opt
->values
[i
].flags
& flagmask
)
426 return &opt
->values
[i
];
431 /* If maxval is missing then there's no range to check. In case minval is
432 * missing then it's considered to be 0.
434 static bool bond_opt_check_range(const struct bond_option
*opt
, u64 val
)
436 const struct bond_opt_value
*minval
, *maxval
;
438 minval
= bond_opt_get_flags(opt
, BOND_VALFLAG_MIN
);
439 maxval
= bond_opt_get_flags(opt
, BOND_VALFLAG_MAX
);
440 if (!maxval
|| (minval
&& val
< minval
->value
) || val
> maxval
->value
)
447 * bond_opt_parse - parse option value
448 * @opt: the option to parse against
449 * @val: value to parse
451 * This function tries to extract the value from @val and check if it's
452 * a possible match for the option and returns NULL if a match isn't found,
453 * or the struct_opt_value that matched. It also strips the new line from
454 * @val->string if it's present.
456 const struct bond_opt_value
*bond_opt_parse(const struct bond_option
*opt
,
457 struct bond_opt_value
*val
)
459 char *p
, valstr
[BOND_OPT_MAX_NAMELEN
+ 1] = { 0, };
460 const struct bond_opt_value
*tbl
;
461 const struct bond_opt_value
*ret
= NULL
;
465 /* No parsing if the option wants a raw val */
466 if (opt
->flags
& BOND_OPTFLAG_RAWVAL
)
473 /* ULLONG_MAX is used to bypass string processing */
474 checkval
= val
->value
!= ULLONG_MAX
;
478 p
= strchr(val
->string
, '\n');
481 for (p
= val
->string
; *p
; p
++)
482 if (!(isdigit(*p
) || isspace(*p
)))
484 /* The following code extracts the string to match or the value
485 * and sets checkval appropriately
488 rv
= sscanf(val
->string
, "%32s", valstr
);
490 rv
= sscanf(val
->string
, "%llu", &val
->value
);
497 for (i
= 0; tbl
[i
].string
; i
++) {
498 /* Check for exact match */
500 if (val
->value
== tbl
[i
].value
)
503 if (!strcmp(valstr
, "default") &&
504 (tbl
[i
].flags
& BOND_VALFLAG_DEFAULT
))
507 if (!strcmp(valstr
, tbl
[i
].string
))
510 /* Found an exact match */
514 /* Possible range match */
515 if (checkval
&& bond_opt_check_range(opt
, val
->value
))
521 /* Check opt's dependencies against bond mode and currently set options */
522 static int bond_opt_check_deps(struct bonding
*bond
,
523 const struct bond_option
*opt
)
525 struct bond_params
*params
= &bond
->params
;
527 if (test_bit(params
->mode
, &opt
->unsuppmodes
))
529 if ((opt
->flags
& BOND_OPTFLAG_NOSLAVES
) && bond_has_slaves(bond
))
531 if ((opt
->flags
& BOND_OPTFLAG_IFDOWN
) && (bond
->dev
->flags
& IFF_UP
))
537 static void bond_opt_dep_print(struct bonding
*bond
,
538 const struct bond_option
*opt
)
540 const struct bond_opt_value
*modeval
;
541 struct bond_params
*params
;
543 params
= &bond
->params
;
544 modeval
= bond_opt_get_val(BOND_OPT_MODE
, params
->mode
);
545 if (test_bit(params
->mode
, &opt
->unsuppmodes
))
546 pr_err("%s: option %s: mode dependency failed, not supported in mode %s(%llu)\n",
547 bond
->dev
->name
, opt
->name
,
548 modeval
->string
, modeval
->value
);
551 static void bond_opt_error_interpret(struct bonding
*bond
,
552 const struct bond_option
*opt
,
553 int error
, const struct bond_opt_value
*val
)
555 const struct bond_opt_value
*minval
, *maxval
;
562 /* sometimes RAWVAL opts may have new lines */
563 p
= strchr(val
->string
, '\n');
566 pr_err("%s: option %s: invalid value (%s)\n",
567 bond
->dev
->name
, opt
->name
, val
->string
);
569 pr_err("%s: option %s: invalid value (%llu)\n",
570 bond
->dev
->name
, opt
->name
, val
->value
);
573 minval
= bond_opt_get_flags(opt
, BOND_VALFLAG_MIN
);
574 maxval
= bond_opt_get_flags(opt
, BOND_VALFLAG_MAX
);
577 pr_err("%s: option %s: allowed values %llu - %llu\n",
578 bond
->dev
->name
, opt
->name
, minval
? minval
->value
: 0,
582 bond_opt_dep_print(bond
, opt
);
585 pr_err("%s: option %s: unable to set because the bond device has slaves\n",
586 bond
->dev
->name
, opt
->name
);
589 pr_err("%s: option %s: unable to set because the bond device is up\n",
590 bond
->dev
->name
, opt
->name
);
598 * __bond_opt_set - set a bonding option
599 * @bond: target bond device
600 * @option: option to set
601 * @val: value to set it to
603 * This function is used to change the bond's option value, it can be
604 * used for both enabling/changing an option and for disabling it. RTNL lock
605 * must be obtained before calling this function.
607 int __bond_opt_set(struct bonding
*bond
,
608 unsigned int option
, struct bond_opt_value
*val
)
610 const struct bond_opt_value
*retval
= NULL
;
611 const struct bond_option
*opt
;
616 opt
= bond_opt_get(option
);
617 if (WARN_ON(!val
) || WARN_ON(!opt
))
619 ret
= bond_opt_check_deps(bond
, opt
);
622 retval
= bond_opt_parse(opt
, val
);
627 ret
= opt
->set(bond
, retval
);
630 bond_opt_error_interpret(bond
, opt
, ret
, val
);
636 * bond_opt_tryset_rtnl - try to acquire rtnl and call __bond_opt_set
637 * @bond: target bond device
638 * @option: option to set
639 * @buf: value to set it to
641 * This function tries to acquire RTNL without blocking and if successful
642 * calls __bond_opt_set. It is mainly used for sysfs option manipulation.
644 int bond_opt_tryset_rtnl(struct bonding
*bond
, unsigned int option
, char *buf
)
646 struct bond_opt_value optval
;
650 return restart_syscall();
651 bond_opt_initstr(&optval
, buf
);
652 ret
= __bond_opt_set(bond
, option
, &optval
);
659 * bond_opt_get - get a pointer to an option
660 * @option: option for which to return a pointer
662 * This function checks if option is valid and if so returns a pointer
663 * to its entry in the bond_opts[] option array.
665 const struct bond_option
*bond_opt_get(unsigned int option
)
667 if (!BOND_OPT_VALID(option
))
670 return &bond_opts
[option
];
673 int bond_option_mode_set(struct bonding
*bond
, const struct bond_opt_value
*newval
)
675 if (BOND_NO_USES_ARP(newval
->value
) && bond
->params
.arp_interval
) {
676 pr_info("%s: %s mode is incompatible with arp monitoring, start mii monitoring\n",
677 bond
->dev
->name
, newval
->string
);
678 /* disable arp monitoring */
679 bond
->params
.arp_interval
= 0;
680 /* set miimon to default value */
681 bond
->params
.miimon
= BOND_DEFAULT_MIIMON
;
682 pr_info("%s: Setting MII monitoring interval to %d\n",
683 bond
->dev
->name
, bond
->params
.miimon
);
686 /* don't cache arp_validate between modes */
687 bond
->params
.arp_validate
= BOND_ARP_VALIDATE_NONE
;
688 bond
->params
.mode
= newval
->value
;
693 static struct net_device
*__bond_option_active_slave_get(struct bonding
*bond
,
696 return USES_PRIMARY(bond
->params
.mode
) && slave
? slave
->dev
: NULL
;
699 struct net_device
*bond_option_active_slave_get_rcu(struct bonding
*bond
)
701 struct slave
*slave
= rcu_dereference(bond
->curr_active_slave
);
703 return __bond_option_active_slave_get(bond
, slave
);
706 struct net_device
*bond_option_active_slave_get(struct bonding
*bond
)
708 return __bond_option_active_slave_get(bond
, bond
->curr_active_slave
);
711 static int bond_option_active_slave_set(struct bonding
*bond
,
712 const struct bond_opt_value
*newval
)
714 char ifname
[IFNAMSIZ
] = { 0, };
715 struct net_device
*slave_dev
;
718 sscanf(newval
->string
, "%15s", ifname
); /* IFNAMSIZ */
719 if (!strlen(ifname
) || newval
->string
[0] == '\n') {
722 slave_dev
= __dev_get_by_name(dev_net(bond
->dev
), ifname
);
728 if (!netif_is_bond_slave(slave_dev
)) {
729 pr_err("Device %s is not bonding slave\n",
734 if (bond
->dev
!= netdev_master_upper_dev_get(slave_dev
)) {
735 pr_err("%s: Device %s is not our slave\n",
736 bond
->dev
->name
, slave_dev
->name
);
742 write_lock_bh(&bond
->curr_slave_lock
);
744 /* check to see if we are clearing active */
746 pr_info("%s: Clearing current active slave\n", bond
->dev
->name
);
747 RCU_INIT_POINTER(bond
->curr_active_slave
, NULL
);
748 bond_select_active_slave(bond
);
750 struct slave
*old_active
= bond
->curr_active_slave
;
751 struct slave
*new_active
= bond_slave_get_rtnl(slave_dev
);
755 if (new_active
== old_active
) {
757 pr_info("%s: %s is already the current active slave\n",
758 bond
->dev
->name
, new_active
->dev
->name
);
760 if (old_active
&& (new_active
->link
== BOND_LINK_UP
) &&
761 IS_UP(new_active
->dev
)) {
762 pr_info("%s: Setting %s as active slave\n",
763 bond
->dev
->name
, new_active
->dev
->name
);
764 bond_change_active_slave(bond
, new_active
);
766 pr_err("%s: Could not set %s as active slave; either %s is down or the link is down\n",
767 bond
->dev
->name
, new_active
->dev
->name
,
768 new_active
->dev
->name
);
774 write_unlock_bh(&bond
->curr_slave_lock
);
775 unblock_netpoll_tx();
780 /* There are two tricky bits here. First, if MII monitoring is activated, then
781 * we must disable ARP monitoring. Second, if the timer isn't running, we must
784 static int bond_option_miimon_set(struct bonding
*bond
,
785 const struct bond_opt_value
*newval
)
787 pr_info("%s: Setting MII monitoring interval to %llu\n",
788 bond
->dev
->name
, newval
->value
);
789 bond
->params
.miimon
= newval
->value
;
790 if (bond
->params
.updelay
)
791 pr_info("%s: Note: Updating updelay (to %d) since it is a multiple of the miimon value\n",
793 bond
->params
.updelay
* bond
->params
.miimon
);
794 if (bond
->params
.downdelay
)
795 pr_info("%s: Note: Updating downdelay (to %d) since it is a multiple of the miimon value\n",
797 bond
->params
.downdelay
* bond
->params
.miimon
);
798 if (newval
->value
&& bond
->params
.arp_interval
) {
799 pr_info("%s: MII monitoring cannot be used with ARP monitoring - disabling ARP monitoring...\n",
801 bond
->params
.arp_interval
= 0;
802 if (bond
->params
.arp_validate
)
803 bond
->params
.arp_validate
= BOND_ARP_VALIDATE_NONE
;
805 if (bond
->dev
->flags
& IFF_UP
) {
806 /* If the interface is up, we may need to fire off
807 * the MII timer. If the interface is down, the
808 * timer will get fired off when the open function
811 if (!newval
->value
) {
812 cancel_delayed_work_sync(&bond
->mii_work
);
814 cancel_delayed_work_sync(&bond
->arp_work
);
815 queue_delayed_work(bond
->wq
, &bond
->mii_work
, 0);
822 /* Set up and down delays. These must be multiples of the
823 * MII monitoring value, and are stored internally as the multiplier.
824 * Thus, we must translate to MS for the real world.
826 static int bond_option_updelay_set(struct bonding
*bond
,
827 const struct bond_opt_value
*newval
)
829 int value
= newval
->value
;
831 if (!bond
->params
.miimon
) {
832 pr_err("%s: Unable to set up delay as MII monitoring is disabled\n",
836 if ((value
% bond
->params
.miimon
) != 0) {
837 pr_warn("%s: Warning: up delay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n",
838 bond
->dev
->name
, value
,
840 (value
/ bond
->params
.miimon
) *
841 bond
->params
.miimon
);
843 bond
->params
.updelay
= value
/ bond
->params
.miimon
;
844 pr_info("%s: Setting up delay to %d\n",
845 bond
->dev
->name
, bond
->params
.updelay
* bond
->params
.miimon
);
850 static int bond_option_downdelay_set(struct bonding
*bond
,
851 const struct bond_opt_value
*newval
)
853 int value
= newval
->value
;
855 if (!bond
->params
.miimon
) {
856 pr_err("%s: Unable to set down delay as MII monitoring is disabled\n",
860 if ((value
% bond
->params
.miimon
) != 0) {
861 pr_warn("%s: Warning: down delay (%d) is not a multiple of miimon (%d), delay rounded to %d ms\n",
862 bond
->dev
->name
, value
,
864 (value
/ bond
->params
.miimon
) *
865 bond
->params
.miimon
);
867 bond
->params
.downdelay
= value
/ bond
->params
.miimon
;
868 pr_info("%s: Setting down delay to %d\n",
869 bond
->dev
->name
, bond
->params
.downdelay
* bond
->params
.miimon
);
874 static int bond_option_use_carrier_set(struct bonding
*bond
,
875 const struct bond_opt_value
*newval
)
877 pr_info("%s: Setting use_carrier to %llu\n",
878 bond
->dev
->name
, newval
->value
);
879 bond
->params
.use_carrier
= newval
->value
;
884 /* There are two tricky bits here. First, if ARP monitoring is activated, then
885 * we must disable MII monitoring. Second, if the ARP timer isn't running,
888 static int bond_option_arp_interval_set(struct bonding
*bond
,
889 const struct bond_opt_value
*newval
)
891 pr_info("%s: Setting ARP monitoring interval to %llu\n",
892 bond
->dev
->name
, newval
->value
);
893 bond
->params
.arp_interval
= newval
->value
;
895 if (bond
->params
.miimon
) {
896 pr_info("%s: ARP monitoring cannot be used with MII monitoring. %s Disabling MII monitoring\n",
897 bond
->dev
->name
, bond
->dev
->name
);
898 bond
->params
.miimon
= 0;
900 if (!bond
->params
.arp_targets
[0])
901 pr_info("%s: ARP monitoring has been set up, but no ARP targets have been specified\n",
904 if (bond
->dev
->flags
& IFF_UP
) {
905 /* If the interface is up, we may need to fire off
906 * the ARP timer. If the interface is down, the
907 * timer will get fired off when the open function
910 if (!newval
->value
) {
911 if (bond
->params
.arp_validate
)
912 bond
->recv_probe
= NULL
;
913 cancel_delayed_work_sync(&bond
->arp_work
);
915 /* arp_validate can be set only in active-backup mode */
916 bond
->recv_probe
= bond_arp_rcv
;
917 cancel_delayed_work_sync(&bond
->mii_work
);
918 queue_delayed_work(bond
->wq
, &bond
->arp_work
, 0);
925 static void _bond_options_arp_ip_target_set(struct bonding
*bond
, int slot
,
927 unsigned long last_rx
)
929 __be32
*targets
= bond
->params
.arp_targets
;
930 struct list_head
*iter
;
933 if (slot
>= 0 && slot
< BOND_MAX_ARP_TARGETS
) {
934 bond_for_each_slave(bond
, slave
, iter
)
935 slave
->target_last_arp_rx
[slot
] = last_rx
;
936 targets
[slot
] = target
;
940 static int _bond_option_arp_ip_target_add(struct bonding
*bond
, __be32 target
)
942 __be32
*targets
= bond
->params
.arp_targets
;
945 if (IS_IP_TARGET_UNUSABLE_ADDRESS(target
)) {
946 pr_err("%s: invalid ARP target %pI4 specified for addition\n",
947 bond
->dev
->name
, &target
);
951 if (bond_get_targets_ip(targets
, target
) != -1) { /* dup */
952 pr_err("%s: ARP target %pI4 is already present\n",
953 bond
->dev
->name
, &target
);
957 ind
= bond_get_targets_ip(targets
, 0); /* first free slot */
959 pr_err("%s: ARP target table is full!\n", bond
->dev
->name
);
963 pr_info("%s: Adding ARP target %pI4\n", bond
->dev
->name
, &target
);
965 _bond_options_arp_ip_target_set(bond
, ind
, target
, jiffies
);
970 static int bond_option_arp_ip_target_add(struct bonding
*bond
, __be32 target
)
974 /* not to race with bond_arp_rcv */
975 write_lock_bh(&bond
->lock
);
976 ret
= _bond_option_arp_ip_target_add(bond
, target
);
977 write_unlock_bh(&bond
->lock
);
982 static int bond_option_arp_ip_target_rem(struct bonding
*bond
, __be32 target
)
984 __be32
*targets
= bond
->params
.arp_targets
;
985 struct list_head
*iter
;
987 unsigned long *targets_rx
;
990 if (IS_IP_TARGET_UNUSABLE_ADDRESS(target
)) {
991 pr_err("%s: invalid ARP target %pI4 specified for removal\n",
992 bond
->dev
->name
, &target
);
996 ind
= bond_get_targets_ip(targets
, target
);
998 pr_err("%s: unable to remove nonexistent ARP target %pI4\n",
999 bond
->dev
->name
, &target
);
1003 if (ind
== 0 && !targets
[1] && bond
->params
.arp_interval
)
1004 pr_warn("%s: Removing last arp target with arp_interval on\n",
1007 pr_info("%s: Removing ARP target %pI4\n", bond
->dev
->name
, &target
);
1009 /* not to race with bond_arp_rcv */
1010 write_lock_bh(&bond
->lock
);
1012 bond_for_each_slave(bond
, slave
, iter
) {
1013 targets_rx
= slave
->target_last_arp_rx
;
1014 for (i
= ind
; (i
< BOND_MAX_ARP_TARGETS
-1) && targets
[i
+1]; i
++)
1015 targets_rx
[i
] = targets_rx
[i
+1];
1018 for (i
= ind
; (i
< BOND_MAX_ARP_TARGETS
-1) && targets
[i
+1]; i
++)
1019 targets
[i
] = targets
[i
+1];
1022 write_unlock_bh(&bond
->lock
);
1027 void bond_option_arp_ip_targets_clear(struct bonding
*bond
)
1031 /* not to race with bond_arp_rcv */
1032 write_lock_bh(&bond
->lock
);
1033 for (i
= 0; i
< BOND_MAX_ARP_TARGETS
; i
++)
1034 _bond_options_arp_ip_target_set(bond
, i
, 0, 0);
1035 write_unlock_bh(&bond
->lock
);
1038 static int bond_option_arp_ip_targets_set(struct bonding
*bond
,
1039 const struct bond_opt_value
*newval
)
1044 if (newval
->string
) {
1045 if (!in4_pton(newval
->string
+1, -1, (u8
*)&target
, -1, NULL
)) {
1046 pr_err("%s: invalid ARP target %pI4 specified\n",
1047 bond
->dev
->name
, &target
);
1050 if (newval
->string
[0] == '+')
1051 ret
= bond_option_arp_ip_target_add(bond
, target
);
1052 else if (newval
->string
[0] == '-')
1053 ret
= bond_option_arp_ip_target_rem(bond
, target
);
1055 pr_err("no command found in arp_ip_targets file for bond %s - use +<addr> or -<addr>\n",
1058 target
= newval
->value
;
1059 ret
= bond_option_arp_ip_target_add(bond
, target
);
1065 static int bond_option_arp_validate_set(struct bonding
*bond
,
1066 const struct bond_opt_value
*newval
)
1068 pr_info("%s: Setting arp_validate to %s (%llu)\n",
1069 bond
->dev
->name
, newval
->string
, newval
->value
);
1071 if (bond
->dev
->flags
& IFF_UP
) {
1073 bond
->recv_probe
= NULL
;
1074 else if (bond
->params
.arp_interval
)
1075 bond
->recv_probe
= bond_arp_rcv
;
1077 bond
->params
.arp_validate
= newval
->value
;
1082 static int bond_option_arp_all_targets_set(struct bonding
*bond
,
1083 const struct bond_opt_value
*newval
)
1085 pr_info("%s: Setting arp_all_targets to %s (%llu)\n",
1086 bond
->dev
->name
, newval
->string
, newval
->value
);
1087 bond
->params
.arp_all_targets
= newval
->value
;
1092 static int bond_option_primary_set(struct bonding
*bond
,
1093 const struct bond_opt_value
*newval
)
1095 char *p
, *primary
= newval
->string
;
1096 struct list_head
*iter
;
1097 struct slave
*slave
;
1100 read_lock(&bond
->lock
);
1101 write_lock_bh(&bond
->curr_slave_lock
);
1103 p
= strchr(primary
, '\n');
1106 /* check to see if we are clearing primary */
1107 if (!strlen(primary
)) {
1108 pr_info("%s: Setting primary slave to None\n", bond
->dev
->name
);
1109 bond
->primary_slave
= NULL
;
1110 memset(bond
->params
.primary
, 0, sizeof(bond
->params
.primary
));
1111 bond_select_active_slave(bond
);
1115 bond_for_each_slave(bond
, slave
, iter
) {
1116 if (strncmp(slave
->dev
->name
, primary
, IFNAMSIZ
) == 0) {
1117 pr_info("%s: Setting %s as primary slave\n",
1118 bond
->dev
->name
, slave
->dev
->name
);
1119 bond
->primary_slave
= slave
;
1120 strcpy(bond
->params
.primary
, slave
->dev
->name
);
1121 bond_select_active_slave(bond
);
1126 if (bond
->primary_slave
) {
1127 pr_info("%s: Setting primary slave to None\n", bond
->dev
->name
);
1128 bond
->primary_slave
= NULL
;
1129 bond_select_active_slave(bond
);
1131 strncpy(bond
->params
.primary
, primary
, IFNAMSIZ
);
1132 bond
->params
.primary
[IFNAMSIZ
- 1] = 0;
1134 pr_info("%s: Recording %s as primary, but it has not been enslaved to %s yet\n",
1135 bond
->dev
->name
, primary
, bond
->dev
->name
);
1138 write_unlock_bh(&bond
->curr_slave_lock
);
1139 read_unlock(&bond
->lock
);
1140 unblock_netpoll_tx();
1145 static int bond_option_primary_reselect_set(struct bonding
*bond
,
1146 const struct bond_opt_value
*newval
)
1148 pr_info("%s: Setting primary_reselect to %s (%llu)\n",
1149 bond
->dev
->name
, newval
->string
, newval
->value
);
1150 bond
->params
.primary_reselect
= newval
->value
;
1153 write_lock_bh(&bond
->curr_slave_lock
);
1154 bond_select_active_slave(bond
);
1155 write_unlock_bh(&bond
->curr_slave_lock
);
1156 unblock_netpoll_tx();
1161 static int bond_option_fail_over_mac_set(struct bonding
*bond
,
1162 const struct bond_opt_value
*newval
)
1164 pr_info("%s: Setting fail_over_mac to %s (%llu)\n",
1165 bond
->dev
->name
, newval
->string
, newval
->value
);
1166 bond
->params
.fail_over_mac
= newval
->value
;
1171 static int bond_option_xmit_hash_policy_set(struct bonding
*bond
,
1172 const struct bond_opt_value
*newval
)
1174 pr_info("%s: Setting xmit hash policy to %s (%llu)\n",
1175 bond
->dev
->name
, newval
->string
, newval
->value
);
1176 bond
->params
.xmit_policy
= newval
->value
;
1181 static int bond_option_resend_igmp_set(struct bonding
*bond
,
1182 const struct bond_opt_value
*newval
)
1184 pr_info("%s: Setting resend_igmp to %llu\n",
1185 bond
->dev
->name
, newval
->value
);
1186 bond
->params
.resend_igmp
= newval
->value
;
1191 static int bond_option_num_peer_notif_set(struct bonding
*bond
,
1192 const struct bond_opt_value
*newval
)
1194 bond
->params
.num_peer_notif
= newval
->value
;
1199 static int bond_option_all_slaves_active_set(struct bonding
*bond
,
1200 const struct bond_opt_value
*newval
)
1202 struct list_head
*iter
;
1203 struct slave
*slave
;
1205 if (newval
->value
== bond
->params
.all_slaves_active
)
1207 bond
->params
.all_slaves_active
= newval
->value
;
1208 bond_for_each_slave(bond
, slave
, iter
) {
1209 if (!bond_is_active_slave(slave
)) {
1211 slave
->inactive
= 0;
1213 slave
->inactive
= 1;
1220 static int bond_option_min_links_set(struct bonding
*bond
,
1221 const struct bond_opt_value
*newval
)
1223 pr_info("%s: Setting min links value to %llu\n",
1224 bond
->dev
->name
, newval
->value
);
1225 bond
->params
.min_links
= newval
->value
;
1230 static int bond_option_lp_interval_set(struct bonding
*bond
,
1231 const struct bond_opt_value
*newval
)
1233 bond
->params
.lp_interval
= newval
->value
;
1238 static int bond_option_pps_set(struct bonding
*bond
,
1239 const struct bond_opt_value
*newval
)
1241 bond
->params
.packets_per_slave
= newval
->value
;
1242 if (newval
->value
> 0) {
1243 bond
->params
.reciprocal_packets_per_slave
=
1244 reciprocal_value(newval
->value
);
1246 /* reciprocal_packets_per_slave is unused if
1247 * packets_per_slave is 0 or 1, just initialize it
1249 bond
->params
.reciprocal_packets_per_slave
=
1250 (struct reciprocal_value
) { 0 };
1256 static int bond_option_lacp_rate_set(struct bonding
*bond
,
1257 const struct bond_opt_value
*newval
)
1259 pr_info("%s: Setting LACP rate to %s (%llu)\n",
1260 bond
->dev
->name
, newval
->string
, newval
->value
);
1261 bond
->params
.lacp_fast
= newval
->value
;
1262 bond_3ad_update_lacp_rate(bond
);
1267 static int bond_option_ad_select_set(struct bonding
*bond
,
1268 const struct bond_opt_value
*newval
)
1270 pr_info("%s: Setting ad_select to %s (%llu)\n",
1271 bond
->dev
->name
, newval
->string
, newval
->value
);
1272 bond
->params
.ad_select
= newval
->value
;
1277 static int bond_option_queue_id_set(struct bonding
*bond
,
1278 const struct bond_opt_value
*newval
)
1280 struct slave
*slave
, *update_slave
;
1281 struct net_device
*sdev
;
1282 struct list_head
*iter
;
1287 /* delim will point to queue id if successful */
1288 delim
= strchr(newval
->string
, ':');
1292 /* Terminate string that points to device name and bump it
1293 * up one, so we can read the queue id there.
1296 if (sscanf(++delim
, "%hd\n", &qid
) != 1)
1299 /* Check buffer length, valid ifname and queue id */
1300 if (!dev_valid_name(newval
->string
) ||
1301 qid
> bond
->dev
->real_num_tx_queues
)
1304 /* Get the pointer to that interface if it exists */
1305 sdev
= __dev_get_by_name(dev_net(bond
->dev
), newval
->string
);
1309 /* Search for thes slave and check for duplicate qids */
1310 update_slave
= NULL
;
1311 bond_for_each_slave(bond
, slave
, iter
) {
1312 if (sdev
== slave
->dev
)
1313 /* We don't need to check the matching
1314 * slave for dups, since we're overwriting it
1316 update_slave
= slave
;
1317 else if (qid
&& qid
== slave
->queue_id
) {
1325 /* Actually set the qids for the slave */
1326 update_slave
->queue_id
= qid
;
1332 pr_info("invalid input for queue_id set for %s\n", bond
->dev
->name
);
1338 static int bond_option_slaves_set(struct bonding
*bond
,
1339 const struct bond_opt_value
*newval
)
1341 char command
[IFNAMSIZ
+ 1] = { 0, };
1342 struct net_device
*dev
;
1346 sscanf(newval
->string
, "%16s", command
); /* IFNAMSIZ*/
1347 ifname
= command
+ 1;
1348 if ((strlen(command
) <= 1) ||
1349 !dev_valid_name(ifname
))
1352 dev
= __dev_get_by_name(dev_net(bond
->dev
), ifname
);
1354 pr_info("%s: interface %s does not exist!\n",
1355 bond
->dev
->name
, ifname
);
1360 switch (command
[0]) {
1362 pr_info("%s: Adding slave %s\n", bond
->dev
->name
, dev
->name
);
1363 ret
= bond_enslave(bond
->dev
, dev
);
1367 pr_info("%s: Removing slave %s\n", bond
->dev
->name
, dev
->name
);
1368 ret
= bond_release(bond
->dev
, dev
);
1379 pr_err("no command found in slaves file for bond %s - use +ifname or -ifname\n",
1385 static int bond_option_tlb_dynamic_lb_set(struct bonding
*bond
,
1386 const struct bond_opt_value
*newval
)
1388 pr_info("%s: Setting dynamic-lb to %s (%llu)\n",
1389 bond
->dev
->name
, newval
->string
, newval
->value
);
1390 bond
->params
.tlb_dynamic_lb
= newval
->value
;