[linux.git] / net / bridge / br_sysfs_br.c

/*
 *	Sysfs attributes of bridge ports
 *	Linux ethernet bridge
 *
 *	Authors:
 *	Stephen Hemminger		<[email protected]>
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 */

#include <linux/capability.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/if_bridge.h>
#include <linux/rtnetlink.h>
#include <linux/spinlock.h>
#include <linux/times.h>

#include "br_private.h"

#define to_dev(obj)	container_of(obj, struct device, kobj)
#define to_bridge(cd)	((struct net_bridge *)(to_net_dev(cd)->priv))

/*
 * Common code for storing bridge parameters.
 */
static ssize_t store_bridge_parm(struct device *d,
				 const char *buf, size_t len,
				 void (*set)(struct net_bridge *, unsigned long))
{
	struct net_bridge *br = to_bridge(d);
	char *endp;
	unsigned long val;

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	val = simple_strtoul(buf, &endp, 0);
	if (endp == buf)
		return -EINVAL;

	spin_lock_bh(&br->lock);
	(*set)(br, val);
	spin_unlock_bh(&br->lock);
	return len;
}


static ssize_t show_forward_delay(struct device *d,
				  struct device_attribute *attr, char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay));
}

static void set_forward_delay(struct net_bridge *br, unsigned long val)
{
	unsigned long delay = clock_t_to_jiffies(val);
	br->forward_delay = delay;
	if (br_is_root_bridge(br))
		br->bridge_forward_delay = delay;
}

static ssize_t store_forward_delay(struct device *d,
				   struct device_attribute *attr,
				   const char *buf, size_t len)
{
	return store_bridge_parm(d, buf, len, set_forward_delay);
}
static DEVICE_ATTR(forward_delay, S_IRUGO | S_IWUSR,
		   show_forward_delay, store_forward_delay);

static ssize_t show_hello_time(struct device *d, struct device_attribute *attr,
			       char *buf)
{
	return sprintf(buf, "%lu\n",
		       jiffies_to_clock_t(to_bridge(d)->hello_time));
}

static void set_hello_time(struct net_bridge *br, unsigned long val)
{
	unsigned long t = clock_t_to_jiffies(val);
	br->hello_time = t;
	if (br_is_root_bridge(br))
		br->bridge_hello_time = t;
}

static ssize_t store_hello_time(struct device *d,
				struct device_attribute *attr, const char *buf,
				size_t len)
{
	return store_bridge_parm(d, buf, len, set_hello_time);
}
static DEVICE_ATTR(hello_time, S_IRUGO | S_IWUSR, show_hello_time,
		   store_hello_time);

static ssize_t show_max_age(struct device *d, struct device_attribute *attr,
			    char *buf)
{
	return sprintf(buf, "%lu\n",
		       jiffies_to_clock_t(to_bridge(d)->max_age));
}

static void set_max_age(struct net_bridge *br, unsigned long val)
{
	unsigned long t = clock_t_to_jiffies(val);
	br->max_age = t;
	if (br_is_root_bridge(br))
		br->bridge_max_age = t;
}

static ssize_t store_max_age(struct device *d, struct device_attribute *attr,
			     const char *buf, size_t len)
{
	return store_bridge_parm(d, buf, len, set_max_age);
}
static DEVICE_ATTR(max_age, S_IRUGO | S_IWUSR, show_max_age, store_max_age);

static ssize_t show_ageing_time(struct device *d,
				struct device_attribute *attr, char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
}

static void set_ageing_time(struct net_bridge *br, unsigned long val)
{
	br->ageing_time = clock_t_to_jiffies(val);
}

static ssize_t store_ageing_time(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t len)
{
	return store_bridge_parm(d, buf, len, set_ageing_time);
}
static DEVICE_ATTR(ageing_time, S_IRUGO | S_IWUSR, show_ageing_time,
		   store_ageing_time);

static ssize_t show_stp_state(struct device *d,
			      struct device_attribute *attr, char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%d\n", br->stp_enabled);
}

