[linux-2.6-block.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();

	return len;
}
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",
			__func__, 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",
			__func__, dev->name, bridge_forward.attr.name);
		goto out2;
	}

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