projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[deliverable/linux.git] / drivers / net / bonding / bond_options.c
1 /*
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>
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>
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>
21 #include "bonding.h"
22
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);
75
76
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},
85 { NULL, -1, 0},
86 };
87
88 static const struct bond_opt_value bond_pps_tbl[] = {
89 { "default", 1, BOND_VALFLAG_DEFAULT},
90 { "maxval", USHRT_MAX, BOND_VALFLAG_MAX},
91 { NULL, -1, 0},
92 };
93
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},
100 { NULL, -1, 0},
101 };
102
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},
111 { NULL, -1, 0},
112 };
113
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},
117 { NULL, -1, 0},
118 };
119
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},
124 { NULL, -1, 0},
125 };
126
127 static const struct bond_opt_value bond_intmax_tbl[] = {
128 { "off", 0, BOND_VALFLAG_DEFAULT},
129 { "maxval", INT_MAX, BOND_VALFLAG_MAX},
130 };
131
132 static const struct bond_opt_value bond_lacp_rate_tbl[] = {
133 { "slow", AD_LACP_SLOW, 0},
134 { "fast", AD_LACP_FAST, 0},
135 { NULL, -1, 0},
136 };
137
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},
142 { NULL, -1, 0},
143 };
144
145 static const struct bond_opt_value bond_num_peer_notif_tbl[] = {
146 { "off", 0, 0},
147 { "maxval", 255, BOND_VALFLAG_MAX},
148 { "default", 1, BOND_VALFLAG_DEFAULT},
149 { NULL, -1, 0}
150 };
151
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},
156 { NULL, -1},
157 };
158
159 static const struct bond_opt_value bond_use_carrier_tbl[] = {
160 { "off", 0, 0},
161 { "on", 1, BOND_VALFLAG_DEFAULT},
162 { NULL, -1, 0}
163 };
164
165 static const struct bond_opt_value bond_all_slaves_active_tbl[] = {
166 { "off", 0, BOND_VALFLAG_DEFAULT},
167 { "on", 1, 0},
168 { NULL, -1, 0}
169 };
170
171 static const struct bond_opt_value bond_resend_igmp_tbl[] = {
172 { "off", 0, 0},
173 { "maxval", 255, BOND_VALFLAG_MAX},
174 { "default", 1, BOND_VALFLAG_DEFAULT},
175 { NULL, -1, 0}
176 };
177
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},
181 { NULL, -1, 0},
182 };
183
184 static const struct bond_opt_value bond_tlb_dynamic_lb_tbl[] = {
185 { "off", 0, 0},
186 { "on", 1, BOND_VALFLAG_DEFAULT},
187 { NULL, -1, 0}
188 };
189
190 static const struct bond_option bond_opts[] = {
191 [BOND_OPT_MODE] = {
192 .id = BOND_OPT_MODE,
193 .name = "mode",
194 .desc = "bond device mode",
195 .flags = BOND_OPTFLAG_NOSLAVES | BOND_OPTFLAG_IFDOWN,
196 .values = bond_mode_tbl,
197 .set = bond_option_mode_set
198 },
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
206 },
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
213 },
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) |
219 BIT(BOND_MODE_ALB),
220 .values = bond_arp_validate_tbl,
221 .set = bond_option_arp_validate_set
222 },
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
229 },
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
237 },
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) |
243 BIT(BOND_MODE_ALB),
244 .values = bond_intmax_tbl,
245 .set = bond_option_arp_interval_set
246 },
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
253 },
254 [BOND_OPT_DOWNDELAY] = {
255 .id = BOND_OPT_DOWNDELAY,
256 .name = "downdelay",
257 .desc = "Delay before considering link down, in milliseconds",
258 .values = bond_intmax_tbl,
259 .set = bond_option_downdelay_set
260 },
261 [BOND_OPT_UPDELAY] = {
262 .id = BOND_OPT_UPDELAY,
263 .name = "updelay",
264 .desc = "Delay before considering link up, in milliseconds",
265 .values = bond_intmax_tbl,
266 .set = bond_option_updelay_set
267 },
268 [BOND_OPT_LACP_RATE] = {
269 .id = BOND_OPT_LACP_RATE,
270 .name = "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
276 },
277 [BOND_OPT_MINLINKS] = {
278 .id = BOND_OPT_MINLINKS,
279 .name = "min_links",
280 .desc = "Minimum number of available links before turning on carrier",
281 .values = bond_intmax_tbl,
282 .set = bond_option_min_links_set
283 },
284 [BOND_OPT_AD_SELECT] = {
285 .id = BOND_OPT_AD_SELECT,
286 .name = "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
291 },
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
298 },
299 [BOND_OPT_MIIMON] = {
300 .id = BOND_OPT_MIIMON,
301 .name = "miimon",
302 .desc = "Link check interval in milliseconds",
303 .values = bond_intmax_tbl,
304 .set = bond_option_miimon_set
305 },
306 [BOND_OPT_PRIMARY] = {
307 .id = BOND_OPT_PRIMARY,
308 .name = "primary",
309 .desc = "Primary network device to use",
310 .flags = BOND_OPTFLAG_RAWVAL,
311 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) |
312 BIT(BOND_MODE_TLB) |
313 BIT(BOND_MODE_ALB)),
314 .set = bond_option_primary_set
315 },
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
322 },
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
329 },
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) |
336 BIT(BOND_MODE_TLB) |
337 BIT(BOND_MODE_ALB)),
338 .set = bond_option_active_slave_set
339 },
340 [BOND_OPT_QUEUE_ID] = {
341 .id = BOND_OPT_QUEUE_ID,
342 .name = "queue_id",
343 .desc = "Set queue id of a slave",
344 .flags = BOND_OPTFLAG_RAWVAL,
345 .set = bond_option_queue_id_set
346 },
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
353 },
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
360 },
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
367 },
368 [BOND_OPT_SLAVES] = {
369 .id = BOND_OPT_SLAVES,
370 .name = "slaves",
371 .desc = "Slave membership management",
372 .flags = BOND_OPTFLAG_RAWVAL,
373 .set = bond_option_slaves_set
374 },
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,
383 },
384 { }
385 };
386
387 /* Searches for an option by name */
388 const struct bond_option *bond_opt_get_by_name(const char *name)
389 {
390 const struct bond_option *opt;
391 int option;
392
393 for (option = 0; option < BOND_OPT_LAST; option++) {
394 opt = bond_opt_get(option);
395 if (opt && !strcmp(opt->name, name))
396 return opt;
397 }
398
399 return NULL;
400 }
401
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)
404 {
405 const struct bond_option *opt;
406 int i;
407
408 opt = bond_opt_get(option);
409 if (WARN_ON(!opt))
410 return NULL;
411 for (i = 0; opt->values && opt->values[i].string; i++)
412 if (opt->values[i].value == val)
413 return &opt->values[i];
414
415 return NULL;
416 }
417
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,
420 u32 flagmask)
421 {
422 int i;
423
424 for (i = 0; opt->values && opt->values[i].string; i++)
425 if (opt->values[i].flags & flagmask)
426 return &opt->values[i];
427
428 return NULL;
429 }
430
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.
433 */
434 static bool bond_opt_check_range(const struct bond_option *opt, u64 val)
435 {
436 const struct bond_opt_value *minval, *maxval;
437
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)
441 return false;
442
443 return true;
444 }
445
446 /**
447 * bond_opt_parse - parse option value
448 * @opt: the option to parse against
449 * @val: value to parse
450 *
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.
455 */
456 const struct bond_opt_value *bond_opt_parse(const struct bond_option *opt,
457 struct bond_opt_value *val)
458 {
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;
462 bool checkval;
463 int i, rv;
464
465 /* No parsing if the option wants a raw val */
466 if (opt->flags & BOND_OPTFLAG_RAWVAL)
467 return val;
468
469 tbl = opt->values;
470 if (!tbl)
471 goto out;
472
473 /* ULLONG_MAX is used to bypass string processing */
474 checkval = val->value != ULLONG_MAX;
475 if (!checkval) {
476 if (!val->string)
477 goto out;
478 p = strchr(val->string, '\n');
479 if (p)
480 *p = '\0';
481 for (p = val->string; *p; p++)
482 if (!(isdigit(*p) || isspace(*p)))
483 break;
484 /* The following code extracts the string to match or the value
485 * and sets checkval appropriately
486 */
487 if (*p) {
488 rv = sscanf(val->string, "%32s", valstr);
489 } else {
490 rv = sscanf(val->string, "%llu", &val->value);
491 checkval = true;
492 }
493 if (!rv)
494 goto out;
495 }
496
497 for (i = 0; tbl[i].string; i++) {
498 /* Check for exact match */
499 if (checkval) {
500 if (val->value == tbl[i].value)
501 ret = &tbl[i];
502 } else {
503 if (!strcmp(valstr, "default") &&
504 (tbl[i].flags & BOND_VALFLAG_DEFAULT))
505 ret = &tbl[i];
506
507 if (!strcmp(valstr, tbl[i].string))
508 ret = &tbl[i];
509 }
510 /* Found an exact match */
511 if (ret)
512 goto out;
513 }
514 /* Possible range match */
515 if (checkval && bond_opt_check_range(opt, val->value))
516 ret = val;
517 out:
518 return ret;
519 }
520
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)
524 {
525 struct bond_params *params = &bond->params;
526
527 if (test_bit(params->mode, &opt->unsuppmodes))
528 return -EACCES;
529 if ((opt->flags & BOND_OPTFLAG_NOSLAVES) && bond_has_slaves(bond))
530 return -ENOTEMPTY;
531 if ((opt->flags & BOND_OPTFLAG_IFDOWN) && (bond->dev->flags & IFF_UP))
532 return -EBUSY;
533
534 return 0;
535 }
536
537 static void bond_opt_dep_print(struct bonding *bond,
538 const struct bond_option *opt)
539 {
540 const struct bond_opt_value *modeval;
541 struct bond_params *params;
542
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);
549 }
550
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)
554 {
555 const struct bond_opt_value *minval, *maxval;
556 char *p;
557
558 switch (error) {
559 case -EINVAL:
560 if (val) {
561 if (val->string) {
562 /* sometimes RAWVAL opts may have new lines */
563 p = strchr(val->string, '\n');
564 if (p)
565 *p = '\0';
566 pr_err("%s: option %s: invalid value (%s)\n",
567 bond->dev->name, opt->name, val->string);
568 } else {
569 pr_err("%s: option %s: invalid value (%llu)\n",
570 bond->dev->name, opt->name, val->value);
571 }
572 }
573 minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN);
574 maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX);
575 if (!maxval)
576 break;
577 pr_err("%s: option %s: allowed values %llu - %llu\n",
578 bond->dev->name, opt->name, minval ? minval->value : 0,
579 maxval->value);
580 break;
581 case -EACCES:
582 bond_opt_dep_print(bond, opt);
583 break;
584 case -ENOTEMPTY:
585 pr_err("%s: option %s: unable to set because the bond device has slaves\n",
586 bond->dev->name, opt->name);
587 break;
588 case -EBUSY:
589 pr_err("%s: option %s: unable to set because the bond device is up\n",
590 bond->dev->name, opt->name);
591 break;
592 default:
593 break;
594 }
595 }
596
597 /**
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
602 *
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.
606 */
607 int __bond_opt_set(struct bonding *bond,
608 unsigned int option, struct bond_opt_value *val)
609 {
610 const struct bond_opt_value *retval = NULL;
611 const struct bond_option *opt;
612 int ret = -ENOENT;
613
614 ASSERT_RTNL();
615
616 opt = bond_opt_get(option);
617 if (WARN_ON(!val) || WARN_ON(!opt))
618 goto out;
619 ret = bond_opt_check_deps(bond, opt);
620 if (ret)
621 goto out;
622 retval = bond_opt_parse(opt, val);
623 if (!retval) {
624 ret = -EINVAL;
625 goto out;
626 }
627 ret = opt->set(bond, retval);
628 out:
629 if (ret)
630 bond_opt_error_interpret(bond, opt, ret, val);
631
632 return ret;
633 }
634
635 /**
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
640 *
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.
643 */
644 int bond_opt_tryset_rtnl(struct bonding *bond, unsigned int option, char *buf)
645 {
646 struct bond_opt_value optval;
647 int ret;
648
649 if (!rtnl_trylock())
650 return restart_syscall();
651 bond_opt_initstr(&optval, buf);
652 ret = __bond_opt_set(bond, option, &optval);
653 rtnl_unlock();
654
655 return ret;
656 }
657
658 /**
659 * bond_opt_get - get a pointer to an option
660 * @option: option for which to return a pointer
661 *
662 * This function checks if option is valid and if so returns a pointer
663 * to its entry in the bond_opts[] option array.
664 */
665 const struct bond_option *bond_opt_get(unsigned int option)
666 {
667 if (!BOND_OPT_VALID(option))
668 return NULL;
669
670 return &bond_opts[option];
671 }
672
673 int bond_option_mode_set(struct bonding *bond, const struct bond_opt_value *newval)
674 {
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);
684 }
685
686 /* don't cache arp_validate between modes */
687 bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
688 bond->params.mode = newval->value;
689
690 return 0;
691 }
692
693 static struct net_device *__bond_option_active_slave_get(struct bonding *bond,
694 struct slave *slave)
695 {
696 return USES_PRIMARY(bond->params.mode) && slave ? slave->dev : NULL;
697 }
698
699 struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond)
700 {
701 struct slave *slave = rcu_dereference(bond->curr_active_slave);
702
703 return __bond_option_active_slave_get(bond, slave);
704 }
705
706 struct net_device *bond_option_active_slave_get(struct bonding *bond)
707 {
708 return __bond_option_active_slave_get(bond, bond->curr_active_slave);
709 }
710
711 static int bond_option_active_slave_set(struct bonding *bond,
712 const struct bond_opt_value *newval)
713 {
714 char ifname[IFNAMSIZ] = { 0, };
715 struct net_device *slave_dev;
716 int ret = 0;
717
718 sscanf(newval->string, "%15s", ifname); /* IFNAMSIZ */
719 if (!strlen(ifname) || newval->string[0] == '\n') {
720 slave_dev = NULL;
721 } else {
722 slave_dev = __dev_get_by_name(dev_net(bond->dev), ifname);
723 if (!slave_dev)
724 return -ENODEV;
725 }
726
727 if (slave_dev) {
728 if (!netif_is_bond_slave(slave_dev)) {
729 pr_err("Device %s is not bonding slave\n",
730 slave_dev->name);
731 return -EINVAL;
732 }
733
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);
737 return -EINVAL;
738 }
739 }
740
741 block_netpoll_tx();
742 write_lock_bh(&bond->curr_slave_lock);
743
744 /* check to see if we are clearing active */
745 if (!slave_dev) {
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);
749 } else {
750 struct slave *old_active = bond->curr_active_slave;
751 struct slave *new_active = bond_slave_get_rtnl(slave_dev);
752
753 BUG_ON(!new_active);
754
755 if (new_active == old_active) {
756 /* do nothing */
757 pr_info("%s: %s is already the current active slave\n",
758 bond->dev->name, new_active->dev->name);
759 } else {
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);
765 } else {
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);
769 ret = -EINVAL;
770 }
771 }
772 }
773
774 write_unlock_bh(&bond->curr_slave_lock);
775 unblock_netpoll_tx();
776
777 return ret;
778 }
779
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
782 * start it.
783 */
784 static int bond_option_miimon_set(struct bonding *bond,
785 const struct bond_opt_value *newval)
786 {
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",
792 bond->dev->name,
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",
796 bond->dev->name,
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",
800 bond->dev->name);
801 bond->params.arp_interval = 0;
802 if (bond->params.arp_validate)
803 bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
804 }
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
809 * is called.
810 */
811 if (!newval->value) {
812 cancel_delayed_work_sync(&bond->mii_work);
813 } else {
814 cancel_delayed_work_sync(&bond->arp_work);
815 queue_delayed_work(bond->wq, &bond->mii_work, 0);
816 }
817 }
818
819 return 0;
820 }
821
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.
825 */
826 static int bond_option_updelay_set(struct bonding *bond,
827 const struct bond_opt_value *newval)
828 {
829 int value = newval->value;
830
831 if (!bond->params.miimon) {
832 pr_err("%s: Unable to set up delay as MII monitoring is disabled\n",
833 bond->dev->name);
834 return -EPERM;
835 }
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,
839 bond->params.miimon,
840 (value / bond->params.miimon) *
841 bond->params.miimon);
842 }
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);
846
847 return 0;
848 }
849
850 static int bond_option_downdelay_set(struct bonding *bond,
851 const struct bond_opt_value *newval)
852 {
853 int value = newval->value;
854
855 if (!bond->params.miimon) {
856 pr_err("%s: Unable to set down delay as MII monitoring is disabled\n",
857 bond->dev->name);
858 return -EPERM;
859 }
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,
863 bond->params.miimon,
864 (value / bond->params.miimon) *
865 bond->params.miimon);
866 }
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);
870
871 return 0;
872 }
873
874 static int bond_option_use_carrier_set(struct bonding *bond,
875 const struct bond_opt_value *newval)
876 {
877 pr_info("%s: Setting use_carrier to %llu\n",
878 bond->dev->name, newval->value);
879 bond->params.use_carrier = newval->value;
880
881 return 0;
882 }
883
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,
886 * we must start it.
887 */
888 static int bond_option_arp_interval_set(struct bonding *bond,
889 const struct bond_opt_value *newval)
890 {
891 pr_info("%s: Setting ARP monitoring interval to %llu\n",
892 bond->dev->name, newval->value);
893 bond->params.arp_interval = newval->value;
894 if (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;
899 }
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",
902 bond->dev->name);
903 }
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
908 * is called.
909 */
910 if (!newval->value) {
911 if (bond->params.arp_validate)
912 bond->recv_probe = NULL;
913 cancel_delayed_work_sync(&bond->arp_work);
914 } else {
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);
919 }
920 }
921
922 return 0;
923 }
924
925 static void _bond_options_arp_ip_target_set(struct bonding *bond, int slot,
926 __be32 target,
927 unsigned long last_rx)
928 {
929 __be32 *targets = bond->params.arp_targets;
930 struct list_head *iter;
931 struct slave *slave;
932
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;
937 }
938 }
939
940 static int _bond_option_arp_ip_target_add(struct bonding *bond, __be32 target)
941 {
942 __be32 *targets = bond->params.arp_targets;
943 int ind;
944
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);
948 return -EINVAL;
949 }
950
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);
954 return -EINVAL;
955 }
956
957 ind = bond_get_targets_ip(targets, 0); /* first free slot */
958 if (ind == -1) {
959 pr_err("%s: ARP target table is full!\n", bond->dev->name);
960 return -EINVAL;
961 }
962
963 pr_info("%s: Adding ARP target %pI4\n", bond->dev->name, &target);
964
965 _bond_options_arp_ip_target_set(bond, ind, target, jiffies);
966
967 return 0;
968 }
969
970 static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target)
971 {
972 int ret;
973
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);
978
979 return ret;
980 }
981
982 static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target)
983 {
984 __be32 *targets = bond->params.arp_targets;
985 struct list_head *iter;
986 struct slave *slave;
987 unsigned long *targets_rx;
988 int ind, i;
989
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);
993 return -EINVAL;
994 }
995
996 ind = bond_get_targets_ip(targets, target);
997 if (ind == -1) {
998 pr_err("%s: unable to remove nonexistent ARP target %pI4\n",
999 bond->dev->name, &target);
1000 return -EINVAL;
1001 }
1002
1003 if (ind == 0 && !targets[1] && bond->params.arp_interval)
1004 pr_warn("%s: Removing last arp target with arp_interval on\n",
1005 bond->dev->name);
1006
1007 pr_info("%s: Removing ARP target %pI4\n", bond->dev->name, &target);
1008
1009 /* not to race with bond_arp_rcv */
1010 write_lock_bh(&bond->lock);
1011
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];
1016 targets_rx[i] = 0;
1017 }
1018 for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++)
1019 targets[i] = targets[i+1];
1020 targets[i] = 0;
1021
1022 write_unlock_bh(&bond->lock);
1023
1024 return 0;
1025 }
1026
1027 void bond_option_arp_ip_targets_clear(struct bonding *bond)
1028 {
1029 int i;
1030
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);
1036 }
1037
1038 static int bond_option_arp_ip_targets_set(struct bonding *bond,
1039 const struct bond_opt_value *newval)
1040 {
1041 int ret = -EPERM;
1042 __be32 target;
1043
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);
1048 return ret;
1049 }
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);
1054 else
1055 pr_err("no command found in arp_ip_targets file for bond %s - use +<addr> or -<addr>\n",
1056 bond->dev->name);
1057 } else {
1058 target = newval->value;
1059 ret = bond_option_arp_ip_target_add(bond, target);
1060 }
1061
1062 return ret;
1063 }
1064
1065 static int bond_option_arp_validate_set(struct bonding *bond,
1066 const struct bond_opt_value *newval)
1067 {
1068 pr_info("%s: Setting arp_validate to %s (%llu)\n",
1069 bond->dev->name, newval->string, newval->value);
1070
1071 if (bond->dev->flags & IFF_UP) {
1072 if (!newval->value)
1073 bond->recv_probe = NULL;
1074 else if (bond->params.arp_interval)
1075 bond->recv_probe = bond_arp_rcv;
1076 }
1077 bond->params.arp_validate = newval->value;
1078
1079 return 0;
1080 }
1081
1082 static int bond_option_arp_all_targets_set(struct bonding *bond,
1083 const struct bond_opt_value *newval)
1084 {
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;
1088
1089 return 0;
1090 }
1091
1092 static int bond_option_primary_set(struct bonding *bond,
1093 const struct bond_opt_value *newval)
1094 {
1095 char *p, *primary = newval->string;
1096 struct list_head *iter;
1097 struct slave *slave;
1098
1099 block_netpoll_tx();
1100 read_lock(&bond->lock);
1101 write_lock_bh(&bond->curr_slave_lock);
1102
1103 p = strchr(primary, '\n');
1104 if (p)
1105 *p = '\0';
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);
1112 goto out;
1113 }
1114
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);
1122 goto out;
1123 }
1124 }
1125
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);
1130 }
1131 strncpy(bond->params.primary, primary, IFNAMSIZ);
1132 bond->params.primary[IFNAMSIZ - 1] = 0;
1133
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);
1136
1137 out:
1138 write_unlock_bh(&bond->curr_slave_lock);
1139 read_unlock(&bond->lock);
1140 unblock_netpoll_tx();
1141
1142 return 0;
1143 }
1144
1145 static int bond_option_primary_reselect_set(struct bonding *bond,
1146 const struct bond_opt_value *newval)
1147 {
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;
1151
1152 block_netpoll_tx();
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();
1157
1158 return 0;
1159 }
1160
1161 static int bond_option_fail_over_mac_set(struct bonding *bond,
1162 const struct bond_opt_value *newval)
1163 {
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;
1167
1168 return 0;
1169 }
1170
1171 static int bond_option_xmit_hash_policy_set(struct bonding *bond,
1172 const struct bond_opt_value *newval)
1173 {
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;
1177
1178 return 0;
1179 }
1180
1181 static int bond_option_resend_igmp_set(struct bonding *bond,
1182 const struct bond_opt_value *newval)
1183 {
1184 pr_info("%s: Setting resend_igmp to %llu\n",
1185 bond->dev->name, newval->value);
1186 bond->params.resend_igmp = newval->value;
1187
1188 return 0;
1189 }
1190
1191 static int bond_option_num_peer_notif_set(struct bonding *bond,
1192 const struct bond_opt_value *newval)
1193 {
1194 bond->params.num_peer_notif = newval->value;
1195
1196 return 0;
1197 }
1198
1199 static int bond_option_all_slaves_active_set(struct bonding *bond,
1200 const struct bond_opt_value *newval)
1201 {
1202 struct list_head *iter;
1203 struct slave *slave;
1204
1205 if (newval->value == bond->params.all_slaves_active)
1206 return 0;
1207 bond->params.all_slaves_active = newval->value;
1208 bond_for_each_slave(bond, slave, iter) {
1209 if (!bond_is_active_slave(slave)) {
1210 if (newval->value)
1211 slave->inactive = 0;
1212 else
1213 slave->inactive = 1;
1214 }
1215 }
1216
1217 return 0;
1218 }
1219
1220 static int bond_option_min_links_set(struct bonding *bond,
1221 const struct bond_opt_value *newval)
1222 {
1223 pr_info("%s: Setting min links value to %llu\n",
1224 bond->dev->name, newval->value);
1225 bond->params.min_links = newval->value;
1226
1227 return 0;
1228 }
1229
1230 static int bond_option_lp_interval_set(struct bonding *bond,
1231 const struct bond_opt_value *newval)
1232 {
1233 bond->params.lp_interval = newval->value;
1234
1235 return 0;
1236 }
1237
1238 static int bond_option_pps_set(struct bonding *bond,
1239 const struct bond_opt_value *newval)
1240 {
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);
1245 } else {
1246 /* reciprocal_packets_per_slave is unused if
1247 * packets_per_slave is 0 or 1, just initialize it
1248 */
1249 bond->params.reciprocal_packets_per_slave =
1250 (struct reciprocal_value) { 0 };
1251 }
1252
1253 return 0;
1254 }
1255
1256 static int bond_option_lacp_rate_set(struct bonding *bond,
1257 const struct bond_opt_value *newval)
1258 {
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);
1263
1264 return 0;
1265 }
1266
1267 static int bond_option_ad_select_set(struct bonding *bond,
1268 const struct bond_opt_value *newval)
1269 {
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;
1273
1274 return 0;
1275 }
1276
1277 static int bond_option_queue_id_set(struct bonding *bond,
1278 const struct bond_opt_value *newval)
1279 {
1280 struct slave *slave, *update_slave;
1281 struct net_device *sdev;
1282 struct list_head *iter;
1283 char *delim;
1284 int ret = 0;
1285 u16 qid;
1286
1287 /* delim will point to queue id if successful */
1288 delim = strchr(newval->string, ':');
1289 if (!delim)
1290 goto err_no_cmd;
1291
1292 /* Terminate string that points to device name and bump it
1293 * up one, so we can read the queue id there.
1294 */
1295 *delim = '\0';
1296 if (sscanf(++delim, "%hd\n", &qid) != 1)
1297 goto err_no_cmd;
1298
1299 /* Check buffer length, valid ifname and queue id */
1300 if (!dev_valid_name(newval->string) ||
1301 qid > bond->dev->real_num_tx_queues)
1302 goto err_no_cmd;
1303
1304 /* Get the pointer to that interface if it exists */
1305 sdev = __dev_get_by_name(dev_net(bond->dev), newval->string);
1306 if (!sdev)
1307 goto err_no_cmd;
1308
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
1315 */
1316 update_slave = slave;
1317 else if (qid && qid == slave->queue_id) {
1318 goto err_no_cmd;
1319 }
1320 }
1321
1322 if (!update_slave)
1323 goto err_no_cmd;
1324
1325 /* Actually set the qids for the slave */
1326 update_slave->queue_id = qid;
1327
1328 out:
1329 return ret;
1330
1331 err_no_cmd:
1332 pr_info("invalid input for queue_id set for %s\n", bond->dev->name);
1333 ret = -EPERM;
1334 goto out;
1335
1336 }
1337
1338 static int bond_option_slaves_set(struct bonding *bond,
1339 const struct bond_opt_value *newval)
1340 {
1341 char command[IFNAMSIZ + 1] = { 0, };
1342 struct net_device *dev;
1343 char *ifname;
1344 int ret;
1345
1346 sscanf(newval->string, "%16s", command); /* IFNAMSIZ*/
1347 ifname = command + 1;
1348 if ((strlen(command) <= 1) ||
1349 !dev_valid_name(ifname))
1350 goto err_no_cmd;
1351
1352 dev = __dev_get_by_name(dev_net(bond->dev), ifname);
1353 if (!dev) {
1354 pr_info("%s: interface %s does not exist!\n",
1355 bond->dev->name, ifname);
1356 ret = -ENODEV;
1357 goto out;
1358 }
1359
1360 switch (command[0]) {
1361 case '+':
1362 pr_info("%s: Adding slave %s\n", bond->dev->name, dev->name);
1363 ret = bond_enslave(bond->dev, dev);
1364 break;
1365
1366 case '-':
1367 pr_info("%s: Removing slave %s\n", bond->dev->name, dev->name);
1368 ret = bond_release(bond->dev, dev);
1369 break;
1370
1371 default:
1372 goto err_no_cmd;
1373 }
1374
1375 out:
1376 return ret;
1377
1378 err_no_cmd:
1379 pr_err("no command found in slaves file for bond %s - use +ifname or -ifname\n",
1380 bond->dev->name);
1381 ret = -EPERM;
1382 goto out;
1383 }
1384
1385 static int bond_option_tlb_dynamic_lb_set(struct bonding *bond,
1386 const struct bond_opt_value *newval)
1387 {
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;
1391
1392 return 0;
1393 }
Linux kernel - Deliverables
This page took 0.063203 seconds and 6 git commands to generate.