static void set_stp_state(struct net_bridge *br, unsigned long val)
{
	rtnl_lock();
	spin_unlock_bh(&br->lock);
	br_stp_set_enabled(br, val);
	spin_lock_bh(&br->lock);
	rtnl_unlock();
}

static ssize_t store_stp_state(struct device *d,
			       struct device_attribute *attr, const char *buf,
			       size_t len)
{
	return store_bridge_parm(d, buf, len, set_stp_state);
}
static DEVICE_ATTR(stp_state, S_IRUGO | S_IWUSR, show_stp_state,
		   store_stp_state);

static ssize_t show_priority(struct device *d, struct device_attribute *attr,
			     char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%d\n",
		       (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]);
}

static void set_priority(struct net_bridge *br, unsigned long val)
{
	br_stp_set_bridge_priority(br, (u16) val);
}

static ssize_t store_priority(struct device *d, struct device_attribute *attr,
			       const char *buf, size_t len)
{
	return store_bridge_parm(d, buf, len, set_priority);
}
static DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, show_priority, store_priority);

static ssize_t show_root_id(struct device *d, struct device_attribute *attr,
			    char *buf)
{
	return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
}
static DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);

static ssize_t show_bridge_id(struct device *d, struct device_attribute *attr,
			      char *buf)
{
	return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
}
static DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);

static ssize_t show_root_port(struct device *d, struct device_attribute *attr,
			      char *buf)
{
	return sprintf(buf, "%d\n", to_bridge(d)->root_port);
}
static DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);

static ssize_t show_root_path_cost(struct device *d,
				   struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
}
static DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);

static ssize_t show_topology_change(struct device *d,
				    struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
}
static DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);

static ssize_t show_topology_change_detected(struct device *d,
					     struct device_attribute *attr,
					     char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%d\n", br->topology_change_detected);
}
static DEVICE_ATTR(topology_change_detected, S_IRUGO,
		   show_topology_change_detected, NULL);

static ssize_t show_hello_timer(struct device *d,
				struct device_attribute *attr, char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
}
static DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);

static ssize_t show_tcn_timer(struct device *d, struct device_attribute *attr,
			      char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
}
static DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);

static ssize_t show_topology_change_timer(struct device *d,
					  struct device_attribute *attr,
					  char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
}
static DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer,
		   NULL);

static ssize_t show_gc_timer(struct device *d, struct device_attribute *attr,
			     char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer));
}
static DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);

static ssize_t show_group_addr(struct device *d,
			       struct device_attribute *attr, char *buf)
{
	struct net_bridge *br = to_bridge(d);
	return sprintf(buf, "%x:%x:%x:%x:%x:%x\n",
		       br->group_addr[0], br->group_addr[1],
		       br->group_addr[2], br->group_addr[3],
		       br->group_addr[4], br->group_addr[5]);
}

static ssize_t store_group_addr(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t len)
{
	struct net_bridge *br = to_bridge(d);
	unsigned new_addr[6];
	int i;

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	if (sscanf(buf, "%x:%x:%x:%x:%x:%x",
		   &new_addr[0], &new_addr[1], &new_addr[2],
		   &new_addr[3], &new_addr[4], &new_addr[5]) != 6)
		return -EINVAL;

	/* Must be 01:80:c2:00:00:0X */
	for (i = 0; i < 5; i++)
		if (new_addr[i] != br_group_address[i])
			return -EINVAL;

	if (new_addr[5] & ~0xf)
		return -EINVAL;

	if (new_addr[5] == 1 	/* 802.3x Pause address */
	    || new_addr[5] == 2 /* 802.3ad Slow protocols */
	    || new_addr[5] == 3) /* 802.1X PAE address */
		return -EINVAL;

	spin_lock_bh(&br->lock);
	for (i = 0; i < 6; i++)
		br->group_addr[i] = new_addr[i];
	spin_unlock_bh(&br->lock);
	return len;
}

static DEVICE_ATTR(group_addr, S_IRUGO | S_IWUSR,
		   show_group_addr, store_group_addr);

