Resguardo inicial

linux-7.2.3/drivers/net/bonding/Makefile

@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: GPL-2.0-only
+#
+# Makefile for the Ethernet Bonding driver
+#
+
+obj-$(CONFIG_BONDING) += bonding.o
+
+bonding-objs := bond_main.o bond_3ad.o bond_alb.o bond_sysfs.o bond_sysfs_slave.o bond_debugfs.o bond_netlink.o bond_options.o
+
+proc-$(CONFIG_PROC_FS) += bond_procfs.o
+bonding-objs += $(proc-y)
+

linux-7.2.3/drivers/net/bonding/bond_debugfs.c

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/netdevice.h>
+
+#include <net/bonding.h>
+#include <net/bond_alb.h>
+
+#if defined(CONFIG_DEBUG_FS) && !defined(CONFIG_NET_NS)
+
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+
+static struct dentry *bonding_debug_root;
+
+/* Show RLB hash table */
+static int bond_debug_rlb_hash_show(struct seq_file *m, void *v)
+{
+	struct bonding *bond = m->private;
+	struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond));
+	struct rlb_client_info *client_info;
+	u32 hash_index;
+
+	if (BOND_MODE(bond) != BOND_MODE_ALB)
+		return 0;
+
+	seq_printf(m, "SourceIP        DestinationIP   "
+			"Destination MAC   DEV\n");
+
+	spin_lock_bh(&bond->mode_lock);
+
+	hash_index = bond_info->rx_hashtbl_used_head;
+	for (; hash_index != RLB_NULL_INDEX;
+	     hash_index = client_info->used_next) {
+		client_info = &(bond_info->rx_hashtbl[hash_index]);
+		if (client_info->slave)
+			seq_printf(m, "%-15pI4 %-15pI4 %-17pM %s\n",
+				   &client_info->ip_src,
+				   &client_info->ip_dst,
+				   &client_info->mac_dst,
+				   client_info->slave->dev->name);
+		else
+			seq_printf(m, "%-15pI4 %-15pI4 %-17pM (none)\n",
+				   &client_info->ip_src,
+				   &client_info->ip_dst,
+				   &client_info->mac_dst);
+	}
+
+	spin_unlock_bh(&bond->mode_lock);
+
+	return 0;
+}
+DEFINE_SHOW_ATTRIBUTE(bond_debug_rlb_hash);
+
+void bond_debug_register(struct bonding *bond)
+{
+	bond->debug_dir =
+		debugfs_create_dir(bond->dev->name, bonding_debug_root);
+
+	debugfs_create_file("rlb_hash_table", 0400, bond->debug_dir,
+				bond, &bond_debug_rlb_hash_fops);
+}
+
+void bond_debug_unregister(struct bonding *bond)
+{
+	debugfs_remove_recursive(bond->debug_dir);
+}
+
+void bond_debug_reregister(struct bonding *bond)
+{
+	int err = debugfs_change_name(bond->debug_dir, "%s", bond->dev->name);
+	if (err) {
+		netdev_warn(bond->dev, "failed to reregister, so just unregister old one\n");
+		bond_debug_unregister(bond);
+	}
+}
+
+void __init bond_create_debugfs(void)
+{
+	bonding_debug_root = debugfs_create_dir("bonding", NULL);
+
+	if (IS_ERR(bonding_debug_root))
+		pr_warn("Warning: Cannot create bonding directory in debugfs\n");
+}
+
+void bond_destroy_debugfs(void)
+{
+	debugfs_remove_recursive(bonding_debug_root);
+	bonding_debug_root = NULL;
+}
+
+
+#else /* !CONFIG_DEBUG_FS */
+
+void bond_debug_register(struct bonding *bond)
+{
+}
+
+void bond_debug_unregister(struct bonding *bond)
+{
+}
+
+void bond_debug_reregister(struct bonding *bond)
+{
+}
+
+void __init bond_create_debugfs(void)
+{
+}
+
+void bond_destroy_debugfs(void)
+{
+}
+
+#endif /* CONFIG_DEBUG_FS */

linux-7.2.3/drivers/net/bonding/bond_procfs.c

