[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 void set_stp_state(struct net_bridge *br, unsigned long val)
{
	spin_unlock_bh(&br->lock);
	br_stp_set_enabled(br, val);
	spin_lock_bh(&br->lock);
}

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