static ssize_t store_flush(struct device *d,
			   struct device_attribute *attr,
			   const char *buf, size_t len)
{
	struct net_bridge *br = to_bridge(d);

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	br_fdb_flush(br);
	return len;
}
static DEVICE_ATTR(flush, S_IWUSR, NULL, store_flush);

static struct attribute *bridge_attrs[] = {
	&dev_attr_forward_delay.attr,
	&dev_attr_hello_time.attr,
	&dev_attr_max_age.attr,
	&dev_attr_ageing_time.attr,
	&dev_attr_stp_state.attr,
	&dev_attr_priority.attr,
	&dev_attr_bridge_id.attr,
	&dev_attr_root_id.attr,
	&dev_attr_root_path_cost.attr,
	&dev_attr_root_port.attr,
	&dev_attr_topology_change.attr,
	&dev_attr_topology_change_detected.attr,
	&dev_attr_hello_timer.attr,
	&dev_attr_tcn_timer.attr,
	&dev_attr_topology_change_timer.attr,
	&dev_attr_gc_timer.attr,
	&dev_attr_group_addr.attr,
	&dev_attr_flush.attr,
	NULL
};

static struct attribute_group bridge_group = {
	.name = SYSFS_BRIDGE_ATTR,
	.attrs = bridge_attrs,
};

/*
 * Export the forwarding information table as a binary file
 * The records are struct __fdb_entry.
 *
 * Returns the number of bytes read.
 */
static ssize_t brforward_read(struct kobject *kobj,
			      struct bin_attribute *bin_attr,
			      char *buf, loff_t off, size_t count)
{
	struct device *dev = to_dev(kobj);
	struct net_bridge *br = to_bridge(dev);
	int n;

	/* must read whole records */
	if (off % sizeof(struct __fdb_entry) != 0)
		return -EINVAL;

	n =  br_fdb_fillbuf(br, buf,
			    count / sizeof(struct __fdb_entry),
			    off / sizeof(struct __fdb_entry));

	if (n > 0)
		n *= sizeof(struct __fdb_entry);

	return n;
}

static struct bin_attribute bridge_forward = {
	.attr = { .name = SYSFS_BRIDGE_FDB,
		  .mode = S_IRUGO, },
	.read = brforward_read,
};

/*
 * Add entries in sysfs onto the existing network class device
 * for the bridge.
 *   Adds a attribute group "bridge" containing tuning parameters.
 *   Binary attribute containing the forward table
 *   Sub directory to hold links to interfaces.
 *
 * Note: the ifobj exists only to be a subdirectory
 *   to hold links.  The ifobj exists in same data structure
 *   as it's parent the bridge so reference counting works.
 */
int br_sysfs_addbr(struct net_device *dev)
{
	struct kobject *brobj = &dev->dev.kobj;
	struct net_bridge *br = netdev_priv(dev);
	int err;

	err = sysfs_create_group(brobj, &bridge_group);
	if (err) {
		pr_info("%s: can't create group %s/%s\n",
			__FUNCTION__, dev->name, bridge_group.name);
		goto out1;
	}

	err = sysfs_create_bin_file(brobj, &bridge_forward);
	if (err) {
		pr_info("%s: can't create attribute file %s/%s\n",
			__FUNCTION__, dev->name, bridge_forward.attr.name);
		goto out2;
	}


	kobject_set_name(&br->ifobj, SYSFS_BRIDGE_PORT_SUBDIR);
	br->ifobj.ktype = NULL;
	br->ifobj.kset = NULL;
	br->ifobj.parent = brobj;

	err = kobject_register(&br->ifobj);
	if (err) {
		pr_info("%s: can't add kobject (directory) %s/%s\n",
			__FUNCTION__, dev->name, br->ifobj.name);
		goto out3;
	}
	return 0;
 out3:
	sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
 out2:
	sysfs_remove_group(&dev->dev.kobj, &bridge_group);
 out1:
	return err;

}