@@ -0,0 +1,340 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <generated/utsrelease.h>
+#include <linux/proc_fs.h>
+#include <linux/ethtool.h>
+#include <linux/export.h>
+#include <net/net_namespace.h>
+#include <net/netns/generic.h>
+#include <net/bonding.h>
+
+#define bond_version "Ethernet Channel Bonding Driver: v" UTS_RELEASE "\n"
+
+static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos)
+	__acquires(RCU)
+{
+	struct bonding *bond = pde_data(file_inode(seq->file));
+	struct list_head *iter;
+	struct slave *slave;
+	loff_t off = 0;
+
+	rcu_read_lock();
+
+	if (*pos == 0)
+		return SEQ_START_TOKEN;
+
+	bond_for_each_slave_rcu(bond, slave, iter)
+		if (++off == *pos)
+			return slave;
+
+	return NULL;
+}
+
+static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+{
+	struct bonding *bond = pde_data(file_inode(seq->file));
+	struct list_head *iter;
+	struct slave *slave;
+	bool found = false;
+
+	++*pos;
+	if (v == SEQ_START_TOKEN)
+		return bond_first_slave_rcu(bond);
+
+	bond_for_each_slave_rcu(bond, slave, iter) {
+		if (found)
+			return slave;
+		if (slave == v)
+			found = true;
+	}
+
+	return NULL;
+}
+
+static void bond_info_seq_stop(struct seq_file *seq, void *v)
+	__releases(RCU)
+{
+	rcu_read_unlock();
+}
+
+static void bond_info_show_master(struct seq_file *seq)
+{
+	struct bonding *bond = pde_data(file_inode(seq->file));
+	const struct bond_opt_value *optval;
+	struct slave *curr, *primary;
+	int arp_interval, fail_over_mac, miimon, i;
+
+	curr = rcu_dereference(bond->curr_active_slave);
+
+	seq_printf(seq, "Bonding Mode: %s",
+		   bond_mode_name(BOND_MODE(bond)));
+
+	fail_over_mac = READ_ONCE(bond->params.fail_over_mac);
+	if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP && fail_over_mac) {
+		optval = bond_opt_get_val(BOND_OPT_FAIL_OVER_MAC,
+					  fail_over_mac);
+		seq_printf(seq, " (fail_over_mac %s)", optval->string);
+	}
+
+	seq_printf(seq, "\n");
+
+	if (bond_mode_uses_xmit_hash(bond)) {
+		int xmit_policy = READ_ONCE(bond->params.xmit_policy);
+
+		optval = bond_opt_get_val(BOND_OPT_XMIT_HASH, xmit_policy);
+		seq_printf(seq, "Transmit Hash Policy: %s (%d)\n",
+			   optval->string, xmit_policy);
+	}
+
+	if (bond_uses_primary(bond)) {
+		primary = rcu_dereference(bond->primary_slave);
+		seq_printf(seq, "Primary Slave: %s",
+			   primary ? primary->dev->name : "None");
+		if (primary) {
+			optval = bond_opt_get_val(BOND_OPT_PRIMARY_RESELECT,
+					READ_ONCE(bond->params.primary_reselect));
+			seq_printf(seq, " (primary_reselect %s)",
+				   optval->string);
+		}
+
+		seq_printf(seq, "\nCurrently Active Slave: %s\n",
+			   (curr) ? curr->dev->name : "None");
+	}
+
+	seq_printf(seq, "MII Status: %s\n", netif_carrier_ok(bond->dev) ?
+		   "up" : "down");
+	miimon = READ_ONCE(bond->params.miimon);
+	seq_printf(seq, "MII Polling Interval (ms): %d\n", miimon);
+	seq_printf(seq, "Up Delay (ms): %d\n",
+		   READ_ONCE(bond->params.updelay) * miimon);
+	seq_printf(seq, "Down Delay (ms): %d\n",
+		   READ_ONCE(bond->params.downdelay) * miimon);
+	seq_printf(seq, "Peer Notification Delay (ms): %d\n",
+		   READ_ONCE(bond->params.peer_notif_delay) * miimon);
+
+
+	/* ARP information */
+	arp_interval = READ_ONCE(bond->params.arp_interval);
+	if (arp_interval > 0) {
+		int printed = 0;
+
+		seq_printf(seq, "ARP Polling Interval (ms): %d\n",
+				arp_interval);
+		seq_printf(seq, "ARP Missed Max: %u\n",
+				READ_ONCE(bond->params.missed_max));
+
+		seq_printf(seq, "ARP IP target/s (n.n.n.n form):");
+
+		for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
+			__be32 t = READ_ONCE(bond->params.arp_targets[i]);
+
+			if (!t)
+				break;
+			if (printed)
+				seq_printf(seq, ",");
+			seq_printf(seq, " %pI4", &t);
+			printed = 1;
+		}
+		seq_printf(seq, "\n");
+
+#if IS_ENABLED(CONFIG_IPV6)
+		printed = 0;
+		seq_printf(seq, "NS IPv6 target/s (xx::xx form):");
+
+		for (i = 0; (i < BOND_MAX_NS_TARGETS); i++) {
+			if (ipv6_addr_any(&bond->params.ns_targets[i]))
+				break;
+			if (printed)
+				seq_printf(seq, ",");
+			seq_printf(seq, " %pI6c", &bond->params.ns_targets[i]);
+			printed = 1;
+		}
+		seq_printf(seq, "\n");
+#endif
+	}
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
+		struct ad_info ad_info;
+
+		seq_puts(seq, "\n802.3ad info\n");
+		seq_printf(seq, "LACP active: %s\n",
+			   READ_ONCE(bond->params.lacp_active) ? "on" : "off");
+		seq_printf(seq, "LACP rate: %s\n",
+			   READ_ONCE(bond->params.lacp_fast) ? "fast" : "slow");
+		seq_printf(seq, "Min links: %d\n",
+			   READ_ONCE(bond->params.min_links));
+		optval = bond_opt_get_val(BOND_OPT_AD_SELECT,
+					  READ_ONCE(bond->params.ad_select));
+		seq_printf(seq, "Aggregator selection policy (ad_select): %s\n",
+			   optval->string);
+		if (capable(CAP_NET_ADMIN)) {
+			seq_printf(seq, "System priority: %d\n",
+				   BOND_AD_INFO(bond).system.sys_priority);
+			seq_printf(seq, "System MAC address: %pM\n",
+				   &BOND_AD_INFO(bond).system.sys_mac_addr);
+
+			if (__bond_3ad_get_active_agg_info(bond, &ad_info)) {
+				seq_printf(seq,
+					   "bond %s has no active aggregator\n",
+					   bond->dev->name);
+			} else {
+				seq_printf(seq, "Active Aggregator Info:\n");
+
+				seq_printf(seq, "\tAggregator ID: %d\n",
+					   ad_info.aggregator_id);
+				seq_printf(seq, "\tNumber of ports: %d\n",
+					   ad_info.ports);
+				seq_printf(seq, "\tActor Key: %d\n",
+					   ad_info.actor_key);
+				seq_printf(seq, "\tPartner Key: %d\n",
+					   ad_info.partner_key);
+				seq_printf(seq, "\tPartner Mac Address: %pM\n",
+					   ad_info.partner_system);
+			}
+		}
+	}
+}
+
+/* Note: runs under rcu_read_lock() */
+static void bond_info_show_slave(struct seq_file *seq,
+				 const struct slave *slave)
+{
+	struct bonding *bond = pde_data(file_inode(seq->file));
+
+	seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name);
+	seq_printf(seq, "MII Status: %s\n", bond_slave_link_status(slave->link));
+	if (slave->speed == SPEED_UNKNOWN)
+		seq_printf(seq, "Speed: %s\n", "Unknown");
+	else
+		seq_printf(seq, "Speed: %d Mbps\n", slave->speed);
+
+	if (slave->duplex == DUPLEX_UNKNOWN)
+		seq_printf(seq, "Duplex: %s\n", "Unknown");
+	else
+		seq_printf(seq, "Duplex: %s\n", slave->duplex ? "full" : "half");
+
+	seq_printf(seq, "Link Failure Count: %u\n",
+		   slave->link_failure_count);
+
+	seq_printf(seq, "Permanent HW addr: %*phC\n",
+		   slave->dev->addr_len, slave->perm_hwaddr);
+	seq_printf(seq, "Slave queue ID: %d\n", READ_ONCE(slave->queue_id));
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
+		const struct port *port = &SLAVE_AD_INFO(slave)->port;
+		const struct aggregator *agg = rcu_dereference(port->aggregator);
+
+		if (agg) {
+			seq_printf(seq, "Aggregator ID: %d\n",
+				   agg->aggregator_identifier);
+			seq_printf(seq, "Actor Churn State: %s\n",
+				   bond_3ad_churn_desc(READ_ONCE(port->sm_churn_actor_state)));
+			seq_printf(seq, "Partner Churn State: %s\n",
+				   bond_3ad_churn_desc(READ_ONCE(port->sm_churn_partner_state)));
+			seq_printf(seq, "Actor Churned Count: %d\n",
+				   READ_ONCE(port->churn_actor_count));
+			seq_printf(seq, "Partner Churned Count: %d\n",
+				   READ_ONCE(port->churn_partner_count));
+
+			if (capable(CAP_NET_ADMIN)) {
+				seq_puts(seq, "details actor lacp pdu:\n");
+				seq_printf(seq, "    system priority: %d\n",
+					   port->actor_system_priority);
+				seq_printf(seq, "    system mac address: %pM\n",
+					   &port->actor_system);
+				seq_printf(seq, "    port key: %d\n",
+					   port->actor_oper_port_key);
+				seq_printf(seq, "    port priority: %d\n",
+					   port->actor_port_priority);
+				seq_printf(seq, "    port number: %d\n",
+					   port->actor_port_number);
+				seq_printf(seq, "    port state: %d\n",
+					   port->actor_oper_port_state);
+
+				seq_puts(seq, "details partner lacp pdu:\n");
+				seq_printf(seq, "    system priority: %d\n",
+					   port->partner_oper.system_priority);
+				seq_printf(seq, "    system mac address: %pM\n",
+					   &port->partner_oper.system);
+				seq_printf(seq, "    oper key: %d\n",
+					   port->partner_oper.key);
+				seq_printf(seq, "    port priority: %d\n",
+					   port->partner_oper.port_priority);
+				seq_printf(seq, "    port number: %d\n",
+					   port->partner_oper.port_number);
+				seq_printf(seq, "    port state: %d\n",
+					   port->partner_oper.port_state);
+			}
+		} else {
+			seq_puts(seq, "Aggregator ID: N/A\n");
+		}
+	}
+}
+
+static int bond_info_seq_show(struct seq_file *seq, void *v)
+{
+	if (v == SEQ_START_TOKEN) {
+		seq_printf(seq, "%s\n", bond_version);
+		bond_info_show_master(seq);
+	} else
+		bond_info_show_slave(seq, v);
+
+	return 0;
+}
+
+static const struct seq_operations bond_info_seq_ops = {
+	.start = bond_info_seq_start,
+	.next  = bond_info_seq_next,
+	.stop  = bond_info_seq_stop,
+	.show  = bond_info_seq_show,
+};
+
+void bond_create_proc_entry(struct bonding *bond)
+{
+	struct net_device *bond_dev = bond->dev;
+	struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
+
+	if (bn->proc_dir) {
+		bond->proc_entry = proc_create_seq_data(bond_dev->name, 0444,
+				bn->proc_dir, &bond_info_seq_ops, bond);
+		if (bond->proc_entry == NULL)
+			netdev_warn(bond_dev, "Cannot create /proc/net/%s/%s\n",
+				    KBUILD_MODNAME, bond_dev->name);
+		else
+			memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ);
+	}
+}
+
+void bond_remove_proc_entry(struct bonding *bond)
+{
+	struct net_device *bond_dev = bond->dev;
+	struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id);
+
+	if (bn->proc_dir && bond->proc_entry) {
+		remove_proc_entry(bond->proc_file_name, bn->proc_dir);
+		memset(bond->proc_file_name, 0, IFNAMSIZ);
+		bond->proc_entry = NULL;
+	}
+}
+
+/* Create the bonding directory under /proc/net, if doesn't exist yet.
+ * Caller must hold rtnl_lock.
+ */
+void __net_init bond_create_proc_dir(struct bond_net *bn)
+{
+	if (!bn->proc_dir) {
+		bn->proc_dir = proc_mkdir(KBUILD_MODNAME, bn->net->proc_net);
+		if (!bn->proc_dir)
+			pr_warn("Warning: Cannot create /proc/net/%s\n",
+				KBUILD_MODNAME);
+	}
+}
+
+/* Destroy the bonding directory under /proc/net, if empty.
+ */
+void __net_exit bond_destroy_proc_dir(struct bond_net *bn)
+{
+	if (bn->proc_dir) {
+		remove_proc_entry(KBUILD_MODNAME, bn->net->proc_net);
+		bn->proc_dir = NULL;
+	}
+}

