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 <net/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/* "show" function for the bond_masters attribute. 49 * The class parameter is ignored. 50 */ 51static ssize_t bonding_show_bonds(struct class *cls, 52 struct class_attribute *attr, 53 char *buf) 54{ 55 struct bond_net *bn = 56 container_of(attr, struct bond_net, class_attr_bonding_masters); 57 int res = 0; 58 struct bonding *bond; 59 60 rtnl_lock(); 61 62 list_for_each_entry(bond, &bn->dev_list, bond_list) { 63 if (res > (PAGE_SIZE - IFNAMSIZ)) { 64 /* not enough space for another interface name */ 65 if ((PAGE_SIZE - res) > 10) 66 res = PAGE_SIZE - 10; 67 res += sprintf(buf + res, "++more++ "); 68 break; 69 } 70 res += sprintf(buf + res, "%s ", bond->dev->name); 71 } 72 if (res) 73 buf[res-1] = '\n'; /* eat the leftover space */ 74 75 rtnl_unlock(); 76 return res; 77} 78 79static struct net_device *bond_get_by_name(struct bond_net *bn, const char *ifname) 80{ 81 struct bonding *bond; 82 83 list_for_each_entry(bond, &bn->dev_list, bond_list) { 84 if (strncmp(bond->dev->name, ifname, IFNAMSIZ) == 0) 85 return bond->dev; 86 } 87 return NULL; 88} 89 90/* "store" function for the bond_masters attribute. This is what 91 * creates and deletes entire bonds. 92 * 93 * The class parameter is ignored. 94 */ 95static ssize_t bonding_store_bonds(struct class *cls, 96 struct class_attribute *attr, 97 const char *buffer, size_t count) 98{ 99 struct bond_net *bn = 100 container_of(attr, struct bond_net, class_attr_bonding_masters); 101 char command[IFNAMSIZ + 1] = {0, }; 102 char *ifname; 103 int rv, res = count; 104 105 sscanf(buffer, "%16s", command); /* IFNAMSIZ*/ 106 ifname = command + 1; 107 if ((strlen(command) <= 1) || 108 !dev_valid_name(ifname)) 109 goto err_no_cmd; 110 111 if (command[0] == '+') { 112 pr_info("%s is being created...\n", ifname); 113 rv = bond_create(bn->net, ifname); 114 if (rv) { 115 if (rv == -EEXIST) 116 pr_info("%s already exists\n", ifname); 117 else 118 pr_info("%s creation failed\n", ifname); 119 res = rv; 120 } 121 } else if (command[0] == '-') { 122 struct net_device *bond_dev; 123 124 rtnl_lock(); 125 bond_dev = bond_get_by_name(bn, ifname); 126 if (bond_dev) { 127 pr_info("%s is being deleted...\n", ifname); 128 unregister_netdevice(bond_dev); 129 } else { 130 pr_err("unable to delete non-existent %s\n", ifname); 131 res = -ENODEV; 132 } 133 rtnl_unlock(); 134 } else 135 goto err_no_cmd; 136 137 /* Always return either count or an error. If you return 0, you'll 138 * get called forever, which is bad. 139 */ 140 return res; 141 142err_no_cmd: 143 pr_err("no command found in bonding_masters - use +ifname or -ifname\n"); 144 return -EPERM; 145} 146 147/* class attribute for bond_masters file. This ends up in /sys/class/net */ 148static const struct class_attribute class_attr_bonding_masters = { 149 .attr = { 150 .name = "bonding_masters", 151 .mode = S_IWUSR | S_IRUGO, 152 }, 153 .show = bonding_show_bonds, 154 .store = bonding_store_bonds, 155}; 156 157/* Generic "store" method for bonding sysfs option setting */ 158static ssize_t bonding_sysfs_store_option(struct device *d, 159 struct device_attribute *attr, 160 const char *buffer, size_t count) 161{ 162 struct bonding *bond = to_bond(d); 163 const struct bond_option *opt; 164 int ret; 165 166 opt = bond_opt_get_by_name(attr->attr.name); 167 if (WARN_ON(!opt)) 168 return -ENOENT; 169 ret = bond_opt_tryset_rtnl(bond, opt->id, (char *)buffer); 170 if (!ret) 171 ret = count; 172 173 return ret; 174} 175 176/* Show the slaves in the current bond. */ 177static ssize_t bonding_show_slaves(struct device *d, 178 struct device_attribute *attr, char *buf) 179{ 180 struct bonding *bond = to_bond(d); 181 struct list_head *iter; 182 struct slave *slave; 183 int res = 0; 184 185 if (!rtnl_trylock()) 186 return restart_syscall(); 187 188 bond_for_each_slave(bond, slave, iter) { 189 if (res > (PAGE_SIZE - IFNAMSIZ)) { 190 /* not enough space for another interface name */ 191 if ((PAGE_SIZE - res) > 10) 192 res = PAGE_SIZE - 10; 193 res += sprintf(buf + res, "++more++ "); 194 break; 195 } 196 res += sprintf(buf + res, "%s ", slave->dev->name); 197 } 198 199 rtnl_unlock(); 200 201 if (res) 202 buf[res-1] = '\n'; /* eat the leftover space */ 203 204 return res; 205} 206static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves, 207 bonding_sysfs_store_option); 208 209/* Show the bonding mode. */ 210static ssize_t bonding_show_mode(struct device *d, 211 struct device_attribute *attr, char *buf) 212{ 213 struct bonding *bond = to_bond(d); 214 const struct bond_opt_value *val; 215 216 val = bond_opt_get_val(BOND_OPT_MODE, BOND_MODE(bond)); 217 218 return sprintf(buf, "%s %d\n", val->string, BOND_MODE(bond)); 219} 220static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, 221 bonding_show_mode, bonding_sysfs_store_option); 222 223/* Show the bonding transmit hash method. */ 224static ssize_t bonding_show_xmit_hash(struct device *d, 225 struct device_attribute *attr, 226 char *buf) 227{ 228 struct bonding *bond = to_bond(d); 229 const struct bond_opt_value *val; 230 231 val = bond_opt_get_val(BOND_OPT_XMIT_HASH, bond->params.xmit_policy); 232 233 return sprintf(buf, "%s %d\n", val->string, bond->params.xmit_policy); 234} 235static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR, 236 bonding_show_xmit_hash, bonding_sysfs_store_option); 237 238/* Show arp_validate. */ 239static ssize_t bonding_show_arp_validate(struct device *d, 240 struct device_attribute *attr, 241 char *buf) 242{ 243 struct bonding *bond = to_bond(d); 244 const struct bond_opt_value *val; 245 246 val = bond_opt_get_val(BOND_OPT_ARP_VALIDATE, 247 bond->params.arp_validate); 248 249 return sprintf(buf, "%s %d\n", val->string, bond->params.arp_validate); 250} 251static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate, 252 bonding_sysfs_store_option); 253 254/* Show arp_all_targets. */ 255static ssize_t bonding_show_arp_all_targets(struct device *d, 256 struct device_attribute *attr, 257 char *buf) 258{ 259 struct bonding *bond = to_bond(d); 260 const struct bond_opt_value *val; 261 262 val = bond_opt_get_val(BOND_OPT_ARP_ALL_TARGETS, 263 bond->params.arp_all_targets); 264 return sprintf(buf, "%s %d\n", 265 val->string, bond->params.arp_all_targets); 266} 267static DEVICE_ATTR(arp_all_targets, S_IRUGO | S_IWUSR, 268 bonding_show_arp_all_targets, bonding_sysfs_store_option); 269 270/* Show fail_over_mac. */ 271static ssize_t bonding_show_fail_over_mac(struct device *d, 272 struct device_attribute *attr, 273 char *buf) 274{ 275 struct bonding *bond = to_bond(d); 276 const struct bond_opt_value *val; 277 278 val = bond_opt_get_val(BOND_OPT_FAIL_OVER_MAC, 279 bond->params.fail_over_mac); 280 281 return sprintf(buf, "%s %d\n", val->string, bond->params.fail_over_mac); 282} 283static DEVICE_ATTR(fail_over_mac, S_IRUGO | S_IWUSR, 284 bonding_show_fail_over_mac, bonding_sysfs_store_option); 285 286/* Show the arp timer interval. */ 287static ssize_t bonding_show_arp_interval(struct device *d, 288 struct device_attribute *attr, 289 char *buf) 290{ 291 struct bonding *bond = to_bond(d); 292 293 return sprintf(buf, "%d\n", bond->params.arp_interval); 294} 295static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR, 296 bonding_show_arp_interval, bonding_sysfs_store_option); 297 298/* Show the arp targets. */ 299static ssize_t bonding_show_arp_targets(struct device *d, 300 struct device_attribute *attr, 301 char *buf) 302{ 303 struct bonding *bond = to_bond(d); 304 int i, res = 0; 305 306 for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) { 307 if (bond->params.arp_targets[i]) 308 res += sprintf(buf + res, "%pI4 ", 309 &bond->params.arp_targets[i]); 310 } 311 if (res) 312 buf[res-1] = '\n'; /* eat the leftover space */ 313 314 return res; 315} 316static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR, 317 bonding_show_arp_targets, bonding_sysfs_store_option); 318 319/* Show the up and down delays. */ 320static ssize_t bonding_show_downdelay(struct device *d, 321 struct device_attribute *attr, 322 char *buf) 323{ 324 struct bonding *bond = to_bond(d); 325 326 return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon); 327} 328static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR, 329 bonding_show_downdelay, bonding_sysfs_store_option); 330 331static ssize_t bonding_show_updelay(struct device *d, 332 struct device_attribute *attr, 333 char *buf) 334{ 335 struct bonding *bond = to_bond(d); 336 337 return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon); 338 339} 340static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR, 341 bonding_show_updelay, bonding_sysfs_store_option); 342 343/* Show the LACP interval. */ 344static ssize_t bonding_show_lacp(struct device *d, 345 struct device_attribute *attr, 346 char *buf) 347{ 348 struct bonding *bond = to_bond(d); 349 const struct bond_opt_value *val; 350 351 val = bond_opt_get_val(BOND_OPT_LACP_RATE, bond->params.lacp_fast); 352 353 return sprintf(buf, "%s %d\n", val->string, bond->params.lacp_fast); 354} 355static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, 356 bonding_show_lacp, bonding_sysfs_store_option); 357 358static ssize_t bonding_show_min_links(struct device *d, 359 struct device_attribute *attr, 360 char *buf) 361{ 362 struct bonding *bond = to_bond(d); 363 364 return sprintf(buf, "%u\n", bond->params.min_links); 365} 366static DEVICE_ATTR(min_links, S_IRUGO | S_IWUSR, 367 bonding_show_min_links, bonding_sysfs_store_option); 368 369static ssize_t bonding_show_ad_select(struct device *d, 370 struct device_attribute *attr, 371 char *buf) 372{ 373 struct bonding *bond = to_bond(d); 374 const struct bond_opt_value *val; 375 376 val = bond_opt_get_val(BOND_OPT_AD_SELECT, bond->params.ad_select); 377 378 return sprintf(buf, "%s %d\n", val->string, bond->params.ad_select); 379} 380static DEVICE_ATTR(ad_select, S_IRUGO | S_IWUSR, 381 bonding_show_ad_select, bonding_sysfs_store_option); 382 383/* Show the number of peer notifications to send after a failover event. */ 384static ssize_t bonding_show_num_peer_notif(struct device *d, 385 struct device_attribute *attr, 386 char *buf) 387{ 388 struct bonding *bond = to_bond(d); 389 return sprintf(buf, "%d\n", bond->params.num_peer_notif); 390} 391static DEVICE_ATTR(num_grat_arp, S_IRUGO | S_IWUSR, 392 bonding_show_num_peer_notif, bonding_sysfs_store_option); 393static DEVICE_ATTR(num_unsol_na, S_IRUGO | S_IWUSR, 394 bonding_show_num_peer_notif, bonding_sysfs_store_option); 395 396/* Show the MII monitor interval. */ 397static ssize_t bonding_show_miimon(struct device *d, 398 struct device_attribute *attr, 399 char *buf) 400{ 401 struct bonding *bond = to_bond(d); 402 403 return sprintf(buf, "%d\n", bond->params.miimon); 404} 405static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, 406 bonding_show_miimon, bonding_sysfs_store_option); 407 408/* Show the primary slave. */ 409static ssize_t bonding_show_primary(struct device *d, 410 struct device_attribute *attr, 411 char *buf) 412{ 413 struct bonding *bond = to_bond(d); 414 struct slave *primary; 415 int count = 0; 416 417 rcu_read_lock(); 418 primary = rcu_dereference(bond->primary_slave); 419 if (primary) 420 count = sprintf(buf, "%s\n", primary->dev->name); 421 rcu_read_unlock(); 422 423 return count; 424} 425static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR, 426 bonding_show_primary, bonding_sysfs_store_option); 427 428/* Show the primary_reselect flag. */ 429static ssize_t bonding_show_primary_reselect(struct device *d, 430 struct device_attribute *attr, 431 char *buf) 432{ 433 struct bonding *bond = to_bond(d); 434 const struct bond_opt_value *val; 435 436 val = bond_opt_get_val(BOND_OPT_PRIMARY_RESELECT, 437 bond->params.primary_reselect); 438 439 return sprintf(buf, "%s %d\n", 440 val->string, bond->params.primary_reselect); 441} 442static DEVICE_ATTR(primary_reselect, S_IRUGO | S_IWUSR, 443 bonding_show_primary_reselect, bonding_sysfs_store_option); 444 445/* Show the use_carrier flag. */ 446static ssize_t bonding_show_carrier(struct device *d, 447 struct device_attribute *attr, 448 char *buf) 449{ 450 struct bonding *bond = to_bond(d); 451 452 return sprintf(buf, "%d\n", bond->params.use_carrier); 453} 454static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR, 455 bonding_show_carrier, bonding_sysfs_store_option); 456 457 458/* Show currently active_slave. */ 459static ssize_t bonding_show_active_slave(struct device *d, 460 struct device_attribute *attr, 461 char *buf) 462{ 463 struct bonding *bond = to_bond(d); 464 struct net_device *slave_dev; 465 int count = 0; 466 467 rcu_read_lock(); 468 slave_dev = bond_option_active_slave_get_rcu(bond); 469 if (slave_dev) 470 count = sprintf(buf, "%s\n", slave_dev->name); 471 rcu_read_unlock(); 472 473 return count; 474} 475static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR, 476 bonding_show_active_slave, bonding_sysfs_store_option); 477 478/* Show link status of the bond interface. */ 479static ssize_t bonding_show_mii_status(struct device *d, 480 struct device_attribute *attr, 481 char *buf) 482{ 483 struct bonding *bond = to_bond(d); 484 bool active = !!rcu_access_pointer(bond->curr_active_slave); 485 486 return sprintf(buf, "%s\n", active ? "up" : "down"); 487} 488static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL); 489 490/* Show current 802.3ad aggregator ID. */ 491static ssize_t bonding_show_ad_aggregator(struct device *d, 492 struct device_attribute *attr, 493 char *buf) 494{ 495 int count = 0; 496 struct bonding *bond = to_bond(d); 497 498 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 499 struct ad_info ad_info; 500 count = sprintf(buf, "%d\n", 501 bond_3ad_get_active_agg_info(bond, &ad_info) 502 ? 0 : ad_info.aggregator_id); 503 } 504 505 return count; 506} 507static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL); 508 509 510/* Show number of active 802.3ad ports. */ 511static ssize_t bonding_show_ad_num_ports(struct device *d, 512 struct device_attribute *attr, 513 char *buf) 514{ 515 int count = 0; 516 struct bonding *bond = to_bond(d); 517 518 if (BOND_MODE(bond) == BOND_MODE_8023AD) { 519 struct ad_info ad_info; 520 count = sprintf(buf, "%d\n", 521 bond_3ad_get_active_agg_info(bond, &ad_info) 522 ? 0 : ad_info.ports); 523 } 524 525 return count; 526} 527static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL); 528 529 530/* Show current 802.3ad actor key. */ 531static ssize_t bonding_show_ad_actor_key(struct device *d, 532 struct device_attribute *attr, 533 char *buf) 534{ 535 int count = 0; 536 struct bonding *bond = to_bond(d); 537 538 if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) { 539 struct ad_info ad_info; 540 count = sprintf(buf, "%d\n", 541 bond_3ad_get_active_agg_info(bond, &ad_info) 542 ? 0 : ad_info.actor_key); 543 } 544 545 return count; 546} 547static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL); 548 549 550/* Show current 802.3ad partner key. */ 551static ssize_t bonding_show_ad_partner_key(struct device *d, 552 struct device_attribute *attr, 553 char *buf) 554{ 555 int count = 0; 556 struct bonding *bond = to_bond(d); 557 558 if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) { 559 struct ad_info ad_info; 560 count = sprintf(buf, "%d\n", 561 bond_3ad_get_active_agg_info(bond, &ad_info) 562 ? 0 : ad_info.partner_key); 563 } 564 565 return count; 566} 567static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL); 568 569 570/* Show current 802.3ad partner mac. */ 571static ssize_t bonding_show_ad_partner_mac(struct device *d, 572 struct device_attribute *attr, 573 char *buf) 574{ 575 int count = 0; 576 struct bonding *bond = to_bond(d); 577 578 if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) { 579 struct ad_info ad_info; 580 if (!bond_3ad_get_active_agg_info(bond, &ad_info)) 581 count = sprintf(buf, "%pM\n", ad_info.partner_system); 582 } 583 584 return count; 585} 586static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL); 587 588/* Show the queue_ids of the slaves in the current bond. */ 589static ssize_t bonding_show_queue_id(struct device *d, 590 struct device_attribute *attr, 591 char *buf) 592{ 593 struct bonding *bond = to_bond(d); 594 struct list_head *iter; 595 struct slave *slave; 596 int res = 0; 597 598 if (!rtnl_trylock()) 599 return restart_syscall(); 600 601 bond_for_each_slave(bond, slave, iter) { 602 if (res > (PAGE_SIZE - IFNAMSIZ - 6)) { 603 /* not enough space for another interface_name:queue_id pair */ 604 if ((PAGE_SIZE - res) > 10) 605 res = PAGE_SIZE - 10; 606 res += sprintf(buf + res, "++more++ "); 607 break; 608 } 609 res += sprintf(buf + res, "%s:%d ", 610 slave->dev->name, slave->queue_id); 611 } 612 if (res) 613 buf[res-1] = '\n'; /* eat the leftover space */ 614 615 rtnl_unlock(); 616 617 return res; 618} 619static DEVICE_ATTR(queue_id, S_IRUGO | S_IWUSR, bonding_show_queue_id, 620 bonding_sysfs_store_option); 621 622 623/* Show the all_slaves_active flag. */ 624static ssize_t bonding_show_slaves_active(struct device *d, 625 struct device_attribute *attr, 626 char *buf) 627{ 628 struct bonding *bond = to_bond(d); 629 630 return sprintf(buf, "%d\n", bond->params.all_slaves_active); 631} 632static DEVICE_ATTR(all_slaves_active, S_IRUGO | S_IWUSR, 633 bonding_show_slaves_active, bonding_sysfs_store_option); 634 635/* Show the number of IGMP membership reports to send on link failure */ 636static ssize_t bonding_show_resend_igmp(struct device *d, 637 struct device_attribute *attr, 638 char *buf) 639{ 640 struct bonding *bond = to_bond(d); 641 642 return sprintf(buf, "%d\n", bond->params.resend_igmp); 643} 644static DEVICE_ATTR(resend_igmp, S_IRUGO | S_IWUSR, 645 bonding_show_resend_igmp, bonding_sysfs_store_option); 646 647 648static ssize_t bonding_show_lp_interval(struct device *d, 649 struct device_attribute *attr, 650 char *buf) 651{ 652 struct bonding *bond = to_bond(d); 653 654 return sprintf(buf, "%d\n", bond->params.lp_interval); 655} 656static DEVICE_ATTR(lp_interval, S_IRUGO | S_IWUSR, 657 bonding_show_lp_interval, bonding_sysfs_store_option); 658 659static ssize_t bonding_show_tlb_dynamic_lb(struct device *d, 660 struct device_attribute *attr, 661 char *buf) 662{ 663 struct bonding *bond = to_bond(d); 664 return sprintf(buf, "%d\n", bond->params.tlb_dynamic_lb); 665} 666static DEVICE_ATTR(tlb_dynamic_lb, S_IRUGO | S_IWUSR, 667 bonding_show_tlb_dynamic_lb, bonding_sysfs_store_option); 668 669static ssize_t bonding_show_packets_per_slave(struct device *d, 670 struct device_attribute *attr, 671 char *buf) 672{ 673 struct bonding *bond = to_bond(d); 674 unsigned int packets_per_slave = bond->params.packets_per_slave; 675 676 return sprintf(buf, "%u\n", packets_per_slave); 677} 678static DEVICE_ATTR(packets_per_slave, S_IRUGO | S_IWUSR, 679 bonding_show_packets_per_slave, bonding_sysfs_store_option); 680 681static ssize_t bonding_show_ad_actor_sys_prio(struct device *d, 682 struct device_attribute *attr, 683 char *buf) 684{ 685 struct bonding *bond = to_bond(d); 686 687 if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) 688 return sprintf(buf, "%hu\n", bond->params.ad_actor_sys_prio); 689 690 return 0; 691} 692static DEVICE_ATTR(ad_actor_sys_prio, S_IRUGO | S_IWUSR, 693 bonding_show_ad_actor_sys_prio, bonding_sysfs_store_option); 694 695static ssize_t bonding_show_ad_actor_system(struct device *d, 696 struct device_attribute *attr, 697 char *buf) 698{ 699 struct bonding *bond = to_bond(d); 700 701 if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) 702 return sprintf(buf, "%pM\n", bond->params.ad_actor_system); 703 704 return 0; 705} 706 707static DEVICE_ATTR(ad_actor_system, S_IRUGO | S_IWUSR, 708 bonding_show_ad_actor_system, bonding_sysfs_store_option); 709 710static ssize_t bonding_show_ad_user_port_key(struct device *d, 711 struct device_attribute *attr, 712 char *buf) 713{ 714 struct bonding *bond = to_bond(d); 715 716 if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) 717 return sprintf(buf, "%hu\n", bond->params.ad_user_port_key); 718 719 return 0; 720} 721static DEVICE_ATTR(ad_user_port_key, S_IRUGO | S_IWUSR, 722 bonding_show_ad_user_port_key, bonding_sysfs_store_option); 723 724static struct attribute *per_bond_attrs[] = { 725 &dev_attr_slaves.attr, 726 &dev_attr_mode.attr, 727 &dev_attr_fail_over_mac.attr, 728 &dev_attr_arp_validate.attr, 729 &dev_attr_arp_all_targets.attr, 730 &dev_attr_arp_interval.attr, 731 &dev_attr_arp_ip_target.attr, 732 &dev_attr_downdelay.attr, 733 &dev_attr_updelay.attr, 734 &dev_attr_lacp_rate.attr, 735 &dev_attr_ad_select.attr, 736 &dev_attr_xmit_hash_policy.attr, 737 &dev_attr_num_grat_arp.attr, 738 &dev_attr_num_unsol_na.attr, 739 &dev_attr_miimon.attr, 740 &dev_attr_primary.attr, 741 &dev_attr_primary_reselect.attr, 742 &dev_attr_use_carrier.attr, 743 &dev_attr_active_slave.attr, 744 &dev_attr_mii_status.attr, 745 &dev_attr_ad_aggregator.attr, 746 &dev_attr_ad_num_ports.attr, 747 &dev_attr_ad_actor_key.attr, 748 &dev_attr_ad_partner_key.attr, 749 &dev_attr_ad_partner_mac.attr, 750 &dev_attr_queue_id.attr, 751 &dev_attr_all_slaves_active.attr, 752 &dev_attr_resend_igmp.attr, 753 &dev_attr_min_links.attr, 754 &dev_attr_lp_interval.attr, 755 &dev_attr_packets_per_slave.attr, 756 &dev_attr_tlb_dynamic_lb.attr, 757 &dev_attr_ad_actor_sys_prio.attr, 758 &dev_attr_ad_actor_system.attr, 759 &dev_attr_ad_user_port_key.attr, 760 NULL, 761}; 762 763static struct attribute_group bonding_group = { 764 .name = "bonding", 765 .attrs = per_bond_attrs, 766}; 767 768/* Initialize sysfs. This sets up the bonding_masters file in 769 * /sys/class/net. 770 */ 771int bond_create_sysfs(struct bond_net *bn) 772{ 773 int ret; 774 775 bn->class_attr_bonding_masters = class_attr_bonding_masters; 776 sysfs_attr_init(&bn->class_attr_bonding_masters.attr); 777 778 ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters, 779 bn->net); 780 /* Permit multiple loads of the module by ignoring failures to 781 * create the bonding_masters sysfs file. Bonding devices 782 * created by second or subsequent loads of the module will 783 * not be listed in, or controllable by, bonding_masters, but 784 * will have the usual "bonding" sysfs directory. 785 * 786 * This is done to preserve backwards compatibility for 787 * initscripts/sysconfig, which load bonding multiple times to 788 * configure multiple bonding devices. 789 */ 790 if (ret == -EEXIST) { 791 /* Is someone being kinky and naming a device bonding_master? */ 792 if (__dev_get_by_name(bn->net, 793 class_attr_bonding_masters.attr.name)) 794 pr_err("network device named %s already exists in sysfs\n", 795 class_attr_bonding_masters.attr.name); 796 ret = 0; 797 } 798 799 return ret; 800 801} 802 803/* Remove /sys/class/net/bonding_masters. */ 804void bond_destroy_sysfs(struct bond_net *bn) 805{ 806 netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, bn->net); 807} 808 809/* Initialize sysfs for each bond. This sets up and registers 810 * the 'bondctl' directory for each individual bond under /sys/class/net. 811 */ 812void bond_prepare_sysfs_group(struct bonding *bond) 813{ 814 bond->dev->sysfs_groups[0] = &bonding_group; 815} 816 817