void br_sysfs_delbr(struct net_device *dev)
{
	struct kobject *kobj = &dev->dev.kobj;
	struct net_bridge *br = netdev_priv(dev);

	kobject_unregister(&br->ifobj);
	sysfs_remove_bin_file(kobj, &bridge_forward);
	sysfs_remove_group(kobj, &bridge_group);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Sysfs attributes of bridge ports
	3	* Linux ethernet bridge
	4	*
	5	* Authors:
	6	* Stephen Hemminger <[email protected]>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License
	10	* as published by the Free Software Foundation; either version
	11	* 2 of the License, or (at your option) any later version.
	12	*/
	13
4fc268d2	14	#include <linux/capability.h>
1da177e4 LT	15	#include <linux/kernel.h>
	16	#include <linux/netdevice.h>
	17	#include <linux/if_bridge.h>
	18	#include <linux/rtnetlink.h>
	19	#include <linux/spinlock.h>
	20	#include <linux/times.h>
	21
	22	#include "br_private.h"
	23
43cb76d9	24	#define to_dev(obj) container_of(obj, struct device, kobj)
1da177e4 LT	25	#define to_bridge(cd) ((struct net_bridge *)(to_net_dev(cd)->priv))
	26
	27	/*
	28	* Common code for storing bridge parameters.
	29	*/
43cb76d9	30	static ssize_t store_bridge_parm(struct device *d,
1da177e4 LT	31	const char *buf, size_t len,
	32	void (set)(struct net_bridge , unsigned long))
	33	{
43cb76d9	34	struct net_bridge *br = to_bridge(d);
1da177e4 LT	35	char *endp;
	36	unsigned long val;
	37
	38	if (!capable(CAP_NET_ADMIN))
	39	return -EPERM;
	40
	41	val = simple_strtoul(buf, &endp, 0);
	42	if (endp == buf)
	43	return -EINVAL;
	44
	45	spin_lock_bh(&br->lock);
	46	(*set)(br, val);
	47	spin_unlock_bh(&br->lock);
	48	return len;
	49	}
	50
	51
43cb76d9 GKH	52	static ssize_t show_forward_delay(struct device *d,
43cb76d9 GKH	53	struct device_attribute attr, char buf)
1da177e4	54	{
43cb76d9	55	struct net_bridge *br = to_bridge(d);
1da177e4 LT	56	return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay));
	57	}
	58
	59	static void set_forward_delay(struct net_bridge *br, unsigned long val)
	60	{
	61	unsigned long delay = clock_t_to_jiffies(val);
	62	br->forward_delay = delay;
	63	if (br_is_root_bridge(br))
	64	br->bridge_forward_delay = delay;
	65	}
	66
43cb76d9 GKH	67	static ssize_t store_forward_delay(struct device *d,
	68	struct device_attribute *attr,
	69	const char *buf, size_t len)
1da177e4	70	{
43cb76d9	71	return store_bridge_parm(d, buf, len, set_forward_delay);
1da177e4	72	}
43cb76d9 GKH	73	static DEVICE_ATTR(forward_delay, S_IRUGO \| S_IWUSR,
43cb76d9 GKH	74	show_forward_delay, store_forward_delay);
1da177e4	75
43cb76d9 GKH	76	static ssize_t show_hello_time(struct device d, struct device_attribute attr,
43cb76d9 GKH	77	char *buf)
1da177e4 LT	78	{
1da177e4 LT	79	return sprintf(buf, "%lu\n",
43cb76d9	80	jiffies_to_clock_t(to_bridge(d)->hello_time));
1da177e4 LT	81	}
	82
	83	static void set_hello_time(struct net_bridge *br, unsigned long val)
	84	{
	85	unsigned long t = clock_t_to_jiffies(val);
	86	br->hello_time = t;
	87	if (br_is_root_bridge(br))
	88	br->bridge_hello_time = t;
	89	}
	90
