Loading...
1/*
2 * Sysfs attributes of bridge
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/etherdevice.h>
18#include <linux/if_bridge.h>
19#include <linux/rtnetlink.h>
20#include <linux/spinlock.h>
21#include <linux/times.h>
22
23#include "br_private.h"
24
25#define to_dev(obj) container_of(obj, struct device, kobj)
26#define to_bridge(cd) ((struct net_bridge *)netdev_priv(to_net_dev(cd)))
27
28/*
29 * Common code for storing bridge parameters.
30 */
31static ssize_t store_bridge_parm(struct device *d,
32 const char *buf, size_t len,
33 int (*set)(struct net_bridge *, unsigned long))
34{
35 struct net_bridge *br = to_bridge(d);
36 char *endp;
37 unsigned long val;
38 int err;
39
40 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
41 return -EPERM;
42
43 val = simple_strtoul(buf, &endp, 0);
44 if (endp == buf)
45 return -EINVAL;
46
47 err = (*set)(br, val);
48 return err ? err : len;
49}
50
51
52static ssize_t forward_delay_show(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
59static ssize_t forward_delay_store(struct device *d,
60 struct device_attribute *attr,
61 const char *buf, size_t len)
62{
63 return store_bridge_parm(d, buf, len, br_set_forward_delay);
64}
65static DEVICE_ATTR_RW(forward_delay);
66
67static ssize_t hello_time_show(struct device *d, struct device_attribute *attr,
68 char *buf)
69{
70 return sprintf(buf, "%lu\n",
71 jiffies_to_clock_t(to_bridge(d)->hello_time));
72}
73
74static ssize_t hello_time_store(struct device *d,
75 struct device_attribute *attr, const char *buf,
76 size_t len)
77{
78 return store_bridge_parm(d, buf, len, br_set_hello_time);
79}
80static DEVICE_ATTR_RW(hello_time);
81
82static ssize_t max_age_show(struct device *d, struct device_attribute *attr,
83 char *buf)
84{
85 return sprintf(buf, "%lu\n",
86 jiffies_to_clock_t(to_bridge(d)->max_age));
87}
88
89static ssize_t max_age_store(struct device *d, struct device_attribute *attr,
90 const char *buf, size_t len)
91{
92 return store_bridge_parm(d, buf, len, br_set_max_age);
93}
94static DEVICE_ATTR_RW(max_age);
95
96static ssize_t ageing_time_show(struct device *d,
97 struct device_attribute *attr, char *buf)
98{
99 struct net_bridge *br = to_bridge(d);
100 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
101}
102
103static int set_ageing_time(struct net_bridge *br, unsigned long val)
104{
105 br->ageing_time = clock_t_to_jiffies(val);
106 return 0;
107}
108
109static ssize_t ageing_time_store(struct device *d,
110 struct device_attribute *attr,
111 const char *buf, size_t len)
112{
113 return store_bridge_parm(d, buf, len, set_ageing_time);
114}
115static DEVICE_ATTR_RW(ageing_time);
116
117static ssize_t stp_state_show(struct device *d,
118 struct device_attribute *attr, char *buf)
119{
120 struct net_bridge *br = to_bridge(d);
121 return sprintf(buf, "%d\n", br->stp_enabled);
122}
123
124
125static ssize_t stp_state_store(struct device *d,
126 struct device_attribute *attr, const char *buf,
127 size_t len)
128{
129 struct net_bridge *br = to_bridge(d);
130 char *endp;
131 unsigned long val;
132
133 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
134 return -EPERM;
135
136 val = simple_strtoul(buf, &endp, 0);
137 if (endp == buf)
138 return -EINVAL;
139
140 if (!rtnl_trylock())
141 return restart_syscall();
142 br_stp_set_enabled(br, val);
143 rtnl_unlock();
144
145 return len;
146}
147static DEVICE_ATTR_RW(stp_state);
148
149static ssize_t group_fwd_mask_show(struct device *d,
150 struct device_attribute *attr,
151 char *buf)
152{
153 struct net_bridge *br = to_bridge(d);
154 return sprintf(buf, "%#x\n", br->group_fwd_mask);
155}
156
157
158static ssize_t group_fwd_mask_store(struct device *d,
159 struct device_attribute *attr,
160 const char *buf,
161 size_t len)
162{
163 struct net_bridge *br = to_bridge(d);
164 char *endp;
165 unsigned long val;
166
167 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
168 return -EPERM;
169
170 val = simple_strtoul(buf, &endp, 0);
171 if (endp == buf)
172 return -EINVAL;
173
174 if (val & BR_GROUPFWD_RESTRICTED)
175 return -EINVAL;
176
177 br->group_fwd_mask = val;
178
179 return len;
180}
181static DEVICE_ATTR_RW(group_fwd_mask);
182
183static ssize_t priority_show(struct device *d, struct device_attribute *attr,
184 char *buf)
185{
186 struct net_bridge *br = to_bridge(d);
187 return sprintf(buf, "%d\n",
188 (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]);
189}
190
191static int set_priority(struct net_bridge *br, unsigned long val)
192{
193 br_stp_set_bridge_priority(br, (u16) val);
194 return 0;
195}
196
197static ssize_t priority_store(struct device *d, struct device_attribute *attr,
198 const char *buf, size_t len)
199{
200 return store_bridge_parm(d, buf, len, set_priority);
201}
202static DEVICE_ATTR_RW(priority);
203
204static ssize_t root_id_show(struct device *d, struct device_attribute *attr,
205 char *buf)
206{
207 return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
208}
209static DEVICE_ATTR_RO(root_id);
210
211static ssize_t bridge_id_show(struct device *d, struct device_attribute *attr,
212 char *buf)
213{
214 return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
215}
216static DEVICE_ATTR_RO(bridge_id);
217
218static ssize_t root_port_show(struct device *d, struct device_attribute *attr,
219 char *buf)
220{
221 return sprintf(buf, "%d\n", to_bridge(d)->root_port);
222}
223static DEVICE_ATTR_RO(root_port);
224
225static ssize_t root_path_cost_show(struct device *d,
226 struct device_attribute *attr, char *buf)
227{
228 return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
229}
230static DEVICE_ATTR_RO(root_path_cost);
231
232static ssize_t topology_change_show(struct device *d,
233 struct device_attribute *attr, char *buf)
234{
235 return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
236}
237static DEVICE_ATTR_RO(topology_change);
238
239static ssize_t topology_change_detected_show(struct device *d,
240 struct device_attribute *attr,
241 char *buf)
242{
243 struct net_bridge *br = to_bridge(d);
244 return sprintf(buf, "%d\n", br->topology_change_detected);
245}
246static DEVICE_ATTR_RO(topology_change_detected);
247
248static ssize_t hello_timer_show(struct device *d,
249 struct device_attribute *attr, char *buf)
250{
251 struct net_bridge *br = to_bridge(d);
252 return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
253}
254static DEVICE_ATTR_RO(hello_timer);
255
256static ssize_t tcn_timer_show(struct device *d, struct device_attribute *attr,
257 char *buf)
258{
259 struct net_bridge *br = to_bridge(d);
260 return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
261}
262static DEVICE_ATTR_RO(tcn_timer);
263
264static ssize_t topology_change_timer_show(struct device *d,
265 struct device_attribute *attr,
266 char *buf)
267{
268 struct net_bridge *br = to_bridge(d);
269 return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
270}
271static DEVICE_ATTR_RO(topology_change_timer);
272
273static ssize_t gc_timer_show(struct device *d, struct device_attribute *attr,
274 char *buf)
275{
276 struct net_bridge *br = to_bridge(d);
277 return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer));
278}
279static DEVICE_ATTR_RO(gc_timer);
280
281static ssize_t group_addr_show(struct device *d,
282 struct device_attribute *attr, char *buf)
283{
284 struct net_bridge *br = to_bridge(d);
285 return sprintf(buf, "%x:%x:%x:%x:%x:%x\n",
286 br->group_addr[0], br->group_addr[1],
287 br->group_addr[2], br->group_addr[3],
288 br->group_addr[4], br->group_addr[5]);
289}
290
291static ssize_t group_addr_store(struct device *d,
292 struct device_attribute *attr,
293 const char *buf, size_t len)
294{
295 struct net_bridge *br = to_bridge(d);
296 u8 new_addr[6];
297 int i;
298
299 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
300 return -EPERM;
301
302 if (sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
303 &new_addr[0], &new_addr[1], &new_addr[2],
304 &new_addr[3], &new_addr[4], &new_addr[5]) != 6)
305 return -EINVAL;
306
307 if (!is_link_local_ether_addr(new_addr))
308 return -EINVAL;
309
310 if (new_addr[5] == 1 || /* 802.3x Pause address */
311 new_addr[5] == 2 || /* 802.3ad Slow protocols */
312 new_addr[5] == 3) /* 802.1X PAE address */
313 return -EINVAL;
314
315 spin_lock_bh(&br->lock);
316 for (i = 0; i < 6; i++)
317 br->group_addr[i] = new_addr[i];
318 spin_unlock_bh(&br->lock);
319 return len;
320}
321
322static DEVICE_ATTR_RW(group_addr);
323
324static ssize_t flush_store(struct device *d,
325 struct device_attribute *attr,
326 const char *buf, size_t len)
327{
328 struct net_bridge *br = to_bridge(d);
329
330 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
331 return -EPERM;
332
333 br_fdb_flush(br);
334 return len;
335}
336static DEVICE_ATTR_WO(flush);
337
338#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
339static ssize_t multicast_router_show(struct device *d,
340 struct device_attribute *attr, char *buf)
341{
342 struct net_bridge *br = to_bridge(d);
343 return sprintf(buf, "%d\n", br->multicast_router);
344}
345
346static ssize_t multicast_router_store(struct device *d,
347 struct device_attribute *attr,
348 const char *buf, size_t len)
349{
350 return store_bridge_parm(d, buf, len, br_multicast_set_router);
351}
352static DEVICE_ATTR_RW(multicast_router);
353
354static ssize_t multicast_snooping_show(struct device *d,
355 struct device_attribute *attr,
356 char *buf)
357{
358 struct net_bridge *br = to_bridge(d);
359 return sprintf(buf, "%d\n", !br->multicast_disabled);
360}
361
362static ssize_t multicast_snooping_store(struct device *d,
363 struct device_attribute *attr,
364 const char *buf, size_t len)
365{
366 return store_bridge_parm(d, buf, len, br_multicast_toggle);
367}
368static DEVICE_ATTR_RW(multicast_snooping);
369
370static ssize_t multicast_query_use_ifaddr_show(struct device *d,
371 struct device_attribute *attr,
372 char *buf)
373{
374 struct net_bridge *br = to_bridge(d);
375 return sprintf(buf, "%d\n", br->multicast_query_use_ifaddr);
376}
377
378static int set_query_use_ifaddr(struct net_bridge *br, unsigned long val)
379{
380 br->multicast_query_use_ifaddr = !!val;
381 return 0;
382}
383
384static ssize_t
385multicast_query_use_ifaddr_store(struct device *d,
386 struct device_attribute *attr,
387 const char *buf, size_t len)
388{
389 return store_bridge_parm(d, buf, len, set_query_use_ifaddr);
390}
391static DEVICE_ATTR_RW(multicast_query_use_ifaddr);
392
393static ssize_t multicast_querier_show(struct device *d,
394 struct device_attribute *attr,
395 char *buf)
396{
397 struct net_bridge *br = to_bridge(d);
398 return sprintf(buf, "%d\n", br->multicast_querier);
399}
400
401static ssize_t multicast_querier_store(struct device *d,
402 struct device_attribute *attr,
403 const char *buf, size_t len)
404{
405 return store_bridge_parm(d, buf, len, br_multicast_set_querier);
406}
407static DEVICE_ATTR_RW(multicast_querier);
408
409static ssize_t hash_elasticity_show(struct device *d,
410 struct device_attribute *attr, char *buf)
411{
412 struct net_bridge *br = to_bridge(d);
413 return sprintf(buf, "%u\n", br->hash_elasticity);
414}
415
416static int set_elasticity(struct net_bridge *br, unsigned long val)
417{
418 br->hash_elasticity = val;
419 return 0;
420}
421
422static ssize_t hash_elasticity_store(struct device *d,
423 struct device_attribute *attr,
424 const char *buf, size_t len)
425{
426 return store_bridge_parm(d, buf, len, set_elasticity);
427}
428static DEVICE_ATTR_RW(hash_elasticity);
429
430static ssize_t hash_max_show(struct device *d, struct device_attribute *attr,
431 char *buf)
432{
433 struct net_bridge *br = to_bridge(d);
434 return sprintf(buf, "%u\n", br->hash_max);
435}
436
437static ssize_t hash_max_store(struct device *d, struct device_attribute *attr,
438 const char *buf, size_t len)
439{
440 return store_bridge_parm(d, buf, len, br_multicast_set_hash_max);
441}
442static DEVICE_ATTR_RW(hash_max);
443
444static ssize_t multicast_last_member_count_show(struct device *d,
445 struct device_attribute *attr,
446 char *buf)
447{
448 struct net_bridge *br = to_bridge(d);
449 return sprintf(buf, "%u\n", br->multicast_last_member_count);
450}
451
452static int set_last_member_count(struct net_bridge *br, unsigned long val)
453{
454 br->multicast_last_member_count = val;
455 return 0;
456}
457
458static ssize_t multicast_last_member_count_store(struct device *d,
459 struct device_attribute *attr,
460 const char *buf, size_t len)
461{
462 return store_bridge_parm(d, buf, len, set_last_member_count);
463}
464static DEVICE_ATTR_RW(multicast_last_member_count);
465
466static ssize_t multicast_startup_query_count_show(
467 struct device *d, struct device_attribute *attr, char *buf)
468{
469 struct net_bridge *br = to_bridge(d);
470 return sprintf(buf, "%u\n", br->multicast_startup_query_count);
471}
472
473static int set_startup_query_count(struct net_bridge *br, unsigned long val)
474{
475 br->multicast_startup_query_count = val;
476 return 0;
477}
478
479static ssize_t multicast_startup_query_count_store(
480 struct device *d, struct device_attribute *attr, const char *buf,
481 size_t len)
482{
483 return store_bridge_parm(d, buf, len, set_startup_query_count);
484}
485static DEVICE_ATTR_RW(multicast_startup_query_count);
486
487static ssize_t multicast_last_member_interval_show(
488 struct device *d, struct device_attribute *attr, char *buf)
489{
490 struct net_bridge *br = to_bridge(d);
491 return sprintf(buf, "%lu\n",
492 jiffies_to_clock_t(br->multicast_last_member_interval));
493}
494
495static int set_last_member_interval(struct net_bridge *br, unsigned long val)
496{
497 br->multicast_last_member_interval = clock_t_to_jiffies(val);
498 return 0;
499}
500
501static ssize_t multicast_last_member_interval_store(
502 struct device *d, struct device_attribute *attr, const char *buf,
503 size_t len)
504{
505 return store_bridge_parm(d, buf, len, set_last_member_interval);
506}
507static DEVICE_ATTR_RW(multicast_last_member_interval);
508
509static ssize_t multicast_membership_interval_show(
510 struct device *d, struct device_attribute *attr, char *buf)
511{
512 struct net_bridge *br = to_bridge(d);
513 return sprintf(buf, "%lu\n",
514 jiffies_to_clock_t(br->multicast_membership_interval));
515}
516
517static int set_membership_interval(struct net_bridge *br, unsigned long val)
518{
519 br->multicast_membership_interval = clock_t_to_jiffies(val);
520 return 0;
521}
522
523static ssize_t multicast_membership_interval_store(
524 struct device *d, struct device_attribute *attr, const char *buf,
525 size_t len)
526{
527 return store_bridge_parm(d, buf, len, set_membership_interval);
528}
529static DEVICE_ATTR_RW(multicast_membership_interval);
530
531static ssize_t multicast_querier_interval_show(struct device *d,
532 struct device_attribute *attr,
533 char *buf)
534{
535 struct net_bridge *br = to_bridge(d);
536 return sprintf(buf, "%lu\n",
537 jiffies_to_clock_t(br->multicast_querier_interval));
538}
539
540static int set_querier_interval(struct net_bridge *br, unsigned long val)
541{
542 br->multicast_querier_interval = clock_t_to_jiffies(val);
543 return 0;
544}
545
546static ssize_t multicast_querier_interval_store(struct device *d,
547 struct device_attribute *attr,
548 const char *buf, size_t len)
549{
550 return store_bridge_parm(d, buf, len, set_querier_interval);
551}
552static DEVICE_ATTR_RW(multicast_querier_interval);
553
554static ssize_t multicast_query_interval_show(struct device *d,
555 struct device_attribute *attr,
556 char *buf)
557{
558 struct net_bridge *br = to_bridge(d);
559 return sprintf(buf, "%lu\n",
560 jiffies_to_clock_t(br->multicast_query_interval));
561}
562
563static int set_query_interval(struct net_bridge *br, unsigned long val)
564{
565 br->multicast_query_interval = clock_t_to_jiffies(val);
566 return 0;
567}
568
569static ssize_t multicast_query_interval_store(struct device *d,
570 struct device_attribute *attr,
571 const char *buf, size_t len)
572{
573 return store_bridge_parm(d, buf, len, set_query_interval);
574}
575static DEVICE_ATTR_RW(multicast_query_interval);
576
577static ssize_t multicast_query_response_interval_show(
578 struct device *d, struct device_attribute *attr, char *buf)
579{
580 struct net_bridge *br = to_bridge(d);
581 return sprintf(
582 buf, "%lu\n",
583 jiffies_to_clock_t(br->multicast_query_response_interval));
584}
585
586static int set_query_response_interval(struct net_bridge *br, unsigned long val)
587{
588 br->multicast_query_response_interval = clock_t_to_jiffies(val);
589 return 0;
590}
591
592static ssize_t multicast_query_response_interval_store(
593 struct device *d, struct device_attribute *attr, const char *buf,
594 size_t len)
595{
596 return store_bridge_parm(d, buf, len, set_query_response_interval);
597}
598static DEVICE_ATTR_RW(multicast_query_response_interval);
599
600static ssize_t multicast_startup_query_interval_show(
601 struct device *d, struct device_attribute *attr, char *buf)
602{
603 struct net_bridge *br = to_bridge(d);
604 return sprintf(
605 buf, "%lu\n",
606 jiffies_to_clock_t(br->multicast_startup_query_interval));
607}
608
609static int set_startup_query_interval(struct net_bridge *br, unsigned long val)
610{
611 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
612 return 0;
613}
614
615static ssize_t multicast_startup_query_interval_store(
616 struct device *d, struct device_attribute *attr, const char *buf,
617 size_t len)
618{
619 return store_bridge_parm(d, buf, len, set_startup_query_interval);
620}
621static DEVICE_ATTR_RW(multicast_startup_query_interval);
622#endif
623#ifdef CONFIG_BRIDGE_NETFILTER
624static ssize_t nf_call_iptables_show(
625 struct device *d, struct device_attribute *attr, char *buf)
626{
627 struct net_bridge *br = to_bridge(d);
628 return sprintf(buf, "%u\n", br->nf_call_iptables);
629}
630
631static int set_nf_call_iptables(struct net_bridge *br, unsigned long val)
632{
633 br->nf_call_iptables = val ? true : false;
634 return 0;
635}
636
637static ssize_t nf_call_iptables_store(
638 struct device *d, struct device_attribute *attr, const char *buf,
639 size_t len)
640{
641 return store_bridge_parm(d, buf, len, set_nf_call_iptables);
642}
643static DEVICE_ATTR_RW(nf_call_iptables);
644
645static ssize_t nf_call_ip6tables_show(
646 struct device *d, struct device_attribute *attr, char *buf)
647{
648 struct net_bridge *br = to_bridge(d);
649 return sprintf(buf, "%u\n", br->nf_call_ip6tables);
650}
651
652static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val)
653{
654 br->nf_call_ip6tables = val ? true : false;
655 return 0;
656}
657
658static ssize_t nf_call_ip6tables_store(
659 struct device *d, struct device_attribute *attr, const char *buf,
660 size_t len)
661{
662 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables);
663}
664static DEVICE_ATTR_RW(nf_call_ip6tables);
665
666static ssize_t nf_call_arptables_show(
667 struct device *d, struct device_attribute *attr, char *buf)
668{
669 struct net_bridge *br = to_bridge(d);
670 return sprintf(buf, "%u\n", br->nf_call_arptables);
671}
672
673static int set_nf_call_arptables(struct net_bridge *br, unsigned long val)
674{
675 br->nf_call_arptables = val ? true : false;
676 return 0;
677}
678
679static ssize_t nf_call_arptables_store(
680 struct device *d, struct device_attribute *attr, const char *buf,
681 size_t len)
682{
683 return store_bridge_parm(d, buf, len, set_nf_call_arptables);
684}
685static DEVICE_ATTR_RW(nf_call_arptables);
686#endif
687#ifdef CONFIG_BRIDGE_VLAN_FILTERING
688static ssize_t vlan_filtering_show(struct device *d,
689 struct device_attribute *attr,
690 char *buf)
691{
692 struct net_bridge *br = to_bridge(d);
693 return sprintf(buf, "%d\n", br->vlan_enabled);
694}
695
696static ssize_t vlan_filtering_store(struct device *d,
697 struct device_attribute *attr,
698 const char *buf, size_t len)
699{
700 return store_bridge_parm(d, buf, len, br_vlan_filter_toggle);
701}
702static DEVICE_ATTR_RW(vlan_filtering);
703#endif
704
705static struct attribute *bridge_attrs[] = {
706 &dev_attr_forward_delay.attr,
707 &dev_attr_hello_time.attr,
708 &dev_attr_max_age.attr,
709 &dev_attr_ageing_time.attr,
710 &dev_attr_stp_state.attr,
711 &dev_attr_group_fwd_mask.attr,
712 &dev_attr_priority.attr,
713 &dev_attr_bridge_id.attr,
714 &dev_attr_root_id.attr,
715 &dev_attr_root_path_cost.attr,
716 &dev_attr_root_port.attr,
717 &dev_attr_topology_change.attr,
718 &dev_attr_topology_change_detected.attr,
719 &dev_attr_hello_timer.attr,
720 &dev_attr_tcn_timer.attr,
721 &dev_attr_topology_change_timer.attr,
722 &dev_attr_gc_timer.attr,
723 &dev_attr_group_addr.attr,
724 &dev_attr_flush.attr,
725#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
726 &dev_attr_multicast_router.attr,
727 &dev_attr_multicast_snooping.attr,
728 &dev_attr_multicast_querier.attr,
729 &dev_attr_multicast_query_use_ifaddr.attr,
730 &dev_attr_hash_elasticity.attr,
731 &dev_attr_hash_max.attr,
732 &dev_attr_multicast_last_member_count.attr,
733 &dev_attr_multicast_startup_query_count.attr,
734 &dev_attr_multicast_last_member_interval.attr,
735 &dev_attr_multicast_membership_interval.attr,
736 &dev_attr_multicast_querier_interval.attr,
737 &dev_attr_multicast_query_interval.attr,
738 &dev_attr_multicast_query_response_interval.attr,
739 &dev_attr_multicast_startup_query_interval.attr,
740#endif
741#ifdef CONFIG_BRIDGE_NETFILTER
742 &dev_attr_nf_call_iptables.attr,
743 &dev_attr_nf_call_ip6tables.attr,
744 &dev_attr_nf_call_arptables.attr,
745#endif
746#ifdef CONFIG_BRIDGE_VLAN_FILTERING
747 &dev_attr_vlan_filtering.attr,
748#endif
749 NULL
750};
751
752static struct attribute_group bridge_group = {
753 .name = SYSFS_BRIDGE_ATTR,
754 .attrs = bridge_attrs,
755};
756
757/*
758 * Export the forwarding information table as a binary file
759 * The records are struct __fdb_entry.
760 *
761 * Returns the number of bytes read.
762 */
763static ssize_t brforward_read(struct file *filp, struct kobject *kobj,
764 struct bin_attribute *bin_attr,
765 char *buf, loff_t off, size_t count)
766{
767 struct device *dev = to_dev(kobj);
768 struct net_bridge *br = to_bridge(dev);
769 int n;
770
771 /* must read whole records */
772 if (off % sizeof(struct __fdb_entry) != 0)
773 return -EINVAL;
774
775 n = br_fdb_fillbuf(br, buf,
776 count / sizeof(struct __fdb_entry),
777 off / sizeof(struct __fdb_entry));
778
779 if (n > 0)
780 n *= sizeof(struct __fdb_entry);
781
782 return n;
783}
784
785static struct bin_attribute bridge_forward = {
786 .attr = { .name = SYSFS_BRIDGE_FDB,
787 .mode = S_IRUGO, },
788 .read = brforward_read,
789};
790
791/*
792 * Add entries in sysfs onto the existing network class device
793 * for the bridge.
794 * Adds a attribute group "bridge" containing tuning parameters.
795 * Binary attribute containing the forward table
796 * Sub directory to hold links to interfaces.
797 *
798 * Note: the ifobj exists only to be a subdirectory
799 * to hold links. The ifobj exists in same data structure
800 * as it's parent the bridge so reference counting works.
801 */
802int br_sysfs_addbr(struct net_device *dev)
803{
804 struct kobject *brobj = &dev->dev.kobj;
805 struct net_bridge *br = netdev_priv(dev);
806 int err;
807
808 err = sysfs_create_group(brobj, &bridge_group);
809 if (err) {
810 pr_info("%s: can't create group %s/%s\n",
811 __func__, dev->name, bridge_group.name);
812 goto out1;
813 }
814
815 err = sysfs_create_bin_file(brobj, &bridge_forward);
816 if (err) {
817 pr_info("%s: can't create attribute file %s/%s\n",
818 __func__, dev->name, bridge_forward.attr.name);
819 goto out2;
820 }
821
822 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj);
823 if (!br->ifobj) {
824 pr_info("%s: can't add kobject (directory) %s/%s\n",
825 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR);
826 goto out3;
827 }
828 return 0;
829 out3:
830 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
831 out2:
832 sysfs_remove_group(&dev->dev.kobj, &bridge_group);
833 out1:
834 return err;
835
836}
837
838void br_sysfs_delbr(struct net_device *dev)
839{
840 struct kobject *kobj = &dev->dev.kobj;
841 struct net_bridge *br = netdev_priv(dev);
842
843 kobject_put(br->ifobj);
844 sysfs_remove_bin_file(kobj, &bridge_forward);
845 sysfs_remove_group(kobj, &bridge_group);
846}