/drivers/net/bonding/bond_sysfs.c
C | 1669 lines | 1265 code | 214 blank | 190 comment | 199 complexity | 31fe7d3014d3f11ea84981d56a85a7ef MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
1/* 2 * Copyright(c) 2004-2005 Intel Corporation. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License as published by the 6 * Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, but 10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 11 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * for more details. 13 * 14 * You should have received a copy of the GNU General Public License along 15 * with this program; if not, write to the Free Software Foundation, Inc., 16 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 17 * 18 * The full GNU General Public License is included in this distribution in the 19 * file called LICENSE. 20 * 21 */ 22 23#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 24 25#include <linux/kernel.h> 26#include <linux/module.h> 27#include <linux/device.h> 28#include <linux/sched.h> 29#include <linux/sysdev.h> 30#include <linux/fs.h> 31#include <linux/types.h> 32#include <linux/string.h> 33#include <linux/netdevice.h> 34#include <linux/inetdevice.h> 35#include <linux/in.h> 36#include <linux/sysfs.h> 37#include <linux/ctype.h> 38#include <linux/inet.h> 39#include <linux/rtnetlink.h> 40#include <linux/etherdevice.h> 41#include <net/net_namespace.h> 42#include <net/netns/generic.h> 43#include <linux/nsproxy.h> 44 45#include "bonding.h" 46 47#define to_dev(obj) container_of(obj, struct device, kobj) 48#define to_bond(cd) ((struct bonding *)(netdev_priv(to_net_dev(cd)))) 49 50/* 51 * "show" function for the bond_masters attribute. 52 * The class parameter is ignored. 53 */ 54static ssize_t bonding_show_bonds(struct class *cls, 55 struct class_attribute *attr, 56 char *buf) 57{ 58 struct net *net = current->nsproxy->net_ns; 59 struct bond_net *bn = net_generic(net, bond_net_id); 60 int res = 0; 61 struct bonding *bond; 62 63 rtnl_lock(); 64 65 list_for_each_entry(bond, &bn->dev_list, bond_list) { 66 if (res > (PAGE_SIZE - IFNAMSIZ)) { 67 /* not enough space for another interface name */ 68 if ((PAGE_SIZE - res) > 10) 69 res = PAGE_SIZE - 10; 70 res += sprintf(buf + res, "++more++ "); 71 break; 72 } 73 res += sprintf(buf + res, "%s ", bond->dev->name); 74 } 75 if (res) 76 buf[res-1] = '\n'; /* eat the leftover space */ 77 78 rtnl_unlock(); 79 return res; 80} 81 82static struct net_device *bond_get_by_name(struct net *net, const char *ifname) 83{ 84 struct bond_net *bn = net_generic(net, bond_net_id); 85 struct bonding *bond; 86 87 list_for_each_entry(bond, &bn->dev_list, bond_list) { 88 if (strncmp(bond->dev->name, ifname, IFNAMSIZ) == 0) 89 return bond->dev; 90 } 91 return NULL; 92} 93 94/* 95 * "store" function for the bond_masters attribute. This is what 96 * creates and deletes entire bonds. 97 * 98 * The class parameter is ignored. 99 * 100 */ 101 102static ssize_t bonding_store_bonds(struct class *cls, 103 struct class_attribute *attr, 104 const char *buffer, size_t count) 105{ 106 struct net *net = current->nsproxy->net_ns; 107 char command[IFNAMSIZ + 1] = {0, }; 108 char *ifname; 109 int rv, res = count; 110 111 sscanf(buffer, "%16s", command); /* IFNAMSIZ*/ 112 ifname = command + 1; 113 if ((strlen(command) <= 1) || 114 !dev_valid_name(ifname)) 115 goto err_no_cmd; 116 117 if (command[0] == '+') { 118 pr_info("%s is being created...\n", ifname); 119 rv = bond_create(net, ifname); 120 if (rv) { 121 if (rv == -EEXIST) 122 pr_info("%s already exists.\n", ifname); 123 else 124 pr_info("%s creation failed.\n", ifname); 125 res = rv; 126 } 127 } else if (command[0] == '-') { 128 struct net_device *bond_dev; 129 130 rtnl_lock(); 131 bond_dev = bond_get_by_name(net, ifname); 132 if (bond_dev) { 133 pr_info("%s is being deleted...\n", ifname); 134 unregister_netdevice(bond_dev); 135 } else { 136 pr_err("unable to delete non-existent %s\n", ifname); 137 res = -ENODEV; 138 } 139 rtnl_unlock(); 140 } else 141 goto err_no_cmd; 142 143 /* Always return either count or an error. If you return 0, you'll 144 * get called forever, which is bad. 145 */ 146 return res; 147 148err_no_cmd: 149 pr_err("no command found in bonding_masters. Use +ifname or -ifname.\n"); 150 return -EPERM; 151} 152 153/* class attribute for bond_masters file. This ends up in /sys/class/net */ 154static CLASS_ATTR(bonding_masters, S_IWUSR | S_IRUGO, 155 bonding_show_bonds, bonding_store_bonds); 156 157int bond_create_slave_symlinks(struct net_device *master, 158 struct net_device *slave) 159{ 160 char linkname[IFNAMSIZ+7]; 161 int ret = 0; 162 163 /* first, create a link from the slave back to the master */ 164 ret = sysfs_create_link(&(slave->dev.kobj), &(master->dev.kobj), 165 "master"); 166 if (ret) 167 return ret; 168 /* next, create a link from the master to the slave */ 169 sprintf(linkname, "slave_%s", slave->name); 170 ret = sysfs_create_link(&(master->dev.kobj), &(slave->dev.kobj), 171 linkname); 172 return ret; 173 174} 175 176void bond_destroy_slave_symlinks(struct net_device *master, 177 struct net_device *slave) 178{ 179 char linkname[IFNAMSIZ+7]; 180 181 sysfs_remove_link(&(slave->dev.kobj), "master"); 182 sprintf(linkname, "slave_%s", slave->name); 183 sysfs_remove_link(&(master->dev.kobj), linkname); 184} 185 186 187/* 188 * Show the slaves in the current bond. 189 */ 190static ssize_t bonding_show_slaves(struct device *d, 191 struct device_attribute *attr, char *buf) 192{ 193 struct slave *slave; 194 int i, res = 0; 195 struct bonding *bond = to_bond(d); 196 197 read_lock(&bond->lock); 198 bond_for_each_slave(bond, slave, i) { 199 if (res > (PAGE_SIZE - IFNAMSIZ)) { 200 /* not enough space for another interface name */ 201 if ((PAGE_SIZE - res) > 10) 202 res = PAGE_SIZE - 10; 203 res += sprintf(buf + res, "++more++ "); 204 break; 205 } 206 res += sprintf(buf + res, "%s ", slave->dev->name); 207 } 208 read_unlock(&bond->lock); 209 if (res) 210 buf[res-1] = '\n'; /* eat the leftover space */ 211 return res; 212} 213 214/* 215 * Set the slaves in the current bond. The bond interface must be 216 * up for this to succeed. 217 * This is supposed to be only thin wrapper for bond_enslave and bond_release. 218 * All hard work should be done there. 219 */ 220static ssize_t bonding_store_slaves(struct device *d, 221 struct device_attribute *attr, 222 const char *buffer, size_t count) 223{ 224 char command[IFNAMSIZ + 1] = { 0, }; 225 char *ifname; 226 int res, ret = count; 227 struct net_device *dev; 228 struct bonding *bond = to_bond(d); 229 230 if (!rtnl_trylock()) 231 return restart_syscall(); 232 233 sscanf(buffer, "%16s", command); /* IFNAMSIZ*/ 234 ifname = command + 1; 235 if ((strlen(command) <= 1) || 236 !dev_valid_name(ifname)) 237 goto err_no_cmd; 238 239 dev = __dev_get_by_name(dev_net(bond->dev), ifname); 240 if (!dev) { 241 pr_info("%s: Interface %s does not exist!\n", 242 bond->dev->name, ifname); 243 ret = -ENODEV; 244 goto out; 245 } 246 247 switch (command[0]) { 248 case '+': 249 pr_info("%s: Adding slave %s.\n", bond->dev->name, dev->name); 250 res = bond_enslave(bond->dev, dev); 251 break; 252 253 case '-': 254 pr_info("%s: Removing slave %s.\n", bond->dev->name, dev->name); 255 res = bond_release(bond->dev, dev); 256 break; 257 258 default: 259 goto err_no_cmd; 260 } 261 262 if (res) 263 ret = res; 264 goto out; 265 266err_no_cmd: 267 pr_err("no command found in slaves file for bond %s. Use +ifname or -ifname.\n", 268 bond->dev->name); 269 ret = -EPERM; 270 271out: 272 rtnl_unlock(); 273 return ret; 274} 275 276static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves, 277 bonding_store_slaves); 278 279/* 280 * Show and set the bonding mode. The bond interface must be down to 281 * change the mode. 282 */ 283static ssize_t bonding_show_mode(struct device *d, 284 struct device_attribute *attr, char *buf) 285{ 286 struct bonding *bond = to_bond(d); 287 288 return sprintf(buf, "%s %d\n", 289 bond_mode_tbl[bond->params.mode].modename, 290 bond->params.mode); 291} 292 293static ssize_t bonding_store_mode(struct device *d, 294 struct device_attribute *attr, 295 const char *buf, size_t count) 296{ 297 int new_value, ret = count; 298 struct bonding *bond = to_bond(d); 299 300 if (bond->dev->flags & IFF_UP) { 301 pr_err("unable to update mode of %s because interface is up.\n", 302 bond->dev->name); 303 ret = -EPERM; 304 goto out; 305 } 306 307 new_value = bond_parse_parm(buf, bond_mode_tbl); 308 if (new_value < 0) { 309 pr_err("%s: Ignoring invalid mode value %.*s.\n", 310 bond->dev->name, (int)strlen(buf) - 1, buf); 311 ret = -EINVAL; 312 goto out; 313 } 314 if ((new_value == BOND_MODE_ALB || 315 new_value == BOND_MODE_TLB) && 316 bond->params.arp_interval) { 317 pr_err("%s: %s mode is incompatible with arp monitoring.\n", 318 bond->dev->name, bond_mode_tbl[new_value].modename); 319 ret = -EINVAL; 320 goto out; 321 } 322 323 bond->params.mode = new_value; 324 bond_set_mode_ops(bond, bond->params.mode); 325 pr_info("%s: setting mode to %s (%d).\n", 326 bond->dev->name, bond_mode_tbl[new_value].modename, 327 new_value); 328out: 329 return ret; 330} 331static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, 332 bonding_show_mode, bonding_store_mode); 333 334/* 335 * Show and set the bonding transmit hash method. 336 * The bond interface must be down to change the xmit hash policy. 337 */ 338static ssize_t bonding_show_xmit_hash(struct device *d, 339 struct device_attribute *attr, 340 char *buf) 341{ 342 struct bonding *bond = to_bond(d); 343 344 return sprintf(buf, "%s %d\n", 345 xmit_hashtype_tbl[bond->params.xmit_policy].modename, 346 bond->params.xmit_policy); 347} 348 349static ssize_t bonding_store_xmit_hash(struct device *d, 350 struct device_attribute *attr, 351 const char *buf, size_t count) 352{ 353 int new_value, ret = count; 354 struct bonding *bond = to_bond(d); 355 356 if (bond->dev->flags & IFF_UP) { 357 pr_err("%s: Interface is up. Unable to update xmit policy.\n", 358 bond->dev->name); 359 ret = -EPERM; 360 goto out; 361 } 362 363 new_value = bond_parse_parm(buf, xmit_hashtype_tbl); 364 if (new_value < 0) { 365 pr_err("%s: Ignoring invalid xmit hash policy value %.*s.\n", 366 bond->dev->name, 367 (int)strlen(buf) - 1, buf); 368 ret = -EINVAL; 369 goto out; 370 } else { 371 bond->params.xmit_policy = new_value; 372 bond_set_mode_ops(bond, bond->params.mode); 373 pr_info("%s: setting xmit hash policy to %s (%d).\n", 374 bond->dev->name, 375 xmit_hashtype_tbl[new_value].modename, new_value); 376 } 377out: 378 return ret; 379} 380static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR, 381 bonding_show_xmit_hash, bonding_store_xmit_hash); 382 383/* 384 * Show and set arp_validate. 385 */ 386static ssize_t bonding_show_arp_validate(struct device *d, 387 struct device_attribute *attr, 388 char *buf) 389{ 390 struct bonding *bond = to_bond(d); 391 392 return sprintf(buf, "%s %d\n", 393 arp_validate_tbl[bond->params.arp_validate].modename, 394 bond->params.arp_validate); 395} 396 397static ssize_t bonding_store_arp_validate(struct device *d, 398 struct device_attribute *attr, 399 const char *buf, size_t count) 400{ 401 int new_value; 402 struct bonding *bond = to_bond(d); 403 404 new_value = bond_parse_parm(buf, arp_validate_tbl); 405 if (new_value < 0) { 406 pr_err("%s: Ignoring invalid arp_validate value %s\n", 407 bond->dev->name, buf); 408 return -EINVAL; 409 } 410 if (new_value && (bond->params.mode != BOND_MODE_ACTIVEBACKUP)) { 411 pr_err("%s: arp_validate only supported in active-backup mode.\n", 412 bond->dev->name); 413 return -EINVAL; 414 } 415 pr_info("%s: setting arp_validate to %s (%d).\n", 416 bond->dev->name, arp_validate_tbl[new_value].modename, 417 new_value); 418 419 bond->params.arp_validate = new_value; 420 421 return count; 422} 423 424static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate, 425 bonding_store_arp_validate); 426 427/* 428 * Show and store fail_over_mac. User only allowed to change the 429 * value when there are no slaves. 430 */ 431static ssize_t bonding_show_fail_over_mac(struct device *d, 432 struct device_attribute *attr, 433 char *buf) 434{ 435 struct bonding *bond = to_bond(d); 436 437 return sprintf(buf, "%s %d\n", 438 fail_over_mac_tbl[bond->params.fail_over_mac].modename, 439 bond->params.fail_over_mac); 440} 441 442static ssize_t bonding_store_fail_over_mac(struct device *d, 443 struct device_attribute *attr, 444 const char *buf, size_t count) 445{ 446 int new_value; 447 struct bonding *bond = to_bond(d); 448 449 if (bond->slave_cnt != 0) { 450 pr_err("%s: Can't alter fail_over_mac with slaves in bond.\n", 451 bond->dev->name); 452 return -EPERM; 453 } 454 455 new_value = bond_parse_parm(buf, fail_over_mac_tbl); 456 if (new_value < 0) { 457 pr_err("%s: Ignoring invalid fail_over_mac value %s.\n", 458 bond->dev->name, buf); 459 return -EINVAL; 460 } 461 462 bond->params.fail_over_mac = new_value; 463 pr_info("%s: Setting fail_over_mac to %s (%d).\n", 464 bond->dev->name, fail_over_mac_tbl[new_value].modename, 465 new_value); 466 467 return count; 468} 469 470static DEVICE_ATTR(fail_over_mac, S_IRUGO | S_IWUSR, 471 bonding_show_fail_over_mac, bonding_store_fail_over_mac); 472 473/* 474 * Show and set the arp timer interval. There are two tricky bits 475 * here. First, if ARP monitoring is activated, then we must disable 476 * MII monitoring. Second, if the ARP timer isn't running, we must 477 * start it. 478 */ 479static ssize_t bonding_show_arp_interval(struct device *d, 480 struct device_attribute *attr, 481 char *buf) 482{ 483 struct bonding *bond = to_bond(d); 484 485 return sprintf(buf, "%d\n", bond->params.arp_interval); 486} 487 488static ssize_t bonding_store_arp_interval(struct device *d, 489 struct device_attribute *attr, 490 const char *buf, size_t count) 491{ 492 int new_value, ret = count; 493 struct bonding *bond = to_bond(d); 494 495 if (sscanf(buf, "%d", &new_value) != 1) { 496 pr_err("%s: no arp_interval value specified.\n", 497 bond->dev->name); 498 ret = -EINVAL; 499 goto out; 500 } 501 if (new_value < 0) { 502 pr_err("%s: Invalid arp_interval value %d not in range 1-%d; rejected.\n", 503 bond->dev->name, new_value, INT_MAX); 504 ret = -EINVAL; 505 goto out; 506 } 507 if (bond->params.mode == BOND_MODE_ALB || 508 bond->params.mode == BOND_MODE_TLB) { 509 pr_info("%s: ARP monitoring cannot be used with ALB/TLB. Only MII monitoring is supported on %s.\n", 510 bond->dev->name, bond->dev->name); 511 ret = -EINVAL; 512 goto out; 513 } 514 pr_info("%s: Setting ARP monitoring interval to %d.\n", 515 bond->dev->name, new_value); 516 bond->params.arp_interval = new_value; 517 if (bond->params.miimon) { 518 pr_info("%s: ARP monitoring cannot be used with MII monitoring. %s Disabling MII monitoring.\n", 519 bond->dev->name, bond->dev->name); 520 bond->params.miimon = 0; 521 if (delayed_work_pending(&bond->mii_work)) { 522 cancel_delayed_work(&bond->mii_work); 523 flush_workqueue(bond->wq); 524 } 525 } 526 if (!bond->params.arp_targets[0]) { 527 pr_info("%s: ARP monitoring has been set up, but no ARP targets have been specified.\n", 528 bond->dev->name); 529 } 530 if (bond->dev->flags & IFF_UP) { 531 /* If the interface is up, we may need to fire off 532 * the ARP timer. If the interface is down, the 533 * timer will get fired off when the open function 534 * is called. 535 */ 536 if (!delayed_work_pending(&bond->arp_work)) { 537 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) 538 INIT_DELAYED_WORK(&bond->arp_work, 539 bond_activebackup_arp_mon); 540 else 541 INIT_DELAYED_WORK(&bond->arp_work, 542 bond_loadbalance_arp_mon); 543 544 queue_delayed_work(bond->wq, &bond->arp_work, 0); 545 } 546 } 547 548out: 549 return ret; 550} 551static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR, 552 bonding_show_arp_interval, bonding_store_arp_interval); 553 554/* 555 * Show and set the arp targets. 556 */ 557static ssize_t bonding_show_arp_targets(struct device *d, 558 struct device_attribute *attr, 559 char *buf) 560{ 561 int i, res = 0; 562 struct bonding *bond = to_bond(d); 563 564 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) { 565 if (bond->params.arp_targets[i]) 566 res += sprintf(buf + res, "%pI4 ", 567 &bond->params.arp_targets[i]); 568 } 569 if (res) 570 buf[res-1] = '\n'; /* eat the leftover space */ 571 return res; 572} 573 574static ssize_t bonding_store_arp_targets(struct device *d, 575 struct device_attribute *attr, 576 const char *buf, size_t count) 577{ 578 __be32 newtarget; 579 int i = 0, done = 0, ret = count; 580 struct bonding *bond = to_bond(d); 581 __be32 *targets; 582 583 targets = bond->params.arp_targets; 584 newtarget = in_aton(buf + 1); 585 /* look for adds */ 586 if (buf[0] == '+') { 587 if ((newtarget == 0) || (newtarget == htonl(INADDR_BROADCAST))) { 588 pr_err("%s: invalid ARP target %pI4 specified for addition\n", 589 bond->dev->name, &newtarget); 590 ret = -EINVAL; 591 goto out; 592 } 593 /* look for an empty slot to put the target in, and check for dupes */ 594 for (i = 0; (i < BOND_MAX_ARP_TARGETS) && !done; i++) { 595 if (targets[i] == newtarget) { /* duplicate */ 596 pr_err("%s: ARP target %pI4 is already present\n", 597 bond->dev->name, &newtarget); 598 ret = -EINVAL; 599 goto out; 600 } 601 if (targets[i] == 0) { 602 pr_info("%s: adding ARP target %pI4.\n", 603 bond->dev->name, &newtarget); 604 done = 1; 605 targets[i] = newtarget; 606 } 607 } 608 if (!done) { 609 pr_err("%s: ARP target table is full!\n", 610 bond->dev->name); 611 ret = -EINVAL; 612 goto out; 613 } 614 615 } else if (buf[0] == '-') { 616 if ((newtarget == 0) || (newtarget == htonl(INADDR_BROADCAST))) { 617 pr_err("%s: invalid ARP target %pI4 specified for removal\n", 618 bond->dev->name, &newtarget); 619 ret = -EINVAL; 620 goto out; 621 } 622 623 for (i = 0; (i < BOND_MAX_ARP_TARGETS) && !done; i++) { 624 if (targets[i] == newtarget) { 625 int j; 626 pr_info("%s: removing ARP target %pI4.\n", 627 bond->dev->name, &newtarget); 628 for (j = i; (j < (BOND_MAX_ARP_TARGETS-1)) && targets[j+1]; j++) 629 targets[j] = targets[j+1]; 630 631 targets[j] = 0; 632 done = 1; 633 } 634 } 635 if (!done) { 636 pr_info("%s: unable to remove nonexistent ARP target %pI4.\n", 637 bond->dev->name, &newtarget); 638 ret = -EINVAL; 639 goto out; 640 } 641 } else { 642 pr_err("no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n", 643 bond->dev->name); 644 ret = -EPERM; 645 goto out; 646 } 647 648out: 649 return ret; 650} 651static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets); 652 653/* 654 * Show and set the up and down delays. These must be multiples of the 655 * MII monitoring value, and are stored internally as the multiplier. 656 * Thus, we must translate to MS for the real world. 657 */ 658static ssize_t bonding_show_downdelay(struct device *d, 659 struct device_attribute *attr, 660 char *buf) 661{ 662 struct bonding *bond = to_bond(d); 663 664 return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon); 665} 666 667static ssize_t bonding_store_downdelay(struct device *d, 668 struct device_attribute *attr, 669 const char *buf, size_t count) 670{ 671 int new_value, ret = count; 672 struct bonding *bond = to_bond(d); 673 674 if (!(bond->params.miimon)) { 675 pr_err("%s: Unable to set down delay as MII monitoring is disabled\n", 676 bond->dev->name); 677 ret = -EPERM; 678 goto out; 679 } 680 681 if (sscanf(buf, "%d", &new_value) != 1) { 682 pr_err("%s: no down delay value specified.\n", bond->dev->name); 683 ret = -EINVAL; 684 goto out; 685 } 686 if (new_value < 0) { 687 pr_err("%s: Invalid down delay value %d not in range %d-%d; rejected.\n", 688 bond->dev->name, new_value, 1, INT_MAX); 689 ret = -EINVAL; 690 goto out; 691 } else { 692 if ((new_value % bond->params.miimon) != 0) { 693 pr_warning("%s: Warning: down delay (%d) is not a multiple of miimon (%d), delay rounded to %d ms\n", 694 bond->dev->name, new_value, 695 bond->params.miimon, 696 (new_value / bond->params.miimon) * 697 bond->params.miimon); 698 } 699 bond->params.downdelay = new_value / bond->params.miimon; 700 pr_info("%s: Setting down delay to %d.\n", 701 bond->dev->name, 702 bond->params.downdelay * bond->params.miimon); 703 704 } 705 706out: 707 return ret; 708} 709static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR, 710 bonding_show_downdelay, bonding_store_downdelay); 711 712static ssize_t bonding_show_updelay(struct device *d, 713 struct device_attribute *attr, 714 char *buf) 715{ 716 struct bonding *bond = to_bond(d); 717 718 return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon); 719 720} 721 722static ssize_t bonding_store_updelay(struct device *d, 723 struct device_attribute *attr, 724 const char *buf, size_t count) 725{ 726 int new_value, ret = count; 727 struct bonding *bond = to_bond(d); 728 729 if (!(bond->params.miimon)) { 730 pr_err("%s: Unable to set up delay as MII monitoring is disabled\n", 731 bond->dev->name); 732 ret = -EPERM; 733 goto out; 734 } 735 736 if (sscanf(buf, "%d", &new_value) != 1) { 737 pr_err("%s: no up delay value specified.\n", 738 bond->dev->name); 739 ret = -EINVAL; 740 goto out; 741 } 742 if (new_value < 0) { 743 pr_err("%s: Invalid down delay value %d not in range %d-%d; rejected.\n", 744 bond->dev->name, new_value, 1, INT_MAX); 745 ret = -EINVAL; 746 goto out; 747 } else { 748 if ((new_value % bond->params.miimon) != 0) { 749 pr_warning("%s: Warning: up delay (%d) is not a multiple of miimon (%d), updelay rounded to %d ms\n", 750 bond->dev->name, new_value, 751 bond->params.miimon, 752 (new_value / bond->params.miimon) * 753 bond->params.miimon); 754 } 755 bond->params.updelay = new_value / bond->params.miimon; 756 pr_info("%s: Setting up delay to %d.\n", 757 bond->dev->name, 758 bond->params.updelay * bond->params.miimon); 759 } 760 761out: 762 return ret; 763} 764static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR, 765 bonding_show_updelay, bonding_store_updelay); 766 767/* 768 * Show and set the LACP interval. Interface must be down, and the mode 769 * must be set to 802.3ad mode. 770 */ 771static ssize_t bonding_show_lacp(struct device *d, 772 struct device_attribute *attr, 773 char *buf) 774{ 775 struct bonding *bond = to_bond(d); 776 777 return sprintf(buf, "%s %d\n", 778 bond_lacp_tbl[bond->params.lacp_fast].modename, 779 bond->params.lacp_fast); 780} 781 782static ssize_t bonding_store_lacp(struct device *d, 783 struct device_attribute *attr, 784 const char *buf, size_t count) 785{ 786 int new_value, ret = count; 787 struct bonding *bond = to_bond(d); 788 789 if (bond->dev->flags & IFF_UP) { 790 pr_err("%s: Unable to update LACP rate because interface is up.\n", 791 bond->dev->name); 792 ret = -EPERM; 793 goto out; 794 } 795 796 if (bond->params.mode != BOND_MODE_8023AD) { 797 pr_err("%s: Unable to update LACP rate because bond is not in 802.3ad mode.\n", 798 bond->dev->name); 799 ret = -EPERM; 800 goto out; 801 } 802 803 new_value = bond_parse_parm(buf, bond_lacp_tbl); 804 805 if ((new_value == 1) || (new_value == 0)) { 806 bond->params.lacp_fast = new_value; 807 pr_info("%s: Setting LACP rate to %s (%d).\n", 808 bond->dev->name, bond_lacp_tbl[new_value].modename, 809 new_value); 810 } else { 811 pr_err("%s: Ignoring invalid LACP rate value %.*s.\n", 812 bond->dev->name, (int)strlen(buf) - 1, buf); 813 ret = -EINVAL; 814 } 815out: 816 return ret; 817} 818static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, 819 bonding_show_lacp, bonding_store_lacp); 820 821static ssize_t bonding_show_ad_select(struct device *d, 822 struct device_attribute *attr, 823 char *buf) 824{ 825 struct bonding *bond = to_bond(d); 826 827 return sprintf(buf, "%s %d\n", 828 ad_select_tbl[bond->params.ad_select].modename, 829 bond->params.ad_select); 830} 831 832 833static ssize_t bonding_store_ad_select(struct device *d, 834 struct device_attribute *attr, 835 const char *buf, size_t count) 836{ 837 int new_value, ret = count; 838 struct bonding *bond = to_bond(d); 839 840 if (bond->dev->flags & IFF_UP) { 841 pr_err("%s: Unable to update ad_select because interface is up.\n", 842 bond->dev->name); 843 ret = -EPERM; 844 goto out; 845 } 846 847 new_value = bond_parse_parm(buf, ad_select_tbl); 848 849 if (new_value != -1) { 850 bond->params.ad_select = new_value; 851 pr_info("%s: Setting ad_select to %s (%d).\n", 852 bond->dev->name, ad_select_tbl[new_value].modename, 853 new_value); 854 } else { 855 pr_err("%s: Ignoring invalid ad_select value %.*s.\n", 856 bond->dev->name, (int)strlen(buf) - 1, buf); 857 ret = -EINVAL; 858 } 859out: 860 return ret; 861} 862static DEVICE_ATTR(ad_select, S_IRUGO | S_IWUSR, 863 bonding_show_ad_select, bonding_store_ad_select); 864 865/* 866 * Show and set the number of peer notifications to send after a failover event. 867 */ 868static ssize_t bonding_show_num_peer_notif(struct device *d, 869 struct device_attribute *attr, 870 char *buf) 871{ 872 struct bonding *bond = to_bond(d); 873 return sprintf(buf, "%d\n", bond->params.num_peer_notif); 874} 875 876static ssize_t bonding_store_num_peer_notif(struct device *d, 877 struct device_attribute *attr, 878 const char *buf, size_t count) 879{ 880 struct bonding *bond = to_bond(d); 881 int err = kstrtou8(buf, 10, &bond->params.num_peer_notif); 882 return err ? err : count; 883} 884static DEVICE_ATTR(num_grat_arp, S_IRUGO | S_IWUSR, 885 bonding_show_num_peer_notif, bonding_store_num_peer_notif); 886static DEVICE_ATTR(num_unsol_na, S_IRUGO | S_IWUSR, 887 bonding_show_num_peer_notif, bonding_store_num_peer_notif); 888 889/* 890 * Show and set the MII monitor interval. There are two tricky bits 891 * here. First, if MII monitoring is activated, then we must disable 892 * ARP monitoring. Second, if the timer isn't running, we must 893 * start it. 894 */ 895static ssize_t bonding_show_miimon(struct device *d, 896 struct device_attribute *attr, 897 char *buf) 898{ 899 struct bonding *bond = to_bond(d); 900 901 return sprintf(buf, "%d\n", bond->params.miimon); 902} 903 904static ssize_t bonding_store_miimon(struct device *d, 905 struct device_attribute *attr, 906 const char *buf, size_t count) 907{ 908 int new_value, ret = count; 909 struct bonding *bond = to_bond(d); 910 911 if (sscanf(buf, "%d", &new_value) != 1) { 912 pr_err("%s: no miimon value specified.\n", 913 bond->dev->name); 914 ret = -EINVAL; 915 goto out; 916 } 917 if (new_value < 0) { 918 pr_err("%s: Invalid miimon value %d not in range %d-%d; rejected.\n", 919 bond->dev->name, new_value, 1, INT_MAX); 920 ret = -EINVAL; 921 goto out; 922 } else { 923 pr_info("%s: Setting MII monitoring interval to %d.\n", 924 bond->dev->name, new_value); 925 bond->params.miimon = new_value; 926 if (bond->params.updelay) 927 pr_info("%s: Note: Updating updelay (to %d) since it is a multiple of the miimon value.\n", 928 bond->dev->name, 929 bond->params.updelay * bond->params.miimon); 930 if (bond->params.downdelay) 931 pr_info("%s: Note: Updating downdelay (to %d) since it is a multiple of the miimon value.\n", 932 bond->dev->name, 933 bond->params.downdelay * bond->params.miimon); 934 if (bond->params.arp_interval) { 935 pr_info("%s: MII monitoring cannot be used with ARP monitoring. Disabling ARP monitoring...\n", 936 bond->dev->name); 937 bond->params.arp_interval = 0; 938 if (bond->params.arp_validate) { 939 bond->params.arp_validate = 940 BOND_ARP_VALIDATE_NONE; 941 } 942 if (delayed_work_pending(&bond->arp_work)) { 943 cancel_delayed_work(&bond->arp_work); 944 flush_workqueue(bond->wq); 945 } 946 } 947 948 if (bond->dev->flags & IFF_UP) { 949 /* If the interface is up, we may need to fire off 950 * the MII timer. If the interface is down, the 951 * timer will get fired off when the open function 952 * is called. 953 */ 954 if (!delayed_work_pending(&bond->mii_work)) { 955 INIT_DELAYED_WORK(&bond->mii_work, 956 bond_mii_monitor); 957 queue_delayed_work(bond->wq, 958 &bond->mii_work, 0); 959 } 960 } 961 } 962out: 963 return ret; 964} 965static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, 966 bonding_show_miimon, bonding_store_miimon); 967 968/* 969 * Show and set the primary slave. The store function is much 970 * simpler than bonding_store_slaves function because it only needs to 971 * handle one interface name. 972 * The bond must be a mode that supports a primary for this be 973 * set. 974 */ 975static ssize_t bonding_show_primary(struct device *d, 976 struct device_attribute *attr, 977 char *buf) 978{ 979 int count = 0; 980 struct bonding *bond = to_bond(d); 981 982 if (bond->primary_slave) 983 count = sprintf(buf, "%s\n", bond->primary_slave->dev->name); 984 985 return count; 986} 987 988static ssize_t bonding_store_primary(struct device *d, 989 struct device_attribute *attr, 990 const char *buf, size_t count) 991{ 992 int i; 993 struct slave *slave; 994 struct bonding *bond = to_bond(d); 995 char ifname[IFNAMSIZ]; 996 997 if (!rtnl_trylock()) 998 return restart_syscall(); 999 block_netpoll_tx(); 1000 read_lock(&bond->lock); 1001 write_lock_bh(&bond->curr_slave_lock); 1002 1003 if (!USES_PRIMARY(bond->params.mode)) { 1004 pr_info("%s: Unable to set primary slave; %s is in mode %d\n", 1005 bond->dev->name, bond->dev->name, bond->params.mode); 1006 goto out; 1007 } 1008 1009 sscanf(buf, "%16s", ifname); /* IFNAMSIZ */ 1010 1011 /* check to see if we are clearing primary */ 1012 if (!strlen(ifname) || buf[0] == '\n') { 1013 pr_info("%s: Setting primary slave to None.\n", 1014 bond->dev->name); 1015 bond->primary_slave = NULL; 1016 bond_select_active_slave(bond); 1017 goto out; 1018 } 1019 1020 bond_for_each_slave(bond, slave, i) { 1021 if (strncmp(slave->dev->name, ifname, IFNAMSIZ) == 0) { 1022 pr_info("%s: Setting %s as primary slave.\n", 1023 bond->dev->name, slave->dev->name); 1024 bond->primary_slave = slave; 1025 strcpy(bond->params.primary, slave->dev->name); 1026 bond_select_active_slave(bond); 1027 goto out; 1028 } 1029 } 1030 1031 pr_info("%s: Unable to set %.*s as primary slave.\n", 1032 bond->dev->name, (int)strlen(buf) - 1, buf); 1033out: 1034 write_unlock_bh(&bond->curr_slave_lock); 1035 read_unlock(&bond->lock); 1036 unblock_netpoll_tx(); 1037 rtnl_unlock(); 1038 1039 return count; 1040} 1041static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR, 1042 bonding_show_primary, bonding_store_primary); 1043 1044/* 1045 * Show and set the primary_reselect flag. 1046 */ 1047static ssize_t bonding_show_primary_reselect(struct device *d, 1048 struct device_attribute *attr, 1049 char *buf) 1050{ 1051 struct bonding *bond = to_bond(d); 1052 1053 return sprintf(buf, "%s %d\n", 1054 pri_reselect_tbl[bond->params.primary_reselect].modename, 1055 bond->params.primary_reselect); 1056} 1057 1058static ssize_t bonding_store_primary_reselect(struct device *d, 1059 struct device_attribute *attr, 1060 const char *buf, size_t count) 1061{ 1062 int new_value, ret = count; 1063 struct bonding *bond = to_bond(d); 1064 1065 if (!rtnl_trylock()) 1066 return restart_syscall(); 1067 1068 new_value = bond_parse_parm(buf, pri_reselect_tbl); 1069 if (new_value < 0) { 1070 pr_err("%s: Ignoring invalid primary_reselect value %.*s.\n", 1071 bond->dev->name, 1072 (int) strlen(buf) - 1, buf); 1073 ret = -EINVAL; 1074 goto out; 1075 } 1076 1077 bond->params.primary_reselect = new_value; 1078 pr_info("%s: setting primary_reselect to %s (%d).\n", 1079 bond->dev->name, pri_reselect_tbl[new_value].modename, 1080 new_value); 1081 1082 block_netpoll_tx(); 1083 read_lock(&bond->lock); 1084 write_lock_bh(&bond->curr_slave_lock); 1085 bond_select_active_slave(bond); 1086 write_unlock_bh(&bond->curr_slave_lock); 1087 read_unlock(&bond->lock); 1088 unblock_netpoll_tx(); 1089out: 1090 rtnl_unlock(); 1091 return ret; 1092} 1093static DEVICE_ATTR(primary_reselect, S_IRUGO | S_IWUSR, 1094 bonding_show_primary_reselect, 1095 bonding_store_primary_reselect); 1096 1097/* 1098 * Show and set the use_carrier flag. 1099 */ 1100static ssize_t bonding_show_carrier(struct device *d, 1101 struct device_attribute *attr, 1102 char *buf) 1103{ 1104 struct bonding *bond = to_bond(d); 1105 1106 return sprintf(buf, "%d\n", bond->params.use_carrier); 1107} 1108 1109static ssize_t bonding_store_carrier(struct device *d, 1110 struct device_attribute *attr, 1111 const char *buf, size_t count) 1112{ 1113 int new_value, ret = count; 1114 struct bonding *bond = to_bond(d); 1115 1116 1117 if (sscanf(buf, "%d", &new_value) != 1) { 1118 pr_err("%s: no use_carrier value specified.\n", 1119 bond->dev->name); 1120 ret = -EINVAL; 1121 goto out; 1122 } 1123 if ((new_value == 0) || (new_value == 1)) { 1124 bond->params.use_carrier = new_value; 1125 pr_info("%s: Setting use_carrier to %d.\n", 1126 bond->dev->name, new_value); 1127 } else { 1128 pr_info("%s: Ignoring invalid use_carrier value %d.\n", 1129 bond->dev->name, new_value); 1130 } 1131out: 1132 return ret; 1133} 1134static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR, 1135 bonding_show_carrier, bonding_store_carrier); 1136 1137 1138/* 1139 * Show and set currently active_slave. 1140 */ 1141static ssize_t bonding_show_active_slave(struct device *d, 1142 struct device_attribute *attr, 1143 char *buf) 1144{ 1145 struct slave *curr; 1146 struct bonding *bond = to_bond(d); 1147 int count = 0; 1148 1149 read_lock(&bond->curr_slave_lock); 1150 curr = bond->curr_active_slave; 1151 read_unlock(&bond->curr_slave_lock); 1152 1153 if (USES_PRIMARY(bond->params.mode) && curr) 1154 count = sprintf(buf, "%s\n", curr->dev->name); 1155 return count; 1156} 1157 1158static ssize_t bonding_store_active_slave(struct device *d, 1159 struct device_attribute *attr, 1160 const char *buf, size_t count) 1161{ 1162 int i; 1163 struct slave *slave; 1164 struct slave *old_active = NULL; 1165 struct slave *new_active = NULL; 1166 struct bonding *bond = to_bond(d); 1167 char ifname[IFNAMSIZ]; 1168 1169 if (!rtnl_trylock()) 1170 return restart_syscall(); 1171 1172 block_netpoll_tx(); 1173 read_lock(&bond->lock); 1174 write_lock_bh(&bond->curr_slave_lock); 1175 1176 if (!USES_PRIMARY(bond->params.mode)) { 1177 pr_info("%s: Unable to change active slave; %s is in mode %d\n", 1178 bond->dev->name, bond->dev->name, bond->params.mode); 1179 goto out; 1180 } 1181 1182 sscanf(buf, "%16s", ifname); /* IFNAMSIZ */ 1183 1184 /* check to see if we are clearing active */ 1185 if (!strlen(ifname) || buf[0] == '\n') { 1186 pr_info("%s: Clearing current active slave.\n", 1187 bond->dev->name); 1188 bond->curr_active_slave = NULL; 1189 bond_select_active_slave(bond); 1190 goto out; 1191 } 1192 1193 bond_for_each_slave(bond, slave, i) { 1194 if (strncmp(slave->dev->name, ifname, IFNAMSIZ) == 0) { 1195 old_active = bond->curr_active_slave; 1196 new_active = slave; 1197 if (new_active == old_active) { 1198 /* do nothing */ 1199 pr_info("%s: %s is already the current" 1200 " active slave.\n", 1201 bond->dev->name, 1202 slave->dev->name); 1203 goto out; 1204 } 1205 else { 1206 if ((new_active) && 1207 (old_active) && 1208 (new_active->link == BOND_LINK_UP) && 1209 IS_UP(new_active->dev)) { 1210 pr_info("%s: Setting %s as active" 1211 " slave.\n", 1212 bond->dev->name, 1213 slave->dev->name); 1214 bond_change_active_slave(bond, 1215 new_active); 1216 } 1217 else { 1218 pr_info("%s: Could not set %s as" 1219 " active slave; either %s is" 1220 " down or the link is down.\n", 1221 bond->dev->name, 1222 slave->dev->name, 1223 slave->dev->name); 1224 } 1225 goto out; 1226 } 1227 } 1228 } 1229 1230 pr_info("%s: Unable to set %.*s as active slave.\n", 1231 bond->dev->name, (int)strlen(buf) - 1, buf); 1232 out: 1233 write_unlock_bh(&bond->curr_slave_lock); 1234 read_unlock(&bond->lock); 1235 unblock_netpoll_tx(); 1236 1237 rtnl_unlock(); 1238 1239 return count; 1240 1241} 1242static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR, 1243 bonding_show_active_slave, bonding_store_active_slave); 1244 1245 1246/* 1247 * Show link status of the bond interface. 1248 */ 1249static ssize_t bonding_show_mii_status(struct device *d, 1250 struct device_attribute *attr, 1251 char *buf) 1252{ 1253 struct slave *curr; 1254 struct bonding *bond = to_bond(d); 1255 1256 read_lock(&bond->curr_slave_lock); 1257 curr = bond->curr_active_slave; 1258 read_unlock(&bond->curr_slave_lock); 1259 1260 return sprintf(buf, "%s\n", curr ? "up" : "down"); 1261} 1262static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL); 1263 1264 1265/* 1266 * Show current 802.3ad aggregator ID. 1267 */ 1268static ssize_t bonding_show_ad_aggregator(struct device *d, 1269 struct device_attribute *attr, 1270 char *buf) 1271{ 1272 int count = 0; 1273 struct bonding *bond = to_bond(d); 1274 1275 if (bond->params.mode == BOND_MODE_8023AD) { 1276 struct ad_info ad_info; 1277 count = sprintf(buf, "%d\n", 1278 (bond_3ad_get_active_agg_info(bond, &ad_info)) 1279 ? 0 : ad_info.aggregator_id); 1280 } 1281 1282 return count; 1283} 1284static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL); 1285 1286 1287/* 1288 * Show number of active 802.3ad ports. 1289 */ 1290static ssize_t bonding_show_ad_num_ports(struct device *d, 1291 struct device_attribute *attr, 1292 char *buf) 1293{ 1294 int count = 0; 1295 struct bonding *bond = to_bond(d); 1296 1297 if (bond->params.mode == BOND_MODE_8023AD) { 1298 struct ad_info ad_info; 1299 count = sprintf(buf, "%d\n", 1300 (bond_3ad_get_active_agg_info(bond, &ad_info)) 1301 ? 0 : ad_info.ports); 1302 } 1303 1304 return count; 1305} 1306static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL); 1307 1308 1309/* 1310 * Show current 802.3ad actor key. 1311 */ 1312static ssize_t bonding_show_ad_actor_key(struct device *d, 1313 struct device_attribute *attr, 1314 char *buf) 1315{ 1316 int count = 0; 1317 struct bonding *bond = to_bond(d); 1318 1319 if (bond->params.mode == BOND_MODE_8023AD) { 1320 struct ad_info ad_info; 1321 count = sprintf(buf, "%d\n", 1322 (bond_3ad_get_active_agg_info(bond, &ad_info)) 1323 ? 0 : ad_info.actor_key); 1324 } 1325 1326 return count; 1327} 1328static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL); 1329 1330 1331/* 1332 * Show current 802.3ad partner key. 1333 */ 1334static ssize_t bonding_show_ad_partner_key(struct device *d, 1335 struct device_attribute *attr, 1336 char *buf) 1337{ 1338 int count = 0; 1339 struct bonding *bond = to_bond(d); 1340 1341 if (bond->params.mode == BOND_MODE_8023AD) { 1342 struct ad_info ad_info; 1343 count = sprintf(buf, "%d\n", 1344 (bond_3ad_get_active_agg_info(bond, &ad_info)) 1345 ? 0 : ad_info.partner_key); 1346 } 1347 1348 return count; 1349} 1350static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL); 1351 1352 1353/* 1354 * Show current 802.3ad partner mac. 1355 */ 1356static ssize_t bonding_show_ad_partner_mac(struct device *d, 1357 struct device_attribute *attr, 1358 char *buf) 1359{ 1360 int count = 0; 1361 struct bonding *bond = to_bond(d); 1362 1363 if (bond->params.mode == BOND_MODE_8023AD) { 1364 struct ad_info ad_info; 1365 if (!bond_3ad_get_active_agg_info(bond, &ad_info)) 1366 count = sprintf(buf, "%pM\n", ad_info.partner_system); 1367 } 1368 1369 return count; 1370} 1371static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL); 1372 1373/* 1374 * Show the queue_ids of the slaves in the current bond. 1375 */ 1376static ssize_t bonding_show_queue_id(struct device *d, 1377 struct device_attribute *attr, 1378 char *buf) 1379{ 1380 struct slave *slave; 1381 int i, res = 0; 1382 struct bonding *bond = to_bond(d); 1383 1384 if (!rtnl_trylock()) 1385 return restart_syscall(); 1386 1387 read_lock(&bond->lock); 1388 bond_for_each_slave(bond, slave, i) { 1389 if (res > (PAGE_SIZE - IFNAMSIZ - 6)) { 1390 /* not enough space for another interface_name:queue_id pair */ 1391 if ((PAGE_SIZE - res) > 10) 1392 res = PAGE_SIZE - 10; 1393 res += sprintf(buf + res, "++more++ "); 1394 break; 1395 } 1396 res += sprintf(buf + res, "%s:%d ", 1397 slave->dev->name, slave->queue_id); 1398 } 1399 read_unlock(&bond->lock); 1400 if (res) 1401 buf[res-1] = '\n'; /* eat the leftover space */ 1402 rtnl_unlock(); 1403 return res; 1404} 1405 1406/* 1407 * Set the queue_ids of the slaves in the current bond. The bond 1408 * interface must be enslaved for this to work. 1409 */ 1410static ssize_t bonding_store_queue_id(struct device *d, 1411 struct device_attribute *attr, 1412 const char *buffer, size_t count) 1413{ 1414 struct slave *slave, *update_slave; 1415 struct bonding *bond = to_bond(d); 1416 u16 qid; 1417 int i, ret = count; 1418 char *delim; 1419 struct net_device *sdev = NULL; 1420 1421 if (!rtnl_trylock()) 1422 return restart_syscall(); 1423 1424 /* delim will point to queue id if successful */ 1425 delim = strchr(buffer, ':'); 1426 if (!delim) 1427 goto err_no_cmd; 1428 1429 /* 1430 * Terminate string that points to device name and bump it 1431 * up one, so we can read the queue id there. 1432 */ 1433 *delim = '\0'; 1434 if (sscanf(++delim, "%hd\n", &qid) != 1) 1435 goto err_no_cmd; 1436 1437 /* Check buffer length, valid ifname and queue id */ 1438 if (strlen(buffer) > IFNAMSIZ || 1439 !dev_valid_name(buffer) || 1440 qid > bond->params.tx_queues) 1441 goto err_no_cmd; 1442 1443 /* Get the pointer to that interface if it exists */ 1444 sdev = __dev_get_by_name(dev_net(bond->dev), buffer); 1445 if (!sdev) 1446 goto err_no_cmd; 1447 1448 read_lock(&bond->lock); 1449 1450 /* Search for thes slave and check for duplicate qids */ 1451 update_slave = NULL; 1452 bond_for_each_slave(bond, slave, i) { 1453 if (sdev == slave->dev) 1454 /* 1455 * We don't need to check the matching 1456 * slave for dups, since we're overwriting it 1457 */ 1458 update_slave = slave; 1459 else if (qid && qid == slave->queue_id) { 1460 goto err_no_cmd_unlock; 1461 } 1462 } 1463 1464 if (!update_slave) 1465 goto err_no_cmd_unlock; 1466 1467 /* Actually set the qids for the slave */ 1468 update_slave->queue_id = qid; 1469 1470 read_unlock(&bond->lock); 1471out: 1472 rtnl_unlock(); 1473 return ret; 1474 1475err_no_cmd_unlock: 1476 read_unlock(&bond->lock); 1477err_no_cmd: 1478 pr_info("invalid input for queue_id set for %s.\n", 1479 bond->dev->name); 1480 ret = -EPERM; 1481 goto out; 1482} 1483 1484static DEVICE_ATTR(queue_id, S_IRUGO | S_IWUSR, bonding_show_queue_id, 1485 bonding_store_queue_id); 1486 1487 1488/* 1489 * Show and set the all_slaves_active flag. 1490 */ 1491static ssize_t bonding_show_slaves_active(struct device *d, 1492 struct device_attribute *attr, 1493 char *buf) 1494{ 1495 struct bonding *bond = to_bond(d); 1496 1497 return sprintf(buf, "%d\n", bond->params.all_slaves_active); 1498} 1499 1500static ssize_t bonding_store_slaves_active(struct device *d, 1501 struct device_attribute *attr, 1502 const char *buf, size_t count) 1503{ 1504 int i, new_value, ret = count; 1505 struct bonding *bond = to_bond(d); 1506 struct slave *slave; 1507 1508 if (sscanf(buf, "%d", &new_value) != 1) { 1509 pr_err("%s: no all_slaves_active value specified.\n", 1510 bond->dev->name); 1511 ret = -EINVAL; 1512 goto out; 1513 } 1514 1515 if (new_value == bond->params.all_slaves_active) 1516 goto out; 1517 1518 if ((new_value == 0) || (new_value == 1)) { 1519 bond->params.all_slaves_active = new_value; 1520 } else { 1521 pr_info("%s: Ignoring invalid all_slaves_active value %d.\n", 1522 bond->dev->name, new_value); 1523 ret = -EINVAL; 1524 goto out; 1525 } 1526 1527 bond_for_each_slave(bond, slave, i) { 1528 if (!bond_is_active_slave(slave)) { 1529 if (new_value) 1530 slave->inactive = 0; 1531 else 1532 slave->inactive = 1; 1533 } 1534 } 1535out: 1536 return ret; 1537} 1538static DEVICE_ATTR(all_slaves_active, S_IRUGO | S_IWUSR, 1539 bonding_show_slaves_active, bonding_store_slaves_active); 1540 1541/* 1542 * Show and set the number of IGMP membership reports to send on link failure 1543 */ 1544static ssize_t bonding_show_resend_igmp(struct device *d, 1545 struct device_attribute *attr, 1546 char *buf) 1547{ 1548 struct bonding *bond = to_bond(d); 1549 1550 return sprintf(buf, "%d\n", bond->params.resend_igmp); 1551} 1552 1553static ssize_t bonding_store_resend_igmp(struct device *d, 1554 struct device_attribute *attr, 1555 const char *buf, size_t count) 1556{ 1557 int new_value, ret = count; 1558 struct bonding *bond = to_bond(d); 1559 1560 if (sscanf(buf, "%d", &new_value) != 1) { 1561 pr_err("%s: no resend_igmp value specified.\n", 1562 bond->dev->name); 1563 ret = -EINVAL; 1564 goto out; 1565 } 1566 1567 if (new_value < 0 || new_value > 255) { 1568 pr_err("%s: Invalid resend_igmp value %d not in range 0-255; rejected.\n", 1569 bond->dev->name, new_value); 1570 ret = -EINVAL; 1571 goto out; 1572 } 1573 1574 pr_info("%s: Setting resend_igmp to %d.\n", 1575 bond->dev->name, new_value); 1576 bond->params.resend_igmp = new_value; 1577out: 1578 return ret; 1579} 1580 1581static DEVICE_ATTR(resend_igmp, S_IRUGO | S_IWUSR, 1582 bonding_show_resend_igmp, bonding_store_resend_igmp); 1583 1584static struct attribute *per_bond_attrs[] = { 1585 &dev_attr_slaves.attr, 1586 &dev_attr_mode.attr, 1587 &dev_attr_fail_over_mac.attr, 1588 &dev_attr_arp_validate.attr, 1589 &dev_attr_arp_interval.attr, 1590 &dev_attr_arp_ip_target.attr, 1591 &dev_attr_downdelay.attr, 1592 &dev_attr_updelay.attr, 1593 &dev_attr_lacp_rate.attr, 1594 &dev_attr_ad_select.attr, 1595 &dev_attr_xmit_hash_policy.attr, 1596 &dev_attr_num_grat_arp.attr, 1597 &dev_attr_num_unsol_na.attr, 1598 &dev_attr_miimon.attr, 1599 &dev_attr_primary.attr, 1600 &dev_attr_primary_reselect.attr, 1601 &dev_attr_use_carrier.attr, 1602 &dev_attr_active_slave.attr, 1603 &dev_attr_mii_status.attr, 1604 &dev_attr_ad_aggregator.attr, 1605 &dev_attr_ad_num_ports.attr, 1606 &dev_attr_ad_actor_key.attr, 1607 &dev_attr_ad_partner_key.attr, 1608 &dev_attr_ad_partner_mac.attr, 1609 &dev_attr_queue_id.attr, 1610 &dev_attr_all_slaves_active.attr, 1611 &dev_attr_resend_igmp.attr, 1612 NULL, 1613}; 1614 1615static struct attribute_group bonding_group = { 1616 .name = "bonding", 1617 .attrs = per_bond_attrs, 1618}; 1619 1620/* 1621 * Initialize sysfs. This sets up the bonding_masters file in 1622 * /sys/class/net. 1623 */ 1624int bond_create_sysfs(void) 1625{ 1626 int ret; 1627 1628 ret = netdev_class_create_file(&class_attr_bonding_masters); 1629 /* 1630 * Permit multiple loads of the module by ignoring failures to 1631 * create the bonding_masters sysfs file. Bonding devices 1632 * created by second or subsequent loads of the module will 1633 * not be listed in, or controllable by, bonding_masters, but 1634 * will have the usual "bonding" sysfs directory. 1635 * 1636 * This is done to preserve backwards compatibility for 1637 * initscripts/sysconfig, which load bonding multiple times to 1638 * configure multiple bonding devices. 1639 */ 1640 if (ret == -EEXIST) { 1641 /* Is someone being kinky and naming a device bonding_master? */ 1642 if (__dev_get_by_name(&init_net, 1643 class_attr_bonding_masters.attr.name)) 1644 pr_err("network device named %s already exists in sysfs", 1645 class_attr_bonding_masters.attr.name); 1646 ret = 0; 1647 } 1648 1649 return ret; 1650 1651} 1652 1653/* 1654 * Remove /sys/class/net/bonding_masters. 1655 */ 1656void bond_destroy_sysfs(void) 1657{ 1658 netdev_class_remove_file(&class_attr_bonding_masters); 1659} 1660 1661/* 1662 * Initialize sysfs for each bond. This sets up and registers 1663 * the 'bondctl' directory for each individual bond under /sys/class/net. 1664 */ 1665void bond_prepare_sysfs_group(struct bonding *bond) 1666{ 1667 bond->dev->sysfs_groups[0] = &bonding_group; 1668} 1669