43cb76d9 GKH	91	static ssize_t store_hello_time(struct device *d,
43cb76d9 GKH	92	struct device_attribute attr, const char buf,
1da177e4 LT	93	size_t len)
1da177e4 LT	94	{
43cb76d9	95	return store_bridge_parm(d, buf, len, set_hello_time);
1da177e4	96	}
43cb76d9 GKH	97	static DEVICE_ATTR(hello_time, S_IRUGO \| S_IWUSR, show_hello_time,
43cb76d9 GKH	98	store_hello_time);
1da177e4	99
43cb76d9 GKH	100	static ssize_t show_max_age(struct device d, struct device_attribute attr,
43cb76d9 GKH	101	char *buf)
1da177e4 LT	102	{
1da177e4 LT	103	return sprintf(buf, "%lu\n",
43cb76d9	104	jiffies_to_clock_t(to_bridge(d)->max_age));
1da177e4 LT	105	}
	106
	107	static void set_max_age(struct net_bridge *br, unsigned long val)
	108	{
	109	unsigned long t = clock_t_to_jiffies(val);
	110	br->max_age = t;
	111	if (br_is_root_bridge(br))
	112	br->bridge_max_age = t;
	113	}
	114
43cb76d9 GKH	115	static ssize_t store_max_age(struct device d, struct device_attribute attr,
43cb76d9 GKH	116	const char *buf, size_t len)
1da177e4	117	{
43cb76d9	118	return store_bridge_parm(d, buf, len, set_max_age);
1da177e4	119	}
43cb76d9	120	static DEVICE_ATTR(max_age, S_IRUGO \| S_IWUSR, show_max_age, store_max_age);
1da177e4	121
43cb76d9 GKH	122	static ssize_t show_ageing_time(struct device *d,
43cb76d9 GKH	123	struct device_attribute attr, char buf)
1da177e4	124	{
43cb76d9	125	struct net_bridge *br = to_bridge(d);
1da177e4 LT	126	return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
	127	}
	128
	129	static void set_ageing_time(struct net_bridge *br, unsigned long val)
	130	{
	131	br->ageing_time = clock_t_to_jiffies(val);
	132	}
	133
43cb76d9 GKH	134	static ssize_t store_ageing_time(struct device *d,
	135	struct device_attribute *attr,
	136	const char *buf, size_t len)
1da177e4	137	{
43cb76d9	138	return store_bridge_parm(d, buf, len, set_ageing_time);
1da177e4	139	}
43cb76d9 GKH	140	static DEVICE_ATTR(ageing_time, S_IRUGO \| S_IWUSR, show_ageing_time,
43cb76d9 GKH	141	store_ageing_time);
1da177e4	142
43cb76d9 GKH	143	static ssize_t show_stp_state(struct device *d,
43cb76d9 GKH	144	struct device_attribute attr, char buf)
1da177e4	145	{
43cb76d9	146	struct net_bridge *br = to_bridge(d);
1da177e4 LT	147	return sprintf(buf, "%d\n", br->stp_enabled);
	148	}
	149
	150	static void set_stp_state(struct net_bridge *br, unsigned long val)
	151	{
98486fa2	152	rtnl_lock();
9cde0708 SH	153	spin_unlock_bh(&br->lock);
	154	br_stp_set_enabled(br, val);
	155	spin_lock_bh(&br->lock);
98486fa2	156	rtnl_unlock();
1da177e4 LT	157	}
1da177e4 LT	158
43cb76d9 GKH	159	static ssize_t store_stp_state(struct device *d,
	160	struct device_attribute attr, const char buf,
	161	size_t len)
1da177e4	162	{
43cb76d9	163	return store_bridge_parm(d, buf, len, set_stp_state);
1da177e4	164	}
43cb76d9 GKH	165	static DEVICE_ATTR(stp_state, S_IRUGO \| S_IWUSR, show_stp_state,
43cb76d9 GKH	166	store_stp_state);
1da177e4	167
43cb76d9 GKH	168	static ssize_t show_priority(struct device d, struct device_attribute attr,
43cb76d9 GKH	169	char *buf)
1da177e4	170	{
43cb76d9	171	struct net_bridge *br = to_bridge(d);
1da177e4 LT	172	return sprintf(buf, "%d\n",
	173	(br->bridge_id.prio[0] << 8) \| br->bridge_id.prio[1]);
	174	}
	175
	176	static void set_priority(struct net_bridge *br, unsigned long val)
	177	{
	178	br_stp_set_bridge_priority(br, (u16) val);
	179	}
	180
