bond_sysfs.c revision edf36b24c58dbbd5f2e708096537bf0a88ffa477
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, see <http://www.gnu.org/licenses/>. 16 * 17 * The full GNU General Public License is included in this distribution in the 18 * file called LICENSE. 19 * 20 */ 21 22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 23 24#include <linux/kernel.h> 25#include <linux/module.h> 26#include <linux/device.h> 27#include <linux/sched.h> 28#include <linux/fs.h> 29#include <linux/types.h> 30#include <linux/string.h> 31#include <linux/netdevice.h> 32#include <linux/inetdevice.h> 33#include <linux/in.h> 34#include <linux/sysfs.h> 35#include <linux/ctype.h> 36#include <linux/inet.h> 37#include <linux/rtnetlink.h> 38#include <linux/etherdevice.h> 39#include <net/net_namespace.h> 40#include <net/netns/generic.h> 41#include <linux/nsproxy.h> 42 43#include "bonding.h" 44 45#define to_dev(obj) container_of(obj, struct device, kobj) 46#define to_bond(cd) ((struct bonding *)(netdev_priv(to_net_dev(cd)))) 47 48/* 49 * "show" function for the bond_masters attribute. 50 * The class parameter is ignored. 51 */ 52static ssize_t bonding_show_bonds(struct class *cls, 53 struct class_attribute *attr, 54 char *buf) 55{ 56 struct bond_net *bn = 57 container_of(attr, struct bond_net, class_attr_bonding_masters); 58 int res = 0; 59 struct bonding *bond; 60 61 rtnl_lock(); 62 63 list_for_each_entry(bond, &bn->dev_list, bond_list) { 64 if (res > (PAGE_SIZE - IFNAMSIZ)) { 65 /* not enough space for another interface name */ 66 if ((PAGE_SIZE - res) > 10) 67 res = PAGE_SIZE - 10; 68 res += sprintf(buf + res, "++more++ "); 69 break; 70 } 71 res += sprintf(buf + res, "%s ", bond->dev->name); 72 } 73 if (res) 74 buf[res-1] = '\n'; /* eat the leftover space */ 75 76 rtnl_unlock(); 77 return res; 78} 79 80static struct net_device *bond_get_by_name(struct bond_net *bn, const char *ifname) 81{ 82 struct bonding *bond; 83 84 list_for_each_entry(bond, &bn->dev_list, bond_list) { 85 if (strncmp(bond->dev->name, ifname, IFNAMSIZ) == 0) 86 return bond->dev; 87 } 88 return NULL; 89} 90 91/* 92 * "store" function for the bond_masters attribute. This is what 93 * creates and deletes entire bonds. 94 * 95 * The class parameter is ignored. 96 * 97 */ 98 99static ssize_t bonding_store_bonds(struct class *cls, 100 struct class_attribute *attr, 101 const char *buffer, size_t count) 102{ 103 struct bond_net *bn = 104 container_of(attr, struct bond_net, class_attr_bonding_masters); 105 char command[IFNAMSIZ + 1] = {0, }; 106 char *ifname; 107 int rv, res = count; 108 109 sscanf(buffer, "%16s", command); /* IFNAMSIZ*/ 110 ifname = command + 1; 111 if ((strlen(command) <= 1) || 112 !dev_valid_name(ifname)) 113 goto err_no_cmd; 114 115 if (command[0] == '+') { 116 pr_info("%s is being created...\n", ifname); 117 rv = bond_create(bn->net, ifname); 118 if (rv) { 119 if (rv == -EEXIST) 120 pr_info("%s already exists.\n", ifname); 121 else 122 pr_info("%s creation failed.\n", ifname); 123 res = rv; 124 } 125 } else if (command[0] == '-') { 126 struct net_device *bond_dev; 127 128 rtnl_lock(); 129 bond_dev = bond_get_by_name(bn, ifname); 130 if (bond_dev) { 131 pr_info("%s is being deleted...\n", ifname); 132 unregister_netdevice(bond_dev); 133 } else { 134 pr_err("unable to delete non-existent %s\n", ifname); 135 res = -ENODEV; 136 } 137 rtnl_unlock(); 138 } else 139 goto err_no_cmd; 140 141 /* Always return either count or an error. If you return 0, you'll 142 * get called forever, which is bad. 143 */ 144 return res; 145 146err_no_cmd: 147 pr_err("no command found in bonding_masters. Use +ifname or -ifname.\n"); 148 return -EPERM; 149} 150 151/* class attribute for bond_masters file. This ends up in /sys/class/net */ 152static const struct class_attribute class_attr_bonding_masters = { 153 .attr = { 154 .name = "bonding_masters", 155 .mode = S_IWUSR | S_IRUGO, 156 }, 157 .show = bonding_show_bonds, 158 .store = bonding_store_bonds, 159}; 160 161/* 162 * Show the slaves in the current bond. 163 */ 164static ssize_t bonding_show_slaves(struct device *d, 165 struct device_attribute *attr, char *buf) 166{ 167 struct bonding *bond = to_bond(d); 168 struct list_head *iter; 169 struct slave *slave; 170 int res = 0; 171 172 if (!rtnl_trylock()) 173 return restart_syscall(); 174 175 bond_for_each_slave(bond, slave, iter) { 176 if (res > (PAGE_SIZE - IFNAMSIZ)) { 177 /* not enough space for another interface name */ 178 if ((PAGE_SIZE - res) > 10) 179 res = PAGE_SIZE - 10; 180 res += sprintf(buf + res, "++more++ "); 181 break; 182 } 183 res += sprintf(buf + res, "%s ", slave->dev->name); 184 } 185 186 rtnl_unlock(); 187 188 if (res) 189 buf[res-1] = '\n'; /* eat the leftover space */ 190 191 return res; 192} 193 194/* 195 * Set the slaves in the current bond. 196 * This is supposed to be only thin wrapper for bond_enslave and bond_release. 197 * All hard work should be done there. 198 */ 199static ssize_t bonding_store_slaves(struct device *d, 200 struct device_attribute *attr, 201 const char *buffer, size_t count) 202{ 203 char command[IFNAMSIZ + 1] = { 0, }; 204 char *ifname; 205 int res, ret = count; 206 struct net_device *dev; 207 struct bonding *bond = to_bond(d); 208 209 if (!rtnl_trylock()) 210 return restart_syscall(); 211 212 sscanf(buffer, "%16s", command); /* IFNAMSIZ*/ 213 ifname = command + 1; 214 if ((strlen(command) <= 1) || 215 !dev_valid_name(ifname)) 216 goto err_no_cmd; 217 218 dev = __dev_get_by_name(dev_net(bond->dev), ifname); 219 if (!dev) { 220 pr_info("%s: Interface %s does not exist!\n", 221 bond->dev->name, ifname); 222 ret = -ENODEV; 223 goto out; 224 } 225 226 switch (command[0]) { 227 case '+': 228 pr_info("%s: Adding slave %s.\n", bond->dev->name, dev->name); 229 res = bond_enslave(bond->dev, dev); 230 break; 231 232 case '-': 233 pr_info("%s: Removing slave %s.\n", bond->dev->name, dev->name); 234 res = bond_release(bond->dev, dev); 235 break; 236 237 default: 238 goto err_no_cmd; 239 } 240 241 if (res) 242 ret = res; 243 goto out; 244 245err_no_cmd: 246 pr_err("no command found in slaves file for bond %s. Use +ifname or -ifname.\n", 247 bond->dev->name); 248 ret = -EPERM; 249 250out: 251 rtnl_unlock(); 252 return ret; 253} 254 255static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves, 256 bonding_store_slaves); 257 258/* 259 * Show and set the bonding mode. The bond interface must be down to 260 * change the mode. 261 */ 262static ssize_t bonding_show_mode(struct device *d, 263 struct device_attribute *attr, char *buf) 264{ 265 struct bonding *bond = to_bond(d); 266 struct bond_opt_value *val; 267 268 val = bond_opt_get_val(BOND_OPT_MODE, bond->params.mode); 269 270 return sprintf(buf, "%s %d\n", val->string, bond->params.mode); 271} 272 273static ssize_t bonding_store_mode(struct device *d, 274 struct device_attribute *attr, 275 const char *buf, size_t count) 276{ 277 struct bonding *bond = to_bond(d); 278 int ret; 279 280 ret = bond_opt_tryset_rtnl(bond, BOND_OPT_MODE, (char *)buf); 281 if (!ret) 282 ret = count; 283 284 return ret; 285} 286static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, 287 bonding_show_mode, bonding_store_mode); 288 289/* 290 * Show and set the bonding transmit hash method. 291 */ 292static ssize_t bonding_show_xmit_hash(struct device *d, 293 struct device_attribute *attr, 294 char *buf) 295{ 296 struct bonding *bond = to_bond(d); 297 struct bond_opt_value *val; 298 299 val = bond_opt_get_val(BOND_OPT_XMIT_HASH, bond->params.xmit_policy); 300 301 return sprintf(buf, "%s %d\n", val->string, bond->params.xmit_policy); 302} 303 304static ssize_t bonding_store_xmit_hash(struct device *d, 305 struct device_attribute *attr, 306 const char *buf, size_t count) 307{ 308 struct bonding *bond = to_bond(d); 309 int ret; 310 311 ret = bond_opt_tryset_rtnl(bond, BOND_OPT_XMIT_HASH, (char *)buf); 312 if (!ret) 313 ret = count; 314 315 return ret; 316} 317static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR, 318 bonding_show_xmit_hash, bonding_store_xmit_hash); 319 320/* 321 * Show and set arp_validate. 322 */ 323static ssize_t bonding_show_arp_validate(struct device *d, 324 struct device_attribute *attr, 325 char *buf) 326{ 327 struct bonding *bond = to_bond(d); 328 struct bond_opt_value *val; 329 330 val = bond_opt_get_val(BOND_OPT_ARP_VALIDATE, 331 bond->params.arp_validate); 332 333 return sprintf(buf, "%s %d\n", val->string, bond->params.arp_validate); 334} 335 336static ssize_t bonding_store_arp_validate(struct device *d, 337 struct device_attribute *attr, 338 const char *buf, size_t count) 339{ 340 struct bonding *bond = to_bond(d); 341 int ret; 342 343 ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_VALIDATE, (char *)buf); 344 if (!ret) 345 ret = count; 346 347 return ret; 348} 349 350static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate, 351 bonding_store_arp_validate); 352/* 353 * Show and set arp_all_targets. 354 */ 355static ssize_t bonding_show_arp_all_targets(struct device *d, 356 struct device_attribute *attr, 357 char *buf) 358{ 359 struct bonding *bond = to_bond(d); 360 struct bond_opt_value *val; 361 362 val = bond_opt_get_val(BOND_OPT_ARP_ALL_TARGETS, 363 bond->params.arp_all_targets); 364 return sprintf(buf, "%s %d\n", 365 val->string, bond->params.arp_all_targets); 366} 367 368static ssize_t bonding_store_arp_all_targets(struct device *d, 369 struct device_attribute *attr, 370 const char *buf, size_t count) 371{ 372 struct bonding *bond = to_bond(d); 373 int ret; 374 375 ret = bond_opt_tryset_rtnl(bond, BOND_OPT_ARP_ALL_TARGETS, (char *)buf); 376 if (!ret) 377 ret = count; 378 379 return ret; 380} 381 382static DEVICE_ATTR(arp_all_targets, S_IRUGO | S_IWUSR, 383 bonding_show_arp_all_targets, bonding_store_arp_all_targets); 384 385/* 386 * Show and store fail_over_mac. User only allowed to change the 387 * value when there are no slaves. 388 */ 389static ssize_t bonding_show_fail_over_mac(struct device *d, 390 struct device_attribute *attr, 391 char *buf) 392{ 393 struct bonding *bond = to_bond(d); 394 395 return sprintf(buf, "%s %d\n", 396 fail_over_mac_tbl[bond->params.fail_over_mac].modename, 397 bond->params.fail_over_mac); 398} 399 400static ssize_t bonding_store_fail_over_mac(struct device *d, 401 struct device_attribute *attr, 402 const char *buf, size_t count) 403{ 404 int new_value, ret; 405 struct bonding *bond = to_bond(d); 406 407 new_value = bond_parse_parm(buf, fail_over_mac_tbl); 408 if (new_value < 0) { 409 pr_err("%s: Ignoring invalid fail_over_mac value %s.\n", 410 bond->dev->name, buf); 411 return -EINVAL; 412 } 413 414 if (!rtnl_trylock()) 415 return restart_syscall(); 416 417 ret = bond_option_fail_over_mac_set(bond, new_value); 418 if (!ret) 419 ret = count; 420 421 rtnl_unlock(); 422 return ret; 423} 424 425static DEVICE_ATTR(fail_over_mac, S_IRUGO | S_IWUSR, 426 bonding_show_fail_over_mac, bonding_store_fail_over_mac); 427 428/* 429 * Show and set the arp timer interval. There are two tricky bits 430 * here. First, if ARP monitoring is activated, then we must disable 431 * MII monitoring. Second, if the ARP timer isn't running, we must 432 * start it. 433 */ 434static ssize_t bonding_show_arp_interval(struct device *d, 435 struct device_attribute *attr, 436 char *buf) 437{ 438 struct bonding *bond = to_bond(d); 439 440 return sprintf(buf, "%d\n", bond->params.arp_interval); 441} 442 443static ssize_t bonding_store_arp_interval(struct device *d, 444 struct device_attribute *attr, 445 const char *buf, size_t count) 446{ 447 struct bonding *bond = to_bond(d); 448 int new_value, ret; 449 450 if (sscanf(buf, "%d", &new_value) != 1) { 451 pr_err("%s: no arp_interval value specified.\n", 452 bond->dev->name); 453 return -EINVAL; 454 } 455 456 if (!rtnl_trylock()) 457 return restart_syscall(); 458 459 ret = bond_option_arp_interval_set(bond, new_value); 460 if (!ret) 461 ret = count; 462 463 rtnl_unlock(); 464 return ret; 465} 466static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR, 467 bonding_show_arp_interval, bonding_store_arp_interval); 468 469/* 470 * Show and set the arp targets. 471 */ 472static ssize_t bonding_show_arp_targets(struct device *d, 473 struct device_attribute *attr, 474 char *buf) 475{ 476 int i, res = 0; 477 struct bonding *bond = to_bond(d); 478 479 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) { 480 if (bond->params.arp_targets[i]) 481 res += sprintf(buf + res, "%pI4 ", 482 &bond->params.arp_targets[i]); 483 } 484 if (res) 485 buf[res-1] = '\n'; /* eat the leftover space */ 486 return res; 487} 488 489static ssize_t bonding_store_arp_targets(struct device *d, 490 struct device_attribute *attr, 491 const char *buf, size_t count) 492{ 493 struct bonding *bond = to_bond(d); 494 __be32 target; 495 int ret = -EPERM; 496 497 if (!in4_pton(buf + 1, -1, (u8 *)&target, -1, NULL)) { 498 pr_err("%s: invalid ARP target %pI4 specified\n", 499 bond->dev->name, &target); 500 return -EPERM; 501 } 502 503 if (!rtnl_trylock()) 504 return restart_syscall(); 505 506 if (buf[0] == '+') 507 ret = bond_option_arp_ip_target_add(bond, target); 508 else if (buf[0] == '-') 509 ret = bond_option_arp_ip_target_rem(bond, target); 510 else 511 pr_err("no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n", 512 bond->dev->name); 513 514 if (!ret) 515 ret = count; 516 517 rtnl_unlock(); 518 return ret; 519} 520static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets); 521 522/* 523 * Show and set the up and down delays. These must be multiples of the 524 * MII monitoring value, and are stored internally as the multiplier. 525 * Thus, we must translate to MS for the real world. 526 */ 527static ssize_t bonding_show_downdelay(struct device *d, 528 struct device_attribute *attr, 529 char *buf) 530{ 531 struct bonding *bond = to_bond(d); 532 533 return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon); 534} 535 536static ssize_t bonding_store_downdelay(struct device *d, 537 struct device_attribute *attr, 538 const char *buf, size_t count) 539{ 540 int new_value, ret; 541 struct bonding *bond = to_bond(d); 542 543 if (sscanf(buf, "%d", &new_value) != 1) { 544 pr_err("%s: no down delay value specified.\n", bond->dev->name); 545 return -EINVAL; 546 } 547 548 if (!rtnl_trylock()) 549 return restart_syscall(); 550 551 ret = bond_option_downdelay_set(bond, new_value); 552 if (!ret) 553 ret = count; 554 555 rtnl_unlock(); 556 return ret; 557} 558static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR, 559 bonding_show_downdelay, bonding_store_downdelay); 560 561static ssize_t bonding_show_updelay(struct device *d, 562 struct device_attribute *attr, 563 char *buf) 564{ 565 struct bonding *bond = to_bond(d); 566 567 return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon); 568 569} 570 571static ssize_t bonding_store_updelay(struct device *d, 572 struct device_attribute *attr, 573 const char *buf, size_t count) 574{ 575 int new_value, ret; 576 struct bonding *bond = to_bond(d); 577 578 if (sscanf(buf, "%d", &new_value) != 1) { 579 pr_err("%s: no up delay value specified.\n", 580 bond->dev->name); 581 return -EINVAL; 582 } 583 584 if (!rtnl_trylock()) 585 return restart_syscall(); 586 587 ret = bond_option_updelay_set(bond, new_value); 588 if (!ret) 589 ret = count; 590 591 rtnl_unlock(); 592 return ret; 593} 594static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR, 595 bonding_show_updelay, bonding_store_updelay); 596 597/* 598 * Show and set the LACP interval. Interface must be down, and the mode 599 * must be set to 802.3ad mode. 600 */ 601static ssize_t bonding_show_lacp(struct device *d, 602 struct device_attribute *attr, 603 char *buf) 604{ 605 struct bonding *bond = to_bond(d); 606 607 return sprintf(buf, "%s %d\n", 608 bond_lacp_tbl[bond->params.lacp_fast].modename, 609 bond->params.lacp_fast); 610} 611 612static ssize_t bonding_store_lacp(struct device *d, 613 struct device_attribute *attr, 614 const char *buf, size_t count) 615{ 616 struct bonding *bond = to_bond(d); 617 int new_value, ret; 618 619 new_value = bond_parse_parm(buf, bond_lacp_tbl); 620 if (new_value < 0) { 621 pr_err("%s: Ignoring invalid LACP rate value %.*s.\n", 622 bond->dev->name, (int)strlen(buf) - 1, buf); 623 return -EINVAL; 624 } 625 626 if (!rtnl_trylock()) 627 return restart_syscall(); 628 629 ret = bond_option_lacp_rate_set(bond, new_value); 630 if (!ret) 631 ret = count; 632 633 rtnl_unlock(); 634 return ret; 635} 636static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, 637 bonding_show_lacp, bonding_store_lacp); 638 639static ssize_t bonding_show_min_links(struct device *d, 640 struct device_attribute *attr, 641 char *buf) 642{ 643 struct bonding *bond = to_bond(d); 644 645 return sprintf(buf, "%d\n", bond->params.min_links); 646} 647 648static ssize_t bonding_store_min_links(struct device *d, 649 struct device_attribute *attr, 650 const char *buf, size_t count) 651{ 652 struct bonding *bond = to_bond(d); 653 int ret; 654 unsigned int new_value; 655 656 ret = kstrtouint(buf, 0, &new_value); 657 if (ret < 0) { 658 pr_err("%s: Ignoring invalid min links value %s.\n", 659 bond->dev->name, buf); 660 return ret; 661 } 662 663 if (!rtnl_trylock()) 664 return restart_syscall(); 665 666 ret = bond_option_min_links_set(bond, new_value); 667 if (!ret) 668 ret = count; 669 670 rtnl_unlock(); 671 return ret; 672} 673static DEVICE_ATTR(min_links, S_IRUGO | S_IWUSR, 674 bonding_show_min_links, bonding_store_min_links); 675 676static ssize_t bonding_show_ad_select(struct device *d, 677 struct device_attribute *attr, 678 char *buf) 679{ 680 struct bonding *bond = to_bond(d); 681 682 return sprintf(buf, "%s %d\n", 683 ad_select_tbl[bond->params.ad_select].modename, 684 bond->params.ad_select); 685} 686 687 688static ssize_t bonding_store_ad_select(struct device *d, 689 struct device_attribute *attr, 690 const char *buf, size_t count) 691{ 692 int new_value, ret; 693 struct bonding *bond = to_bond(d); 694 695 new_value = bond_parse_parm(buf, ad_select_tbl); 696 if (new_value < 0) { 697 pr_err("%s: Ignoring invalid ad_select value %.*s.\n", 698 bond->dev->name, (int)strlen(buf) - 1, buf); 699 return -EINVAL; 700 } 701 702 if (!rtnl_trylock()) 703 return restart_syscall(); 704 705 ret = bond_option_ad_select_set(bond, new_value); 706 if (!ret) 707 ret = count; 708 709 rtnl_unlock(); 710 return ret; 711} 712static DEVICE_ATTR(ad_select, S_IRUGO | S_IWUSR, 713 bonding_show_ad_select, bonding_store_ad_select); 714 715/* 716 * Show and set the number of peer notifications to send after a failover event. 717 */ 718static ssize_t bonding_show_num_peer_notif(struct device *d, 719 struct device_attribute *attr, 720 char *buf) 721{ 722 struct bonding *bond = to_bond(d); 723 return sprintf(buf, "%d\n", bond->params.num_peer_notif); 724} 725 726static ssize_t bonding_store_num_peer_notif(struct device *d, 727 struct device_attribute *attr, 728 const char *buf, size_t count) 729{ 730 struct bonding *bond = to_bond(d); 731 u8 new_value; 732 int ret; 733 734 ret = kstrtou8(buf, 10, &new_value); 735 if (ret) { 736 pr_err("%s: invalid value %s specified.\n", 737 bond->dev->name, buf); 738 return ret; 739 } 740 741 if (!rtnl_trylock()) 742 return restart_syscall(); 743 744 ret = bond_option_num_peer_notif_set(bond, new_value); 745 if (!ret) 746 ret = count; 747 748 rtnl_unlock(); 749 return ret; 750} 751static DEVICE_ATTR(num_grat_arp, S_IRUGO | S_IWUSR, 752 bonding_show_num_peer_notif, bonding_store_num_peer_notif); 753static DEVICE_ATTR(num_unsol_na, S_IRUGO | S_IWUSR, 754 bonding_show_num_peer_notif, bonding_store_num_peer_notif); 755 756/* 757 * Show and set the MII monitor interval. There are two tricky bits 758 * here. First, if MII monitoring is activated, then we must disable 759 * ARP monitoring. Second, if the timer isn't running, we must 760 * start it. 761 */ 762static ssize_t bonding_show_miimon(struct device *d, 763 struct device_attribute *attr, 764 char *buf) 765{ 766 struct bonding *bond = to_bond(d); 767 768 return sprintf(buf, "%d\n", bond->params.miimon); 769} 770 771static ssize_t bonding_store_miimon(struct device *d, 772 struct device_attribute *attr, 773 const char *buf, size_t count) 774{ 775 int new_value, ret; 776 struct bonding *bond = to_bond(d); 777 778 if (sscanf(buf, "%d", &new_value) != 1) { 779 pr_err("%s: no miimon value specified.\n", 780 bond->dev->name); 781 return -EINVAL; 782 } 783 784 if (!rtnl_trylock()) 785 return restart_syscall(); 786 787 ret = bond_option_miimon_set(bond, new_value); 788 if (!ret) 789 ret = count; 790 791 rtnl_unlock(); 792 return ret; 793} 794static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, 795 bonding_show_miimon, bonding_store_miimon); 796 797/* 798 * Show and set the primary slave. The store function is much 799 * simpler than bonding_store_slaves function because it only needs to 800 * handle one interface name. 801 * The bond must be a mode that supports a primary for this be 802 * set. 803 */ 804static ssize_t bonding_show_primary(struct device *d, 805 struct device_attribute *attr, 806 char *buf) 807{ 808 int count = 0; 809 struct bonding *bond = to_bond(d); 810 811 if (bond->primary_slave) 812 count = sprintf(buf, "%s\n", bond->primary_slave->dev->name); 813 814 return count; 815} 816 817static ssize_t bonding_store_primary(struct device *d, 818 struct device_attribute *attr, 819 const char *buf, size_t count) 820{ 821 struct bonding *bond = to_bond(d); 822 char ifname[IFNAMSIZ]; 823 int ret; 824 825 sscanf(buf, "%15s", ifname); /* IFNAMSIZ */ 826 if (ifname[0] == '\n') 827 ifname[0] = '\0'; 828 829 if (!rtnl_trylock()) 830 return restart_syscall(); 831 832 ret = bond_option_primary_set(bond, ifname); 833 if (!ret) 834 ret = count; 835 836 rtnl_unlock(); 837 return ret; 838} 839static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR, 840 bonding_show_primary, bonding_store_primary); 841 842/* 843 * Show and set the primary_reselect flag. 844 */ 845static ssize_t bonding_show_primary_reselect(struct device *d, 846 struct device_attribute *attr, 847 char *buf) 848{ 849 struct bonding *bond = to_bond(d); 850 851 return sprintf(buf, "%s %d\n", 852 pri_reselect_tbl[bond->params.primary_reselect].modename, 853 bond->params.primary_reselect); 854} 855 856static ssize_t bonding_store_primary_reselect(struct device *d, 857 struct device_attribute *attr, 858 const char *buf, size_t count) 859{ 860 int new_value, ret; 861 struct bonding *bond = to_bond(d); 862 863 new_value = bond_parse_parm(buf, pri_reselect_tbl); 864 if (new_value < 0) { 865 pr_err("%s: Ignoring invalid primary_reselect value %.*s.\n", 866 bond->dev->name, 867 (int) strlen(buf) - 1, buf); 868 return -EINVAL; 869 } 870 871 if (!rtnl_trylock()) 872 return restart_syscall(); 873 874 ret = bond_option_primary_reselect_set(bond, new_value); 875 if (!ret) 876 ret = count; 877 878 rtnl_unlock(); 879 return ret; 880} 881static DEVICE_ATTR(primary_reselect, S_IRUGO | S_IWUSR, 882 bonding_show_primary_reselect, 883 bonding_store_primary_reselect); 884 885/* 886 * Show and set the use_carrier flag. 887 */ 888static ssize_t bonding_show_carrier(struct device *d, 889 struct device_attribute *attr, 890 char *buf) 891{ 892 struct bonding *bond = to_bond(d); 893 894 return sprintf(buf, "%d\n", bond->params.use_carrier); 895} 896 897static ssize_t bonding_store_carrier(struct device *d, 898 struct device_attribute *attr, 899 const char *buf, size_t count) 900{ 901 int new_value, ret; 902 struct bonding *bond = to_bond(d); 903 904 if (sscanf(buf, "%d", &new_value) != 1) { 905 pr_err("%s: no use_carrier value specified.\n", 906 bond->dev->name); 907 return -EINVAL; 908 } 909 910 if (!rtnl_trylock()) 911 return restart_syscall(); 912 913 ret = bond_option_use_carrier_set(bond, new_value); 914 if (!ret) 915 ret = count; 916 917 rtnl_unlock(); 918 return ret; 919} 920static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR, 921 bonding_show_carrier, bonding_store_carrier); 922 923 924/* 925 * Show and set currently active_slave. 926 */ 927static ssize_t bonding_show_active_slave(struct device *d, 928 struct device_attribute *attr, 929 char *buf) 930{ 931 struct bonding *bond = to_bond(d); 932 struct net_device *slave_dev; 933 int count = 0; 934 935 rcu_read_lock(); 936 slave_dev = bond_option_active_slave_get_rcu(bond); 937 if (slave_dev) 938 count = sprintf(buf, "%s\n", slave_dev->name); 939 rcu_read_unlock(); 940 941 return count; 942} 943 944static ssize_t bonding_store_active_slave(struct device *d, 945 struct device_attribute *attr, 946 const char *buf, size_t count) 947{ 948 int ret; 949 struct bonding *bond = to_bond(d); 950 char ifname[IFNAMSIZ]; 951 struct net_device *dev; 952 953 if (!rtnl_trylock()) 954 return restart_syscall(); 955 956 sscanf(buf, "%15s", ifname); /* IFNAMSIZ */ 957 if (!strlen(ifname) || buf[0] == '\n') { 958 dev = NULL; 959 } else { 960 dev = __dev_get_by_name(dev_net(bond->dev), ifname); 961 if (!dev) { 962 ret = -ENODEV; 963 goto out; 964 } 965 } 966 967 ret = bond_option_active_slave_set(bond, dev); 968 if (!ret) 969 ret = count; 970 971 out: 972 rtnl_unlock(); 973 974 return ret; 975 976} 977static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR, 978 bonding_show_active_slave, bonding_store_active_slave); 979 980 981/* 982 * Show link status of the bond interface. 983 */ 984static ssize_t bonding_show_mii_status(struct device *d, 985 struct device_attribute *attr, 986 char *buf) 987{ 988 struct bonding *bond = to_bond(d); 989 990 return sprintf(buf, "%s\n", bond->curr_active_slave ? "up" : "down"); 991} 992static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL); 993 994/* 995 * Show current 802.3ad aggregator ID. 996 */ 997static ssize_t bonding_show_ad_aggregator(struct device *d, 998 struct device_attribute *attr, 999 char *buf) 1000{ 1001 int count = 0; 1002 struct bonding *bond = to_bond(d); 1003 1004 if (bond->params.mode == BOND_MODE_8023AD) { 1005 struct ad_info ad_info; 1006 count = sprintf(buf, "%d\n", 1007 bond_3ad_get_active_agg_info(bond, &ad_info) 1008 ? 0 : ad_info.aggregator_id); 1009 } 1010 1011 return count; 1012} 1013static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL); 1014 1015 1016/* 1017 * Show number of active 802.3ad ports. 1018 */ 1019static ssize_t bonding_show_ad_num_ports(struct device *d, 1020 struct device_attribute *attr, 1021 char *buf) 1022{ 1023 int count = 0; 1024 struct bonding *bond = to_bond(d); 1025 1026 if (bond->params.mode == BOND_MODE_8023AD) { 1027 struct ad_info ad_info; 1028 count = sprintf(buf, "%d\n", 1029 bond_3ad_get_active_agg_info(bond, &ad_info) 1030 ? 0 : ad_info.ports); 1031 } 1032 1033 return count; 1034} 1035static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL); 1036 1037 1038/* 1039 * Show current 802.3ad actor key. 1040 */ 1041static ssize_t bonding_show_ad_actor_key(struct device *d, 1042 struct device_attribute *attr, 1043 char *buf) 1044{ 1045 int count = 0; 1046 struct bonding *bond = to_bond(d); 1047 1048 if (bond->params.mode == BOND_MODE_8023AD) { 1049 struct ad_info ad_info; 1050 count = sprintf(buf, "%d\n", 1051 bond_3ad_get_active_agg_info(bond, &ad_info) 1052 ? 0 : ad_info.actor_key); 1053 } 1054 1055 return count; 1056} 1057static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL); 1058 1059 1060/* 1061 * Show current 802.3ad partner key. 1062 */ 1063static ssize_t bonding_show_ad_partner_key(struct device *d, 1064 struct device_attribute *attr, 1065 char *buf) 1066{ 1067 int count = 0; 1068 struct bonding *bond = to_bond(d); 1069 1070 if (bond->params.mode == BOND_MODE_8023AD) { 1071 struct ad_info ad_info; 1072 count = sprintf(buf, "%d\n", 1073 bond_3ad_get_active_agg_info(bond, &ad_info) 1074 ? 0 : ad_info.partner_key); 1075 } 1076 1077 return count; 1078} 1079static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL); 1080 1081 1082/* 1083 * Show current 802.3ad partner mac. 1084 */ 1085static ssize_t bonding_show_ad_partner_mac(struct device *d, 1086 struct device_attribute *attr, 1087 char *buf) 1088{ 1089 int count = 0; 1090 struct bonding *bond = to_bond(d); 1091 1092 if (bond->params.mode == BOND_MODE_8023AD) { 1093 struct ad_info ad_info; 1094 if (!bond_3ad_get_active_agg_info(bond, &ad_info)) 1095 count = sprintf(buf, "%pM\n", ad_info.partner_system); 1096 } 1097 1098 return count; 1099} 1100static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL); 1101 1102/* 1103 * Show the queue_ids of the slaves in the current bond. 1104 */ 1105static ssize_t bonding_show_queue_id(struct device *d, 1106 struct device_attribute *attr, 1107 char *buf) 1108{ 1109 struct bonding *bond = to_bond(d); 1110 struct list_head *iter; 1111 struct slave *slave; 1112 int res = 0; 1113 1114 if (!rtnl_trylock()) 1115 return restart_syscall(); 1116 1117 bond_for_each_slave(bond, slave, iter) { 1118 if (res > (PAGE_SIZE - IFNAMSIZ - 6)) { 1119 /* not enough space for another interface_name:queue_id pair */ 1120 if ((PAGE_SIZE - res) > 10) 1121 res = PAGE_SIZE - 10; 1122 res += sprintf(buf + res, "++more++ "); 1123 break; 1124 } 1125 res += sprintf(buf + res, "%s:%d ", 1126 slave->dev->name, slave->queue_id); 1127 } 1128 if (res) 1129 buf[res-1] = '\n'; /* eat the leftover space */ 1130 1131 rtnl_unlock(); 1132 1133 return res; 1134} 1135 1136/* 1137 * Set the queue_ids of the slaves in the current bond. The bond 1138 * interface must be enslaved for this to work. 1139 */ 1140static ssize_t bonding_store_queue_id(struct device *d, 1141 struct device_attribute *attr, 1142 const char *buffer, size_t count) 1143{ 1144 struct slave *slave, *update_slave; 1145 struct bonding *bond = to_bond(d); 1146 struct list_head *iter; 1147 u16 qid; 1148 int ret = count; 1149 char *delim; 1150 struct net_device *sdev = NULL; 1151 1152 if (!rtnl_trylock()) 1153 return restart_syscall(); 1154 1155 /* delim will point to queue id if successful */ 1156 delim = strchr(buffer, ':'); 1157 if (!delim) 1158 goto err_no_cmd; 1159 1160 /* 1161 * Terminate string that points to device name and bump it 1162 * up one, so we can read the queue id there. 1163 */ 1164 *delim = '\0'; 1165 if (sscanf(++delim, "%hd\n", &qid) != 1) 1166 goto err_no_cmd; 1167 1168 /* Check buffer length, valid ifname and queue id */ 1169 if (strlen(buffer) > IFNAMSIZ || 1170 !dev_valid_name(buffer) || 1171 qid > bond->dev->real_num_tx_queues) 1172 goto err_no_cmd; 1173 1174 /* Get the pointer to that interface if it exists */ 1175 sdev = __dev_get_by_name(dev_net(bond->dev), buffer); 1176 if (!sdev) 1177 goto err_no_cmd; 1178 1179 /* Search for thes slave and check for duplicate qids */ 1180 update_slave = NULL; 1181 bond_for_each_slave(bond, slave, iter) { 1182 if (sdev == slave->dev) 1183 /* 1184 * We don't need to check the matching 1185 * slave for dups, since we're overwriting it 1186 */ 1187 update_slave = slave; 1188 else if (qid && qid == slave->queue_id) { 1189 goto err_no_cmd; 1190 } 1191 } 1192 1193 if (!update_slave) 1194 goto err_no_cmd; 1195 1196 /* Actually set the qids for the slave */ 1197 update_slave->queue_id = qid; 1198 1199out: 1200 rtnl_unlock(); 1201 return ret; 1202 1203err_no_cmd: 1204 pr_info("invalid input for queue_id set for %s.\n", 1205 bond->dev->name); 1206 ret = -EPERM; 1207 goto out; 1208} 1209 1210static DEVICE_ATTR(queue_id, S_IRUGO | S_IWUSR, bonding_show_queue_id, 1211 bonding_store_queue_id); 1212 1213 1214/* 1215 * Show and set the all_slaves_active flag. 1216 */ 1217static ssize_t bonding_show_slaves_active(struct device *d, 1218 struct device_attribute *attr, 1219 char *buf) 1220{ 1221 struct bonding *bond = to_bond(d); 1222 1223 return sprintf(buf, "%d\n", bond->params.all_slaves_active); 1224} 1225 1226static ssize_t bonding_store_slaves_active(struct device *d, 1227 struct device_attribute *attr, 1228 const char *buf, size_t count) 1229{ 1230 struct bonding *bond = to_bond(d); 1231 int new_value, ret; 1232 1233 if (sscanf(buf, "%d", &new_value) != 1) { 1234 pr_err("%s: no all_slaves_active value specified.\n", 1235 bond->dev->name); 1236 return -EINVAL; 1237 } 1238 1239 if (!rtnl_trylock()) 1240 return restart_syscall(); 1241 1242 ret = bond_option_all_slaves_active_set(bond, new_value); 1243 if (!ret) 1244 ret = count; 1245 1246 rtnl_unlock(); 1247 return ret; 1248} 1249static DEVICE_ATTR(all_slaves_active, S_IRUGO | S_IWUSR, 1250 bonding_show_slaves_active, bonding_store_slaves_active); 1251 1252/* 1253 * Show and set the number of IGMP membership reports to send on link failure 1254 */ 1255static ssize_t bonding_show_resend_igmp(struct device *d, 1256 struct device_attribute *attr, 1257 char *buf) 1258{ 1259 struct bonding *bond = to_bond(d); 1260 1261 return sprintf(buf, "%d\n", bond->params.resend_igmp); 1262} 1263 1264static ssize_t bonding_store_resend_igmp(struct device *d, 1265 struct device_attribute *attr, 1266 const char *buf, size_t count) 1267{ 1268 int new_value, ret = count; 1269 struct bonding *bond = to_bond(d); 1270 1271 if (sscanf(buf, "%d", &new_value) != 1) { 1272 pr_err("%s: no resend_igmp value specified.\n", 1273 bond->dev->name); 1274 return -EINVAL; 1275 } 1276 1277 if (!rtnl_trylock()) 1278 return restart_syscall(); 1279 1280 ret = bond_option_resend_igmp_set(bond, new_value); 1281 if (!ret) 1282 ret = count; 1283 1284 rtnl_unlock(); 1285 return ret; 1286} 1287 1288static DEVICE_ATTR(resend_igmp, S_IRUGO | S_IWUSR, 1289 bonding_show_resend_igmp, bonding_store_resend_igmp); 1290 1291 1292static ssize_t bonding_show_lp_interval(struct device *d, 1293 struct device_attribute *attr, 1294 char *buf) 1295{ 1296 struct bonding *bond = to_bond(d); 1297 return sprintf(buf, "%d\n", bond->params.lp_interval); 1298} 1299 1300static ssize_t bonding_store_lp_interval(struct device *d, 1301 struct device_attribute *attr, 1302 const char *buf, size_t count) 1303{ 1304 struct bonding *bond = to_bond(d); 1305 int new_value, ret; 1306 1307 if (sscanf(buf, "%d", &new_value) != 1) { 1308 pr_err("%s: no lp interval value specified.\n", 1309 bond->dev->name); 1310 return -EINVAL; 1311 } 1312 1313 if (!rtnl_trylock()) 1314 return restart_syscall(); 1315 1316 ret = bond_option_lp_interval_set(bond, new_value); 1317 if (!ret) 1318 ret = count; 1319 1320 rtnl_unlock(); 1321 return ret; 1322} 1323 1324static DEVICE_ATTR(lp_interval, S_IRUGO | S_IWUSR, 1325 bonding_show_lp_interval, bonding_store_lp_interval); 1326 1327static ssize_t bonding_show_packets_per_slave(struct device *d, 1328 struct device_attribute *attr, 1329 char *buf) 1330{ 1331 struct bonding *bond = to_bond(d); 1332 unsigned int packets_per_slave = bond->params.packets_per_slave; 1333 return sprintf(buf, "%u\n", packets_per_slave); 1334} 1335 1336static ssize_t bonding_store_packets_per_slave(struct device *d, 1337 struct device_attribute *attr, 1338 const char *buf, size_t count) 1339{ 1340 struct bonding *bond = to_bond(d); 1341 int ret; 1342 1343 ret = bond_opt_tryset_rtnl(bond, BOND_OPT_PACKETS_PER_SLAVE, 1344 (char *)buf); 1345 if (!ret) 1346 ret = count; 1347 1348 return ret; 1349} 1350 1351static DEVICE_ATTR(packets_per_slave, S_IRUGO | S_IWUSR, 1352 bonding_show_packets_per_slave, 1353 bonding_store_packets_per_slave); 1354 1355static struct attribute *per_bond_attrs[] = { 1356 &dev_attr_slaves.attr, 1357 &dev_attr_mode.attr, 1358 &dev_attr_fail_over_mac.attr, 1359 &dev_attr_arp_validate.attr, 1360 &dev_attr_arp_all_targets.attr, 1361 &dev_attr_arp_interval.attr, 1362 &dev_attr_arp_ip_target.attr, 1363 &dev_attr_downdelay.attr, 1364 &dev_attr_updelay.attr, 1365 &dev_attr_lacp_rate.attr, 1366 &dev_attr_ad_select.attr, 1367 &dev_attr_xmit_hash_policy.attr, 1368 &dev_attr_num_grat_arp.attr, 1369 &dev_attr_num_unsol_na.attr, 1370 &dev_attr_miimon.attr, 1371 &dev_attr_primary.attr, 1372 &dev_attr_primary_reselect.attr, 1373 &dev_attr_use_carrier.attr, 1374 &dev_attr_active_slave.attr, 1375 &dev_attr_mii_status.attr, 1376 &dev_attr_ad_aggregator.attr, 1377 &dev_attr_ad_num_ports.attr, 1378 &dev_attr_ad_actor_key.attr, 1379 &dev_attr_ad_partner_key.attr, 1380 &dev_attr_ad_partner_mac.attr, 1381 &dev_attr_queue_id.attr, 1382 &dev_attr_all_slaves_active.attr, 1383 &dev_attr_resend_igmp.attr, 1384 &dev_attr_min_links.attr, 1385 &dev_attr_lp_interval.attr, 1386 &dev_attr_packets_per_slave.attr, 1387 NULL, 1388}; 1389 1390static struct attribute_group bonding_group = { 1391 .name = "bonding", 1392 .attrs = per_bond_attrs, 1393}; 1394 1395/* 1396 * Initialize sysfs. This sets up the bonding_masters file in 1397 * /sys/class/net. 1398 */ 1399int bond_create_sysfs(struct bond_net *bn) 1400{ 1401 int ret; 1402 1403 bn->class_attr_bonding_masters = class_attr_bonding_masters; 1404 sysfs_attr_init(&bn->class_attr_bonding_masters.attr); 1405 1406 ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters, 1407 bn->net); 1408 /* 1409 * Permit multiple loads of the module by ignoring failures to 1410 * create the bonding_masters sysfs file. Bonding devices 1411 * created by second or subsequent loads of the module will 1412 * not be listed in, or controllable by, bonding_masters, but 1413 * will have the usual "bonding" sysfs directory. 1414 * 1415 * This is done to preserve backwards compatibility for 1416 * initscripts/sysconfig, which load bonding multiple times to 1417 * configure multiple bonding devices. 1418 */ 1419 if (ret == -EEXIST) { 1420 /* Is someone being kinky and naming a device bonding_master? */ 1421 if (__dev_get_by_name(bn->net, 1422 class_attr_bonding_masters.attr.name)) 1423 pr_err("network device named %s already exists in sysfs", 1424 class_attr_bonding_masters.attr.name); 1425 ret = 0; 1426 } 1427 1428 return ret; 1429 1430} 1431 1432/* 1433 * Remove /sys/class/net/bonding_masters. 1434 */ 1435void bond_destroy_sysfs(struct bond_net *bn) 1436{ 1437 netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, bn->net); 1438} 1439 1440/* 1441 * Initialize sysfs for each bond. This sets up and registers 1442 * the 'bondctl' directory for each individual bond under /sys/class/net. 1443 */ 1444void bond_prepare_sysfs_group(struct bonding *bond) 1445{ 1446 bond->dev->sysfs_groups[0] = &bonding_group; 1447} 1448 1449