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