43cb76d9	181	static ssize_t store_priority(struct device d, struct device_attribute attr,
1da177e4 LT	182	const char *buf, size_t len)
1da177e4 LT	183	{
43cb76d9	184	return store_bridge_parm(d, buf, len, set_priority);
1da177e4	185	}
43cb76d9	186	static DEVICE_ATTR(priority, S_IRUGO \| S_IWUSR, show_priority, store_priority);
1da177e4	187
43cb76d9 GKH	188	static ssize_t show_root_id(struct device d, struct device_attribute attr,
43cb76d9 GKH	189	char *buf)
1da177e4	190	{
43cb76d9	191	return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
1da177e4	192	}
43cb76d9	193	static DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);
1da177e4	194
43cb76d9 GKH	195	static ssize_t show_bridge_id(struct device d, struct device_attribute attr,
43cb76d9 GKH	196	char *buf)
1da177e4	197	{
43cb76d9	198	return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
1da177e4	199	}
43cb76d9	200	static DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);
1da177e4	201
43cb76d9 GKH	202	static ssize_t show_root_port(struct device d, struct device_attribute attr,
43cb76d9 GKH	203	char *buf)
1da177e4	204	{
43cb76d9	205	return sprintf(buf, "%d\n", to_bridge(d)->root_port);
1da177e4	206	}
43cb76d9	207	static DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);
1da177e4	208
43cb76d9 GKH	209	static ssize_t show_root_path_cost(struct device *d,
43cb76d9 GKH	210	struct device_attribute attr, char buf)
1da177e4	211	{
43cb76d9	212	return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
1da177e4	213	}
43cb76d9	214	static DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);
1da177e4	215
43cb76d9 GKH	216	static ssize_t show_topology_change(struct device *d,
43cb76d9 GKH	217	struct device_attribute attr, char buf)
1da177e4	218	{
43cb76d9	219	return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
1da177e4	220	}
43cb76d9	221	static DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);
1da177e4	222
43cb76d9 GKH	223	static ssize_t show_topology_change_detected(struct device *d,
	224	struct device_attribute *attr,
	225	char *buf)
1da177e4	226	{
43cb76d9	227	struct net_bridge *br = to_bridge(d);
1da177e4 LT	228	return sprintf(buf, "%d\n", br->topology_change_detected);
1da177e4 LT	229	}
43cb76d9 GKH	230	static DEVICE_ATTR(topology_change_detected, S_IRUGO,
43cb76d9 GKH	231	show_topology_change_detected, NULL);
1da177e4	232
43cb76d9 GKH	233	static ssize_t show_hello_timer(struct device *d,
43cb76d9 GKH	234	struct device_attribute attr, char buf)
1da177e4	235	{
43cb76d9	236	struct net_bridge *br = to_bridge(d);
1da177e4 LT	237	return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
1da177e4 LT	238	}
43cb76d9	239	static DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);
1da177e4	240
43cb76d9 GKH	241	static ssize_t show_tcn_timer(struct device d, struct device_attribute attr,
43cb76d9 GKH	242	char *buf)
1da177e4	243	{
43cb76d9	244	struct net_bridge *br = to_bridge(d);
1da177e4 LT	245	return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
1da177e4 LT	246	}
43cb76d9	247	static DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);
1da177e4	248
43cb76d9 GKH	249	static ssize_t show_topology_change_timer(struct device *d,
	250	struct device_attribute *attr,
	251	char *buf)
