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

/*
 *	Sysfs attributes of bridge ports
 *	Linux ethernet bridge
 *
 *	Authors:
 *	Stephen Hemminger		<shemminger@osdl.org>
 *
 *	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 ssize_t store_stp_state(struct device *d,
			       struct device_attribute *attr, const char *buf,
			       size_t len)
{
	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;

	rtnl_lock();
	br_stp_set_enabled(br, val);
	rtnl_unlock();

}
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 <shemminger@osdl.org>
	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
1da177e4	150
43cb76d9 GKH	151	static ssize_t store_stp_state(struct device *d,
	152	struct device_attribute attr, const char buf,
	153	size_t len)
1da177e4	154	{
17120889 SH	155	struct net_bridge *br = to_bridge(d);
	156	char *endp;
	157	unsigned long val;
	158
	159	if (!capable(CAP_NET_ADMIN))
	160	return -EPERM;
	161
	162	val = simple_strtoul(buf, &endp, 0);
	163	if (endp == buf)
	164	return -EINVAL;
	165
	166	rtnl_lock();
	167	br_stp_set_enabled(br, val);
	168	rtnl_unlock();
	169
1da177e4	170	}
43cb76d9 GKH	171	static DEVICE_ATTR(stp_state, S_IRUGO \| S_IWUSR, show_stp_state,
43cb76d9 GKH	172	store_stp_state);
1da177e4	173
43cb76d9 GKH	174	static ssize_t show_priority(struct device d, struct device_attribute attr,
43cb76d9 GKH	175	char *buf)
1da177e4	176	{
43cb76d9	177	struct net_bridge *br = to_bridge(d);
1da177e4 LT	178	return sprintf(buf, "%d\n",
	179	(br->bridge_id.prio[0] << 8) \| br->bridge_id.prio[1]);
	180	}
	181
	182	static void set_priority(struct net_bridge *br, unsigned long val)
	183	{
	184	br_stp_set_bridge_priority(br, (u16) val);
	185	}
	186
43cb76d9	187	static ssize_t store_priority(struct device d, struct device_attribute attr,
1da177e4 LT	188	const char *buf, size_t len)
1da177e4 LT	189	{
43cb76d9	190	return store_bridge_parm(d, buf, len, set_priority);
1da177e4	191	}
43cb76d9	192	static DEVICE_ATTR(priority, S_IRUGO \| S_IWUSR, show_priority, store_priority);
1da177e4	193
43cb76d9 GKH	194	static ssize_t show_root_id(struct device d, struct device_attribute attr,
43cb76d9 GKH	195	char *buf)
1da177e4	196	{
43cb76d9	197	return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
1da177e4	198	}
43cb76d9	199	static DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);
1da177e4	200
43cb76d9 GKH	201	static ssize_t show_bridge_id(struct device d, struct device_attribute attr,
43cb76d9 GKH	202	char *buf)
1da177e4	203	{
43cb76d9	204	return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
1da177e4	205	}
43cb76d9	206	static DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);
1da177e4	207
43cb76d9 GKH	208	static ssize_t show_root_port(struct device d, struct device_attribute attr,
43cb76d9 GKH	209	char *buf)
1da177e4	210	{
43cb76d9	211	return sprintf(buf, "%d\n", to_bridge(d)->root_port);
1da177e4	212	}
43cb76d9	213	static DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);
1da177e4	214
43cb76d9 GKH	215	static ssize_t show_root_path_cost(struct device *d,
43cb76d9 GKH	216	struct device_attribute attr, char buf)
1da177e4	217	{
43cb76d9	218	return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
1da177e4	219	}
43cb76d9	220	static DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);
1da177e4	221
43cb76d9 GKH	222	static ssize_t show_topology_change(struct device *d,
43cb76d9 GKH	223	struct device_attribute attr, char buf)
1da177e4	224	{
43cb76d9	225	return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
1da177e4	226	}
43cb76d9	227	static DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);
1da177e4	228
43cb76d9 GKH	229	static ssize_t show_topology_change_detected(struct device *d,
	230	struct device_attribute *attr,
	231	char *buf)
1da177e4	232	{
43cb76d9	233	struct net_bridge *br = to_bridge(d);
1da177e4 LT	234	return sprintf(buf, "%d\n", br->topology_change_detected);
1da177e4 LT	235	}
43cb76d9 GKH	236	static DEVICE_ATTR(topology_change_detected, S_IRUGO,
43cb76d9 GKH	237	show_topology_change_detected, NULL);
1da177e4	238
43cb76d9 GKH	239	static ssize_t show_hello_timer(struct device *d,
43cb76d9 GKH	240	struct device_attribute attr, char buf)
1da177e4	241	{
43cb76d9	242	struct net_bridge *br = to_bridge(d);
1da177e4 LT	243	return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
1da177e4 LT	244	}
43cb76d9	245	static DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);
1da177e4	246
43cb76d9 GKH	247	static ssize_t show_tcn_timer(struct device d, struct device_attribute attr,
43cb76d9 GKH	248	char *buf)
1da177e4	249	{
43cb76d9	250	struct net_bridge *br = to_bridge(d);
1da177e4 LT	251	return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
1da177e4 LT	252	}
43cb76d9	253	static DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);
1da177e4	254
43cb76d9 GKH	255	static ssize_t show_topology_change_timer(struct device *d,
	256	struct device_attribute *attr,
	257	char *buf)
1da177e4	258	{
43cb76d9	259	struct net_bridge *br = to_bridge(d);
1da177e4 LT	260	return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
1da177e4 LT	261	}
43cb76d9 GKH	262	static DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer,
43cb76d9 GKH	263	NULL);
1da177e4	264
43cb76d9 GKH	265	static ssize_t show_gc_timer(struct device d, struct device_attribute attr,
43cb76d9 GKH	266	char *buf)
1da177e4	267	{
43cb76d9	268	struct net_bridge *br = to_bridge(d);
1da177e4 LT	269	return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer));
1da177e4 LT	270	}
43cb76d9	271	static DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);
1da177e4	272
43cb76d9 GKH	273	static ssize_t show_group_addr(struct device *d,
43cb76d9 GKH	274	struct device_attribute attr, char buf)
fda93d92	275	{
43cb76d9	276	struct net_bridge *br = to_bridge(d);
fda93d92 SH	277	return sprintf(buf, "%x:%x:%x:%x:%x:%x\n",
	278	br->group_addr[0], br->group_addr[1],
	279	br->group_addr[2], br->group_addr[3],
	280	br->group_addr[4], br->group_addr[5]);
	281	}
	282
43cb76d9 GKH	283	static ssize_t store_group_addr(struct device *d,
	284	struct device_attribute *attr,
	285	const char *buf, size_t len)
fda93d92	286	{
43cb76d9	287	struct net_bridge *br = to_bridge(d);
fda93d92 SH	288	unsigned new_addr[6];
	289	int i;
	290
	291	if (!capable(CAP_NET_ADMIN))
	292	return -EPERM;
	293
	294	if (sscanf(buf, "%x:%x:%x:%x:%x:%x",
	295	&new_addr[0], &new_addr[1], &new_addr[2],
	296	&new_addr[3], &new_addr[4], &new_addr[5]) != 6)
	297	return -EINVAL;
	298
	299	/* Must be 01:80:c2:00:00:0X */
	300	for (i = 0; i < 5; i++)
	301	if (new_addr[i] != br_group_address[i])
	302	return -EINVAL;
	303
	304	if (new_addr[5] & ~0xf)
	305	return -EINVAL;
	306
	307	if (new_addr[5] == 1 /* 802.3x Pause address */
	308	\|\| new_addr[5] == 2 /* 802.3ad Slow protocols */
	309	\|\| new_addr[5] == 3) /* 802.1X PAE address */
	310	return -EINVAL;
	311
	312	spin_lock_bh(&br->lock);
	313	for (i = 0; i < 6; i++)
	314	br->group_addr[i] = new_addr[i];
	315	spin_unlock_bh(&br->lock);
	316	return len;
	317	}
	318
