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 74 75 static const struct bond_opt_value bond_mode_tbl[] = { 76 { "balance-rr", BOND_MODE_ROUNDROBIN, BOND_VALFLAG_DEFAULT}, 77 { "active-backup", BOND_MODE_ACTIVEBACKUP, 0}, 78 { "balance-xor", BOND_MODE_XOR, 0}, 79 { "broadcast", BOND_MODE_BROADCAST, 0}, 80 { "802.3ad", BOND_MODE_8023AD, 0}, 81 { "balance-tlb", BOND_MODE_TLB, 0}, 82 { "balance-alb", BOND_MODE_ALB, 0}, 83 { NULL, -1, 0}, 84 }; 85 86 static const struct bond_opt_value bond_pps_tbl[] = { 87 { "default", 1, BOND_VALFLAG_DEFAULT}, 88 { "maxval", USHRT_MAX, BOND_VALFLAG_MAX}, 89 { NULL, -1, 0}, 90 }; 91 92 static const struct bond_opt_value bond_xmit_hashtype_tbl[] = { 93 { "layer2", BOND_XMIT_POLICY_LAYER2, BOND_VALFLAG_DEFAULT}, 94 { "layer3+4", BOND_XMIT_POLICY_LAYER34, 0}, 95 { "layer2+3", BOND_XMIT_POLICY_LAYER23, 0}, 96 { "encap2+3", BOND_XMIT_POLICY_ENCAP23, 0}, 97 { "encap3+4", BOND_XMIT_POLICY_ENCAP34, 0}, 98 { NULL, -1, 0}, 99 }; 100 101 static const struct bond_opt_value bond_arp_validate_tbl[] = { 102 { "none", BOND_ARP_VALIDATE_NONE, BOND_VALFLAG_DEFAULT}, 103 { "active", BOND_ARP_VALIDATE_ACTIVE, 0}, 104 { "backup", BOND_ARP_VALIDATE_BACKUP, 0}, 105 { "all", BOND_ARP_VALIDATE_ALL, 0}, 106 { "filter", BOND_ARP_FILTER, 0}, 107 { "filter_active", BOND_ARP_FILTER_ACTIVE, 0}, 108 { "filter_backup", BOND_ARP_FILTER_BACKUP, 0}, 109 { NULL, -1, 0}, 110 }; 111 112 static const struct bond_opt_value bond_arp_all_targets_tbl[] = { 113 { "any", BOND_ARP_TARGETS_ANY, BOND_VALFLAG_DEFAULT}, 114 { "all", BOND_ARP_TARGETS_ALL, 0}, 115 { NULL, -1, 0}, 116 }; 117 118 static const struct bond_opt_value bond_fail_over_mac_tbl[] = { 119 { "none", BOND_FOM_NONE, BOND_VALFLAG_DEFAULT}, 120 { "active", BOND_FOM_ACTIVE, 0}, 121 { "follow", BOND_FOM_FOLLOW, 0}, 122 { NULL, -1, 0}, 123 }; 124 125 static const struct bond_opt_value bond_intmax_tbl[] = { 126 { "off", 0, BOND_VALFLAG_DEFAULT}, 127 { "maxval", INT_MAX, BOND_VALFLAG_MAX}, 128 { NULL, -1, 0} 129 }; 130 131 static const struct bond_opt_value bond_lacp_rate_tbl[] = { 132 { "slow", AD_LACP_SLOW, 0}, 133 { "fast", AD_LACP_FAST, 0}, 134 { NULL, -1, 0}, 135 }; 136 137 static const struct bond_opt_value bond_ad_select_tbl[] = { 138 { "stable", BOND_AD_STABLE, BOND_VALFLAG_DEFAULT}, 139 { "bandwidth", BOND_AD_BANDWIDTH, 0}, 140 { "count", BOND_AD_COUNT, 0}, 141 { NULL, -1, 0}, 142 }; 143 144 static const struct bond_opt_value bond_num_peer_notif_tbl[] = { 145 { "off", 0, 0}, 146 { "maxval", 255, BOND_VALFLAG_MAX}, 147 { "default", 1, BOND_VALFLAG_DEFAULT}, 148 { NULL, -1, 0} 149 }; 150 151 static const struct bond_opt_value bond_primary_reselect_tbl[] = { 152 { "always", BOND_PRI_RESELECT_ALWAYS, BOND_VALFLAG_DEFAULT}, 153 { "better", BOND_PRI_RESELECT_BETTER, 0}, 154 { "failure", BOND_PRI_RESELECT_FAILURE, 0}, 155 { NULL, -1}, 156 }; 157 158 static const struct bond_opt_value bond_use_carrier_tbl[] = { 159 { "off", 0, 0}, 160 { "on", 1, BOND_VALFLAG_DEFAULT}, 161 { NULL, -1, 0} 162 }; 163 164 static const struct bond_opt_value bond_all_slaves_active_tbl[] = { 165 { "off", 0, BOND_VALFLAG_DEFAULT}, 166 { "on", 1, 0}, 167 { NULL, -1, 0} 168 }; 169 170 static const struct bond_opt_value bond_resend_igmp_tbl[] = { 171 { "off", 0, 0}, 172 { "maxval", 255, BOND_VALFLAG_MAX}, 173 { "default", 1, BOND_VALFLAG_DEFAULT}, 174 { NULL, -1, 0} 175 }; 176 177 static const struct bond_opt_value bond_lp_interval_tbl[] = { 178 { "minval", 1, BOND_VALFLAG_MIN | BOND_VALFLAG_DEFAULT}, 179 { "maxval", INT_MAX, BOND_VALFLAG_MAX}, 180 { NULL, -1, 0}, 181 }; 182 183 static const struct bond_option bond_opts[] = { 184 [BOND_OPT_MODE] = { 185 .id = BOND_OPT_MODE, 186 .name = "mode", 187 .desc = "bond device mode", 188 .flags = BOND_OPTFLAG_NOSLAVES | BOND_OPTFLAG_IFDOWN, 189 .values = bond_mode_tbl, 190 .set = bond_option_mode_set 191 }, 192 [BOND_OPT_PACKETS_PER_SLAVE] = { 193 .id = BOND_OPT_PACKETS_PER_SLAVE, 194 .name = "packets_per_slave", 195 .desc = "Packets to send per slave in RR mode", 196 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ROUNDROBIN)), 197 .values = bond_pps_tbl, 198 .set = bond_option_pps_set 199 }, 200 [BOND_OPT_XMIT_HASH] = { 201 .id = BOND_OPT_XMIT_HASH, 202 .name = "xmit_hash_policy", 203 .desc = "balance-xor and 802.3ad hashing method", 204 .values = bond_xmit_hashtype_tbl, 205 .set = bond_option_xmit_hash_policy_set 206 }, 207 [BOND_OPT_ARP_VALIDATE] = { 208 .id = BOND_OPT_ARP_VALIDATE, 209 .name = "arp_validate", 210 .desc = "validate src/dst of ARP probes", 211 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) | 212 BIT(BOND_MODE_ALB), 213 .values = bond_arp_validate_tbl, 214 .set = bond_option_arp_validate_set 215 }, 216 [BOND_OPT_ARP_ALL_TARGETS] = { 217 .id = BOND_OPT_ARP_ALL_TARGETS, 218 .name = "arp_all_targets", 219 .desc = "fail on any/all arp targets timeout", 220 .values = bond_arp_all_targets_tbl, 221 .set = bond_option_arp_all_targets_set 222 }, 223 [BOND_OPT_FAIL_OVER_MAC] = { 224 .id = BOND_OPT_FAIL_OVER_MAC, 225 .name = "fail_over_mac", 226 .desc = "For active-backup, do not set all slaves to the same MAC", 227 .flags = BOND_OPTFLAG_NOSLAVES, 228 .values = bond_fail_over_mac_tbl, 229 .set = bond_option_fail_over_mac_set 230 }, 231 [BOND_OPT_ARP_INTERVAL] = { 232 .id = BOND_OPT_ARP_INTERVAL, 233 .name = "arp_interval", 234 .desc = "arp interval in milliseconds", 235 .unsuppmodes = BIT(BOND_MODE_8023AD) | BIT(BOND_MODE_TLB) | 236 BIT(BOND_MODE_ALB), 237 .values = bond_intmax_tbl, 238 .set = bond_option_arp_interval_set 239 }, 240 [BOND_OPT_ARP_TARGETS] = { 241 .id = BOND_OPT_ARP_TARGETS, 242 .name = "arp_ip_target", 243 .desc = "arp targets in n.n.n.n form", 244 .flags = BOND_OPTFLAG_RAWVAL, 245 .set = bond_option_arp_ip_targets_set 246 }, 247 [BOND_OPT_DOWNDELAY] = { 248 .id = BOND_OPT_DOWNDELAY, 249 .name = "downdelay", 250 .desc = "Delay before considering link down, in milliseconds", 251 .values = bond_intmax_tbl, 252 .set = bond_option_downdelay_set 253 }, 254 [BOND_OPT_UPDELAY] = { 255 .id = BOND_OPT_UPDELAY, 256 .name = "updelay", 257 .desc = "Delay before considering link up, in milliseconds", 258 .values = bond_intmax_tbl, 259 .set = bond_option_updelay_set 260 }, 261 [BOND_OPT_LACP_RATE] = { 262 .id = BOND_OPT_LACP_RATE, 263 .name = "lacp_rate", 264 .desc = "LACPDU tx rate to request from 802.3ad partner", 265 .flags = BOND_OPTFLAG_IFDOWN, 266 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_8023AD)), 267 .values = bond_lacp_rate_tbl, 268 .set = bond_option_lacp_rate_set 269 }, 270 [BOND_OPT_MINLINKS] = { 271 .id = BOND_OPT_MINLINKS, 272 .name = "min_links", 273 .desc = "Minimum number of available links before turning on carrier", 274 .values = bond_intmax_tbl, 275 .set = bond_option_min_links_set 276 }, 277 [BOND_OPT_AD_SELECT] = { 278 .id = BOND_OPT_AD_SELECT, 279 .name = "ad_select", 280 .desc = "803.ad aggregation selection logic", 281 .flags = BOND_OPTFLAG_IFDOWN, 282 .values = bond_ad_select_tbl, 283 .set = bond_option_ad_select_set 284 }, 285 [BOND_OPT_NUM_PEER_NOTIF] = { 286 .id = BOND_OPT_NUM_PEER_NOTIF, 287 .name = "num_unsol_na", 288 .desc = "Number of peer notifications to send on failover event", 289 .values = bond_num_peer_notif_tbl, 290 .set = bond_option_num_peer_notif_set 291 }, 292 [BOND_OPT_MIIMON] = { 293 .id = BOND_OPT_MIIMON, 294 .name = "miimon", 295 .desc = "Link check interval in milliseconds", 296 .values = bond_intmax_tbl, 297 .set = bond_option_miimon_set 298 }, 299 [BOND_OPT_PRIMARY] = { 300 .id = BOND_OPT_PRIMARY, 301 .name = "primary", 302 .desc = "Primary network device to use", 303 .flags = BOND_OPTFLAG_RAWVAL, 304 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) | 305 BIT(BOND_MODE_TLB) | 306 BIT(BOND_MODE_ALB)), 307 .set = bond_option_primary_set 308 }, 309 [BOND_OPT_PRIMARY_RESELECT] = { 310 .id = BOND_OPT_PRIMARY_RESELECT, 311 .name = "primary_reselect", 312 .desc = "Reselect primary slave once it comes up", 313 .values = bond_primary_reselect_tbl, 314 .set = bond_option_primary_reselect_set 315 }, 316 [BOND_OPT_USE_CARRIER] = { 317 .id = BOND_OPT_USE_CARRIER, 318 .name = "use_carrier", 319 .desc = "Use netif_carrier_ok (vs MII ioctls) in miimon", 320 .values = bond_use_carrier_tbl, 321 .set = bond_option_use_carrier_set 322 }, 323 [BOND_OPT_ACTIVE_SLAVE] = { 324 .id = BOND_OPT_ACTIVE_SLAVE, 325 .name = "active_slave", 326 .desc = "Currently active slave", 327 .flags = BOND_OPTFLAG_RAWVAL, 328 .unsuppmodes = BOND_MODE_ALL_EX(BIT(BOND_MODE_ACTIVEBACKUP) | 329 BIT(BOND_MODE_TLB) | 330 BIT(BOND_MODE_ALB)), 331 .set = bond_option_active_slave_set 332 }, 333 [BOND_OPT_QUEUE_ID] = { 334 .id = BOND_OPT_QUEUE_ID, 335 .name = "queue_id", 336 .desc = "Set queue id of a slave", 337 .flags = BOND_OPTFLAG_RAWVAL, 338 .set = bond_option_queue_id_set 339 }, 340 [BOND_OPT_ALL_SLAVES_ACTIVE] = { 341 .id = BOND_OPT_ALL_SLAVES_ACTIVE, 342 .name = "all_slaves_active", 343 .desc = "Keep all frames received on an interface by setting active flag for all slaves", 344 .values = bond_all_slaves_active_tbl, 345 .set = bond_option_all_slaves_active_set 346 }, 347 [BOND_OPT_RESEND_IGMP] = { 348 .id = BOND_OPT_RESEND_IGMP, 349 .name = "resend_igmp", 350 .desc = "Number of IGMP membership reports to send on link failure", 351 .values = bond_resend_igmp_tbl, 352 .set = bond_option_resend_igmp_set 353 }, 354 [BOND_OPT_LP_INTERVAL] = { 355 .id = BOND_OPT_LP_INTERVAL, 356 .name = "lp_interval", 357 .desc = "The number of seconds between instances where the bonding driver sends learning packets to each slave's peer switch", 358 .values = bond_lp_interval_tbl, 359 .set = bond_option_lp_interval_set 360 }, 361 [BOND_OPT_SLAVES] = { 362 .id = BOND_OPT_SLAVES, 363 .name = "slaves", 364 .desc = "Slave membership management", 365 .flags = BOND_OPTFLAG_RAWVAL, 366 .set = bond_option_slaves_set 367 }, 368 { } 369 }; 370 371 /* Searches for a value in opt's values[] table */ 372 const struct bond_opt_value *bond_opt_get_val(unsigned int option, u64 val) 373 { 374 const struct bond_option *opt; 375 int i; 376 377 opt = bond_opt_get(option); 378 if (WARN_ON(!opt)) 379 return NULL; 380 for (i = 0; opt->values && opt->values[i].string; i++) 381 if (opt->values[i].value == val) 382 return &opt->values[i]; 383 384 return NULL; 385 } 386 387 /* Searches for a value in opt's values[] table which matches the flagmask */ 388 static const struct bond_opt_value *bond_opt_get_flags(const struct bond_option *opt, 389 u32 flagmask) 390 { 391 int i; 392 393 for (i = 0; opt->values && opt->values[i].string; i++) 394 if (opt->values[i].flags & flagmask) 395 return &opt->values[i]; 396 397 return NULL; 398 } 399 400 /* If maxval is missing then there's no range to check. In case minval is 401 * missing then it's considered to be 0. 402 */ 403 static bool bond_opt_check_range(const struct bond_option *opt, u64 val) 404 { 405 const struct bond_opt_value *minval, *maxval; 406 407 minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN); 408 maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX); 409 if (!maxval || (minval && val < minval->value) || val > maxval->value) 410 return false; 411 412 return true; 413 } 414 415 /** 416 * bond_opt_parse - parse option value 417 * @opt: the option to parse against 418 * @val: value to parse 419 * 420 * This function tries to extract the value from @val and check if it's 421 * a possible match for the option and returns NULL if a match isn't found, 422 * or the struct_opt_value that matched. It also strips the new line from 423 * @val->string if it's present. 424 */ 425 const struct bond_opt_value *bond_opt_parse(const struct bond_option *opt, 426 struct bond_opt_value *val) 427 { 428 char *p, valstr[BOND_OPT_MAX_NAMELEN + 1] = { 0, }; 429 const struct bond_opt_value *tbl; 430 const struct bond_opt_value *ret = NULL; 431 bool checkval; 432 int i, rv; 433 434 /* No parsing if the option wants a raw val */ 435 if (opt->flags & BOND_OPTFLAG_RAWVAL) 436 return val; 437 438 tbl = opt->values; 439 if (!tbl) 440 goto out; 441 442 /* ULLONG_MAX is used to bypass string processing */ 443 checkval = val->value != ULLONG_MAX; 444 if (!checkval) { 445 if (!val->string) 446 goto out; 447 p = strchr(val->string, '\n'); 448 if (p) 449 *p = '\0'; 450 for (p = val->string; *p; p++) 451 if (!(isdigit(*p) || isspace(*p))) 452 break; 453 /* The following code extracts the string to match or the value 454 * and sets checkval appropriately 455 */ 456 if (*p) { 457 rv = sscanf(val->string, "%32s", valstr); 458 } else { 459 rv = sscanf(val->string, "%llu", &val->value); 460 checkval = true; 461 } 462 if (!rv) 463 goto out; 464 } 465 466 for (i = 0; tbl[i].string; i++) { 467 /* Check for exact match */ 468 if (checkval) { 469 if (val->value == tbl[i].value) 470 ret = &tbl[i]; 471 } else { 472 if (!strcmp(valstr, "default") && 473 (tbl[i].flags & BOND_VALFLAG_DEFAULT)) 474 ret = &tbl[i]; 475 476 if (!strcmp(valstr, tbl[i].string)) 477 ret = &tbl[i]; 478 } 479 /* Found an exact match */ 480 if (ret) 481 goto out; 482 } 483 /* Possible range match */ 484 if (checkval && bond_opt_check_range(opt, val->value)) 485 ret = val; 486 out: 487 return ret; 488 } 489 490 /* Check opt's dependencies against bond mode and currently set options */ 491 static int bond_opt_check_deps(struct bonding *bond, 492 const struct bond_option *opt) 493 { 494 struct bond_params *params = &bond->params; 495 496 if (test_bit(params->mode, &opt->unsuppmodes)) 497 return -EACCES; 498 if ((opt->flags & BOND_OPTFLAG_NOSLAVES) && bond_has_slaves(bond)) 499 return -ENOTEMPTY; 500 if ((opt->flags & BOND_OPTFLAG_IFDOWN) && (bond->dev->flags & IFF_UP)) 501 return -EBUSY; 502 503 return 0; 504 } 505 506 static void bond_opt_dep_print(struct bonding *bond, 507 const struct bond_option *opt) 508 { 509 const struct bond_opt_value *modeval; 510 struct bond_params *params; 511 512 params = &bond->params; 513 modeval = bond_opt_get_val(BOND_OPT_MODE, params->mode); 514 if (test_bit(params->mode, &opt->unsuppmodes)) 515 pr_err("%s: option %s: mode dependency failed, not supported in mode %s(%llu)\n", 516 bond->dev->name, opt->name, 517 modeval->string, modeval->value); 518 } 519 520 static void bond_opt_error_interpret(struct bonding *bond, 521 const struct bond_option *opt, 522 int error, const struct bond_opt_value *val) 523 { 524 const struct bond_opt_value *minval, *maxval; 525 char *p; 526 527 switch (error) { 528 case -EINVAL: 529 if (val) { 530 if (val->string) { 531 /* sometimes RAWVAL opts may have new lines */ 532 p = strchr(val->string, '\n'); 533 if (p) 534 *p = '\0'; 535 pr_err("%s: option %s: invalid value (%s)\n", 536 bond->dev->name, opt->name, val->string); 537 } else { 538 pr_err("%s: option %s: invalid value (%llu)\n", 539 bond->dev->name, opt->name, val->value); 540 } 541 } 542 minval = bond_opt_get_flags(opt, BOND_VALFLAG_MIN); 543 maxval = bond_opt_get_flags(opt, BOND_VALFLAG_MAX); 544 if (!maxval) 545 break; 546 pr_err("%s: option %s: allowed values %llu - %llu\n", 547 bond->dev->name, opt->name, minval ? minval->value : 0, 548 maxval->value); 549 break; 550 case -EACCES: 551 bond_opt_dep_print(bond, opt); 552 break; 553 case -ENOTEMPTY: 554 pr_err("%s: option %s: unable to set because the bond device has slaves\n", 555 bond->dev->name, opt->name); 556 break; 557 case -EBUSY: 558 pr_err("%s: option %s: unable to set because the bond device is up\n", 559 bond->dev->name, opt->name); 560 break; 561 default: 562 break; 563 } 564 } 565 566 /** 567 * __bond_opt_set - set a bonding option 568 * @bond: target bond device 569 * @option: option to set 570 * @val: value to set it to 571 * 572 * This function is used to change the bond's option value, it can be 573 * used for both enabling/changing an option and for disabling it. RTNL lock 574 * must be obtained before calling this function. 575 */ 576 int __bond_opt_set(struct bonding *bond, 577 unsigned int option, struct bond_opt_value *val) 578 { 579 const struct bond_opt_value *retval = NULL; 580 const struct bond_option *opt; 581 int ret = -ENOENT; 582 583 ASSERT_RTNL(); 584 585 opt = bond_opt_get(option); 586 if (WARN_ON(!val) || WARN_ON(!opt)) 587 goto out; 588 ret = bond_opt_check_deps(bond, opt); 589 if (ret) 590 goto out; 591 retval = bond_opt_parse(opt, val); 592 if (!retval) { 593 ret = -EINVAL; 594 goto out; 595 } 596 ret = opt->set(bond, retval); 597 out: 598 if (ret) 599 bond_opt_error_interpret(bond, opt, ret, val); 600 601 return ret; 602 } 603 604 /** 605 * bond_opt_tryset_rtnl - try to acquire rtnl and call __bond_opt_set 606 * @bond: target bond device 607 * @option: option to set 608 * @buf: value to set it to 609 * 610 * This function tries to acquire RTNL without blocking and if successful 611 * calls __bond_opt_set. It is mainly used for sysfs option manipulation. 612 */ 613 int bond_opt_tryset_rtnl(struct bonding *bond, unsigned int option, char *buf) 614 { 615 struct bond_opt_value optval; 616 int ret; 617 618 if (!rtnl_trylock()) 619 return restart_syscall(); 620 bond_opt_initstr(&optval, buf); 621 ret = __bond_opt_set(bond, option, &optval); 622 rtnl_unlock(); 623 624 return ret; 625 } 626 627 /** 628 * bond_opt_get - get a pointer to an option 629 * @option: option for which to return a pointer 630 * 631 * This function checks if option is valid and if so returns a pointer 632 * to its entry in the bond_opts[] option array. 633 */ 634 const struct bond_option *bond_opt_get(unsigned int option) 635 { 636 if (!BOND_OPT_VALID(option)) 637 return NULL; 638 639 return &bond_opts[option]; 640 } 641 642 int bond_option_mode_set(struct bonding *bond, const struct bond_opt_value *newval) 643 { 644 if (BOND_NO_USES_ARP(newval->value) && bond->params.arp_interval) { 645 pr_info("%s: %s mode is incompatible with arp monitoring, start mii monitoring\n", 646 bond->dev->name, newval->string); 647 /* disable arp monitoring */ 648 bond->params.arp_interval = 0; 649 /* set miimon to default value */ 650 bond->params.miimon = BOND_DEFAULT_MIIMON; 651 pr_info("%s: Setting MII monitoring interval to %d\n", 652 bond->dev->name, bond->params.miimon); 653 } 654 655 /* don't cache arp_validate between modes */ 656 bond->params.arp_validate = BOND_ARP_VALIDATE_NONE; 657 bond->params.mode = newval->value; 658 659 return 0; 660 } 661 662 static struct net_device *__bond_option_active_slave_get(struct bonding *bond, 663 struct slave *slave) 664 { 665 return USES_PRIMARY(bond->params.mode) && slave ? slave->dev : NULL; 666 } 667 668 struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond) 669 { 670 struct slave *slave = rcu_dereference(bond->curr_active_slave); 671 672 return __bond_option_active_slave_get(bond, slave); 673 } 674 675 struct net_device *bond_option_active_slave_get(struct bonding *bond) 676 { 677 return __bond_option_active_slave_get(bond, bond->curr_active_slave); 678 } 679 680 static int bond_option_active_slave_set(struct bonding *bond, 681 const struct bond_opt_value *newval) 682 { 683 char ifname[IFNAMSIZ] = { 0, }; 684 struct net_device *slave_dev; 685 int ret = 0; 686 687 sscanf(newval->string, "%15s", ifname); /* IFNAMSIZ */ 688 if (!strlen(ifname) || newval->string[0] == '\n') { 689 slave_dev = NULL; 690 } else { 691 slave_dev = __dev_get_by_name(dev_net(bond->dev), ifname); 692 if (!slave_dev) 693 return -ENODEV; 694 } 695 696 if (slave_dev) { 697 if (!netif_is_bond_slave(slave_dev)) { 698 pr_err("Device %s is not bonding slave\n", 699 slave_dev->name); 700 return -EINVAL; 701 } 702 703 if (bond->dev != netdev_master_upper_dev_get(slave_dev)) { 704 pr_err("%s: Device %s is not our slave\n", 705 bond->dev->name, slave_dev->name); 706 return -EINVAL; 707 } 708 } 709 710 block_netpoll_tx(); 711 write_lock_bh(&bond->curr_slave_lock); 712 713 /* check to see if we are clearing active */ 714 if (!slave_dev) { 715 pr_info("%s: Clearing current active slave\n", bond->dev->name); 716 RCU_INIT_POINTER(bond->curr_active_slave, NULL); 717 bond_select_active_slave(bond); 718 } else { 719 struct slave *old_active = bond->curr_active_slave; 720 struct slave *new_active = bond_slave_get_rtnl(slave_dev); 721 722 BUG_ON(!new_active); 723 724 if (new_active == old_active) { 725 /* do nothing */ 726 pr_info("%s: %s is already the current active slave\n", 727 bond->dev->name, new_active->dev->name); 728 } else { 729 if (old_active && (new_active->link == BOND_LINK_UP) && 730 IS_UP(new_active->dev)) { 731 pr_info("%s: Setting %s as active slave\n", 732 bond->dev->name, new_active->dev->name); 733 bond_change_active_slave(bond, new_active); 734 } else { 735 pr_err("%s: Could not set %s as active slave; either %s is down or the link is down\n", 736 bond->dev->name, new_active->dev->name, 737 new_active->dev->name); 738 ret = -EINVAL; 739 } 740 } 741 } 742 743 write_unlock_bh(&bond->curr_slave_lock); 744 unblock_netpoll_tx(); 745 746 return ret; 747 } 748 749 static int bond_option_miimon_set(struct bonding *bond, 750 const struct bond_opt_value *newval) 751 { 752 pr_info("%s: Setting MII monitoring interval to %llu\n", 753 bond->dev->name, newval->value); 754 bond->params.miimon = newval->value; 755 if (bond->params.updelay) 756 pr_info("%s: Note: Updating updelay (to %d) since it is a multiple of the miimon value\n", 757 bond->dev->name, 758 bond->params.updelay * bond->params.miimon); 759 if (bond->params.downdelay) 760 pr_info("%s: Note: Updating downdelay (to %d) since it is a multiple of the miimon value\n", 761 bond->dev->name, 762 bond->params.downdelay * bond->params.miimon); 763 if (newval->value && bond->params.arp_interval) { 764 pr_info("%s: MII monitoring cannot be used with ARP monitoring - disabling ARP monitoring...\n", 765 bond->dev->name); 766 bond->params.arp_interval = 0; 767 if (bond->params.arp_validate) 768 bond->params.arp_validate = BOND_ARP_VALIDATE_NONE; 769 } 770 if (bond->dev->flags & IFF_UP) { 771 /* If the interface is up, we may need to fire off 772 * the MII timer. If the interface is down, the 773 * timer will get fired off when the open function 774 * is called. 775 */ 776 if (!newval->value) { 777 cancel_delayed_work_sync(&bond->mii_work); 778 } else { 779 cancel_delayed_work_sync(&bond->arp_work); 780 queue_delayed_work(bond->wq, &bond->mii_work, 0); 781 } 782 } 783 784 return 0; 785 } 786 787 static int bond_option_updelay_set(struct bonding *bond, 788 const struct bond_opt_value *newval) 789 { 790 int value = newval->value; 791 792 if (!bond->params.miimon) { 793 pr_err("%s: Unable to set up delay as MII monitoring is disabled\n", 794 bond->dev->name); 795 return -EPERM; 796 } 797 if ((value % bond->params.miimon) != 0) { 798 pr_warn("%s: Warning: up delay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n", 799 bond->dev->name, value, 800 bond->params.miimon, 801 (value / bond->params.miimon) * 802 bond->params.miimon); 803 } 804 bond->params.updelay = value / bond->params.miimon; 805 pr_info("%s: Setting up delay to %d\n", 806 bond->dev->name, bond->params.updelay * bond->params.miimon); 807 808 return 0; 809 } 810 811 static int bond_option_downdelay_set(struct bonding *bond, 812 const struct bond_opt_value *newval) 813 { 814 int value = newval->value; 815 816 if (!bond->params.miimon) { 817 pr_err("%s: Unable to set down delay as MII monitoring is disabled\n", 818 bond->dev->name); 819 return -EPERM; 820 } 821 if ((value % bond->params.miimon) != 0) { 822 pr_warn("%s: Warning: down delay (%d) is not a multiple of miimon (%d), delay rounded to %d ms\n", 823 bond->dev->name, value, 824 bond->params.miimon, 825 (value / bond->params.miimon) * 826 bond->params.miimon); 827 } 828 bond->params.downdelay = value / bond->params.miimon; 829 pr_info("%s: Setting down delay to %d\n", 830 bond->dev->name, bond->params.downdelay * bond->params.miimon); 831 832 return 0; 833 } 834 835 static int bond_option_use_carrier_set(struct bonding *bond, 836 const struct bond_opt_value *newval) 837 { 838 pr_info("%s: Setting use_carrier to %llu\n", 839 bond->dev->name, newval->value); 840 bond->params.use_carrier = newval->value; 841 842 return 0; 843 } 844 845 static int bond_option_arp_interval_set(struct bonding *bond, 846 const struct bond_opt_value *newval) 847 { 848 pr_info("%s: Setting ARP monitoring interval to %llu\n", 849 bond->dev->name, newval->value); 850 bond->params.arp_interval = newval->value; 851 if (newval->value) { 852 if (bond->params.miimon) { 853 pr_info("%s: ARP monitoring cannot be used with MII monitoring. %s Disabling MII monitoring\n", 854 bond->dev->name, bond->dev->name); 855 bond->params.miimon = 0; 856 } 857 if (!bond->params.arp_targets[0]) 858 pr_info("%s: ARP monitoring has been set up, but no ARP targets have been specified\n", 859 bond->dev->name); 860 } 861 if (bond->dev->flags & IFF_UP) { 862 /* If the interface is up, we may need to fire off 863 * the ARP timer. If the interface is down, the 864 * timer will get fired off when the open function 865 * is called. 866 */ 867 if (!newval->value) { 868 if (bond->params.arp_validate) 869 bond->recv_probe = NULL; 870 cancel_delayed_work_sync(&bond->arp_work); 871 } else { 872 /* arp_validate can be set only in active-backup mode */ 873 bond->recv_probe = bond_arp_rcv; 874 cancel_delayed_work_sync(&bond->mii_work); 875 queue_delayed_work(bond->wq, &bond->arp_work, 0); 876 } 877 } 878 879 return 0; 880 } 881 882 static void _bond_options_arp_ip_target_set(struct bonding *bond, int slot, 883 __be32 target, 884 unsigned long last_rx) 885 { 886 __be32 *targets = bond->params.arp_targets; 887 struct list_head *iter; 888 struct slave *slave; 889 890 if (slot >= 0 && slot < BOND_MAX_ARP_TARGETS) { 891 bond_for_each_slave(bond, slave, iter) 892 slave->target_last_arp_rx[slot] = last_rx; 893 targets[slot] = target; 894 } 895 } 896 897 static int _bond_option_arp_ip_target_add(struct bonding *bond, __be32 target) 898 { 899 __be32 *targets = bond->params.arp_targets; 900 int ind; 901 902 if (IS_IP_TARGET_UNUSABLE_ADDRESS(target)) { 903 pr_err("%s: invalid ARP target %pI4 specified for addition\n", 904 bond->dev->name, &target); 905 return -EINVAL; 906 } 907 908 if (bond_get_targets_ip(targets, target) != -1) { /* dup */ 909 pr_err("%s: ARP target %pI4 is already present\n", 910 bond->dev->name, &target); 911 return -EINVAL; 912 } 913 914 ind = bond_get_targets_ip(targets, 0); /* first free slot */ 915 if (ind == -1) { 916 pr_err("%s: ARP target table is full!\n", bond->dev->name); 917 return -EINVAL; 918 } 919 920 pr_info("%s: Adding ARP target %pI4\n", bond->dev->name, &target); 921 922 _bond_options_arp_ip_target_set(bond, ind, target, jiffies); 923 924 return 0; 925 } 926 927 static int bond_option_arp_ip_target_add(struct bonding *bond, __be32 target) 928 { 929 int ret; 930 931 /* not to race with bond_arp_rcv */ 932 write_lock_bh(&bond->lock); 933 ret = _bond_option_arp_ip_target_add(bond, target); 934 write_unlock_bh(&bond->lock); 935 936 return ret; 937 } 938 939 static int bond_option_arp_ip_target_rem(struct bonding *bond, __be32 target) 940 { 941 __be32 *targets = bond->params.arp_targets; 942 struct list_head *iter; 943 struct slave *slave; 944 unsigned long *targets_rx; 945 int ind, i; 946 947 if (IS_IP_TARGET_UNUSABLE_ADDRESS(target)) { 948 pr_err("%s: invalid ARP target %pI4 specified for removal\n", 949 bond->dev->name, &target); 950 return -EINVAL; 951 } 952 953 ind = bond_get_targets_ip(targets, target); 954 if (ind == -1) { 955 pr_err("%s: unable to remove nonexistent ARP target %pI4\n", 956 bond->dev->name, &target); 957 return -EINVAL; 958 } 959 960 if (ind == 0 && !targets[1] && bond->params.arp_interval) 961 pr_warn("%s: Removing last arp target with arp_interval on\n", 962 bond->dev->name); 963 964 pr_info("%s: Removing ARP target %pI4\n", bond->dev->name, &target); 965 966 /* not to race with bond_arp_rcv */ 967 write_lock_bh(&bond->lock); 968 969 bond_for_each_slave(bond, slave, iter) { 970 targets_rx = slave->target_last_arp_rx; 971 for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++) 972 targets_rx[i] = targets_rx[i+1]; 973 targets_rx[i] = 0; 974 } 975 for (i = ind; (i < BOND_MAX_ARP_TARGETS-1) && targets[i+1]; i++) 976 targets[i] = targets[i+1]; 977 targets[i] = 0; 978 979 write_unlock_bh(&bond->lock); 980 981 return 0; 982 } 983 984 void bond_option_arp_ip_targets_clear(struct bonding *bond) 985 { 986 int i; 987 988 /* not to race with bond_arp_rcv */ 989 write_lock_bh(&bond->lock); 990 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) 991 _bond_options_arp_ip_target_set(bond, i, 0, 0); 992 write_unlock_bh(&bond->lock); 993 } 994 995 static int bond_option_arp_ip_targets_set(struct bonding *bond, 996 const struct bond_opt_value *newval) 997 { 998 int ret = -EPERM; 999 __be32 target; 1000 1001 if (newval->string) { 1002 if (!in4_pton(newval->string+1, -1, (u8 *)&target, -1, NULL)) { 1003 pr_err("%s: invalid ARP target %pI4 specified\n", 1004 bond->dev->name, &target); 1005 return ret; 1006 } 1007 if (newval->string[0] == '+') 1008 ret = bond_option_arp_ip_target_add(bond, target); 1009 else if (newval->string[0] == '-') 1010 ret = bond_option_arp_ip_target_rem(bond, target); 1011 else 1012 pr_err("no command found in arp_ip_targets file for bond %s - use +<addr> or -<addr>\n", 1013 bond->dev->name); 1014 } else { 1015 target = newval->value; 1016 ret = bond_option_arp_ip_target_add(bond, target); 1017 } 1018 1019 return ret; 1020 } 1021 1022 static int bond_option_arp_validate_set(struct bonding *bond, 1023 const struct bond_opt_value *newval) 1024 { 1025 pr_info("%s: Setting arp_validate to %s (%llu)\n", 1026 bond->dev->name, newval->string, newval->value); 1027 1028 if (bond->dev->flags & IFF_UP) { 1029 if (!newval->value) 1030 bond->recv_probe = NULL; 1031 else if (bond->params.arp_interval) 1032 bond->recv_probe = bond_arp_rcv; 1033 } 1034 bond->params.arp_validate = newval->value; 1035 1036 return 0; 1037 } 1038 1039 static int bond_option_arp_all_targets_set(struct bonding *bond, 1040 const struct bond_opt_value *newval) 1041 { 1042 pr_info("%s: Setting arp_all_targets to %s (%llu)\n", 1043 bond->dev->name, newval->string, newval->value); 1044 bond->params.arp_all_targets = newval->value; 1045 1046 return 0; 1047 } 1048 1049 static int bond_option_primary_set(struct bonding *bond, 1050 const struct bond_opt_value *newval) 1051 { 1052 char *p, *primary = newval->string; 1053 struct list_head *iter; 1054 struct slave *slave; 1055 1056 block_netpoll_tx(); 1057 read_lock(&bond->lock); 1058 write_lock_bh(&bond->curr_slave_lock); 1059 1060 p = strchr(primary, '\n'); 1061 if (p) 1062 *p = '\0'; 1063 /* check to see if we are clearing primary */ 1064 if (!strlen(primary)) { 1065 pr_info("%s: Setting primary slave to None\n", bond->dev->name); 1066 bond->primary_slave = NULL; 1067 memset(bond->params.primary, 0, sizeof(bond->params.primary)); 1068 bond_select_active_slave(bond); 1069 goto out; 1070 } 1071 1072 bond_for_each_slave(bond, slave, iter) { 1073 if (strncmp(slave->dev->name, primary, IFNAMSIZ) == 0) { 1074 pr_info("%s: Setting %s as primary slave\n", 1075 bond->dev->name, slave->dev->name); 1076 bond->primary_slave = slave; 1077 strcpy(bond->params.primary, slave->dev->name); 1078 bond_select_active_slave(bond); 1079 goto out; 1080 } 1081 } 1082 1083 if (bond->primary_slave) { 1084 pr_info("%s: Setting primary slave to None\n", bond->dev->name); 1085 bond->primary_slave = NULL; 1086 bond_select_active_slave(bond); 1087 } 1088 strncpy(bond->params.primary, primary, IFNAMSIZ); 1089 bond->params.primary[IFNAMSIZ - 1] = 0; 1090 1091 pr_info("%s: Recording %s as primary, but it has not been enslaved to %s yet\n", 1092 bond->dev->name, primary, bond->dev->name); 1093 1094 out: 1095 write_unlock_bh(&bond->curr_slave_lock); 1096 read_unlock(&bond->lock); 1097 unblock_netpoll_tx(); 1098 1099 return 0; 1100 } 1101 1102 static int bond_option_primary_reselect_set(struct bonding *bond, 1103 const struct bond_opt_value *newval) 1104 { 1105 pr_info("%s: Setting primary_reselect to %s (%llu)\n", 1106 bond->dev->name, newval->string, newval->value); 1107 bond->params.primary_reselect = newval->value; 1108 1109 block_netpoll_tx(); 1110 write_lock_bh(&bond->curr_slave_lock); 1111 bond_select_active_slave(bond); 1112 write_unlock_bh(&bond->curr_slave_lock); 1113 unblock_netpoll_tx(); 1114 1115 return 0; 1116 } 1117 1118 static int bond_option_fail_over_mac_set(struct bonding *bond, 1119 const struct bond_opt_value *newval) 1120 { 1121 pr_info("%s: Setting fail_over_mac to %s (%llu)\n", 1122 bond->dev->name, newval->string, newval->value); 1123 bond->params.fail_over_mac = newval->value; 1124 1125 return 0; 1126 } 1127 1128 static int bond_option_xmit_hash_policy_set(struct bonding *bond, 1129 const struct bond_opt_value *newval) 1130 { 1131 pr_info("%s: Setting xmit hash policy to %s (%llu)\n", 1132 bond->dev->name, newval->string, newval->value); 1133 bond->params.xmit_policy = newval->value; 1134 1135 return 0; 1136 } 1137 1138 static int bond_option_resend_igmp_set(struct bonding *bond, 1139 const struct bond_opt_value *newval) 1140 { 1141 pr_info("%s: Setting resend_igmp to %llu\n", 1142 bond->dev->name, newval->value); 1143 bond->params.resend_igmp = newval->value; 1144 1145 return 0; 1146 } 1147 1148 static int bond_option_num_peer_notif_set(struct bonding *bond, 1149 const struct bond_opt_value *newval) 1150 { 1151 bond->params.num_peer_notif = newval->value; 1152 1153 return 0; 1154 } 1155 1156 static int bond_option_all_slaves_active_set(struct bonding *bond, 1157 const struct bond_opt_value *newval) 1158 { 1159 struct list_head *iter; 1160 struct slave *slave; 1161 1162 if (newval->value == bond->params.all_slaves_active) 1163 return 0; 1164 bond->params.all_slaves_active = newval->value; 1165 bond_for_each_slave(bond, slave, iter) { 1166 if (!bond_is_active_slave(slave)) { 1167 if (newval->value) 1168 slave->inactive = 0; 1169 else 1170 slave->inactive = 1; 1171 } 1172 } 1173 1174 return 0; 1175 } 1176 1177 static int bond_option_min_links_set(struct bonding *bond, 1178 const struct bond_opt_value *newval) 1179 { 1180 pr_info("%s: Setting min links value to %llu\n", 1181 bond->dev->name, newval->value); 1182 bond->params.min_links = newval->value; 1183 1184 return 0; 1185 } 1186 1187 static int bond_option_lp_interval_set(struct bonding *bond, 1188 const struct bond_opt_value *newval) 1189 { 1190 bond->params.lp_interval = newval->value; 1191 1192 return 0; 1193 } 1194 1195 static int bond_option_pps_set(struct bonding *bond, 1196 const struct bond_opt_value *newval) 1197 { 1198 bond->params.packets_per_slave = newval->value; 1199 if (newval->value > 0) { 1200 bond->params.reciprocal_packets_per_slave = 1201 reciprocal_value(newval->value); 1202 } else { 1203 /* reciprocal_packets_per_slave is unused if 1204 * packets_per_slave is 0 or 1, just initialize it 1205 */ 1206 bond->params.reciprocal_packets_per_slave = 1207 (struct reciprocal_value) { 0 }; 1208 } 1209 1210 return 0; 1211 } 1212 1213 static int bond_option_lacp_rate_set(struct bonding *bond, 1214 const struct bond_opt_value *newval) 1215 { 1216 pr_info("%s: Setting LACP rate to %s (%llu)\n", 1217 bond->dev->name, newval->string, newval->value); 1218 bond->params.lacp_fast = newval->value; 1219 bond_3ad_update_lacp_rate(bond); 1220 1221 return 0; 1222 } 1223 1224 static int bond_option_ad_select_set(struct bonding *bond, 1225 const struct bond_opt_value *newval) 1226 { 1227 pr_info("%s: Setting ad_select to %s (%llu)\n", 1228 bond->dev->name, newval->string, newval->value); 1229 bond->params.ad_select = newval->value; 1230 1231 return 0; 1232 } 1233 1234 static int bond_option_queue_id_set(struct bonding *bond, 1235 const struct bond_opt_value *newval) 1236 { 1237 struct slave *slave, *update_slave; 1238 struct net_device *sdev; 1239 struct list_head *iter; 1240 char *delim; 1241 int ret = 0; 1242 u16 qid; 1243 1244 /* delim will point to queue id if successful */ 1245 delim = strchr(newval->string, ':'); 1246 if (!delim) 1247 goto err_no_cmd; 1248 1249 /* Terminate string that points to device name and bump it 1250 * up one, so we can read the queue id there. 1251 */ 1252 *delim = '\0'; 1253 if (sscanf(++delim, "%hd\n", &qid) != 1) 1254 goto err_no_cmd; 1255 1256 /* Check buffer length, valid ifname and queue id */ 1257 if (!dev_valid_name(newval->string) || 1258 qid > bond->dev->real_num_tx_queues) 1259 goto err_no_cmd; 1260 1261 /* Get the pointer to that interface if it exists */ 1262 sdev = __dev_get_by_name(dev_net(bond->dev), newval->string); 1263 if (!sdev) 1264 goto err_no_cmd; 1265 1266 /* Search for thes slave and check for duplicate qids */ 1267 update_slave = NULL; 1268 bond_for_each_slave(bond, slave, iter) { 1269 if (sdev == slave->dev) 1270 /* We don't need to check the matching 1271 * slave for dups, since we're overwriting it 1272 */ 1273 update_slave = slave; 1274 else if (qid && qid == slave->queue_id) { 1275 goto err_no_cmd; 1276 } 1277 } 1278 1279 if (!update_slave) 1280 goto err_no_cmd; 1281 1282 /* Actually set the qids for the slave */ 1283 update_slave->queue_id = qid; 1284 1285 out: 1286 return ret; 1287 1288 err_no_cmd: 1289 pr_info("invalid input for queue_id set for %s\n", bond->dev->name); 1290 ret = -EPERM; 1291 goto out; 1292 1293 } 1294 1295 static int bond_option_slaves_set(struct bonding *bond, 1296 const struct bond_opt_value *newval) 1297 { 1298 char command[IFNAMSIZ + 1] = { 0, }; 1299 struct net_device *dev; 1300 char *ifname; 1301 int ret; 1302 1303 sscanf(newval->string, "%16s", command); /* IFNAMSIZ*/ 1304 ifname = command + 1; 1305 if ((strlen(command) <= 1) || 1306 !dev_valid_name(ifname)) 1307 goto err_no_cmd; 1308 1309 dev = __dev_get_by_name(dev_net(bond->dev), ifname); 1310 if (!dev) { 1311 pr_info("%s: interface %s does not exist!\n", 1312 bond->dev->name, ifname); 1313 ret = -ENODEV; 1314 goto out; 1315 } 1316 1317 switch (command[0]) { 1318 case '+': 1319 pr_info("%s: Adding slave %s\n", bond->dev->name, dev->name); 1320 ret = bond_enslave(bond->dev, dev); 1321 break; 1322 1323 case '-': 1324 pr_info("%s: Removing slave %s\n", bond->dev->name, dev->name); 1325 ret = bond_release(bond->dev, dev); 1326 break; 1327 1328 default: 1329 goto err_no_cmd; 1330 } 1331 1332 out: 1333 return ret; 1334 1335 err_no_cmd: 1336 pr_err("no command found in slaves file for bond %s - use +ifname or -ifname\n", 1337 bond->dev->name); 1338 ret = -EPERM; 1339 goto out; 1340 } 1341