blob: c236c0e439848342f2d5c3825b33b6c8bdc6ab47 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Randy Dunlap4fc268d2006-01-11 12:17:47 -080014#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#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
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070024#define to_dev(obj) container_of(obj, struct device, kobj)
Wang Chen524ad0a2008-11-12 23:39:10 -080025#define to_bridge(cd) ((struct net_bridge *)netdev_priv(to_net_dev(cd)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27/*
28 * Common code for storing bridge parameters.
29 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070030static ssize_t store_bridge_parm(struct device *d,
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 const char *buf, size_t len,
Stephen Hemminger8d4698f2008-09-08 13:44:40 -070032 int (*set)(struct net_bridge *, unsigned long))
Linus Torvalds1da177e2005-04-16 15:20:36 -070033{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070034 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 char *endp;
36 unsigned long val;
Stephen Hemminger8d4698f2008-09-08 13:44:40 -070037 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39 if (!capable(CAP_NET_ADMIN))
40 return -EPERM;
41
42 val = simple_strtoul(buf, &endp, 0);
43 if (endp == buf)
44 return -EINVAL;
45
Stephen Hemminger8d4698f2008-09-08 13:44:40 -070046 err = (*set)(br, val);
Stephen Hemminger8d4698f2008-09-08 13:44:40 -070047 return err ? err : len;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048}
49
50
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070051static ssize_t show_forward_delay(struct device *d,
52 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070054 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay));
56}
57
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070058static ssize_t store_forward_delay(struct device *d,
59 struct device_attribute *attr,
60 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061{
stephen hemminger14f98f22011-04-04 14:03:33 +000062 return store_bridge_parm(d, buf, len, br_set_forward_delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070064static DEVICE_ATTR(forward_delay, S_IRUGO | S_IWUSR,
65 show_forward_delay, store_forward_delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070067static ssize_t show_hello_time(struct device *d, struct device_attribute *attr,
68 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069{
70 return sprintf(buf, "%lu\n",
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070071 jiffies_to_clock_t(to_bridge(d)->hello_time));
Linus Torvalds1da177e2005-04-16 15:20:36 -070072}
73
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070074static ssize_t store_hello_time(struct device *d,
75 struct device_attribute *attr, const char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 size_t len)
77{
stephen hemminger14f98f22011-04-04 14:03:33 +000078 return store_bridge_parm(d, buf, len, br_set_hello_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070080static DEVICE_ATTR(hello_time, S_IRUGO | S_IWUSR, show_hello_time,
81 store_hello_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070083static ssize_t show_max_age(struct device *d, struct device_attribute *attr,
84 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085{
86 return sprintf(buf, "%lu\n",
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070087 jiffies_to_clock_t(to_bridge(d)->max_age));
Linus Torvalds1da177e2005-04-16 15:20:36 -070088}
89
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070090static ssize_t store_max_age(struct device *d, struct device_attribute *attr,
91 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
stephen hemminger14f98f22011-04-04 14:03:33 +000093 return store_bridge_parm(d, buf, len, br_set_max_age);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070095static DEVICE_ATTR(max_age, S_IRUGO | S_IWUSR, show_max_age, store_max_age);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070097static ssize_t show_ageing_time(struct device *d,
98 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700100 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
102}
103
Stephen Hemminger8d4698f2008-09-08 13:44:40 -0700104static int set_ageing_time(struct net_bridge *br, unsigned long val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
106 br->ageing_time = clock_t_to_jiffies(val);
Stephen Hemminger8d4698f2008-09-08 13:44:40 -0700107 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
109
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700110static ssize_t store_ageing_time(struct device *d,
111 struct device_attribute *attr,
112 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700114 return store_bridge_parm(d, buf, len, set_ageing_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700116static DEVICE_ATTR(ageing_time, S_IRUGO | S_IWUSR, show_ageing_time,
117 store_ageing_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700119static ssize_t show_stp_state(struct device *d,
120 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700122 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 return sprintf(buf, "%d\n", br->stp_enabled);
124}
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700127static ssize_t store_stp_state(struct device *d,
128 struct device_attribute *attr, const char *buf,
129 size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
Stephen Hemminger17120882007-08-14 13:21:34 -0700131 struct net_bridge *br = to_bridge(d);
132 char *endp;
133 unsigned long val;
134
135 if (!capable(CAP_NET_ADMIN))
136 return -EPERM;
137
138 val = simple_strtoul(buf, &endp, 0);
139 if (endp == buf)
140 return -EINVAL;
141
Eric W. Biedermanaf38f292009-05-13 17:00:41 +0000142 if (!rtnl_trylock())
143 return restart_syscall();
Stephen Hemminger17120882007-08-14 13:21:34 -0700144 br_stp_set_enabled(br, val);
145 rtnl_unlock();
146
Al Viro35b426c2007-08-19 04:51:26 +0100147 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700149static DEVICE_ATTR(stp_state, S_IRUGO | S_IWUSR, show_stp_state,
150 store_stp_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
stephen hemminger515853c2011-10-03 18:14:46 +0000152static ssize_t show_group_fwd_mask(struct device *d,
153 struct device_attribute *attr, char *buf)
154{
155 struct net_bridge *br = to_bridge(d);
156 return sprintf(buf, "%#x\n", br->group_fwd_mask);
157}
158
159
160static ssize_t store_group_fwd_mask(struct device *d,
161 struct device_attribute *attr, const char *buf,
162 size_t len)
163{
164 struct net_bridge *br = to_bridge(d);
165 char *endp;
166 unsigned long val;
167
168 if (!capable(CAP_NET_ADMIN))
169 return -EPERM;
170
171 val = simple_strtoul(buf, &endp, 0);
172 if (endp == buf)
173 return -EINVAL;
174
175 if (val & BR_GROUPFWD_RESTRICTED)
176 return -EINVAL;
177
178 br->group_fwd_mask = val;
179
180 return len;
181}
182static DEVICE_ATTR(group_fwd_mask, S_IRUGO | S_IWUSR, show_group_fwd_mask,
183 store_group_fwd_mask);
184
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700185static ssize_t show_priority(struct device *d, struct device_attribute *attr,
186 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700188 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 return sprintf(buf, "%d\n",
190 (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]);
191}
192
Stephen Hemminger8d4698f2008-09-08 13:44:40 -0700193static int set_priority(struct net_bridge *br, unsigned long val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194{
195 br_stp_set_bridge_priority(br, (u16) val);
Stephen Hemminger8d4698f2008-09-08 13:44:40 -0700196 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197}
198
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700199static ssize_t store_priority(struct device *d, struct device_attribute *attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 const char *buf, size_t len)
201{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700202 return store_bridge_parm(d, buf, len, set_priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700204static DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, show_priority, store_priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700206static ssize_t show_root_id(struct device *d, struct device_attribute *attr,
207 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700209 return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700211static DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700213static ssize_t show_bridge_id(struct device *d, struct device_attribute *attr,
214 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700216 return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700218static DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700220static ssize_t show_root_port(struct device *d, struct device_attribute *attr,
221 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700223 return sprintf(buf, "%d\n", to_bridge(d)->root_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700225static DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700227static ssize_t show_root_path_cost(struct device *d,
228 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700230 return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700232static DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700234static ssize_t show_topology_change(struct device *d,
235 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700237 return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700239static DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700241static ssize_t show_topology_change_detected(struct device *d,
242 struct device_attribute *attr,
243 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700245 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 return sprintf(buf, "%d\n", br->topology_change_detected);
247}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700248static DEVICE_ATTR(topology_change_detected, S_IRUGO,
249 show_topology_change_detected, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700251static ssize_t show_hello_timer(struct device *d,
252 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700254 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
256}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700257static DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700259static ssize_t show_tcn_timer(struct device *d, struct device_attribute *attr,
260 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700262 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
264}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700265static DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700267static ssize_t show_topology_change_timer(struct device *d,
268 struct device_attribute *attr,
269 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700271 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
273}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700274static DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer,
275 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700277static ssize_t show_gc_timer(struct device *d, struct device_attribute *attr,
278 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700280 struct net_bridge *br = to_bridge(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer));
282}
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700283static DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700285static ssize_t show_group_addr(struct device *d,
286 struct device_attribute *attr, char *buf)
Stephen Hemmingerfda93d92006-03-20 22:59:21 -0800287{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700288 struct net_bridge *br = to_bridge(d);
Stephen Hemmingerfda93d92006-03-20 22:59:21 -0800289 return sprintf(buf, "%x:%x:%x:%x:%x:%x\n",
290 br->group_addr[0], br->group_addr[1],
291 br->group_addr[2], br->group_addr[3],
292 br->group_addr[4], br->group_addr[5]);
293}
294
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700295static ssize_t store_group_addr(struct device *d,
296 struct device_attribute *attr,
297 const char *buf, size_t len)
Stephen Hemmingerfda93d92006-03-20 22:59:21 -0800298{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700299 struct net_bridge *br = to_bridge(d);
Stephen Hemmingerfda93d92006-03-20 22:59:21 -0800300 unsigned new_addr[6];
301 int i;
302
303 if (!capable(CAP_NET_ADMIN))
304 return -EPERM;
305
306 if (sscanf(buf, "%x:%x:%x:%x:%x:%x",
307 &new_addr[0], &new_addr[1], &new_addr[2],
308 &new_addr[3], &new_addr[4], &new_addr[5]) != 6)
309 return -EINVAL;
310
311 /* Must be 01:80:c2:00:00:0X */
312 for (i = 0; i < 5; i++)
313 if (new_addr[i] != br_group_address[i])
314 return -EINVAL;
315
316 if (new_addr[5] & ~0xf)
317 return -EINVAL;
318
Joe Perchesf64f9e72009-11-29 16:55:45 -0800319 if (new_addr[5] == 1 || /* 802.3x Pause address */
320 new_addr[5] == 2 || /* 802.3ad Slow protocols */
321 new_addr[5] == 3) /* 802.1X PAE address */
Stephen Hemmingerfda93d92006-03-20 22:59:21 -0800322 return -EINVAL;
323
324 spin_lock_bh(&br->lock);
325 for (i = 0; i < 6; i++)
326 br->group_addr[i] = new_addr[i];
327 spin_unlock_bh(&br->lock);
328 return len;
329}
330
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700331static DEVICE_ATTR(group_addr, S_IRUGO | S_IWUSR,
332 show_group_addr, store_group_addr);
Stephen Hemmingerfda93d92006-03-20 22:59:21 -0800333
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700334static ssize_t store_flush(struct device *d,
335 struct device_attribute *attr,
336 const char *buf, size_t len)
337{
338 struct net_bridge *br = to_bridge(d);
339
340 if (!capable(CAP_NET_ADMIN))
341 return -EPERM;
342
343 br_fdb_flush(br);
344 return len;
345}
346static DEVICE_ATTR(flush, S_IWUSR, NULL, store_flush);
Stephen Hemmingerfda93d92006-03-20 22:59:21 -0800347
Herbert Xu0909e112010-02-27 19:41:49 +0000348#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
349static ssize_t show_multicast_router(struct device *d,
350 struct device_attribute *attr, char *buf)
351{
352 struct net_bridge *br = to_bridge(d);
353 return sprintf(buf, "%d\n", br->multicast_router);
354}
355
356static ssize_t store_multicast_router(struct device *d,
357 struct device_attribute *attr,
358 const char *buf, size_t len)
359{
360 return store_bridge_parm(d, buf, len, br_multicast_set_router);
361}
362static DEVICE_ATTR(multicast_router, S_IRUGO | S_IWUSR, show_multicast_router,
363 store_multicast_router);
Herbert Xu561f11032010-02-27 19:41:50 +0000364
365static ssize_t show_multicast_snooping(struct device *d,
366 struct device_attribute *attr,
367 char *buf)
368{
369 struct net_bridge *br = to_bridge(d);
370 return sprintf(buf, "%d\n", !br->multicast_disabled);
371}
372
373static ssize_t store_multicast_snooping(struct device *d,
374 struct device_attribute *attr,
375 const char *buf, size_t len)
376{
377 return store_bridge_parm(d, buf, len, br_multicast_toggle);
378}
379static DEVICE_ATTR(multicast_snooping, S_IRUGO | S_IWUSR,
380 show_multicast_snooping, store_multicast_snooping);
Herbert Xub1951672010-02-27 19:41:51 +0000381
382static ssize_t show_hash_elasticity(struct device *d,
383 struct device_attribute *attr, char *buf)
384{
385 struct net_bridge *br = to_bridge(d);
386 return sprintf(buf, "%u\n", br->hash_elasticity);
387}
388
389static int set_elasticity(struct net_bridge *br, unsigned long val)
390{
391 br->hash_elasticity = val;
392 return 0;
393}
394
395static ssize_t store_hash_elasticity(struct device *d,
396 struct device_attribute *attr,
397 const char *buf, size_t len)
398{
399 return store_bridge_parm(d, buf, len, set_elasticity);
400}
401static DEVICE_ATTR(hash_elasticity, S_IRUGO | S_IWUSR, show_hash_elasticity,
402 store_hash_elasticity);
403
404static ssize_t show_hash_max(struct device *d, struct device_attribute *attr,
405 char *buf)
406{
407 struct net_bridge *br = to_bridge(d);
408 return sprintf(buf, "%u\n", br->hash_max);
409}
410
411static ssize_t store_hash_max(struct device *d, struct device_attribute *attr,
412 const char *buf, size_t len)
413{
414 return store_bridge_parm(d, buf, len, br_multicast_set_hash_max);
415}
416static DEVICE_ATTR(hash_max, S_IRUGO | S_IWUSR, show_hash_max,
417 store_hash_max);
Herbert Xud902eee2010-02-27 19:41:52 +0000418
419static ssize_t show_multicast_last_member_count(struct device *d,
420 struct device_attribute *attr,
421 char *buf)
422{
423 struct net_bridge *br = to_bridge(d);
424 return sprintf(buf, "%u\n", br->multicast_last_member_count);
425}
426
427static int set_last_member_count(struct net_bridge *br, unsigned long val)
428{
429 br->multicast_last_member_count = val;
430 return 0;
431}
432
433static ssize_t store_multicast_last_member_count(struct device *d,
434 struct device_attribute *attr,
435 const char *buf, size_t len)
436{
437 return store_bridge_parm(d, buf, len, set_last_member_count);
438}
439static DEVICE_ATTR(multicast_last_member_count, S_IRUGO | S_IWUSR,
440 show_multicast_last_member_count,
441 store_multicast_last_member_count);
442
443static ssize_t show_multicast_startup_query_count(
444 struct device *d, struct device_attribute *attr, char *buf)
445{
446 struct net_bridge *br = to_bridge(d);
447 return sprintf(buf, "%u\n", br->multicast_startup_query_count);
448}
449
450static int set_startup_query_count(struct net_bridge *br, unsigned long val)
451{
452 br->multicast_startup_query_count = val;
453 return 0;
454}
455
456static ssize_t store_multicast_startup_query_count(
457 struct device *d, struct device_attribute *attr, const char *buf,
458 size_t len)
459{
460 return store_bridge_parm(d, buf, len, set_startup_query_count);
461}
462static DEVICE_ATTR(multicast_startup_query_count, S_IRUGO | S_IWUSR,
463 show_multicast_startup_query_count,
464 store_multicast_startup_query_count);
465
466static ssize_t show_multicast_last_member_interval(
467 struct device *d, struct device_attribute *attr, char *buf)
468{
469 struct net_bridge *br = to_bridge(d);
470 return sprintf(buf, "%lu\n",
471 jiffies_to_clock_t(br->multicast_last_member_interval));
472}
473
474static int set_last_member_interval(struct net_bridge *br, unsigned long val)
475{
476 br->multicast_last_member_interval = clock_t_to_jiffies(val);
477 return 0;
478}
479
480static ssize_t store_multicast_last_member_interval(
481 struct device *d, struct device_attribute *attr, const char *buf,
482 size_t len)
483{
484 return store_bridge_parm(d, buf, len, set_last_member_interval);
485}
486static DEVICE_ATTR(multicast_last_member_interval, S_IRUGO | S_IWUSR,
487 show_multicast_last_member_interval,
488 store_multicast_last_member_interval);
489
490static ssize_t show_multicast_membership_interval(
491 struct device *d, struct device_attribute *attr, char *buf)
492{
493 struct net_bridge *br = to_bridge(d);
494 return sprintf(buf, "%lu\n",
495 jiffies_to_clock_t(br->multicast_membership_interval));
496}
497
498static int set_membership_interval(struct net_bridge *br, unsigned long val)
499{
500 br->multicast_membership_interval = clock_t_to_jiffies(val);
501 return 0;
502}
503
504static ssize_t store_multicast_membership_interval(
505 struct device *d, struct device_attribute *attr, const char *buf,
506 size_t len)
507{
508 return store_bridge_parm(d, buf, len, set_membership_interval);
509}
510static DEVICE_ATTR(multicast_membership_interval, S_IRUGO | S_IWUSR,
511 show_multicast_membership_interval,
512 store_multicast_membership_interval);
513
514static ssize_t show_multicast_querier_interval(struct device *d,
515 struct device_attribute *attr,
516 char *buf)
517{
518 struct net_bridge *br = to_bridge(d);
519 return sprintf(buf, "%lu\n",
520 jiffies_to_clock_t(br->multicast_querier_interval));
521}
522
523static int set_querier_interval(struct net_bridge *br, unsigned long val)
524{
525 br->multicast_querier_interval = clock_t_to_jiffies(val);
526 return 0;
527}
528
529static ssize_t store_multicast_querier_interval(struct device *d,
530 struct device_attribute *attr,
531 const char *buf, size_t len)
532{
533 return store_bridge_parm(d, buf, len, set_querier_interval);
534}
535static DEVICE_ATTR(multicast_querier_interval, S_IRUGO | S_IWUSR,
536 show_multicast_querier_interval,
537 store_multicast_querier_interval);
538
539static ssize_t show_multicast_query_interval(struct device *d,
540 struct device_attribute *attr,
541 char *buf)
542{
543 struct net_bridge *br = to_bridge(d);
544 return sprintf(buf, "%lu\n",
545 jiffies_to_clock_t(br->multicast_query_interval));
546}
547
548static int set_query_interval(struct net_bridge *br, unsigned long val)
549{
550 br->multicast_query_interval = clock_t_to_jiffies(val);
551 return 0;
552}
553
554static ssize_t store_multicast_query_interval(struct device *d,
555 struct device_attribute *attr,
556 const char *buf, size_t len)
557{
558 return store_bridge_parm(d, buf, len, set_query_interval);
559}
560static DEVICE_ATTR(multicast_query_interval, S_IRUGO | S_IWUSR,
561 show_multicast_query_interval,
562 store_multicast_query_interval);
563
564static ssize_t show_multicast_query_response_interval(
565 struct device *d, struct device_attribute *attr, char *buf)
566{
567 struct net_bridge *br = to_bridge(d);
568 return sprintf(
569 buf, "%lu\n",
570 jiffies_to_clock_t(br->multicast_query_response_interval));
571}
572
573static int set_query_response_interval(struct net_bridge *br, unsigned long val)
574{
575 br->multicast_query_response_interval = clock_t_to_jiffies(val);
576 return 0;
577}
578
579static ssize_t store_multicast_query_response_interval(
580 struct device *d, struct device_attribute *attr, const char *buf,
581 size_t len)
582{
583 return store_bridge_parm(d, buf, len, set_query_response_interval);
584}
585static DEVICE_ATTR(multicast_query_response_interval, S_IRUGO | S_IWUSR,
586 show_multicast_query_response_interval,
587 store_multicast_query_response_interval);
588
589static ssize_t show_multicast_startup_query_interval(
590 struct device *d, struct device_attribute *attr, char *buf)
591{
592 struct net_bridge *br = to_bridge(d);
593 return sprintf(
594 buf, "%lu\n",
595 jiffies_to_clock_t(br->multicast_startup_query_interval));
596}
597
598static int set_startup_query_interval(struct net_bridge *br, unsigned long val)
599{
600 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
601 return 0;
602}
603
604static ssize_t store_multicast_startup_query_interval(
605 struct device *d, struct device_attribute *attr, const char *buf,
606 size_t len)
607{
608 return store_bridge_parm(d, buf, len, set_startup_query_interval);
609}
610static DEVICE_ATTR(multicast_startup_query_interval, S_IRUGO | S_IWUSR,
611 show_multicast_startup_query_interval,
612 store_multicast_startup_query_interval);
Herbert Xu0909e112010-02-27 19:41:49 +0000613#endif
Patrick McHardy4df53d82010-07-02 09:32:57 +0200614#ifdef CONFIG_BRIDGE_NETFILTER
615static ssize_t show_nf_call_iptables(
616 struct device *d, struct device_attribute *attr, char *buf)
617{
618 struct net_bridge *br = to_bridge(d);
619 return sprintf(buf, "%u\n", br->nf_call_iptables);
620}
621
622static int set_nf_call_iptables(struct net_bridge *br, unsigned long val)
623{
624 br->nf_call_iptables = val ? true : false;
625 return 0;
626}
627
628static ssize_t store_nf_call_iptables(
629 struct device *d, struct device_attribute *attr, const char *buf,
630 size_t len)
631{
632 return store_bridge_parm(d, buf, len, set_nf_call_iptables);
633}
634static DEVICE_ATTR(nf_call_iptables, S_IRUGO | S_IWUSR,
635 show_nf_call_iptables, store_nf_call_iptables);
636
637static ssize_t show_nf_call_ip6tables(
638 struct device *d, struct device_attribute *attr, char *buf)
639{
640 struct net_bridge *br = to_bridge(d);
641 return sprintf(buf, "%u\n", br->nf_call_ip6tables);
642}
643
644static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val)
645{
646 br->nf_call_ip6tables = val ? true : false;
647 return 0;
648}
649
650static ssize_t store_nf_call_ip6tables(
651 struct device *d, struct device_attribute *attr, const char *buf,
652 size_t len)
653{
654 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables);
655}
656static DEVICE_ATTR(nf_call_ip6tables, S_IRUGO | S_IWUSR,
657 show_nf_call_ip6tables, store_nf_call_ip6tables);
658
659static ssize_t show_nf_call_arptables(
660 struct device *d, struct device_attribute *attr, char *buf)
661{
662 struct net_bridge *br = to_bridge(d);
663 return sprintf(buf, "%u\n", br->nf_call_arptables);
664}
665
666static int set_nf_call_arptables(struct net_bridge *br, unsigned long val)
667{
668 br->nf_call_arptables = val ? true : false;
669 return 0;
670}
671
672static ssize_t store_nf_call_arptables(
673 struct device *d, struct device_attribute *attr, const char *buf,
674 size_t len)
675{
676 return store_bridge_parm(d, buf, len, set_nf_call_arptables);
677}
678static DEVICE_ATTR(nf_call_arptables, S_IRUGO | S_IWUSR,
679 show_nf_call_arptables, store_nf_call_arptables);
680#endif
Herbert Xu0909e112010-02-27 19:41:49 +0000681
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682static struct attribute *bridge_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700683 &dev_attr_forward_delay.attr,
684 &dev_attr_hello_time.attr,
685 &dev_attr_max_age.attr,
686 &dev_attr_ageing_time.attr,
687 &dev_attr_stp_state.attr,
stephen hemminger515853c2011-10-03 18:14:46 +0000688 &dev_attr_group_fwd_mask.attr,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700689 &dev_attr_priority.attr,
690 &dev_attr_bridge_id.attr,
691 &dev_attr_root_id.attr,
692 &dev_attr_root_path_cost.attr,
693 &dev_attr_root_port.attr,
694 &dev_attr_topology_change.attr,
695 &dev_attr_topology_change_detected.attr,
696 &dev_attr_hello_timer.attr,
697 &dev_attr_tcn_timer.attr,
698 &dev_attr_topology_change_timer.attr,
699 &dev_attr_gc_timer.attr,
700 &dev_attr_group_addr.attr,
Stephen Hemminger9cf63742007-04-09 12:57:54 -0700701 &dev_attr_flush.attr,
Herbert Xu0909e112010-02-27 19:41:49 +0000702#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
703 &dev_attr_multicast_router.attr,
Herbert Xu561f11032010-02-27 19:41:50 +0000704 &dev_attr_multicast_snooping.attr,
Herbert Xub1951672010-02-27 19:41:51 +0000705 &dev_attr_hash_elasticity.attr,
706 &dev_attr_hash_max.attr,
Herbert Xud902eee2010-02-27 19:41:52 +0000707 &dev_attr_multicast_last_member_count.attr,
708 &dev_attr_multicast_startup_query_count.attr,
709 &dev_attr_multicast_last_member_interval.attr,
710 &dev_attr_multicast_membership_interval.attr,
711 &dev_attr_multicast_querier_interval.attr,
712 &dev_attr_multicast_query_interval.attr,
713 &dev_attr_multicast_query_response_interval.attr,
714 &dev_attr_multicast_startup_query_interval.attr,
Herbert Xu0909e112010-02-27 19:41:49 +0000715#endif
Patrick McHardy4df53d82010-07-02 09:32:57 +0200716#ifdef CONFIG_BRIDGE_NETFILTER
717 &dev_attr_nf_call_iptables.attr,
718 &dev_attr_nf_call_ip6tables.attr,
719 &dev_attr_nf_call_arptables.attr,
720#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 NULL
722};
723
724static struct attribute_group bridge_group = {
725 .name = SYSFS_BRIDGE_ATTR,
726 .attrs = bridge_attrs,
727};
728
729/*
730 * Export the forwarding information table as a binary file
731 * The records are struct __fdb_entry.
732 *
733 * Returns the number of bytes read.
734 */
Chris Wright2c3c8be2010-05-12 18:28:57 -0700735static ssize_t brforward_read(struct file *filp, struct kobject *kobj,
Zhang Rui91a69022007-06-09 13:57:22 +0800736 struct bin_attribute *bin_attr,
737 char *buf, loff_t off, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700739 struct device *dev = to_dev(kobj);
740 struct net_bridge *br = to_bridge(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 int n;
742
743 /* must read whole records */
744 if (off % sizeof(struct __fdb_entry) != 0)
745 return -EINVAL;
746
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900747 n = br_fdb_fillbuf(br, buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 count / sizeof(struct __fdb_entry),
749 off / sizeof(struct __fdb_entry));
750
751 if (n > 0)
752 n *= sizeof(struct __fdb_entry);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 return n;
755}
756
757static struct bin_attribute bridge_forward = {
758 .attr = { .name = SYSFS_BRIDGE_FDB,
Tejun Heo7b595752007-06-14 03:45:17 +0900759 .mode = S_IRUGO, },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 .read = brforward_read,
761};
762
763/*
764 * Add entries in sysfs onto the existing network class device
765 * for the bridge.
766 * Adds a attribute group "bridge" containing tuning parameters.
767 * Binary attribute containing the forward table
768 * Sub directory to hold links to interfaces.
769 *
770 * Note: the ifobj exists only to be a subdirectory
771 * to hold links. The ifobj exists in same data structure
772 * as it's parent the bridge so reference counting works.
773 */
774int br_sysfs_addbr(struct net_device *dev)
775{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700776 struct kobject *brobj = &dev->dev.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 struct net_bridge *br = netdev_priv(dev);
778 int err;
779
780 err = sysfs_create_group(brobj, &bridge_group);
781 if (err) {
782 pr_info("%s: can't create group %s/%s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800783 __func__, dev->name, bridge_group.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 goto out1;
785 }
786
787 err = sysfs_create_bin_file(brobj, &bridge_forward);
788 if (err) {
Randy Dunlap1842c4b2006-10-25 23:07:37 -0700789 pr_info("%s: can't create attribute file %s/%s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800790 __func__, dev->name, bridge_forward.attr.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 goto out2;
792 }
793
Greg Kroah-Hartman43b98c42007-12-17 15:54:39 -0400794 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj);
795 if (!br->ifobj) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 pr_info("%s: can't add kobject (directory) %s/%s\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800797 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 goto out3;
799 }
800 return 0;
801 out3:
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700802 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 out2:
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700804 sysfs_remove_group(&dev->dev.kobj, &bridge_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 out1:
806 return err;
807
808}
809
810void br_sysfs_delbr(struct net_device *dev)
811{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700812 struct kobject *kobj = &dev->dev.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 struct net_bridge *br = netdev_priv(dev);
814
Greg Kroah-Hartman78a2d902007-12-20 08:13:05 -0800815 kobject_put(br->ifobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 sysfs_remove_bin_file(kobj, &bridge_forward);
817 sysfs_remove_group(kobj, &bridge_group);
818}