43cb76d9 GKH	319	static DEVICE_ATTR(group_addr, S_IRUGO \| S_IWUSR,
43cb76d9 GKH	320	show_group_addr, store_group_addr);
fda93d92	321
9cf63747 SH	322	static ssize_t store_flush(struct device *d,
	323	struct device_attribute *attr,
	324	const char *buf, size_t len)
	325	{
	326	struct net_bridge *br = to_bridge(d);
	327
	328	if (!capable(CAP_NET_ADMIN))
	329	return -EPERM;
	330
	331	br_fdb_flush(br);
	332	return len;
	333	}
	334	static DEVICE_ATTR(flush, S_IWUSR, NULL, store_flush);
fda93d92	335
1da177e4	336	static struct attribute *bridge_attrs[] = {
43cb76d9 GKH	337	&dev_attr_forward_delay.attr,
	338	&dev_attr_hello_time.attr,
	339	&dev_attr_max_age.attr,
	340	&dev_attr_ageing_time.attr,
	341	&dev_attr_stp_state.attr,
	342	&dev_attr_priority.attr,
	343	&dev_attr_bridge_id.attr,
	344	&dev_attr_root_id.attr,
	345	&dev_attr_root_path_cost.attr,
	346	&dev_attr_root_port.attr,
	347	&dev_attr_topology_change.attr,
	348	&dev_attr_topology_change_detected.attr,
	349	&dev_attr_hello_timer.attr,
	350	&dev_attr_tcn_timer.attr,
	351	&dev_attr_topology_change_timer.attr,
	352	&dev_attr_gc_timer.attr,
	353	&dev_attr_group_addr.attr,
9cf63747	354	&dev_attr_flush.attr,
1da177e4 LT	355	NULL
	356	};
	357
	358	static struct attribute_group bridge_group = {
	359	.name = SYSFS_BRIDGE_ATTR,
	360	.attrs = bridge_attrs,
	361	};
	362
	363	/*
	364	* Export the forwarding information table as a binary file
	365	* The records are struct __fdb_entry.
	366	*
	367	* Returns the number of bytes read.
	368	*/
