7ec0b76cdd279c266ac9138416637ad56c95d8ac
[linux-2.6.git] / net / bridge / br_sysfs_br.c
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
14 #include <linux/capability.h>
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
24 #define to_dev(obj)     container_of(obj, struct device, kobj)
25 #define to_bridge(cd)   ((struct net_bridge *)(to_net_dev(cd)->priv))
26
27 /*
28  * Common code for storing bridge parameters.
29  */
30 static ssize_t store_bridge_parm(struct device *d,
31                                  const char *buf, size_t len,
32                                  void (*set)(struct net_bridge *, unsigned long))
33 {
34         struct net_bridge *br = to_bridge(d);
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
52 static ssize_t show_forward_delay(struct device *d,
53                                   struct device_attribute *attr, char *buf)
54 {
55         struct net_bridge *br = to_bridge(d);
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
67 static ssize_t store_forward_delay(struct device *d,
68                                    struct device_attribute *attr,
69                                    const char *buf, size_t len)
70 {
71         return store_bridge_parm(d, buf, len, set_forward_delay);
72 }
73 static DEVICE_ATTR(forward_delay, S_IRUGO | S_IWUSR,
74                    show_forward_delay, store_forward_delay);
75
76 static ssize_t show_hello_time(struct device *d, struct device_attribute *attr,
77                                char *buf)
78 {
79         return sprintf(buf, "%lu\n",
80                        jiffies_to_clock_t(to_bridge(d)->hello_time));
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
91 static ssize_t store_hello_time(struct device *d,
92                                 struct device_attribute *attr, const char *buf,
93                                 size_t len)
94 {
95         return store_bridge_parm(d, buf, len, set_hello_time);
96 }
97 static DEVICE_ATTR(hello_time, S_IRUGO | S_IWUSR, show_hello_time,
98                    store_hello_time);
99
100 static ssize_t show_max_age(struct device *d, struct device_attribute *attr,
101                             char *buf)
102 {
103         return sprintf(buf, "%lu\n",
104                        jiffies_to_clock_t(to_bridge(d)->max_age));
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
115 static ssize_t store_max_age(struct device *d, struct device_attribute *attr,
116                              const char *buf, size_t len)
117 {
118         return store_bridge_parm(d, buf, len, set_max_age);
119 }
120 static DEVICE_ATTR(max_age, S_IRUGO | S_IWUSR, show_max_age, store_max_age);
121
122 static ssize_t show_ageing_time(struct device *d,
123                                 struct device_attribute *attr, char *buf)
124 {
125         struct net_bridge *br = to_bridge(d);
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
134 static ssize_t store_ageing_time(struct device *d,
135                                  struct device_attribute *attr,
136                                  const char *buf, size_t len)
137 {
138         return store_bridge_parm(d, buf, len, set_ageing_time);
139 }
140 static DEVICE_ATTR(ageing_time, S_IRUGO | S_IWUSR, show_ageing_time,
141                    store_ageing_time);
142
143 static ssize_t show_stp_state(struct device *d,
144                               struct device_attribute *attr, char *buf)
145 {
146         struct net_bridge *br = to_bridge(d);
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         spin_unlock_bh(&br->lock);
153         br_stp_set_enabled(br, val);
154         spin_lock_bh(&br->lock);
155 }
156
157 static ssize_t store_stp_state(struct device *d,
158                                struct device_attribute *attr, const char *buf,
159                                size_t len)
160 {
161         return store_bridge_parm(d, buf, len, set_stp_state);
162 }
163 static DEVICE_ATTR(stp_state, S_IRUGO | S_IWUSR, show_stp_state,
164                    store_stp_state);
165
166 static ssize_t show_priority(struct device *d, struct device_attribute *attr,
167                              char *buf)
168 {
169         struct net_bridge *br = to_bridge(d);
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
179 static ssize_t store_priority(struct device *d, struct device_attribute *attr,
180                                const char *buf, size_t len)
181 {
182         return store_bridge_parm(d, buf, len, set_priority);
183 }
184 static DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, show_priority, store_priority);
185
186 static ssize_t show_root_id(struct device *d, struct device_attribute *attr,
187                             char *buf)
188 {
189         return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
190 }
191 static DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);
192
193 static ssize_t show_bridge_id(struct device *d, struct device_attribute *attr,
194                               char *buf)
195 {
196         return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
197 }
198 static DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);
199
200 static ssize_t show_root_port(struct device *d, struct device_attribute *attr,
201                               char *buf)
202 {
203         return sprintf(buf, "%d\n", to_bridge(d)->root_port);
204 }
205 static DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);
206
207 static ssize_t show_root_path_cost(struct device *d,
208                                    struct device_attribute *attr, char *buf)
209 {
210         return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
211 }
212 static DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);
213
214 static ssize_t show_topology_change(struct device *d,
215                                     struct device_attribute *attr, char *buf)
216 {
217         return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
218 }
219 static DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);
220
221 static ssize_t show_topology_change_detected(struct device *d,
222                                              struct device_attribute *attr,
223                                              char *buf)
224 {
225         struct net_bridge *br = to_bridge(d);
226         return sprintf(buf, "%d\n", br->topology_change_detected);
227 }
228 static DEVICE_ATTR(topology_change_detected, S_IRUGO,
229                    show_topology_change_detected, NULL);
230
231 static ssize_t show_hello_timer(struct device *d,
232                                 struct device_attribute *attr, char *buf)
233 {
234         struct net_bridge *br = to_bridge(d);
235         return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
236 }
237 static DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);
238
239 static ssize_t show_tcn_timer(struct device *d, struct device_attribute *attr,
240                               char *buf)
241 {
242         struct net_bridge *br = to_bridge(d);
243         return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
244 }
245 static DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);
246
247 static ssize_t show_topology_change_timer(struct device *d,
248                                           struct device_attribute *attr,
249                                           char *buf)
250 {
251         struct net_bridge *br = to_bridge(d);
252         return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
253 }
254 static DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer,
255                    NULL);
256
257 static ssize_t show_gc_timer(struct device *d, struct device_attribute *attr,
258                              char *buf)
259 {
260         struct net_bridge *br = to_bridge(d);
261         return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer));
262 }
263 static DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);
264
265 static ssize_t show_group_addr(struct device *d,
266                                struct device_attribute *attr, char *buf)
267 {
268         struct net_bridge *br = to_bridge(d);
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
275 static ssize_t store_group_addr(struct device *d,
276                                 struct device_attribute *attr,
277                                 const char *buf, size_t len)
278 {
279         struct net_bridge *br = to_bridge(d);
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
311 static DEVICE_ATTR(group_addr, S_IRUGO | S_IWUSR,
312                    show_group_addr, store_group_addr);
313
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);
327
328 static struct attribute *bridge_attrs[] = {
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,
346         &dev_attr_flush.attr,
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 {
364         struct device *dev = to_dev(kobj);
365         struct net_bridge *br = to_bridge(dev);
366         int n;
367
368         /* must read whole records */
369         if (off % sizeof(struct __fdb_entry) != 0)
370                 return -EINVAL;
371
372         n =  br_fdb_fillbuf(br, buf,
373                             count / sizeof(struct __fdb_entry),
374                             off / sizeof(struct __fdb_entry));
375
376         if (n > 0)
377                 n *= sizeof(struct __fdb_entry);
378
379         return n;
380 }
381
382 static struct bin_attribute bridge_forward = {
383         .attr = { .name = SYSFS_BRIDGE_FDB,
384                   .mode = S_IRUGO,
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 {
402         struct kobject *brobj = &dev->dev.kobj;
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) {
415                 pr_info("%s: can't create attribute file %s/%s\n",
416                         __FUNCTION__, dev->name, bridge_forward.attr.name);
417                 goto out2;
418         }
419
420
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:
434         sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
435  out2:
436         sysfs_remove_group(&dev->dev.kobj, &bridge_group);
437  out1:
438         return err;
439
440 }
441
442 void br_sysfs_delbr(struct net_device *dev)
443 {
444         struct kobject *kobj = &dev->dev.kobj;
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 }