1da177e4	252	{
43cb76d9	253	struct net_bridge *br = to_bridge(d);
1da177e4 LT	254	return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
1da177e4 LT	255	}
43cb76d9 GKH	256	static DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer,
43cb76d9 GKH	257	NULL);
1da177e4	258
43cb76d9 GKH	259	static ssize_t show_gc_timer(struct device d, struct device_attribute attr,
43cb76d9 GKH	260	char *buf)
1da177e4	261	{
43cb76d9	262	struct net_bridge *br = to_bridge(d);
1da177e4 LT	263	return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer));
1da177e4 LT	264	}
43cb76d9	265	static DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);
1da177e4	266
43cb76d9 GKH	267	static ssize_t show_group_addr(struct device *d,
43cb76d9 GKH	268	struct device_attribute attr, char buf)
fda93d92	269	{
43cb76d9	270	struct net_bridge *br = to_bridge(d);
fda93d92 SH	271	return sprintf(buf, "%x:%x:%x:%x:%x:%x\n",
	272	br->group_addr[0], br->group_addr[1],
	273	br->group_addr[2], br->group_addr[3],
	274	br->group_addr[4], br->group_addr[5]);
	275	}
	276
43cb76d9 GKH	277	static ssize_t store_group_addr(struct device *d,
	278	struct device_attribute *attr,
	279	const char *buf, size_t len)
fda93d92	280	{
43cb76d9	281	struct net_bridge *br = to_bridge(d);
fda93d92 SH	282	unsigned new_addr[6];
	283	int i;
	284
	285	if (!capable(CAP_NET_ADMIN))
	286	return -EPERM;
	287
	288	if (sscanf(buf, "%x:%x:%x:%x:%x:%x",
	289	&new_addr[0], &new_addr[1], &new_addr[2],
	290	&new_addr[3], &new_addr[4], &new_addr[5]) != 6)
	291	return -EINVAL;
	292
	293	/* Must be 01:80:c2:00:00:0X */
	294	for (i = 0; i < 5; i++)
	295	if (new_addr[i] != br_group_address[i])
	296	return -EINVAL;
	297
	298	if (new_addr[5] & ~0xf)
	299	return -EINVAL;
	300
	301	if (new_addr[5] == 1 /* 802.3x Pause address */
	302	\|\| new_addr[5] == 2 /* 802.3ad Slow protocols */
	303	\|\| new_addr[5] == 3) /* 802.1X PAE address */
	304	return -EINVAL;
	305
	306	spin_lock_bh(&br->lock);
	307	for (i = 0; i < 6; i++)
	308	br->group_addr[i] = new_addr[i];
	309	spin_unlock_bh(&br->lock);
	310	return len;
	311	}
	312
43cb76d9 GKH	313	static DEVICE_ATTR(group_addr, S_IRUGO \| S_IWUSR,
43cb76d9 GKH	314	show_group_addr, store_group_addr);
fda93d92	315
9cf63747 SH	316	static ssize_t store_flush(struct device *d,
	317	struct device_attribute *attr,
	318	const char *buf, size_t len)
	319	{
	320	struct net_bridge *br = to_bridge(d);
	321
	322	if (!capable(CAP_NET_ADMIN))
	323	return -EPERM;
	324
	325	br_fdb_flush(br);
	326	return len;
	327	}
	328	static DEVICE_ATTR(flush, S_IWUSR, NULL, store_flush);
fda93d92	329
1da177e4	330	static struct attribute *bridge_attrs[] = {
43cb76d9 GKH	331	&dev_attr_forward_delay.attr,
	332	&dev_attr_hello_time.attr,
	333	&dev_attr_max_age.attr,
	334	&dev_attr_ageing_time.attr,
	335	&dev_attr_stp_state.attr,
	336	&dev_attr_priority.attr,
	337	&dev_attr_bridge_id.attr,
	338	&dev_attr_root_id.attr,
	339	&dev_attr_root_path_cost.attr,
	340	&dev_attr_root_port.attr,
	341	&dev_attr_topology_change.attr,
	342	&dev_attr_topology_change_detected.attr,
	343	&dev_attr_hello_timer.attr,
	344	&dev_attr_tcn_timer.attr,
	345	&dev_attr_topology_change_timer.attr,
	346	&dev_attr_gc_timer.attr,
	347	&dev_attr_group_addr.attr,
9cf63747	348	&dev_attr_flush.attr,
1da177e4 LT	349	NULL
	350	};
	351
	352	static struct attribute_group bridge_group = {
	353	.name = SYSFS_BRIDGE_ATTR,
	354	.attrs = bridge_attrs,
	355	};
	356
	357	/*
	358	* Export the forwarding information table as a binary file
	359	* The records are struct __fdb_entry.
	360	*
	361	* Returns the number of bytes read.
	362	*/
