[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)
{
	br->stp_enabled = val;
}

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