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 struct bond_opt_value bond_mode_tbl
[] = {
24 { "balance-rr", BOND_MODE_ROUNDROBIN
, BOND_VALFLAG_DEFAULT
},
25 { "active-backup", BOND_MODE_ACTIVEBACKUP
, 0},
26 { "balance-xor", BOND_MODE_XOR
, 0},
27 { "broadcast", BOND_MODE_BROADCAST
, 0},
28 { "802.3ad", BOND_MODE_8023AD
, 0},
29 { "balance-tlb", BOND_MODE_TLB
, 0},
30 { "balance-alb", BOND_MODE_ALB
, 0},
34 static struct bond_opt_value bond_pps_tbl
[] = {
35 { "default", 1, BOND_VALFLAG_DEFAULT
},
36 { "maxval", USHRT_MAX
, BOND_VALFLAG_MAX
},
40 static struct bond_opt_value bond_xmit_hashtype_tbl
[] = {
41 { "layer2", BOND_XMIT_POLICY_LAYER2
, BOND_VALFLAG_DEFAULT
},
42 { "layer3+4", BOND_XMIT_POLICY_LAYER34
, 0},
43 { "layer2+3", BOND_XMIT_POLICY_LAYER23
, 0},
44 { "encap2+3", BOND_XMIT_POLICY_ENCAP23
, 0},
45 { "encap3+4", BOND_XMIT_POLICY_ENCAP34
, 0},
49 static struct bond_opt_value bond_arp_validate_tbl
[] = {
50 { "none", BOND_ARP_VALIDATE_NONE
, BOND_VALFLAG_DEFAULT
},
51 { "active", BOND_ARP_VALIDATE_ACTIVE
, 0},
52 { "backup", BOND_ARP_VALIDATE_BACKUP
, 0},
53 { "all", BOND_ARP_VALIDATE_ALL
, 0},
57 static struct bond_opt_value bond_arp_all_targets_tbl
[] = {
58 { "any", BOND_ARP_TARGETS_ANY
, BOND_VALFLAG_DEFAULT
},
59 { "all", BOND_ARP_TARGETS_ALL
, 0},
63 static struct bond_opt_value bond_fail_over_mac_tbl
[] = {
64 { "none", BOND_FOM_NONE
, BOND_VALFLAG_DEFAULT
},
65 { "active", BOND_FOM_ACTIVE
, 0},
66 { "follow", BOND_FOM_FOLLOW
, 0},
70 static struct bond_opt_value bond_intmax_tbl
[] = {
71 { "off", 0, BOND_VALFLAG_DEFAULT
},
72 { "maxval", INT_MAX
, BOND_VALFLAG_MAX
},
75 static struct bond_opt_value bond_lacp_rate_tbl
[] = {
76 { "slow", AD_LACP_SLOW
, 0},
77 { "fast", AD_LACP_FAST
, 0},
81 static struct bond_opt_value bond_ad_select_tbl
[] = {
82 { "stable", BOND_AD_STABLE
, BOND_VALFLAG_DEFAULT
},
83 { "bandwidth", BOND_AD_BANDWIDTH
, 0},
84 { "count", BOND_AD_COUNT
, 0},
88 static struct bond_opt_value bond_num_peer_notif_tbl
[] = {
90 { "maxval", 255, BOND_VALFLAG_MAX
},
91 { "default", 1, BOND_VALFLAG_DEFAULT
},
95 static struct bond_opt_value bond_primary_reselect_tbl
[] = {
96 { "always", BOND_PRI_RESELECT_ALWAYS
, BOND_VALFLAG_DEFAULT
},
97 { "better", BOND_PRI_RESELECT_BETTER
, 0},
98 { "failure", BOND_PRI_RESELECT_FAILURE
, 0},
102 static struct bond_opt_value bond_use_carrier_tbl
[] = {
104 { "on", 1, BOND_VALFLAG_DEFAULT
},
108 static struct bond_opt_value bond_all_slaves_active_tbl
[] = {
109 { "off", 0, BOND_VALFLAG_DEFAULT
},
114 static struct bond_opt_value bond_resend_igmp_tbl
[] = {
116 { "maxval", 255, BOND_VALFLAG_MAX
},
117 { "default", 1, BOND_VALFLAG_DEFAULT
},
121 static struct bond_opt_value bond_lp_interval_tbl
[] = {
122 { "minval", 1, BOND_VALFLAG_MIN
| BOND_VALFLAG_DEFAULT
},
123 { "maxval", INT_MAX
, BOND_VALFLAG_MAX
},
127 static struct bond_option bond_opts
[] = {
131 .desc
= "bond device mode",
132 .flags
= BOND_OPTFLAG_NOSLAVES
| BOND_OPTFLAG_IFDOWN
,
133 .values
= bond_mode_tbl
,
134 .set
= bond_option_mode_set
136 [BOND_OPT_PACKETS_PER_SLAVE
] = {
137 .id
= BOND_OPT_PACKETS_PER_SLAVE
,
138 .name
= "packets_per_slave",
139 .desc
= "Packets to send per slave in RR mode",
140 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_ROUNDROBIN
)),
141 .values
= bond_pps_tbl
,
142 .set
= bond_option_pps_set
144 [BOND_OPT_XMIT_HASH
] = {
145 .id
= BOND_OPT_XMIT_HASH
,
146 .name
= "xmit_hash_policy",
147 .desc
= "balance-xor and 802.3ad hashing method",
148 .values
= bond_xmit_hashtype_tbl
,
149 .set
= bond_option_xmit_hash_policy_set
151 [BOND_OPT_ARP_VALIDATE
] = {
152 .id
= BOND_OPT_ARP_VALIDATE
,
153 .name
= "arp_validate",
154 .desc
= "validate src/dst of ARP probes",
155 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP
)),
156 .values
= bond_arp_validate_tbl
,
157 .set
= bond_option_arp_validate_set
159 [BOND_OPT_ARP_ALL_TARGETS
] = {
160 .id
= BOND_OPT_ARP_ALL_TARGETS
,
161 .name
= "arp_all_targets",
162 .desc
= "fail on any/all arp targets timeout",
163 .values
= bond_arp_all_targets_tbl
,
164 .set
= bond_option_arp_all_targets_set
166 [BOND_OPT_FAIL_OVER_MAC
] = {
167 .id
= BOND_OPT_FAIL_OVER_MAC
,
168 .name
= "fail_over_mac",
169 .desc
= "For active-backup, do not set all slaves to the same MAC",
170 .flags
= BOND_OPTFLAG_NOSLAVES
,
171 .values
= bond_fail_over_mac_tbl
,
172 .set
= bond_option_fail_over_mac_set
174 [BOND_OPT_ARP_INTERVAL
] = {
175 .id
= BOND_OPT_ARP_INTERVAL
,
176 .name
= "arp_interval",
177 .desc
= "arp interval in milliseconds",
178 .unsuppmodes
= BIT(BOND_MODE_8023AD
) | BIT(BOND_MODE_TLB
) |
180 .values
= bond_intmax_tbl
,
181 .set
= bond_option_arp_interval_set
183 [BOND_OPT_ARP_TARGETS
] = {
184 .id
= BOND_OPT_ARP_TARGETS
,
185 .name
= "arp_ip_target",
186 .desc
= "arp targets in n.n.n.n form",
187 .flags
= BOND_OPTFLAG_RAWVAL
,
188 .set
= bond_option_arp_ip_targets_set
190 [BOND_OPT_DOWNDELAY
] = {
191 .id
= BOND_OPT_DOWNDELAY
,
193 .desc
= "Delay before considering link down, in milliseconds",
194 .values
= bond_intmax_tbl
,
195 .set
= bond_option_downdelay_set
197 [BOND_OPT_UPDELAY
] = {
198 .id
= BOND_OPT_UPDELAY
,
200 .desc
= "Delay before considering link up, in milliseconds",
201 .values
= bond_intmax_tbl
,
202 .set
= bond_option_updelay_set
204 [BOND_OPT_LACP_RATE
] = {
205 .id
= BOND_OPT_LACP_RATE
,
207 .desc
= "LACPDU tx rate to request from 802.3ad partner",
208 .flags
= BOND_OPTFLAG_IFDOWN
,
209 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD
)),
210 .values
= bond_lacp_rate_tbl
,
211 .set
= bond_option_lacp_rate_set
213 [BOND_OPT_MINLINKS
] = {
214 .id
= BOND_OPT_MINLINKS
,
216 .desc
= "Minimum number of available links before turning on carrier",
217 .values
= bond_intmax_tbl
,
218 .set
= bond_option_min_links_set
220 [BOND_OPT_AD_SELECT
] = {
221 .id
= BOND_OPT_AD_SELECT
,
223 .desc
= "803.ad aggregation selection logic",
224 .flags
= BOND_OPTFLAG_IFDOWN
,
225 .values
= bond_ad_select_tbl
,
226 .set
= bond_option_ad_select_set
228 [BOND_OPT_NUM_PEER_NOTIF
] = {
229 .id
= BOND_OPT_NUM_PEER_NOTIF
,
230 .name
= "num_unsol_na",
231 .desc
= "Number of peer notifications to send on failover event",
232 .values
= bond_num_peer_notif_tbl
,
233 .set
= bond_option_num_peer_notif_set
235 [BOND_OPT_MIIMON
] = {
236 .id
= BOND_OPT_MIIMON
,
238 .desc
= "Link check interval in milliseconds",
239 .values
= bond_intmax_tbl
,
240 .set
= bond_option_miimon_set
242 [BOND_OPT_PRIMARY
] = {
243 .id
= BOND_OPT_PRIMARY
,
245 .desc
= "Primary network device to use",
246 .flags
= BOND_OPTFLAG_RAWVAL
,
247 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP
) |
250 .set
= bond_option_primary_set
252 [BOND_OPT_PRIMARY_RESELECT
] = {
253 .id
= BOND_OPT_PRIMARY_RESELECT
,
254 .name
= "primary_reselect",
255 .desc
= "Reselect primary slave once it comes up",
256 .values
= bond_primary_reselect_tbl
,
257 .set
= bond_option_primary_reselect_set
259 [BOND_OPT_USE_CARRIER
] = {
260 .id
= BOND_OPT_USE_CARRIER
,
261 .name
= "use_carrier",
262 .desc
= "Use netif_carrier_ok (vs MII ioctls) in miimon",
263 .values
= bond_use_carrier_tbl
,
264 .set
= bond_option_use_carrier_set
266 [BOND_OPT_ACTIVE_SLAVE
] = {
267 .id
= BOND_OPT_ACTIVE_SLAVE
,
268 .name
= "active_slave",
269 .desc
= "Currently active slave",
270 .flags
= BOND_OPTFLAG_RAWVAL
,
271 .unsuppmodes
= BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP
) |
274 .set
= bond_option_active_slave_set
276 [BOND_OPT_QUEUE_ID
] = {
277 .id
= BOND_OPT_QUEUE_ID
,
279 .desc
= "Set queue id of a slave",
280 .flags
= BOND_OPTFLAG_RAWVAL
,
281 .set
= bond_option_queue_id_set
283 [BOND_OPT_ALL_SLAVES_ACTIVE
] = {
284 .id
= BOND_OPT_ALL_SLAVES_ACTIVE
,
285 .name
= "all_slaves_active",
286 .desc
= "Keep all frames received on an interface by setting active flag for all slaves",
287 .values
= bond_all_slaves_active_tbl
,
288 .set
= bond_option_all_slaves_active_set
290 [BOND_OPT_RESEND_IGMP
] = {
291 .id
= BOND_OPT_RESEND_IGMP
,
292 .name
= "resend_igmp",
293 .desc
= "Number of IGMP membership reports to send on link failure",
294 .values
= bond_resend_igmp_tbl
,
295 .set
= bond_option_resend_igmp_set
297 [BOND_OPT_LP_INTERVAL
] = {
298 .id
= BOND_OPT_LP_INTERVAL
,
299 .name
= "lp_interval",
300 .desc
= "The number of seconds between instances where the bonding driver sends learning packets to each slave's peer switch",
301 .values
= bond_lp_interval_tbl
,
302 .set
= bond_option_lp_interval_set
304 [BOND_OPT_SLAVES
] = {
305 .id
= BOND_OPT_SLAVES
,
307 .desc
= "Slave membership management",
308 .flags
= BOND_OPTFLAG_RAWVAL
,
309 .set
= bond_option_slaves_set
314 /* Searches for a value in opt's values[] table */
315 struct bond_opt_value
*bond_opt_get_val(unsigned int option
, u64 val
)
317 struct bond_option
*opt
;
320 opt
= bond_opt_get(option
);
323 for (i
= 0; opt
->values
&& opt
->values
[i
].string
; i
++)
324 if (opt
->values
[i
].value
== val
)
325 return &opt
->values
[i
];
330 /* Searches for a value in opt's values[] table which matches the flagmask */
331 static struct bond_opt_value
*bond_opt_get_flags(const struct bond_option
*opt
,
336 for (i
= 0; opt
->values
&& opt
->values
[i
].string
; i
++)
337 if (opt
->values
[i
].flags
& flagmask
)
338 return &opt
->values
[i
];
343 /* If maxval is missing then there's no range to check. In case minval is
344 * missing then it's considered to be 0.
346 static bool bond_opt_check_range(const struct bond_option
*opt
, u64 val
)
348 struct bond_opt_value
*minval
, *maxval
;
350 minval
= bond_opt_get_flags(opt
, BOND_VALFLAG_MIN
);
351 maxval
= bond_opt_get_flags(opt
, BOND_VALFLAG_MAX
);
352 if (!maxval
|| (minval
&& val
< minval
->value
) || val
> maxval
->value
)
359 * bond_opt_parse - parse option value
360 * @opt: the option to parse against
361 * @val: value to parse
363 * This function tries to extract the value from @val and check if it's
364 * a possible match for the option and returns NULL if a match isn't found,
365 * or the struct_opt_value that matched. It also strips the new line from
366 * @val->string if it's present.
368 struct bond_opt_value
*bond_opt_parse(const struct bond_option
*opt
,
369 struct bond_opt_value
*val
)
371 char *p
, valstr
[BOND_OPT_MAX_NAMELEN
+ 1] = { 0, };
372 struct bond_opt_value
*tbl
, *ret
= NULL
;
376 /* No parsing if the option wants a raw val */
377 if (opt
->flags
& BOND_OPTFLAG_RAWVAL
)
384 /* ULLONG_MAX is used to bypass string processing */
385 checkval
= val
->value
!= ULLONG_MAX
;
389 p
= strchr(val
->string
, '\n');
392 for (p
= val
->string
; *p
; p
++)
393 if (!(isdigit(*p
) || isspace(*p
)))
395 /* The following code extracts the string to match or the value
396 * and sets checkval appropriately
399 rv
= sscanf(val
->string
, "%32s", valstr
);
401 rv
= sscanf(val
->string
, "%llu", &val
->value
);
408 for (i
= 0; tbl
[i
].string
; i
++) {
409 /* Check for exact match */
411 if (val
->value
== tbl
[i
].value
)
414 if (!strcmp(valstr
, "default") &&
415 (tbl
[i
].flags
& BOND_VALFLAG_DEFAULT
))
418 if (!strcmp(valstr
, tbl
[i
].string
))
421 /* Found an exact match */
425 /* Possible range match */
426 if (checkval
&& bond_opt_check_range(opt
, val
->value
))
432 /* Check opt's dependencies against bond mode and currently set options */
433 static int bond_opt_check_deps(struct bonding
*bond
,
434 const struct bond_option
*opt
)
436 struct bond_params
*params
= &bond
->params
;
438 if (test_bit(params
->mode
, &opt
->unsuppmodes
))
440 if ((opt
->flags
& BOND_OPTFLAG_NOSLAVES
) && bond_has_slaves(bond
))
442 if ((opt
->flags
& BOND_OPTFLAG_IFDOWN
) && (bond
->dev
->flags
& IFF_UP
))
448 static void bond_opt_dep_print(struct bonding
*bond
,
449 const struct bond_option
*opt
)
451 struct bond_opt_value
*modeval
;
452 struct bond_params
*params
;
454 params
= &bond
->params
;
455 modeval
= bond_opt_get_val(BOND_OPT_MODE
, params
->mode
);
456 if (test_bit(params
->mode
, &opt
->unsuppmodes
))
457 pr_err("%s: option %s: mode dependency failed, not supported in mode %s(%llu)\n",
458 bond
->dev
->name
, opt
->name
,
459 modeval
->string
, modeval
->value
);
462 static void bond_opt_error_interpret(struct bonding
*bond
,
463 const struct bond_option
*opt
,
464 int error
, struct bond_opt_value
*val
)
466 struct bond_opt_value
*minval
, *maxval
;
473 /* sometimes RAWVAL opts may have new lines */
474 p
= strchr(val
->string
, '\n');
477 pr_err("%s: option %s: invalid value (%s).\n",
478 bond
->dev
->name
, opt
->name
, val
->string
);
480 pr_err("%s: option %s: invalid value (%llu).\n",
481 bond
->dev
->name
, opt
->name
, val
->value
);
484 minval
= bond_opt_get_flags(opt
, BOND_VALFLAG_MIN
);
485 maxval
= bond_opt_get_flags(opt
, BOND_VALFLAG_MAX
);
488 pr_err("%s: option %s: allowed values %llu - %llu.\n",
489 bond
->dev
->name
, opt
->name
, minval
? minval
->value
: 0,
493 bond_opt_dep_print(bond
, opt
);
496 pr_err("%s: option %s: unable to set because the bond device has slaves.\n",
497 bond
->dev
->name
, opt
->name
);
500 pr_err("%s: option %s: unable to set because the bond device is up.\n",
501 bond
->dev
->name
, opt
->name
);
509 * __bond_opt_set - set a bonding option
510 * @bond: target bond device
511 * @option: option to set
512 * @val: value to set it to
514 * This function is used to change the bond's option value, it can be
515 * used for both enabling/changing an option and for disabling it. RTNL lock
516 * must be obtained before calling this function.
518 int __bond_opt_set(struct bonding
*bond
,
519 unsigned int option
, struct bond_opt_value
*val
)
521 struct bond_opt_value
*retval
= NULL
;
522 const struct bond_option
*opt
;
527 opt
= bond_opt_get(option
);
528 if (WARN_ON(!val
) || WARN_ON(!opt
))
530 ret
= bond_opt_check_deps(bond
, opt
);
533 retval
= bond_opt_parse(opt
, val
);
538 ret
= opt
->set(bond
, retval
);
541 bond_opt_error_interpret(bond
, opt
, ret
, val
);
547 * bond_opt_tryset_rtnl - try to acquire rtnl and call __bond_opt_set
548 * @bond: target bond device
549 * @option: option to set
550 * @buf: value to set it to
552 * This function tries to acquire RTNL without blocking and if successful
553 * calls __bond_opt_set. It is mainly used for sysfs option manipulation.
555 int bond_opt_tryset_rtnl(struct bonding
*bond
, unsigned int option
, char *buf
)
557 struct bond_opt_value optval
;
561 return restart_syscall();
562 bond_opt_initstr(&optval
, buf
);
563 ret
= __bond_opt_set(bond
, option
, &optval
);
570 * bond_opt_get - get a pointer to an option
571 * @option: option for which to return a pointer
573 * This function checks if option is valid and if so returns a pointer
574 * to its entry in the bond_opts[] option array.
576 struct bond_option
*bond_opt_get(unsigned int option
)
578 if (!BOND_OPT_VALID(option
))
581 return &bond_opts
[option
];
584 int bond_option_mode_set(struct bonding
*bond
, struct bond_opt_value
*newval
)
586 if (BOND_NO_USES_ARP(newval
->value
) && bond
->params
.arp_interval
) {
587 pr_info("%s: %s mode is incompatible with arp monitoring, start mii monitoring\n",
588 bond
->dev
->name
, newval
->string
);
589 /* disable arp monitoring */
590 bond
->params
.arp_interval
= 0;
591 /* set miimon to default value */
592 bond
->params
.miimon
= BOND_DEFAULT_MIIMON
;
593 pr_info("%s: Setting MII monitoring interval to %d.\n",
594 bond
->dev
->name
, bond
->params
.miimon
);
597 /* don't cache arp_validate between modes */
598 bond
->params
.arp_validate
= BOND_ARP_VALIDATE_NONE
;
599 bond
->params
.mode
= newval
->value
;
604 static struct net_device
*__bond_option_active_slave_get(struct bonding
*bond
,
607 return USES_PRIMARY(bond
->params
.mode
) && slave
? slave
->dev
: NULL
;
610 struct net_device
*bond_option_active_slave_get_rcu(struct bonding
*bond
)
612 struct slave
*slave
= rcu_dereference(bond
->curr_active_slave
);
614 return __bond_option_active_slave_get(bond
, slave
);
617 struct net_device
*bond_option_active_slave_get(struct bonding
*bond
)
619 return __bond_option_active_slave_get(bond
, bond
->curr_active_slave
);
622 int bond_option_active_slave_set(struct bonding
*bond
,
623 struct bond_opt_value
*newval
)
625 char ifname
[IFNAMSIZ
] = { 0, };
626 struct net_device
*slave_dev
;
629 sscanf(newval
->string
, "%15s", ifname
); /* IFNAMSIZ */
630 if (!strlen(ifname
) || newval
->string
[0] == '\n') {
633 slave_dev
= __dev_get_by_name(dev_net(bond
->dev
), ifname
);
639 if (!netif_is_bond_slave(slave_dev
)) {
640 pr_err("Device %s is not bonding slave.\n",
645 if (bond
->dev
!= netdev_master_upper_dev_get(slave_dev
)) {
646 pr_err("%s: Device %s is not our slave.\n",
647 bond
->dev
->name
, slave_dev
->name
);
653 write_lock_bh(&bond
->curr_slave_lock
);
655 /* check to see if we are clearing active */
657 pr_info("%s: Clearing current active slave.\n",
659 rcu_assign_pointer(bond
->curr_active_slave
, NULL
);
660 bond_select_active_slave(bond
);
662 struct slave
*old_active
= bond
->curr_active_slave
;
663 struct slave
*new_active
= bond_slave_get_rtnl(slave_dev
);
667 if (new_active
== old_active
) {
669 pr_info("%s: %s is already the current active slave.\n",
670 bond
->dev
->name
, new_active
->dev
->name
);
672 if (old_active
&& (new_active
->link
== BOND_LINK_UP
) &&
673 IS_UP(new_active
->dev
)) {
674 pr_info("%s: Setting %s as active slave.\n",
675 bond
->dev
->name
, new_active
->dev
->name
);
676 bond_change_active_slave(bond
, new_active
);
678 pr_err("%s: Could not set %s as active slave; either %s is down or the link is down.\n",
679 bond
->dev
->name
, new_active
->dev
->name
,
680 new_active
->dev
->name
);
686 write_unlock_bh(&bond
->curr_slave_lock
);
687 unblock_netpoll_tx();
692 int bond_option_miimon_set(struct bonding
*bond
, struct bond_opt_value
*newval
)
694 pr_info("%s: Setting MII monitoring interval to %llu.\n",
695 bond
->dev
->name
, newval
->value
);
696 bond
->params
.miimon
= newval
->value
;
697 if (bond
->params
.updelay
)
698 pr_info("%s: Note: Updating updelay (to %d) since it is a multiple of the miimon value.\n",
700 bond
->params
.updelay
* bond
->params
.miimon
);
701 if (bond
->params
.downdelay
)
702 pr_info("%s: Note: Updating downdelay (to %d) since it is a multiple of the miimon value.\n",
704 bond
->params
.downdelay
* bond
->params
.miimon
);
705 if (newval
->value
&& bond
->params
.arp_interval
) {
706 pr_info("%s: MII monitoring cannot be used with ARP monitoring. Disabling ARP monitoring...\n",
708 bond
->params
.arp_interval
= 0;
709 if (bond
->params
.arp_validate
)
710 bond
->params
.arp_validate
= BOND_ARP_VALIDATE_NONE
;
712 if (bond
->dev
->flags
& IFF_UP
) {
713 /* If the interface is up, we may need to fire off
714 * the MII timer. If the interface is down, the
715 * timer will get fired off when the open function
718 if (!newval
->value
) {
719 cancel_delayed_work_sync(&bond
->mii_work
);
721 cancel_delayed_work_sync(&bond
->arp_work
);
722 queue_delayed_work(bond
->wq
, &bond
->mii_work
, 0);
729 int bond_option_updelay_set(struct bonding
*bond
, struct bond_opt_value
*newval
)
731 int value
= newval
->value
;
733 if (!bond
->params
.miimon
) {
734 pr_err("%s: Unable to set up delay as MII monitoring is disabled\n",
738 if ((value
% bond
->params
.miimon
) != 0) {
739 pr_warn("%s: Warning: up delay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n",
740 bond
->dev
->name
, value
,
742 (value
/ bond
->params
.miimon
) *
743 bond
->params
.miimon
);
745 bond
->params
.updelay
= value
/ bond
->params
.miimon
;
746 pr_info("%s: Setting up delay to %d.\n",
748 bond
->params
.updelay
* bond
->params
.miimon
);
753 int bond_option_downdelay_set(struct bonding
*bond
,
754 struct bond_opt_value
*newval
)
756 int value
= newval
->value
;
758 if (!bond
->params
.miimon
) {
759 pr_err("%s: Unable to set down delay as MII monitoring is disabled\n",
763 if ((value
% bond
->params
.miimon
) != 0) {
764 pr_warn("%s: Warning: down delay (%d) is not a multiple of miimon (%d), delay rounded to %d ms\n",
765 bond
->dev
->name
, value
,
767 (value
/ bond
->params
.miimon
) *
768 bond
->params
.miimon
);
770 bond
->params
.downdelay
= value
/ bond
->params
.miimon
;
771 pr_info("%s: Setting down delay to %d.\n",
773 bond
->params
.downdelay
* bond
->params
.miimon
);
778 int bond_option_use_carrier_set(struct bonding
*bond
,
779 struct bond_opt_value
*newval
)
781 pr_info("%s: Setting use_carrier to %llu.\n",
782 bond
->dev
->name
, newval
->value
);
783 bond
->params
.use_carrier
= newval
->value
;
788 int bond_option_arp_interval_set(struct bonding
*bond
,
789 struct bond_opt_value
*newval
)
791 pr_info("%s: Setting ARP monitoring interval to %llu.\n",
792 bond
->dev
->name
, newval
->value
);
793 bond
->params
.arp_interval
= newval
->value
;
795 if (bond
->params
.miimon
) {
796 pr_info("%s: ARP monitoring cannot be used with MII monitoring. %s Disabling MII monitoring.\n",
797 bond
->dev
->name
, bond
->dev
->name
);
798 bond
->params
.miimon
= 0;
800 if (!bond
->params
.arp_targets
[0])
801 pr_info("%s: ARP monitoring has been set up, but no ARP targets have been specified.\n",
804 if (bond
->dev
->flags
& IFF_UP
) {
805 /* If the interface is up, we may need to fire off
806 * the ARP timer. If the interface is down, the
807 * timer will get fired off when the open function
810 if (!newval
->value
) {
811 if (bond
->params
.arp_validate
)
812 bond
->recv_probe
= NULL
;
813 cancel_delayed_work_sync(&bond
->arp_work
);
815 /* arp_validate can be set only in active-backup mode */
816 if (bond
->params
.arp_validate
)
817 bond
->recv_probe
= bond_arp_rcv
;
818 cancel_delayed_work_sync(&bond
->mii_work
);
819 queue_delayed_work(bond
->wq
, &bond
->arp_work
, 0);
826 static void _bond_options_arp_ip_target_set(struct bonding
*bond
, int slot
,
828 unsigned long last_rx
)
830 __be32
*targets
= bond
->params
.arp_targets
;
831 struct list_head
*iter
;
834 if (slot
>= 0 && slot
< BOND_MAX_ARP_TARGETS
) {
835 bond_for_each_slave(bond
, slave
, iter
)
836 slave
->target_last_arp_rx
[slot
] = last_rx
;
837 targets
[slot
] = target
;
841 static int _bond_option_arp_ip_target_add(struct bonding
*bond
, __be32 target
)
843 __be32
*targets
= bond
->params
.arp_targets
;
846 if (IS_IP_TARGET_UNUSABLE_ADDRESS(target
)) {
847 pr_err("%s: invalid ARP target %pI4 specified for addition\n",
848 bond
->dev
->name
, &target
);
852 if (bond_get_targets_ip(targets
, target
) != -1) { /* dup */
853 pr_err("%s: ARP target %pI4 is already present\n",
854 bond
->dev
->name
, &target
);
858 ind
= bond_get_targets_ip(targets
, 0); /* first free slot */
860 pr_err("%s: ARP target table is full!\n",
865 pr_info("%s: adding ARP target %pI4.\n", bond
->dev
->name
, &target
);
867 _bond_options_arp_ip_target_set(bond
, ind
, target
, jiffies
);
872 int bond_option_arp_ip_target_add(struct bonding
*bond
, __be32 target
)
876 /* not to race with bond_arp_rcv */
877 write_lock_bh(&bond
->lock
);
878 ret
= _bond_option_arp_ip_target_add(bond
, target
);
879 write_unlock_bh(&bond
->lock
);
884 int bond_option_arp_ip_target_rem(struct bonding
*bond
, __be32 target
)
886 __be32
*targets
= bond
->params
.arp_targets
;
887 struct list_head
*iter
;
889 unsigned long *targets_rx
;
892 if (IS_IP_TARGET_UNUSABLE_ADDRESS(target
)) {
893 pr_err("%s: invalid ARP target %pI4 specified for removal\n",
894 bond
->dev
->name
, &target
);
898 ind
= bond_get_targets_ip(targets
, target
);
900 pr_err("%s: unable to remove nonexistent ARP target %pI4.\n",
901 bond
->dev
->name
, &target
);
905 if (ind
== 0 && !targets
[1] && bond
->params
.arp_interval
)
906 pr_warn("%s: removing last arp target with arp_interval on\n",
909 pr_info("%s: removing ARP target %pI4.\n", bond
->dev
->name
,
912 /* not to race with bond_arp_rcv */
913 write_lock_bh(&bond
->lock
);
915 bond_for_each_slave(bond
, slave
, iter
) {
916 targets_rx
= slave
->target_last_arp_rx
;
917 for (i
= ind
; (i
< BOND_MAX_ARP_TARGETS
-1) && targets
[i
+1]; i
++)
918 targets_rx
[i
] = targets_rx
[i
+1];
921 for (i
= ind
; (i
< BOND_MAX_ARP_TARGETS
-1) && targets
[i
+1]; i
++)
922 targets
[i
] = targets
[i
+1];
925 write_unlock_bh(&bond
->lock
);
930 void bond_option_arp_ip_targets_clear(struct bonding
*bond
)
934 /* not to race with bond_arp_rcv */
935 write_lock_bh(&bond
->lock
);
936 for (i
= 0; i
< BOND_MAX_ARP_TARGETS
; i
++)
937 _bond_options_arp_ip_target_set(bond
, i
, 0, 0);
938 write_unlock_bh(&bond
->lock
);
941 int bond_option_arp_ip_targets_set(struct bonding
*bond
,
942 struct bond_opt_value
*newval
)
947 if (newval
->string
) {
948 if (!in4_pton(newval
->string
+1, -1, (u8
*)&target
, -1, NULL
)) {
949 pr_err("%s: invalid ARP target %pI4 specified\n",
950 bond
->dev
->name
, &target
);
953 if (newval
->string
[0] == '+')
954 ret
= bond_option_arp_ip_target_add(bond
, target
);
955 else if (newval
->string
[0] == '-')
956 ret
= bond_option_arp_ip_target_rem(bond
, target
);
958 pr_err("no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n",
961 target
= newval
->value
;
962 ret
= bond_option_arp_ip_target_add(bond
, target
);
968 int bond_option_arp_validate_set(struct bonding
*bond
,
969 struct bond_opt_value
*newval
)
971 pr_info("%s: setting arp_validate to %s (%llu).\n",
972 bond
->dev
->name
, newval
->string
, newval
->value
);
974 if (bond
->dev
->flags
& IFF_UP
) {
976 bond
->recv_probe
= NULL
;
977 else if (bond
->params
.arp_interval
)
978 bond
->recv_probe
= bond_arp_rcv
;
980 bond
->params
.arp_validate
= newval
->value
;
985 int bond_option_arp_all_targets_set(struct bonding
*bond
,
986 struct bond_opt_value
*newval
)
988 pr_info("%s: setting arp_all_targets to %s (%llu).\n",
989 bond
->dev
->name
, newval
->string
, newval
->value
);
990 bond
->params
.arp_all_targets
= newval
->value
;
995 int bond_option_primary_set(struct bonding
*bond
, struct bond_opt_value
*newval
)
997 char *p
, *primary
= newval
->string
;
998 struct list_head
*iter
;
1002 read_lock(&bond
->lock
);
1003 write_lock_bh(&bond
->curr_slave_lock
);
1005 p
= strchr(primary
, '\n');
1008 /* check to see if we are clearing primary */
1009 if (!strlen(primary
)) {
1010 pr_info("%s: Setting primary slave to None.\n",
1012 bond
->primary_slave
= NULL
;
1013 memset(bond
->params
.primary
, 0, sizeof(bond
->params
.primary
));
1014 bond_select_active_slave(bond
);
1018 bond_for_each_slave(bond
, slave
, iter
) {
1019 if (strncmp(slave
->dev
->name
, primary
, IFNAMSIZ
) == 0) {
1020 pr_info("%s: Setting %s as primary slave.\n",
1021 bond
->dev
->name
, slave
->dev
->name
);
1022 bond
->primary_slave
= slave
;
1023 strcpy(bond
->params
.primary
, slave
->dev
->name
);
1024 bond_select_active_slave(bond
);
1029 if (bond
->primary_slave
) {
1030 pr_info("%s: Setting primary slave to None.\n",
1032 bond
->primary_slave
= NULL
;
1033 bond_select_active_slave(bond
);
1035 strncpy(bond
->params
.primary
, primary
, IFNAMSIZ
);
1036 bond
->params
.primary
[IFNAMSIZ
- 1] = 0;
1038 pr_info("%s: Recording %s as primary, but it has not been enslaved to %s yet.\n",
1039 bond
->dev
->name
, primary
, bond
->dev
->name
);
1042 write_unlock_bh(&bond
->curr_slave_lock
);
1043 read_unlock(&bond
->lock
);
1044 unblock_netpoll_tx();
1049 int bond_option_primary_reselect_set(struct bonding
*bond
,
1050 struct bond_opt_value
*newval
)
1052 pr_info("%s: setting primary_reselect to %s (%llu).\n",
1053 bond
->dev
->name
, newval
->string
, newval
->value
);
1054 bond
->params
.primary_reselect
= newval
->value
;
1057 write_lock_bh(&bond
->curr_slave_lock
);
1058 bond_select_active_slave(bond
);
1059 write_unlock_bh(&bond
->curr_slave_lock
);
1060 unblock_netpoll_tx();
1065 int bond_option_fail_over_mac_set(struct bonding
*bond
,
1066 struct bond_opt_value
*newval
)
1068 pr_info("%s: Setting fail_over_mac to %s (%llu).\n",
1069 bond
->dev
->name
, newval
->string
, newval
->value
);
1070 bond
->params
.fail_over_mac
= newval
->value
;
1075 int bond_option_xmit_hash_policy_set(struct bonding
*bond
,
1076 struct bond_opt_value
*newval
)
1078 pr_info("%s: setting xmit hash policy to %s (%llu).\n",
1079 bond
->dev
->name
, newval
->string
, newval
->value
);
1080 bond
->params
.xmit_policy
= newval
->value
;
1085 int bond_option_resend_igmp_set(struct bonding
*bond
,
1086 struct bond_opt_value
*newval
)
1088 pr_info("%s: Setting resend_igmp to %llu.\n",
1089 bond
->dev
->name
, newval
->value
);
1090 bond
->params
.resend_igmp
= newval
->value
;
1095 int bond_option_num_peer_notif_set(struct bonding
*bond
,
1096 struct bond_opt_value
*newval
)
1098 bond
->params
.num_peer_notif
= newval
->value
;
1103 int bond_option_all_slaves_active_set(struct bonding
*bond
,
1104 struct bond_opt_value
*newval
)
1106 struct list_head
*iter
;
1107 struct slave
*slave
;
1109 if (newval
->value
== bond
->params
.all_slaves_active
)
1111 bond
->params
.all_slaves_active
= newval
->value
;
1112 bond_for_each_slave(bond
, slave
, iter
) {
1113 if (!bond_is_active_slave(slave
)) {
1115 slave
->inactive
= 0;
1117 slave
->inactive
= 1;
1124 int bond_option_min_links_set(struct bonding
*bond
,
1125 struct bond_opt_value
*newval
)
1127 pr_info("%s: Setting min links value to %llu\n",
1128 bond
->dev
->name
, newval
->value
);
1129 bond
->params
.min_links
= newval
->value
;
1134 int bond_option_lp_interval_set(struct bonding
*bond
,
1135 struct bond_opt_value
*newval
)
1137 bond
->params
.lp_interval
= newval
->value
;
1142 int bond_option_pps_set(struct bonding
*bond
, struct bond_opt_value
*newval
)
1144 bond
->params
.packets_per_slave
= newval
->value
;
1145 if (newval
->value
> 0) {
1146 bond
->params
.reciprocal_packets_per_slave
=
1147 reciprocal_value(newval
->value
);
1149 /* reciprocal_packets_per_slave is unused if
1150 * packets_per_slave is 0 or 1, just initialize it
1152 bond
->params
.reciprocal_packets_per_slave
=
1153 (struct reciprocal_value
) { 0 };
1159 int bond_option_lacp_rate_set(struct bonding
*bond
,
1160 struct bond_opt_value
*newval
)
1162 pr_info("%s: Setting LACP rate to %s (%llu).\n",
1163 bond
->dev
->name
, newval
->string
, newval
->value
);
1164 bond
->params
.lacp_fast
= newval
->value
;
1165 bond_3ad_update_lacp_rate(bond
);
1170 int bond_option_ad_select_set(struct bonding
*bond
,
1171 struct bond_opt_value
*newval
)
1173 pr_info("%s: Setting ad_select to %s (%llu).\n",
1174 bond
->dev
->name
, newval
->string
, newval
->value
);
1175 bond
->params
.ad_select
= newval
->value
;
1180 int bond_option_queue_id_set(struct bonding
*bond
,
1181 struct bond_opt_value
*newval
)
1183 struct slave
*slave
, *update_slave
;
1184 struct net_device
*sdev
;
1185 struct list_head
*iter
;
1190 /* delim will point to queue id if successful */
1191 delim
= strchr(newval
->string
, ':');
1195 /* Terminate string that points to device name and bump it
1196 * up one, so we can read the queue id there.
1199 if (sscanf(++delim
, "%hd\n", &qid
) != 1)
1202 /* Check buffer length, valid ifname and queue id */
1203 if (strlen(newval
->string
) > IFNAMSIZ
||
1204 !dev_valid_name(newval
->string
) ||
1205 qid
> bond
->dev
->real_num_tx_queues
)
1208 /* Get the pointer to that interface if it exists */
1209 sdev
= __dev_get_by_name(dev_net(bond
->dev
), newval
->string
);
1213 /* Search for thes slave and check for duplicate qids */
1214 update_slave
= NULL
;
1215 bond_for_each_slave(bond
, slave
, iter
) {
1216 if (sdev
== slave
->dev
)
1217 /* We don't need to check the matching
1218 * slave for dups, since we're overwriting it
1220 update_slave
= slave
;
1221 else if (qid
&& qid
== slave
->queue_id
) {
1229 /* Actually set the qids for the slave */
1230 update_slave
->queue_id
= qid
;
1236 pr_info("invalid input for queue_id set for %s.\n",
1243 int bond_option_slaves_set(struct bonding
*bond
, struct bond_opt_value
*newval
)
1245 char command
[IFNAMSIZ
+ 1] = { 0, };
1246 struct net_device
*dev
;
1250 sscanf(newval
->string
, "%16s", command
); /* IFNAMSIZ*/
1251 ifname
= command
+ 1;
1252 if ((strlen(command
) <= 1) ||
1253 !dev_valid_name(ifname
))
1256 dev
= __dev_get_by_name(dev_net(bond
->dev
), ifname
);
1258 pr_info("%s: Interface %s does not exist!\n",
1259 bond
->dev
->name
, ifname
);
1264 switch (command
[0]) {
1266 pr_info("%s: Adding slave %s.\n", bond
->dev
->name
, dev
->name
);
1267 ret
= bond_enslave(bond
->dev
, dev
);
1271 pr_info("%s: Removing slave %s.\n", bond
->dev
->name
, dev
->name
);
1272 ret
= bond_release(bond
->dev
, dev
);
1283 pr_err("no command found in slaves file for bond %s. Use +ifname or -ifname.\n",