linux-7.2.3/drivers/net/bonding/bond_sysfs.c

@@ -0,0 +1,864 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/sched/signal.h>
+#include <linux/fs.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/netdevice.h>
+#include <linux/inetdevice.h>
+#include <linux/in.h>
+#include <linux/sysfs.h>
+#include <linux/ctype.h>
+#include <linux/inet.h>
+#include <linux/rtnetlink.h>
+#include <linux/etherdevice.h>
+#include <net/net_namespace.h>
+#include <net/netns/generic.h>
+#include <linux/nsproxy.h>
+
+#include <net/bonding.h>
+
+#define to_bond(cd)	((struct bonding *)(netdev_priv(to_net_dev(cd))))
+
+/* "show" function for the bond_masters attribute.
+ * The class parameter is ignored.
+ */
+static ssize_t bonding_show_bonds(const struct class *cls,
+				  const struct class_attribute *attr,
+				  char *buf)
+{
+	const struct bond_net *bn =
+		container_of_const(attr, struct bond_net, class_attr_bonding_masters);
+	struct bonding *bond;
+	int res = 0;
+
+	rcu_read_lock();
+
+	list_for_each_entry_rcu(bond, &bn->dev_list, bond_list) {
+		if (res > (PAGE_SIZE - IFNAMSIZ)) {
+			/* not enough space for another interface name */
+			if ((PAGE_SIZE - res) > 10)
+				res = PAGE_SIZE - 10;
+			res += sysfs_emit_at(buf, res, "++more++ ");
+			break;
+		}
+		res += sysfs_emit_at(buf, res, "%s ", bond->dev->name);
+	}
+	if (res)
+		buf[res-1] = '\n'; /* eat the leftover space */
+
+	rcu_read_unlock();
+	return res;
+}
+
+static struct net_device *bond_get_by_name(const struct bond_net *bn, const char *ifname)
+{
+	struct bonding *bond;
+
+	list_for_each_entry(bond, &bn->dev_list, bond_list) {
+		if (strncmp(bond->dev->name, ifname, IFNAMSIZ) == 0)
+			return bond->dev;
+	}
+	return NULL;
+}
+
+/* "store" function for the bond_masters attribute.  This is what
+ * creates and deletes entire bonds.
+ *
+ * The class parameter is ignored.
+ */
+static ssize_t bonding_store_bonds(const struct class *cls,
+				   const struct class_attribute *attr,
+				   const char *buffer, size_t count)
+{
+	const struct bond_net *bn =
+		container_of_const(attr, struct bond_net, class_attr_bonding_masters);
+	char command[IFNAMSIZ + 1] = {0, };
+	char *ifname;
+	int rv, res = count;
+
+	sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
+	ifname = command + 1;
+	if ((strlen(command) <= 1) ||
+	    !dev_valid_name(ifname))
+		goto err_no_cmd;
+
+	if (command[0] == '+') {
+		pr_info("%s is being created...\n", ifname);
+		rv = bond_create(bn->net, ifname);
+		if (rv) {
+			if (rv == -EEXIST)
+				pr_info("%s already exists\n", ifname);
+			else
+				pr_info("%s creation failed\n", ifname);
+			res = rv;
+		}
+	} else if (command[0] == '-') {
+		struct net_device *bond_dev;
+
+		rtnl_lock();
+		bond_dev = bond_get_by_name(bn, ifname);
+		if (bond_dev) {
+			pr_info("%s is being deleted...\n", ifname);
+			unregister_netdevice(bond_dev);
+		} else {
+			pr_err("unable to delete non-existent %s\n", ifname);
+			res = -ENODEV;
+		}
+		rtnl_unlock();
+	} else
+		goto err_no_cmd;
+
+	/* Always return either count or an error.  If you return 0, you'll
+	 * get called forever, which is bad.
+	 */
+	return res;
+
+err_no_cmd:
+	pr_err("no command found in bonding_masters - use +ifname or -ifname\n");
+	return -EPERM;
+}
+
+/* class attribute for bond_masters file.  This ends up in /sys/class/net */
+static const struct class_attribute class_attr_bonding_masters = {
+	.attr = {
+		.name = "bonding_masters",
+		.mode = 0644,
+	},
+	.show = bonding_show_bonds,
+	.store = bonding_store_bonds,
+};
+
+/* Generic "store" method for bonding sysfs option setting */
+static ssize_t bonding_sysfs_store_option(struct device *d,
+					  struct device_attribute *attr,
+					  const char *buffer, size_t count)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_option *opt;
+	char *buffer_clone;
+	int ret;
+
+	opt = bond_opt_get_by_name(attr->attr.name);
+	if (WARN_ON(!opt))
+		return -ENOENT;
+	buffer_clone = kstrndup(buffer, count, GFP_KERNEL);
+	if (!buffer_clone)
+		return -ENOMEM;
+	ret = bond_opt_tryset_rtnl(bond, opt->id, buffer_clone);
+	if (!ret)
+		ret = count;
+	kfree(buffer_clone);
+
+	return ret;
+}
+
+/* Show the slaves in the current bond. */
+static ssize_t bonding_show_slaves(struct device *d,
+				   struct device_attribute *attr, char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	struct list_head *iter;
+	struct slave *slave;
+	int res = 0;
+
+	rcu_read_lock();
+
+	bond_for_each_slave_rcu(bond, slave, iter) {
+		if (res > (PAGE_SIZE - IFNAMSIZ)) {
+			/* not enough space for another interface name */
+			if ((PAGE_SIZE - res) > 10)
+				res = PAGE_SIZE - 10;
+			res += sysfs_emit_at(buf, res, "++more++ ");
+			break;
+		}
+		res += sysfs_emit_at(buf, res, "%s ", slave->dev->name);
+	}
+
+	rcu_read_unlock();
+
+	if (res)
+		buf[res-1] = '\n'; /* eat the leftover space */
+
+	return res;
+}
+static DEVICE_ATTR(slaves, 0644, bonding_show_slaves,
+		   bonding_sysfs_store_option);
+
+/* Show the bonding mode. */
+static ssize_t bonding_show_mode(struct device *d,
+				 struct device_attribute *attr, char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+
+	val = bond_opt_get_val(BOND_OPT_MODE, BOND_MODE(bond));
+
+	return sysfs_emit(buf, "%s %d\n", val->string, BOND_MODE(bond));
+}
+static DEVICE_ATTR(mode, 0644, bonding_show_mode, bonding_sysfs_store_option);
+
+/* Show the bonding transmit hash method. */
+static ssize_t bonding_show_xmit_hash(struct device *d,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+	int xmit_policy;
+
+	xmit_policy = READ_ONCE(bond->params.xmit_policy);
+	val = bond_opt_get_val(BOND_OPT_XMIT_HASH, xmit_policy);
+
+	return sysfs_emit(buf, "%s %d\n", val->string, xmit_policy);
+}
+static DEVICE_ATTR(xmit_hash_policy, 0644,
+		   bonding_show_xmit_hash, bonding_sysfs_store_option);
+
+/* Show arp_validate. */
+static ssize_t bonding_show_arp_validate(struct device *d,
+					 struct device_attribute *attr,
+					 char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+	int arp_validate;
+
+	arp_validate = READ_ONCE(bond->params.arp_validate);
+	val = bond_opt_get_val(BOND_OPT_ARP_VALIDATE, arp_validate);
+
+	return sysfs_emit(buf, "%s %d\n", val->string, arp_validate);
+}
+static DEVICE_ATTR(arp_validate, 0644, bonding_show_arp_validate,
+		   bonding_sysfs_store_option);
+
+/* Show arp_all_targets. */
+static ssize_t bonding_show_arp_all_targets(struct device *d,
+					 struct device_attribute *attr,
+					 char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+	int arp_all_targets;
+
+	arp_all_targets = READ_ONCE(bond->params.arp_all_targets);
+	val = bond_opt_get_val(BOND_OPT_ARP_ALL_TARGETS, arp_all_targets);
+	return sysfs_emit(buf, "%s %d\n", val->string, arp_all_targets);
+}
+static DEVICE_ATTR(arp_all_targets, 0644,
+		   bonding_show_arp_all_targets, bonding_sysfs_store_option);
+
+/* Show fail_over_mac. */
+static ssize_t bonding_show_fail_over_mac(struct device *d,
+					  struct device_attribute *attr,
+					  char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+	int fail_over_mac;
+
+	fail_over_mac = READ_ONCE(bond->params.fail_over_mac);
+	val = bond_opt_get_val(BOND_OPT_FAIL_OVER_MAC, fail_over_mac);
+
+	return sysfs_emit(buf, "%s %d\n", val->string, fail_over_mac);
+}
+static DEVICE_ATTR(fail_over_mac, 0644,
+		   bonding_show_fail_over_mac, bonding_sysfs_store_option);
+
+/* Show the arp timer interval. */
+static ssize_t bonding_show_arp_interval(struct device *d,
+					 struct device_attribute *attr,
+					 char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.arp_interval));
+}
+static DEVICE_ATTR(arp_interval, 0644,
+		   bonding_show_arp_interval, bonding_sysfs_store_option);
+
+/* Show the arp targets. */
+static ssize_t bonding_show_arp_targets(struct device *d,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	int i, res = 0;
+
+	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
+		__be32 t = READ_ONCE(bond->params.arp_targets[i]);
+
+		if (t)
+			res += sysfs_emit_at(buf, res, "%pI4 ", &t);
+	}
+	if (res)
+		buf[res-1] = '\n'; /* eat the leftover space */
+
+	return res;
+}
+static DEVICE_ATTR(arp_ip_target, 0644,
+		   bonding_show_arp_targets, bonding_sysfs_store_option);
+
+/* Show the arp missed max. */
+static ssize_t bonding_show_missed_max(struct device *d,
+				       struct device_attribute *attr,
+				       char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%u\n", READ_ONCE(bond->params.missed_max));
+}
+static DEVICE_ATTR(arp_missed_max, 0644,
+		   bonding_show_missed_max, bonding_sysfs_store_option);
+
+/* Show the up and down delays. */
+static ssize_t bonding_show_downdelay(struct device *d,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.downdelay) *
+				       READ_ONCE(bond->params.miimon));
+}
+static DEVICE_ATTR(downdelay, 0644,
+		   bonding_show_downdelay, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_updelay(struct device *d,
+				    struct device_attribute *attr,
+				    char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.updelay) *
+				       READ_ONCE(bond->params.miimon));
+
+}
+static DEVICE_ATTR(updelay, 0644,
+		   bonding_show_updelay, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_peer_notif_delay(struct device *d,
+					     struct device_attribute *attr,
+					     char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n",
+			  READ_ONCE(bond->params.peer_notif_delay) *
+			  READ_ONCE(bond->params.miimon));
+}
+static DEVICE_ATTR(peer_notif_delay, 0644,
+		   bonding_show_peer_notif_delay, bonding_sysfs_store_option);
+
+/* Show the LACP activity and interval. */
+static ssize_t bonding_show_lacp_active(struct device *d,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+	int lacp_active;
+
+	lacp_active = READ_ONCE(bond->params.lacp_active);
+	val = bond_opt_get_val(BOND_OPT_LACP_ACTIVE, lacp_active);
+
+	return sysfs_emit(buf, "%s %d\n", val->string, lacp_active);
+}
+static DEVICE_ATTR(lacp_active, 0644,
+		   bonding_show_lacp_active, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_lacp_rate(struct device *d,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+	int lacp_fast;
+
+	lacp_fast = READ_ONCE(bond->params.lacp_fast);
+	val = bond_opt_get_val(BOND_OPT_LACP_RATE, lacp_fast);
+
+	return sysfs_emit(buf, "%s %d\n", val->string, lacp_fast);
+}
+static DEVICE_ATTR(lacp_rate, 0644,
+		   bonding_show_lacp_rate, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_min_links(struct device *d,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%u\n", READ_ONCE(bond->params.min_links));
+}
+static DEVICE_ATTR(min_links, 0644,
+		   bonding_show_min_links, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_ad_select(struct device *d,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+	int ad_select;
+
+	ad_select = READ_ONCE(bond->params.ad_select);
+	val = bond_opt_get_val(BOND_OPT_AD_SELECT, ad_select);
+
+	return sysfs_emit(buf, "%s %d\n", val->string, ad_select);
+}
+static DEVICE_ATTR(ad_select, 0644,
+		   bonding_show_ad_select, bonding_sysfs_store_option);
+
+/* Show the number of peer notifications to send after a failover event. */
+static ssize_t bonding_show_num_peer_notif(struct device *d,
+					   struct device_attribute *attr,
+					   char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.num_peer_notif));
+}
+static DEVICE_ATTR(num_grat_arp, 0644,
+		   bonding_show_num_peer_notif, bonding_sysfs_store_option);
+static DEVICE_ATTR(num_unsol_na, 0644,
+		   bonding_show_num_peer_notif, bonding_sysfs_store_option);
+
+/* Show the MII monitor interval. */
+static ssize_t bonding_show_miimon(struct device *d,
+				   struct device_attribute *attr,
+				   char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.miimon));
+}
+static DEVICE_ATTR(miimon, 0644,
+		   bonding_show_miimon, bonding_sysfs_store_option);
+
+/* Show the primary slave. */
+static ssize_t bonding_show_primary(struct device *d,
+				    struct device_attribute *attr,
+				    char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	struct slave *primary;
+	int count = 0;
+
+	rcu_read_lock();
+	primary = rcu_dereference(bond->primary_slave);
+	if (primary)
+		count = sysfs_emit(buf, "%s\n", primary->dev->name);
+	rcu_read_unlock();
+
+	return count;
+}
+static DEVICE_ATTR(primary, 0644,
+		   bonding_show_primary, bonding_sysfs_store_option);
+
+/* Show the primary_reselect flag. */
+static ssize_t bonding_show_primary_reselect(struct device *d,
+					     struct device_attribute *attr,
+					     char *buf)
+{
+	const struct bonding *bond = to_bond(d);
+	const struct bond_opt_value *val;
+	int primary_reselect;
+
+	primary_reselect = READ_ONCE(bond->params.primary_reselect);
+
+	val = bond_opt_get_val(BOND_OPT_PRIMARY_RESELECT, primary_reselect);
+
+	return sysfs_emit(buf, "%s %d\n", val->string, primary_reselect);
+}
+static DEVICE_ATTR(primary_reselect, 0644,
+		   bonding_show_primary_reselect, bonding_sysfs_store_option);
+
+/* use_carrier is obsolete, but print value for compatibility */
+static ssize_t bonding_show_carrier(struct device *d,
+				    struct device_attribute *attr,
+				    char *buf)
+{
+	return sysfs_emit(buf, "1\n");
+}
+static DEVICE_ATTR(use_carrier, 0644,
+		   bonding_show_carrier, bonding_sysfs_store_option);
+
+
+/* Show currently active_slave. */
+static ssize_t bonding_show_active_slave(struct device *d,
+					 struct device_attribute *attr,
+					 char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	struct net_device *slave_dev;
+	int count = 0;
+
+	rcu_read_lock();
+	slave_dev = bond_option_active_slave_get_rcu(bond);
+	if (slave_dev)
+		count = sysfs_emit(buf, "%s\n", slave_dev->name);
+	rcu_read_unlock();
+
+	return count;
+}
+static DEVICE_ATTR(active_slave, 0644,
+		   bonding_show_active_slave, bonding_sysfs_store_option);
+
+/* Show link status of the bond interface. */
+static ssize_t bonding_show_mii_status(struct device *d,
+				       struct device_attribute *attr,
+				       char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	bool active = netif_carrier_ok(bond->dev);
+
+	return sysfs_emit(buf, "%s\n", active ? "up" : "down");
+}
+static DEVICE_ATTR(mii_status, 0444, bonding_show_mii_status, NULL);
+
+/* Show current 802.3ad aggregator ID. */
+static ssize_t bonding_show_ad_aggregator(struct device *d,
+					  struct device_attribute *attr,
+					  char *buf)
+{
+	int count = 0;
+	struct bonding *bond = to_bond(d);
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
+		struct ad_info ad_info;
+
+		count = sysfs_emit(buf, "%d\n",
+				   bond_3ad_get_active_agg_info(bond, &ad_info)
+				   ?  0 : ad_info.aggregator_id);
+	}
+
+	return count;
+}
+static DEVICE_ATTR(ad_aggregator, 0444, bonding_show_ad_aggregator, NULL);
+
+
+/* Show number of active 802.3ad ports. */
+static ssize_t bonding_show_ad_num_ports(struct device *d,
+					 struct device_attribute *attr,
+					 char *buf)
+{
+	int count = 0;
+	struct bonding *bond = to_bond(d);
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
+		struct ad_info ad_info;
+
+		count = sysfs_emit(buf, "%d\n",
+				   bond_3ad_get_active_agg_info(bond, &ad_info)
+				   ?  0 : ad_info.ports);
+	}
+
+	return count;
+}
+static DEVICE_ATTR(ad_num_ports, 0444, bonding_show_ad_num_ports, NULL);
+
+
+/* Show current 802.3ad actor key. */
+static ssize_t bonding_show_ad_actor_key(struct device *d,
+					 struct device_attribute *attr,
+					 char *buf)
+{
+	int count = 0;
+	struct bonding *bond = to_bond(d);
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) {
+		struct ad_info ad_info;
+
+		count = sysfs_emit(buf, "%d\n",
+				   bond_3ad_get_active_agg_info(bond, &ad_info)
+				   ?  0 : ad_info.actor_key);
+	}
+
+	return count;
+}
+static DEVICE_ATTR(ad_actor_key, 0444, bonding_show_ad_actor_key, NULL);
+
+
+/* Show current 802.3ad partner key. */
+static ssize_t bonding_show_ad_partner_key(struct device *d,
+					   struct device_attribute *attr,
+					   char *buf)
+{
+	int count = 0;
+	struct bonding *bond = to_bond(d);
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) {
+		struct ad_info ad_info;
+
+		count = sysfs_emit(buf, "%d\n",
+				   bond_3ad_get_active_agg_info(bond, &ad_info)
+				   ?  0 : ad_info.partner_key);
+	}
+
+	return count;
+}
+static DEVICE_ATTR(ad_partner_key, 0444, bonding_show_ad_partner_key, NULL);
+
+
+/* Show current 802.3ad partner mac. */
+static ssize_t bonding_show_ad_partner_mac(struct device *d,
+					   struct device_attribute *attr,
+					   char *buf)
+{
+	int count = 0;
+	struct bonding *bond = to_bond(d);
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) {
+		struct ad_info ad_info;
+
+		if (!bond_3ad_get_active_agg_info(bond, &ad_info))
+			count = sysfs_emit(buf, "%pM\n", ad_info.partner_system);
+	}
+
+	return count;
+}
+static DEVICE_ATTR(ad_partner_mac, 0444, bonding_show_ad_partner_mac, NULL);
+
+/* Show the queue_ids of the slaves in the current bond. */
+static ssize_t bonding_show_queue_id(struct device *d,
+				     struct device_attribute *attr,
+				     char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	struct list_head *iter;
+	struct slave *slave;
+	int res = 0;
+
+	rcu_read_lock();
+
+	bond_for_each_slave_rcu(bond, slave, iter) {
+		if (res > (PAGE_SIZE - IFNAMSIZ - 6)) {
+			/* not enough space for another interface_name:queue_id pair */
+			if ((PAGE_SIZE - res) > 10)
+				res = PAGE_SIZE - 10;
+			res += sysfs_emit_at(buf, res, "++more++ ");
+			break;
+		}
+		res += sysfs_emit_at(buf, res, "%s:%d ",
+				     slave->dev->name,
+				     READ_ONCE(slave->queue_id));
+	}
+	if (res)
+		buf[res-1] = '\n'; /* eat the leftover space */
+
+	rcu_read_unlock();
+
+	return res;
+}
+static DEVICE_ATTR(queue_id, 0644, bonding_show_queue_id,
+		   bonding_sysfs_store_option);
+
+
+/* Show the all_slaves_active flag. */
+static ssize_t bonding_show_slaves_active(struct device *d,
+					  struct device_attribute *attr,
+					  char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.all_slaves_active));
+}
+static DEVICE_ATTR(all_slaves_active, 0644,
+		   bonding_show_slaves_active, bonding_sysfs_store_option);
+
+/* Show the number of IGMP membership reports to send on link failure */
+static ssize_t bonding_show_resend_igmp(struct device *d,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.resend_igmp));
+}
+static DEVICE_ATTR(resend_igmp, 0644,
+		   bonding_show_resend_igmp, bonding_sysfs_store_option);
+
+
+static ssize_t bonding_show_lp_interval(struct device *d,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.lp_interval));
+}
+static DEVICE_ATTR(lp_interval, 0644,
+		   bonding_show_lp_interval, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_tlb_dynamic_lb(struct device *d,
+					   struct device_attribute *attr,
+					   char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	return sysfs_emit(buf, "%d\n", READ_ONCE(bond->params.tlb_dynamic_lb));
+}
+static DEVICE_ATTR(tlb_dynamic_lb, 0644,
+		   bonding_show_tlb_dynamic_lb, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_packets_per_slave(struct device *d,
+					      struct device_attribute *attr,
+					      char *buf)
+{
+	struct bonding *bond = to_bond(d);
+	unsigned int packets_per_slave = READ_ONCE(bond->params.packets_per_slave);
+
+	return sysfs_emit(buf, "%u\n", packets_per_slave);
+}
+static DEVICE_ATTR(packets_per_slave, 0644,
+		   bonding_show_packets_per_slave, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_ad_actor_sys_prio(struct device *d,
+					      struct device_attribute *attr,
+					      char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN))
+		return sysfs_emit(buf, "%hu\n", READ_ONCE(bond->params.ad_actor_sys_prio));
+
+	return 0;
+}
+static DEVICE_ATTR(ad_actor_sys_prio, 0644,
+		   bonding_show_ad_actor_sys_prio, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_ad_actor_system(struct device *d,
+					    struct device_attribute *attr,
+					    char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN))
+		return sysfs_emit(buf, "%pM\n", bond->params.ad_actor_system);
+
+	return 0;
+}
+
+static DEVICE_ATTR(ad_actor_system, 0644,
+		   bonding_show_ad_actor_system, bonding_sysfs_store_option);
+
+static ssize_t bonding_show_ad_user_port_key(struct device *d,
+					     struct device_attribute *attr,
+					     char *buf)
+{
+	struct bonding *bond = to_bond(d);
+
+	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN))
+		return sysfs_emit(buf, "%hu\n",
+				  READ_ONCE(bond->params.ad_user_port_key));
+
+	return 0;
+}
+static DEVICE_ATTR(ad_user_port_key, 0644,
+		   bonding_show_ad_user_port_key, bonding_sysfs_store_option);
+
+static struct attribute *per_bond_attrs[] = {
+	&dev_attr_slaves.attr,
+	&dev_attr_mode.attr,
+	&dev_attr_fail_over_mac.attr,
+	&dev_attr_arp_validate.attr,
+	&dev_attr_arp_all_targets.attr,
+	&dev_attr_arp_interval.attr,
+	&dev_attr_arp_ip_target.attr,
+	&dev_attr_downdelay.attr,
+	&dev_attr_updelay.attr,
+	&dev_attr_peer_notif_delay.attr,
+	&dev_attr_lacp_active.attr,
+	&dev_attr_lacp_rate.attr,
+	&dev_attr_ad_select.attr,
+	&dev_attr_xmit_hash_policy.attr,
+	&dev_attr_num_grat_arp.attr,
+	&dev_attr_num_unsol_na.attr,
+	&dev_attr_miimon.attr,
+	&dev_attr_primary.attr,
+	&dev_attr_primary_reselect.attr,
+	&dev_attr_use_carrier.attr,
+	&dev_attr_active_slave.attr,
+	&dev_attr_mii_status.attr,
+	&dev_attr_ad_aggregator.attr,
+	&dev_attr_ad_num_ports.attr,
+	&dev_attr_ad_actor_key.attr,
+	&dev_attr_ad_partner_key.attr,
+	&dev_attr_ad_partner_mac.attr,
+	&dev_attr_queue_id.attr,
+	&dev_attr_all_slaves_active.attr,
+	&dev_attr_resend_igmp.attr,
+	&dev_attr_min_links.attr,
+	&dev_attr_lp_interval.attr,
+	&dev_attr_packets_per_slave.attr,
+	&dev_attr_tlb_dynamic_lb.attr,
+	&dev_attr_ad_actor_sys_prio.attr,
+	&dev_attr_ad_actor_system.attr,
+	&dev_attr_ad_user_port_key.attr,
+	&dev_attr_arp_missed_max.attr,
+	NULL,
+};
+
+static const struct attribute_group bonding_group = {
+	.name = "bonding",
+	.attrs = per_bond_attrs,
+};
+
+/* Initialize sysfs.  This sets up the bonding_masters file in
+ * /sys/class/net.
+ */
+int __net_init bond_create_sysfs(struct bond_net *bn)
+{
+	int ret;
+
+	bn->class_attr_bonding_masters = class_attr_bonding_masters;
+	sysfs_attr_init(&bn->class_attr_bonding_masters.attr);
+
+	ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters,
+					  to_ns_common(bn->net));
+	/* Permit multiple loads of the module by ignoring failures to
+	 * create the bonding_masters sysfs file.  Bonding devices
+	 * created by second or subsequent loads of the module will
+	 * not be listed in, or controllable by, bonding_masters, but
+	 * will have the usual "bonding" sysfs directory.
+	 *
+	 * This is done to preserve backwards compatibility for
+	 * initscripts/sysconfig, which load bonding multiple times to
+	 * configure multiple bonding devices.
+	 */
+	if (ret == -EEXIST) {
+		/* Is someone being kinky and naming a device bonding_master? */
+		if (netdev_name_in_use(bn->net,
+				       class_attr_bonding_masters.attr.name))
+			pr_err("network device named %s already exists in sysfs\n",
+			       class_attr_bonding_masters.attr.name);
+		ret = 0;
+	}
+
+	return ret;
+
+}
+
+/* Remove /sys/class/net/bonding_masters. */
+void __net_exit bond_destroy_sysfs(struct bond_net *bn)
+{
+	netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, to_ns_common(bn->net));
+}
+
+/* Initialize sysfs for each bond.  This sets up and registers
+ * the 'bondctl' directory for each individual bond under /sys/class/net.
+ */
+void bond_prepare_sysfs_group(struct bonding *bond)
+{
+	bond->dev->sysfs_groups[0] = &bonding_group;
+}
+