91a69029 ZR	369	static ssize_t brforward_read(struct kobject *kobj,
	370	struct bin_attribute *bin_attr,
	371	char *buf, loff_t off, size_t count)
1da177e4	372	{
43cb76d9 GKH	373	struct device *dev = to_dev(kobj);
43cb76d9 GKH	374	struct net_bridge *br = to_bridge(dev);
1da177e4 LT	375	int n;
	376
	377	/* must read whole records */
	378	if (off % sizeof(struct __fdb_entry) != 0)
	379	return -EINVAL;
	380
9d6f229f	381	n = br_fdb_fillbuf(br, buf,
1da177e4 LT	382	count / sizeof(struct __fdb_entry),
	383	off / sizeof(struct __fdb_entry));
	384
	385	if (n > 0)
	386	n *= sizeof(struct __fdb_entry);
9d6f229f	387
1da177e4 LT	388	return n;
	389	}
	390
	391	static struct bin_attribute bridge_forward = {
	392	.attr = { .name = SYSFS_BRIDGE_FDB,
7b595756	393	.mode = S_IRUGO, },
1da177e4 LT	394	.read = brforward_read,
	395	};
	396
	397	/*
	398	* Add entries in sysfs onto the existing network class device
	399	* for the bridge.
	400	* Adds a attribute group "bridge" containing tuning parameters.
	401	* Binary attribute containing the forward table
	402	* Sub directory to hold links to interfaces.
	403	*
	404	* Note: the ifobj exists only to be a subdirectory
	405	* to hold links. The ifobj exists in same data structure
	406	* as it's parent the bridge so reference counting works.
	407	*/
	408	int br_sysfs_addbr(struct net_device *dev)
	409	{
43cb76d9	410	struct kobject *brobj = &dev->dev.kobj;
1da177e4 LT	411	struct net_bridge *br = netdev_priv(dev);
	412	int err;
	413
	414	err = sysfs_create_group(brobj, &bridge_group);
	415	if (err) {
	416	pr_info("%s: can't create group %s/%s\n",
	417	__FUNCTION__, dev->name, bridge_group.name);
	418	goto out1;
	419	}
	420
	421	err = sysfs_create_bin_file(brobj, &bridge_forward);
	422	if (err) {
1842c4be	423	pr_info("%s: can't create attribute file %s/%s\n",
1da177e4 LT	424	__FUNCTION__, dev->name, bridge_forward.attr.name);
	425	goto out2;
	426	}
	427
9d6f229f	428
1da177e4 LT	429	kobject_set_name(&br->ifobj, SYSFS_BRIDGE_PORT_SUBDIR);
	430	br->ifobj.ktype = NULL;
	431	br->ifobj.kset = NULL;
	432	br->ifobj.parent = brobj;
	433
	434	err = kobject_register(&br->ifobj);
	435	if (err) {
	436	pr_info("%s: can't add kobject (directory) %s/%s\n",
	437	__FUNCTION__, dev->name, br->ifobj.name);
	438	goto out3;
	439	}
	440	return 0;
	441	out3:
43cb76d9	442	sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
1da177e4	443	out2:
43cb76d9	444	sysfs_remove_group(&dev->dev.kobj, &bridge_group);
1da177e4 LT	445	out1:
	446	return err;
	447
	448	}
	449
	450	void br_sysfs_delbr(struct net_device *dev)
	451	{
43cb76d9	452	struct kobject *kobj = &dev->dev.kobj;
1da177e4 LT	453	struct net_bridge *br = netdev_priv(dev);
	454
	455	kobject_unregister(&br->ifobj);
	456	sysfs_remove_bin_file(kobj, &bridge_forward);
	457	sysfs_remove_group(kobj, &bridge_group);
	458	}