91a69029 ZR	363	static ssize_t brforward_read(struct kobject *kobj,
	364	struct bin_attribute *bin_attr,
	365	char *buf, loff_t off, size_t count)
1da177e4	366	{
43cb76d9 GKH	367	struct device *dev = to_dev(kobj);
43cb76d9 GKH	368	struct net_bridge *br = to_bridge(dev);
1da177e4 LT	369	int n;
	370
	371	/* must read whole records */
	372	if (off % sizeof(struct __fdb_entry) != 0)
	373	return -EINVAL;
	374
9d6f229f	375	n = br_fdb_fillbuf(br, buf,
1da177e4 LT	376	count / sizeof(struct __fdb_entry),
	377	off / sizeof(struct __fdb_entry));
	378
	379	if (n > 0)
	380	n *= sizeof(struct __fdb_entry);
9d6f229f	381
1da177e4 LT	382	return n;
	383	}
	384
	385	static struct bin_attribute bridge_forward = {
	386	.attr = { .name = SYSFS_BRIDGE_FDB,
7b595756	387	.mode = S_IRUGO, },
1da177e4 LT	388	.read = brforward_read,
	389	};
	390
	391	/*
	392	* Add entries in sysfs onto the existing network class device
	393	* for the bridge.
	394	* Adds a attribute group "bridge" containing tuning parameters.
	395	* Binary attribute containing the forward table
	396	* Sub directory to hold links to interfaces.
	397	*
	398	* Note: the ifobj exists only to be a subdirectory
	399	* to hold links. The ifobj exists in same data structure
	400	* as it's parent the bridge so reference counting works.
	401	*/
	402	int br_sysfs_addbr(struct net_device *dev)
	403	{
43cb76d9	404	struct kobject *brobj = &dev->dev.kobj;
1da177e4 LT	405	struct net_bridge *br = netdev_priv(dev);
	406	int err;
	407
	408	err = sysfs_create_group(brobj, &bridge_group);
	409	if (err) {
	410	pr_info("%s: can't create group %s/%s\n",
	411	__FUNCTION__, dev->name, bridge_group.name);
	412	goto out1;
	413	}
	414
	415	err = sysfs_create_bin_file(brobj, &bridge_forward);
	416	if (err) {
1842c4be	417	pr_info("%s: can't create attribute file %s/%s\n",
1da177e4 LT	418	__FUNCTION__, dev->name, bridge_forward.attr.name);
	419	goto out2;
	420	}
	421
9d6f229f	422
1da177e4 LT	423	kobject_set_name(&br->ifobj, SYSFS_BRIDGE_PORT_SUBDIR);
	424	br->ifobj.ktype = NULL;
	425	br->ifobj.kset = NULL;
	426	br->ifobj.parent = brobj;
	427
	428	err = kobject_register(&br->ifobj);
	429	if (err) {
	430	pr_info("%s: can't add kobject (directory) %s/%s\n",
	431	__FUNCTION__, dev->name, br->ifobj.name);
	432	goto out3;
	433	}
	434	return 0;
	435	out3:
43cb76d9	436	sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
1da177e4	437	out2:
43cb76d9	438	sysfs_remove_group(&dev->dev.kobj, &bridge_group);
1da177e4 LT	439	out1:
	440	return err;
	441
	442	}
	443
	444	void br_sysfs_delbr(struct net_device *dev)
	445	{
43cb76d9	446	struct kobject *kobj = &dev->dev.kobj;
1da177e4 LT	447	struct net_bridge *br = netdev_priv(dev);
	448
	449	kobject_unregister(&br->ifobj);
	450	sysfs_remove_bin_file(kobj, &bridge_forward);
	451	sysfs_remove_group(kobj, &bridge_group);
	452	}