linux-7.2.3/drivers/net/bonding/bond_sysfs_slave.c

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*	Sysfs attributes of bond slaves
+ *
+ *      Copyright (c) 2014 Scott Feldman <sfeldma@cumulusnetworks.com>
+ */
+
+#include <linux/capability.h>
+#include <linux/kernel.h>
+#include <linux/netdevice.h>
+
+#include <net/bonding.h>
+
+struct slave_attribute {
+	struct attribute attr;
+	ssize_t (*show)(struct slave *, char *);
+};
+
+#define SLAVE_ATTR_RO(_name)					\
+const struct slave_attribute slave_attr_##_name = __ATTR_RO(_name)
+
+static ssize_t state_show(struct slave *slave, char *buf)
+{
+	switch (bond_slave_state(slave)) {
+	case BOND_STATE_ACTIVE:
+		return sysfs_emit(buf, "active\n");
+	case BOND_STATE_BACKUP:
+		return sysfs_emit(buf, "backup\n");
+	default:
+		return sysfs_emit(buf, "UNKNOWN\n");
+	}
+}
+static SLAVE_ATTR_RO(state);
+
+static ssize_t mii_status_show(struct slave *slave, char *buf)
+{
+	return sysfs_emit(buf, "%s\n", bond_slave_link_status(slave->link));
+}
+static SLAVE_ATTR_RO(mii_status);
+
+static ssize_t link_failure_count_show(struct slave *slave, char *buf)
+{
+	return sysfs_emit(buf, "%d\n", slave->link_failure_count);
+}
+static SLAVE_ATTR_RO(link_failure_count);
+
+static ssize_t perm_hwaddr_show(struct slave *slave, char *buf)
+{
+	return sysfs_emit(buf, "%*phC\n",
+		       slave->dev->addr_len,
+		       slave->perm_hwaddr);
+}
+static SLAVE_ATTR_RO(perm_hwaddr);
+
+static ssize_t queue_id_show(struct slave *slave, char *buf)
+{
+	return sysfs_emit(buf, "%d\n", READ_ONCE(slave->queue_id));
+}
+static SLAVE_ATTR_RO(queue_id);
+
+static ssize_t ad_aggregator_id_show(struct slave *slave, char *buf)
+{
+	const struct aggregator *agg;
+
+	if (BOND_MODE(slave->bond) == BOND_MODE_8023AD) {
+		rcu_read_lock();
+		agg = rcu_dereference(SLAVE_AD_INFO(slave)->port.aggregator);
+		if (agg) {
+			ssize_t res = sysfs_emit(buf, "%d\n",
+						 agg->aggregator_identifier);
+			rcu_read_unlock();
+			return res;
+		}
+		rcu_read_unlock();
+	}
+
+	return sysfs_emit(buf, "N/A\n");
+}
+static SLAVE_ATTR_RO(ad_aggregator_id);
+
+static ssize_t ad_actor_oper_port_state_show(struct slave *slave, char *buf)
+{
+	const struct port *ad_port;
+
+	if (BOND_MODE(slave->bond) == BOND_MODE_8023AD) {
+		ad_port = &SLAVE_AD_INFO(slave)->port;
+		if (rcu_access_pointer(ad_port->aggregator))
+			return sysfs_emit(buf, "%u\n",
+				       ad_port->actor_oper_port_state);
+	}
+
+	return sysfs_emit(buf, "N/A\n");
+}
+static SLAVE_ATTR_RO(ad_actor_oper_port_state);
+
+static ssize_t ad_partner_oper_port_state_show(struct slave *slave, char *buf)
+{
+	const struct port *ad_port;
+
+	if (BOND_MODE(slave->bond) == BOND_MODE_8023AD) {
+		ad_port = &SLAVE_AD_INFO(slave)->port;
+		if (rcu_access_pointer(ad_port->aggregator))
+			return sysfs_emit(buf, "%u\n",
+				       ad_port->partner_oper.port_state);
+	}
+
+	return sysfs_emit(buf, "N/A\n");
+}
+static SLAVE_ATTR_RO(ad_partner_oper_port_state);
+
+static const struct attribute *slave_attrs[] = {
+	&slave_attr_state.attr,
+	&slave_attr_mii_status.attr,
+	&slave_attr_link_failure_count.attr,
+	&slave_attr_perm_hwaddr.attr,
+	&slave_attr_queue_id.attr,
+	&slave_attr_ad_aggregator_id.attr,
+	&slave_attr_ad_actor_oper_port_state.attr,
+	&slave_attr_ad_partner_oper_port_state.attr,
+	NULL
+};
+
+#define to_slave_attr(_at) container_of(_at, struct slave_attribute, attr)
+
+static ssize_t slave_show(struct kobject *kobj,
+			  struct attribute *attr, char *buf)
+{
+	struct slave_attribute *slave_attr = to_slave_attr(attr);
+	struct slave *slave = to_slave(kobj);
+
+	return slave_attr->show(slave, buf);
+}
+
+const struct sysfs_ops slave_sysfs_ops = {
+	.show = slave_show,
+};
+
+int bond_sysfs_slave_add(struct slave *slave)
+{
+	return sysfs_create_files(&slave->kobj, slave_attrs);
+}
+
+void bond_sysfs_slave_del(struct slave *slave)
+{
+	sysfs_remove_files(&slave->kobj, slave_attrs);
+}