]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/net/bonding/bond_options.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bonding: convert min_links to use the new option API
[mirror_ubuntu-artful-kernel.git] / drivers / net / bonding / bond_options.c
CommitLineData
72be35fe
JP		 1/*
2 * drivers/net/bond/bond_options.c - bonding options
3 * Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us>
eecdaa6e 4 * Copyright (c) 2013 Scott Feldman <sfeldma@cumulusnetworks.com>
72be35fe
JP		 5 *
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.
10 */
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/errno.h>
15#include <linux/if.h>
d9e32b21
JP		 16#include <linux/netdevice.h>
17#include <linux/rwlock.h>
18#include <linux/rcupdate.h>
09117362 19#include <linux/ctype.h>
4fb0ef58 20#include <linux/inet.h>
72be35fe
JP		 21#include "bonding.h"
22
2b3798d5
NA		 23static 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},
31 { NULL, -1, 0},
32};
33
aa59d851
NA		 34static struct bond_opt_value bond_pps_tbl[] = {
35 { "default", 1, BOND_VALFLAG_DEFAULT},
36 { "maxval", USHRT_MAX, BOND_VALFLAG_MAX},
37 { NULL, -1, 0},
38};
39
a4b32ce7
NA		 40static 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},
46 { NULL, -1, 0},
47};
48
16228881
NA		 49static 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},
54 { NULL, -1, 0},
55};
56
edf36b24
NA		 57static 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},
60 { NULL, -1, 0},
61};
62
1df6b6aa
NA		 63static 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},
67 { NULL, -1, 0},
68};
69
7bdb04ed
NA		 70static struct bond_opt_value bond_intmax_tbl[] = {
71 { "off", 0, BOND_VALFLAG_DEFAULT},
72 { "maxval", INT_MAX, BOND_VALFLAG_MAX},
73};
74
d3131de7
NA		 75static struct bond_opt_value bond_lacp_rate_tbl[] = {
76 { "slow", AD_LACP_SLOW, 0},
77 { "fast", AD_LACP_FAST, 0},
78 { NULL, -1, 0},
79};
80
09117362 81static struct bond_option bond_opts[] = {
2b3798d5
NA		 82 [BOND_OPT_MODE] = {
83 .id = BOND_OPT_MODE,
84 .name = "mode",
85 .desc = "bond device mode",
86 .flags = BOND_OPTFLAG_NOSLAVES | BOND_OPTFLAG_IFDOWN,
87 .values = bond_mode_tbl,
88 .set = bond_option_mode_set
89 },
aa59d851
NA		 90 [BOND_OPT_PACKETS_PER_SLAVE] = {
91 .id = BOND_OPT_PACKETS_PER_SLAVE,
92 .name = "packets_per_slave",
93 .desc = "Packets to send per slave in RR mode",
94 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ROUNDROBIN)),
95 .values = bond_pps_tbl,
96 .set = bond_option_pps_set
97 },
a4b32ce7
NA		 98 [BOND_OPT_XMIT_HASH] = {
99 .id = BOND_OPT_XMIT_HASH,
100 .name = "xmit_hash_policy",
101 .desc = "balance-xor and 802.3ad hashing method",
102 .values = bond_xmit_hashtype_tbl,
103 .set = bond_option_xmit_hash_policy_set
104 },
16228881
NA		 105 [BOND_OPT_ARP_VALIDATE] = {
106 .id = BOND_OPT_ARP_VALIDATE,
107 .name = "arp_validate",
108 .desc = "validate src/dst of ARP probes",
109 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP)),
110 .values = bond_arp_validate_tbl,
111 .set = bond_option_arp_validate_set
112 },
edf36b24
NA		 113 [BOND_OPT_ARP_ALL_TARGETS] = {
114 .id = BOND_OPT_ARP_ALL_TARGETS,
115 .name = "arp_all_targets",
116 .desc = "fail on any/all arp targets timeout",
117 .values = bond_arp_all_targets_tbl,
118 .set = bond_option_arp_all_targets_set
119 },
1df6b6aa
NA		 120 [BOND_OPT_FAIL_OVER_MAC] = {
121 .id = BOND_OPT_FAIL_OVER_MAC,
122 .name = "fail_over_mac",
123 .desc = "For active-backup, do not set all slaves to the same MAC",
124 .flags = BOND_OPTFLAG_NOSLAVES,
125 .values = bond_fail_over_mac_tbl,
126 .set = bond_option_fail_over_mac_set
127 },
7bdb04ed
NA		 128 [BOND_OPT_ARP_INTERVAL] = {
129 .id = BOND_OPT_ARP_INTERVAL,
130 .name = "arp_interval",
131 .desc = "arp interval in milliseconds",
132 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) |
133 BIT(BOND_MODE_ALB),
134 .values = bond_intmax_tbl,
135 .set = bond_option_arp_interval_set
136 },
4fb0ef58
NA		 137 [BOND_OPT_ARP_TARGETS] = {
138 .id = BOND_OPT_ARP_TARGETS,
139 .name = "arp_ip_target",
140 .desc = "arp targets in n.n.n.n form",
141 .flags = BOND_OPTFLAG_RAWVAL,
142 .set = bond_option_arp_ip_targets_set
143 },
25a9b54a
NA		 144 [BOND_OPT_DOWNDELAY] = {
145 .id = BOND_OPT_DOWNDELAY,
146 .name = "downdelay",
147 .desc = "Delay before considering link down, in milliseconds",
148 .values = bond_intmax_tbl,
149 .set = bond_option_downdelay_set
150 },
e4994612
NA		 151 [BOND_OPT_UPDELAY] = {
152 .id = BOND_OPT_UPDELAY,
153 .name = "updelay",
154 .desc = "Delay before considering link up, in milliseconds",
155 .values = bond_intmax_tbl,
156 .set = bond_option_updelay_set
157 },
d3131de7
NA		 158 [BOND_OPT_LACP_RATE] = {
159 .id = BOND_OPT_LACP_RATE,
160 .name = "lacp_rate",
161 .desc = "LACPDU tx rate to request from 802.3ad partner",
162 .flags = BOND_OPTFLAG_IFDOWN,
163 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)),
164 .values = bond_lacp_rate_tbl,
165 .set = bond_option_lacp_rate_set
166 },
633ddc9e
NA		 167 [BOND_OPT_MINLINKS] = {
168 .id = BOND_OPT_MINLINKS,
169 .name = "min_links",
170 .desc = "Minimum number of available links before turning on carrier",
171 .values = bond_intmax_tbl,
172 .set = bond_option_min_links_set
173 },
09117362
NA		 174 { }
175};
176
177/* Searches for a value in opt's values[] table */
178struct bond_opt_value *bond_opt_get_val(unsigned int option, u64 val)
179{
180 struct bond_option *opt;
181 int i;
182
183 opt = bond_opt_get(option);
184 if (WARN_ON(!opt))
185 return NULL;
186 for (i = 0; opt->values && opt->values[i].string; i++)
187 if (opt->values[i].value == val)
188 return &opt->values[i];
189
190 return NULL;
191}
192
193/* Searches for a value in opt's values[] table which matches the flagmask */
194static struct bond_opt_value *bond_opt_get_flags(const struct bond_option *opt,
195 u32 flagmask)
196{
197 int i;
198
199 for (i = 0; opt->values && opt->values[i].string; i++)
200 if (opt->values[i].flags & flagmask)
201 return &opt->values[i];
202
203 return NULL;
204}
205
206/* If maxval is missing then there's no range to check. In case minval is
207 * missing then it's considered to be 0.
208 */
209static bool bond_opt_check_range(const struct bond_option *opt, u64 val)
210{
211 struct bond_opt_value *minval, *maxval;
212
213 minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN);
214 maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX);
215 if (!maxval || (minval && val < minval->value) || val > maxval->value)
216 return false;
217
218 return true;
219}
220
221/**
222 * bond_opt_parse - parse option value
223 * @opt: the option to parse against
224 * @val: value to parse
225 *
226 * This function tries to extract the value from @val and check if it's
227 * a possible match for the option and returns NULL if a match isn't found,
228 * or the struct_opt_value that matched. It also strips the new line from
229 * @val->string if it's present.
230 */
231struct bond_opt_value *bond_opt_parse(const struct bond_option *opt,
232 struct bond_opt_value *val)
233{
234 char *p, valstr[BOND_OPT_MAX_NAMELEN + 1] = { 0, };
235 struct bond_opt_value *tbl, *ret = NULL;
236 bool checkval;
237 int i, rv;
238
239 /* No parsing if the option wants a raw val */
240 if (opt->flags & BOND_OPTFLAG_RAWVAL)
241 return val;
242
243 tbl = opt->values;
244 if (!tbl)
245 goto out;
246
247 /* ULLONG_MAX is used to bypass string processing */
248 checkval = val->value != ULLONG_MAX;
249 if (!checkval) {
250 if (!val->string)
251 goto out;
252 p = strchr(val->string, '\n');
253 if (p)
254 *p = '\0';
255 for (p = val->string; *p; p++)
256 if (!(isdigit(*p) || isspace(*p)))
257 break;
258 /* The following code extracts the string to match or the value
259 * and sets checkval appropriately
260 */
261 if (*p) {
262 rv = sscanf(val->string, "%32s", valstr);
263 } else {
264 rv = sscanf(val->string, "%llu", &val->value);
265 checkval = true;
266 }
267 if (!rv)
268 goto out;
269 }
270
271 for (i = 0; tbl[i].string; i++) {
272 /* Check for exact match */
273 if (checkval) {
274 if (val->value == tbl[i].value)
275 ret = &tbl[i];
276 } else {
277 if (!strcmp(valstr, "default") &&
278 (tbl[i].flags & BOND_VALFLAG_DEFAULT))
279 ret = &tbl[i];
280
281 if (!strcmp(valstr, tbl[i].string))
282 ret = &tbl[i];
283 }
284 /* Found an exact match */
285 if (ret)
286 goto out;
287 }
288 /* Possible range match */
289 if (checkval && bond_opt_check_range(opt, val->value))
290 ret = val;
291out:
292 return ret;
293}
294
295/* Check opt's dependencies against bond mode and currently set options */
296static int bond_opt_check_deps(struct bonding *bond,
297 const struct bond_option *opt)
298{
299 struct bond_params *params = &bond->params;
300
301 if (test_bit(params->mode, &opt->unsuppmodes))
302 return -EACCES;
303 if ((opt->flags & BOND_OPTFLAG_NOSLAVES) && bond_has_slaves(bond))
304 return -ENOTEMPTY;
305 if ((opt->flags & BOND_OPTFLAG_IFDOWN) && (bond->dev->flags & IFF_UP))
306 return -EBUSY;
307
308 return 0;
309}
310
311static void bond_opt_dep_print(struct bonding *bond,
312 const struct bond_option *opt)
313{
2b3798d5 314 struct bond_opt_value *modeval;
09117362
NA		 315 struct bond_params *params;
316
317 params = &bond->params;
2b3798d5 318 modeval = bond_opt_get_val(BOND_OPT_MODE, params->mode);
09117362 319 if (test_bit(params->mode, &opt->unsuppmodes))
2b3798d5
NA		 320 pr_err("%s: option %s: mode dependency failed, not supported in mode %s(%llu)\n",
321 bond->dev->name, opt->name,
322 modeval->string, modeval->value);
09117362
NA		 323}
324
325static void bond_opt_error_interpret(struct bonding *bond,
326 const struct bond_option *opt,
327 int error, struct bond_opt_value *val)
328{
329 struct bond_opt_value *minval, *maxval;
330 char *p;
331
332 switch (error) {
333 case -EINVAL:
334 if (val) {
335 if (val->string) {
336 /* sometimes RAWVAL opts may have new lines */
337 p = strchr(val->string, '\n');
338 if (p)
339 *p = '\0';
340 pr_err("%s: option %s: invalid value (%s).\n",
341 bond->dev->name, opt->name, val->string);
342 } else {
343 pr_err("%s: option %s: invalid value (%llu).\n",
344 bond->dev->name, opt->name, val->value);
345 }
346 }
347 minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN);
348 maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX);
349 if (!maxval)
350 break;
351 pr_err("%s: option %s: allowed values %llu - %llu.\n",
352 bond->dev->name, opt->name, minval ? minval->value : 0,
353 maxval->value);
354 break;
355 case -EACCES:
356 bond_opt_dep_print(bond, opt);
357 break;
358 case -ENOTEMPTY:
359 pr_err("%s: option %s: unable to set because the bond device has slaves.\n",
360 bond->dev->name, opt->name);
361 break;
362 case -EBUSY:
363 pr_err("%s: option %s: unable to set because the bond device is up.\n",
364 bond->dev->name, opt->name);
365 break;
366 default:
367 break;
368 }
369}
370
371/**
372 * __bond_opt_set - set a bonding option
373 * @bond: target bond device
374 * @option: option to set
375 * @val: value to set it to
376 *
377 * This function is used to change the bond's option value, it can be
378 * used for both enabling/changing an option and for disabling it. RTNL lock
379 * must be obtained before calling this function.
380 */
381int __bond_opt_set(struct bonding *bond,
382 unsigned int option, struct bond_opt_value *val)
383{
384 struct bond_opt_value *retval = NULL;
385 const struct bond_option *opt;
386 int ret = -ENOENT;
387
388 ASSERT_RTNL();
389
390 opt = bond_opt_get(option);
391 if (WARN_ON(!val) || WARN_ON(!opt))
392 goto out;
393 ret = bond_opt_check_deps(bond, opt);
394 if (ret)
395 goto out;
396 retval = bond_opt_parse(opt, val);
397 if (!retval) {
398 ret = -EINVAL;
399 goto out;
400 }
401 ret = opt->set(bond, retval);
402out:
403 if (ret)
404 bond_opt_error_interpret(bond, opt, ret, val);
405
406 return ret;
407}
408
409/**
410 * bond_opt_tryset_rtnl - try to acquire rtnl and call __bond_opt_set
411 * @bond: target bond device
412 * @option: option to set
413 * @buf: value to set it to
414 *
415 * This function tries to acquire RTNL without blocking and if successful
416 * calls __bond_opt_set. It is mainly used for sysfs option manipulation.
417 */
418int bond_opt_tryset_rtnl(struct bonding *bond, unsigned int option, char *buf)
419{
420 struct bond_opt_value optval;
421 int ret;
422
423 if (!rtnl_trylock())
424 return restart_syscall();
425 bond_opt_initstr(&optval, buf);
426 ret = __bond_opt_set(bond, option, &optval);
427 rtnl_unlock();
428
429 return ret;
430}
431
432/**
433 * bond_opt_get - get a pointer to an option
434 * @option: option for which to return a pointer
435 *
436 * This function checks if option is valid and if so returns a pointer
437 * to its entry in the bond_opts[] option array.
438 */
439struct bond_option *bond_opt_get(unsigned int option)
440{
441 if (!BOND_OPT_VALID(option))
442 return NULL;
443
444 return &bond_opts[option];
445}
446
2b3798d5 447int bond_option_mode_set(struct bonding *bond, struct bond_opt_value *newval)
72be35fe 448{
2b3798d5 449 if (BOND_NO_USES_ARP(newval->value) && bond->params.arp_interval) {
fe9d04af 450 pr_info("%s: %s mode is incompatible with arp monitoring, start mii monitoring\n",
2b3798d5 451 bond->dev->name, newval->string);
fe9d04af 452 /* disable arp monitoring */
453 bond->params.arp_interval = 0;
454 /* set miimon to default value */
455 bond->params.miimon = BOND_DEFAULT_MIIMON;
456 pr_info("%s: Setting MII monitoring interval to %d.\n",
457 bond->dev->name, bond->params.miimon);
72be35fe
JP		 458 }
459
460 /* don't cache arp_validate between modes */
461 bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
2b3798d5
NA		 462 bond->params.mode = newval->value;
463
72be35fe
JP		 464 return 0;
465}
d9e32b21 466
752d48b5
JP		 467static struct net_device *__bond_option_active_slave_get(struct bonding *bond,
468 struct slave *slave)
469{
470 return USES_PRIMARY(bond->params.mode) && slave ? slave->dev : NULL;
471}
472
473struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond)
474{
475 struct slave *slave = rcu_dereference(bond->curr_active_slave);
476
477 return __bond_option_active_slave_get(bond, slave);
478}
479
480struct net_device *bond_option_active_slave_get(struct bonding *bond)
481{
482 return __bond_option_active_slave_get(bond, bond->curr_active_slave);
483}
484
d9e32b21
JP		 485int bond_option_active_slave_set(struct bonding *bond,
486 struct net_device *slave_dev)
487{
488 int ret = 0;
489
490 if (slave_dev) {
491 if (!netif_is_bond_slave(slave_dev)) {
492 pr_err("Device %s is not bonding slave.\n",
493 slave_dev->name);
494 return -EINVAL;
495 }
496
497 if (bond->dev != netdev_master_upper_dev_get(slave_dev)) {
498 pr_err("%s: Device %s is not our slave.\n",
499 bond->dev->name, slave_dev->name);
500 return -EINVAL;
501 }
502 }
503
504 if (!USES_PRIMARY(bond->params.mode)) {
505 pr_err("%s: Unable to change active slave; %s is in mode %d\n",
506 bond->dev->name, bond->dev->name, bond->params.mode);
507 return -EINVAL;
508 }
509
510 block_netpoll_tx();
d9e32b21
JP		 511 write_lock_bh(&bond->curr_slave_lock);
512
513 /* check to see if we are clearing active */
514 if (!slave_dev) {
515 pr_info("%s: Clearing current active slave.\n",
516 bond->dev->name);
517 rcu_assign_pointer(bond->curr_active_slave, NULL);
518 bond_select_active_slave(bond);
519 } else {
520 struct slave *old_active = bond->curr_active_slave;
521 struct slave *new_active = bond_slave_get_rtnl(slave_dev);
522
523 BUG_ON(!new_active);
524
525 if (new_active == old_active) {
526 /* do nothing */
527 pr_info("%s: %s is already the current active slave.\n",
528 bond->dev->name, new_active->dev->name);
529 } else {
530 if (old_active && (new_active->link == BOND_LINK_UP) &&
531 IS_UP(new_active->dev)) {
532 pr_info("%s: Setting %s as active slave.\n",
533 bond->dev->name, new_active->dev->name);
534 bond_change_active_slave(bond, new_active);
535 } else {
536 pr_err("%s: Could not set %s as active slave; either %s is down or the link is down.\n",
537 bond->dev->name, new_active->dev->name,
538 new_active->dev->name);
539 ret = -EINVAL;
540 }
541 }
542 }
543
544 write_unlock_bh(&bond->curr_slave_lock);
d9e32b21
JP		 545 unblock_netpoll_tx();
546 return ret;
547}
eecdaa6e 548
549int bond_option_miimon_set(struct bonding *bond, int miimon)
550{
551 if (miimon < 0) {
552 pr_err("%s: Invalid miimon value %d not in range %d-%d; rejected.\n",
553 bond->dev->name, miimon, 0, INT_MAX);
554 return -EINVAL;
555 }
556 pr_info("%s: Setting MII monitoring interval to %d.\n",
557 bond->dev->name, miimon);
558 bond->params.miimon = miimon;
559 if (bond->params.updelay)
560 pr_info("%s: Note: Updating updelay (to %d) since it is a multiple of the miimon value.\n",
561 bond->dev->name,
562 bond->params.updelay * bond->params.miimon);
563 if (bond->params.downdelay)
564 pr_info("%s: Note: Updating downdelay (to %d) since it is a multiple of the miimon value.\n",
565 bond->dev->name,
566 bond->params.downdelay * bond->params.miimon);
567 if (miimon && bond->params.arp_interval) {
568 pr_info("%s: MII monitoring cannot be used with ARP monitoring. Disabling ARP monitoring...\n",
569 bond->dev->name);
570 bond->params.arp_interval = 0;
571 if (bond->params.arp_validate)
572 bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
573 }
574 if (bond->dev->flags & IFF_UP) {
575 /* If the interface is up, we may need to fire off
576 * the MII timer. If the interface is down, the
577 * timer will get fired off when the open function
578 * is called.
579 */
580 if (!miimon) {
581 cancel_delayed_work_sync(&bond->mii_work);
582 } else {
583 cancel_delayed_work_sync(&bond->arp_work);
584 queue_delayed_work(bond->wq, &bond->mii_work, 0);
585 }
586 }
587 return 0;
588}
25852e29 589
e4994612 590int bond_option_updelay_set(struct bonding *bond, struct bond_opt_value *newval)
25852e29 591{
e4994612 592 if (!bond->params.miimon) {
25852e29 593 pr_err("%s: Unable to set up delay as MII monitoring is disabled\n",
594 bond->dev->name);
595 return -EPERM;
596 }
e4994612
NA		 597 if ((newval->value % bond->params.miimon) != 0) {
598 pr_warn("%s: Warning: up delay (%llu) is not a multiple of miimon (%d), updelay rounded to %llu ms\n",
599 bond->dev->name, newval->value,
600 bond->params.miimon,
601 (newval->value / bond->params.miimon) *
602 bond->params.miimon);
25852e29 603 }
e4994612
NA		 604 bond->params.updelay = newval->value / bond->params.miimon;
605 pr_info("%s: Setting up delay to %d.\n",
606 bond->dev->name,
607 bond->params.updelay * bond->params.miimon);
25852e29 608
609 return 0;
610}
c7461f9b 611
25a9b54a
NA		 612int bond_option_downdelay_set(struct bonding *bond,
613 struct bond_opt_value *newval)
c7461f9b 614{
25a9b54a 615 if (!bond->params.miimon) {
c7461f9b 616 pr_err("%s: Unable to set down delay as MII monitoring is disabled\n",
617 bond->dev->name);
618 return -EPERM;
619 }
25a9b54a
NA		 620 if ((newval->value % bond->params.miimon) != 0) {
621 pr_warn("%s: Warning: down delay (%llu) is not a multiple of miimon (%d), delay rounded to %llu ms\n",
622 bond->dev->name, newval->value,
623 bond->params.miimon,
624 (newval->value / bond->params.miimon) *
625 bond->params.miimon);
c7461f9b 626 }
25a9b54a
NA		 627 bond->params.downdelay = newval->value / bond->params.miimon;
628 pr_info("%s: Setting down delay to %d.\n",
629 bond->dev->name,
630 bond->params.downdelay * bond->params.miimon);
c7461f9b 631
632 return 0;
633}
9f53e14e 634
635int bond_option_use_carrier_set(struct bonding *bond, int use_carrier)
636{
637 if ((use_carrier == 0) || (use_carrier == 1)) {
638 bond->params.use_carrier = use_carrier;
639 pr_info("%s: Setting use_carrier to %d.\n",
640 bond->dev->name, use_carrier);
641 } else {
642 pr_info("%s: Ignoring invalid use_carrier value %d.\n",
643 bond->dev->name, use_carrier);
644 }
645
646 return 0;
647}
06151dbc 648
7bdb04ed
NA		 649int bond_option_arp_interval_set(struct bonding *bond,
650 struct bond_opt_value *newval)
06151dbc 651{
7bdb04ed
NA		 652 pr_info("%s: Setting ARP monitoring interval to %llu.\n",
653 bond->dev->name, newval->value);
654 bond->params.arp_interval = newval->value;
655 if (newval->value) {
06151dbc 656 if (bond->params.miimon) {
657 pr_info("%s: ARP monitoring cannot be used with MII monitoring. %s Disabling MII monitoring.\n",
658 bond->dev->name, bond->dev->name);
659 bond->params.miimon = 0;
660 }
661 if (!bond->params.arp_targets[0])
662 pr_info("%s: ARP monitoring has been set up, but no ARP targets have been specified.\n",
663 bond->dev->name);
664 }
665 if (bond->dev->flags & IFF_UP) {
666 /* If the interface is up, we may need to fire off
667 * the ARP timer. If the interface is down, the
668 * timer will get fired off when the open function
669 * is called.
670 */
7bdb04ed 671 if (!newval->value) {
06151dbc 672 if (bond->params.arp_validate)
673 bond->recv_probe = NULL;
674 cancel_delayed_work_sync(&bond->arp_work);
675 } else {
676 /* arp_validate can be set only in active-backup mode */
677 if (bond->params.arp_validate)
678 bond->recv_probe = bond_arp_rcv;
679 cancel_delayed_work_sync(&bond->mii_work);
680 queue_delayed_work(bond->wq, &bond->arp_work, 0);
681 }
682 }
683
684 return 0;
685}
7f28fa10 686
687static void _bond_options_arp_ip_target_set(struct bonding *bond, int slot,
688 __be32 target,
689 unsigned long last_rx)
690{
691 __be32 *targets = bond->params.arp_targets;
692 struct list_head *iter;
693 struct slave *slave;
694
695 if (slot >= 0 && slot < BOND_MAX_ARP_TARGETS) {
696 bond_for_each_slave(bond, slave, iter)
697 slave->target_last_arp_rx[slot] = last_rx;
698 targets[slot] = target;
699 }
700}
701
702static int _bond_option_arp_ip_target_add(struct bonding *bond, __be32 target)
703{
704 __be32 *targets = bond->params.arp_targets;
705 int ind;
706
707 if (IS_IP_TARGET_UNUSABLE_ADDRESS(target)) {
708 pr_err("%s: invalid ARP target %pI4 specified for addition\n",
709 bond->dev->name, &target);
710 return -EINVAL;
711 }
712
713 if (bond_get_targets_ip(targets, target) != -1) { /* dup */
714 pr_err("%s: ARP target %pI4 is already present\n",
715 bond->dev->name, &target);
716 return -EINVAL;
717 }
718
719 ind = bond_get_targets_ip(targets, 0); /* first free slot */
720 if (ind == -1) {
721 pr_err("%s: ARP target table is full!\n",
722 bond->dev->name);
723 return -EINVAL;
724 }
725
726 pr_info("%s: adding ARP target %pI4.\n", bond->dev->name, &target);
727
728 _bond_options_arp_ip_target_set(bond, ind, target, jiffies);
729
730 return 0;
731}
732
733int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target)
734{
735 int ret;
736
737 /* not to race with bond_arp_rcv */
738 write_lock_bh(&bond->lock);
739 ret = _bond_option_arp_ip_target_add(bond, target);
740 write_unlock_bh(&bond->lock);
741
742 return ret;
743}
744
745int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target)
746{
747 __be32 *targets = bond->params.arp_targets;
748 struct list_head *iter;
749 struct slave *slave;
750 unsigned long *targets_rx;
751 int ind, i;
752
753 if (IS_IP_TARGET_UNUSABLE_ADDRESS(target)) {
754 pr_err("%s: invalid ARP target %pI4 specified for removal\n",
755 bond->dev->name, &target);
756 return -EINVAL;
757 }
758
759 ind = bond_get_targets_ip(targets, target);
760 if (ind == -1) {
761 pr_err("%s: unable to remove nonexistent ARP target %pI4.\n",
762 bond->dev->name, &target);
763 return -EINVAL;
764 }
765
766 if (ind == 0 && !targets[1] && bond->params.arp_interval)
767 pr_warn("%s: removing last arp target with arp_interval on\n",
768 bond->dev->name);
769
770 pr_info("%s: removing ARP target %pI4.\n", bond->dev->name,
771 &target);
772
773 /* not to race with bond_arp_rcv */
774 write_lock_bh(&bond->lock);
775
776 bond_for_each_slave(bond, slave, iter) {
777 targets_rx = slave->target_last_arp_rx;
778 for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++)
779 targets_rx[i] = targets_rx[i+1];
780 targets_rx[i] = 0;
781 }
782 for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++)
783 targets[i] = targets[i+1];
784 targets[i] = 0;
785
786 write_unlock_bh(&bond->lock);
787
788 return 0;
789}
790
4fb0ef58 791void bond_option_arp_ip_targets_clear(struct bonding *bond)
7f28fa10 792{
4fb0ef58 793 int i;
7f28fa10 794
795 /* not to race with bond_arp_rcv */
796 write_lock_bh(&bond->lock);
7f28fa10 797 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++)
798 _bond_options_arp_ip_target_set(bond, i, 0, 0);
4fb0ef58
NA		 799 write_unlock_bh(&bond->lock);
800}
7f28fa10 801
4fb0ef58
NA		 802int bond_option_arp_ip_targets_set(struct bonding *bond,
803 struct bond_opt_value *newval)
804{
805 int ret = -EPERM;
806 __be32 target;
807
808 if (newval->string) {
809 if (!in4_pton(newval->string+1, -1, (u8 *)&target, -1, NULL)) {
810 pr_err("%s: invalid ARP target %pI4 specified\n",
811 bond->dev->name, &target);
812 return ret;
813 }
814 if (newval->string[0] == '+')
815 ret = bond_option_arp_ip_target_add(bond, target);
816 else if (newval->string[0] == '-')
817 ret = bond_option_arp_ip_target_rem(bond, target);
818 else
819 pr_err("no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n",
820 bond->dev->name);
821 } else {
822 target = newval->value;
823 ret = bond_option_arp_ip_target_add(bond, target);
7f28fa10 824 }
825
7f28fa10 826 return ret;
827}
29c49482 828
16228881
NA		 829int bond_option_arp_validate_set(struct bonding *bond,
830 struct bond_opt_value *newval)
29c49482 831{
16228881
NA		 832 pr_info("%s: setting arp_validate to %s (%llu).\n",
833 bond->dev->name, newval->string, newval->value);
29c49482 834
835 if (bond->dev->flags & IFF_UP) {
16228881 836 if (!newval->value)
29c49482 837 bond->recv_probe = NULL;
838 else if (bond->params.arp_interval)
839 bond->recv_probe = bond_arp_rcv;
840 }
16228881 841 bond->params.arp_validate = newval->value;
29c49482 842
843 return 0;
844}
d5c84254 845
edf36b24
NA		 846int bond_option_arp_all_targets_set(struct bonding *bond,
847 struct bond_opt_value *newval)
d5c84254 848{
edf36b24
NA		 849 pr_info("%s: setting arp_all_targets to %s (%llu).\n",
850 bond->dev->name, newval->string, newval->value);
851 bond->params.arp_all_targets = newval->value;
d5c84254 852
853 return 0;
854}
0a98a0d1 855
856int bond_option_primary_set(struct bonding *bond, const char *primary)
857{
858 struct list_head *iter;
859 struct slave *slave;
860 int err = 0;
861
862 block_netpoll_tx();
863 read_lock(&bond->lock);
864 write_lock_bh(&bond->curr_slave_lock);
865
866 if (!USES_PRIMARY(bond->params.mode)) {
867 pr_err("%s: Unable to set primary slave; %s is in mode %d\n",
868 bond->dev->name, bond->dev->name, bond->params.mode);
869 err = -EINVAL;
870 goto out;
871 }
872
873 /* check to see if we are clearing primary */
874 if (!strlen(primary)) {
875 pr_info("%s: Setting primary slave to None.\n",
876 bond->dev->name);
877 bond->primary_slave = NULL;
878 memset(bond->params.primary, 0, sizeof(bond->params.primary));
879 bond_select_active_slave(bond);
880 goto out;
881 }
882
883 bond_for_each_slave(bond, slave, iter) {
884 if (strncmp(slave->dev->name, primary, IFNAMSIZ) == 0) {
885 pr_info("%s: Setting %s as primary slave.\n",
886 bond->dev->name, slave->dev->name);
887 bond->primary_slave = slave;
888 strcpy(bond->params.primary, slave->dev->name);
889 bond_select_active_slave(bond);
890 goto out;
891 }
892 }
893
894 strncpy(bond->params.primary, primary, IFNAMSIZ);
895 bond->params.primary[IFNAMSIZ - 1] = 0;
896
897 pr_info("%s: Recording %s as primary, but it has not been enslaved to %s yet.\n",
898 bond->dev->name, primary, bond->dev->name);
899
900out:
901 write_unlock_bh(&bond->curr_slave_lock);
902 read_unlock(&bond->lock);
903 unblock_netpoll_tx();
904
905 return err;
906}
8a41ae44 907
908int bond_option_primary_reselect_set(struct bonding *bond, int primary_reselect)
909{
3243c47b 910 if (bond_parm_tbl_lookup(primary_reselect, pri_reselect_tbl) < 0) {
911 pr_err("%s: Ignoring invalid primary_reselect value %d.\n",
912 bond->dev->name, primary_reselect);
913 return -EINVAL;
914 }
915
8a41ae44 916 bond->params.primary_reselect = primary_reselect;
917 pr_info("%s: setting primary_reselect to %s (%d).\n",
918 bond->dev->name, pri_reselect_tbl[primary_reselect].modename,
919 primary_reselect);
920
921 block_netpoll_tx();
922 write_lock_bh(&bond->curr_slave_lock);
923 bond_select_active_slave(bond);
924 write_unlock_bh(&bond->curr_slave_lock);
925 unblock_netpoll_tx();
926
927 return 0;
928}
89901972 929
1df6b6aa
NA		 930int bond_option_fail_over_mac_set(struct bonding *bond,
931 struct bond_opt_value *newval)
89901972 932{
1df6b6aa
NA		 933 pr_info("%s: Setting fail_over_mac to %s (%llu).\n",
934 bond->dev->name, newval->string, newval->value);
935 bond->params.fail_over_mac = newval->value;
89901972 936
937 return 0;
938}
f70161c6 939
a4b32ce7
NA		 940int bond_option_xmit_hash_policy_set(struct bonding *bond,
941 struct bond_opt_value *newval)
f70161c6 942{
a4b32ce7
NA		 943 pr_info("%s: setting xmit hash policy to %s (%llu).\n",
944 bond->dev->name, newval->string, newval->value);
945 bond->params.xmit_policy = newval->value;
f70161c6 946
947 return 0;
948}
d8838de7 949
950int bond_option_resend_igmp_set(struct bonding *bond, int resend_igmp)
951{
952 if (resend_igmp < 0 || resend_igmp > 255) {
953 pr_err("%s: Invalid resend_igmp value %d not in range 0-255; rejected.\n",
954 bond->dev->name, resend_igmp);
955 return -EINVAL;
956 }
957
958 bond->params.resend_igmp = resend_igmp;
959 pr_info("%s: Setting resend_igmp to %d.\n",
960 bond->dev->name, resend_igmp);
961
962 return 0;
963}
2c9839c1 964
965int bond_option_num_peer_notif_set(struct bonding *bond, int num_peer_notif)
966{
967 bond->params.num_peer_notif = num_peer_notif;
968 return 0;
969}
1cc0b1e3 970
971int bond_option_all_slaves_active_set(struct bonding *bond,
972 int all_slaves_active)
973{
974 struct list_head *iter;
975 struct slave *slave;
976
977 if (all_slaves_active == bond->params.all_slaves_active)
978 return 0;
979
980 if ((all_slaves_active == 0) || (all_slaves_active == 1)) {
981 bond->params.all_slaves_active = all_slaves_active;
982 } else {
983 pr_info("%s: Ignoring invalid all_slaves_active value %d.\n",
984 bond->dev->name, all_slaves_active);
985 return -EINVAL;
986 }
987
988 bond_for_each_slave(bond, slave, iter) {
989 if (!bond_is_active_slave(slave)) {
990 if (all_slaves_active)
991 slave->inactive = 0;
992 else
993 slave->inactive = 1;
994 }
995 }
996
997 return 0;
998}
7d101008 999
633ddc9e
NA		 1000int bond_option_min_links_set(struct bonding *bond,
1001 struct bond_opt_value *newval)
7d101008 1002{
633ddc9e
NA		 1003 pr_info("%s: Setting min links value to %llu\n",
1004 bond->dev->name, newval->value);
1005 bond->params.min_links = newval->value;
7d101008 1006
1007 return 0;
1008}
8d836d09 1009
1010int bond_option_lp_interval_set(struct bonding *bond, int lp_interval)
1011{
1012 if (lp_interval <= 0) {
1013 pr_err("%s: lp_interval must be between 1 and %d\n",
1014 bond->dev->name, INT_MAX);
1015 return -EINVAL;
1016 }
1017
1018 bond->params.lp_interval = lp_interval;
1019
1020 return 0;
1021}
c13ab3ff 1022
aa59d851 1023int bond_option_pps_set(struct bonding *bond, struct bond_opt_value *newval)
c13ab3ff 1024{
aa59d851
NA		 1025 bond->params.packets_per_slave = newval->value;
1026 if (newval->value > 0) {
809fa972 1027 bond->params.reciprocal_packets_per_slave =
aa59d851 1028 reciprocal_value(newval->value);
809fa972
HFS		 1029 } else {
1030 /* reciprocal_packets_per_slave is unused if
1031 * packets_per_slave is 0 or 1, just initialize it
1032 */
1033 bond->params.reciprocal_packets_per_slave =
1034 (struct reciprocal_value) { 0 };
1035 }
c13ab3ff 1036
1037 return 0;
1038}
998e40bb 1039
d3131de7
NA		 1040int bond_option_lacp_rate_set(struct bonding *bond,
1041 struct bond_opt_value *newval)
998e40bb 1042{
d3131de7
NA		 1043 pr_info("%s: Setting LACP rate to %s (%llu).\n",
1044 bond->dev->name, newval->string, newval->value);
1045 bond->params.lacp_fast = newval->value;
3243c47b 1046 bond_3ad_update_lacp_rate(bond);
998e40bb 1047
1048 return 0;
1049}
ec029fac 1050
1051int bond_option_ad_select_set(struct bonding *bond, int ad_select)
1052{
ec029fac 1053 if (bond_parm_tbl_lookup(ad_select, ad_select_tbl) < 0) {
1054 pr_err("%s: Ignoring invalid ad_select value %d.\n",
1055 bond->dev->name, ad_select);
1056 return -EINVAL;
1057 }
1058
3243c47b 1059 if (bond->dev->flags & IFF_UP) {
1060 pr_err("%s: Unable to update ad_select because interface is up.\n",
1061 bond->dev->name);
1062 return -EPERM;
1063 }
1064
ec029fac 1065 bond->params.ad_select = ad_select;
1066 pr_info("%s: Setting ad_select to %s (%d).\n",
1067 bond->dev->name, ad_select_tbl[ad_select].modename,
1068 ad_select);
1069
1070 return 0;
1071}
Ubuntu Artful kernel mirror