1
2
3
4
5
6
7
8
9
10
11
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
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 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
59static ssize_t store_forward_delay(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(forward_delay, S_IRUGO | S_IWUSR,
66 show_forward_delay, store_forward_delay);
67
68static ssize_t show_hello_time(struct device *d, struct device_attribute *attr,
69 char *buf)
70{
71 return sprintf(buf, "%lu\n",
72 jiffies_to_clock_t(to_bridge(d)->hello_time));
73}
74
75static ssize_t store_hello_time(struct device *d,
76 struct device_attribute *attr, const char *buf,
77 size_t len)
78{
79 return store_bridge_parm(d, buf, len, br_set_hello_time);
80}
81static DEVICE_ATTR(hello_time, S_IRUGO | S_IWUSR, show_hello_time,
82 store_hello_time);
83
84static ssize_t show_max_age(struct device *d, struct device_attribute *attr,
85 char *buf)
86{
87 return sprintf(buf, "%lu\n",
88 jiffies_to_clock_t(to_bridge(d)->max_age));
89}
90
91static ssize_t store_max_age(struct device *d, struct device_attribute *attr,
92 const char *buf, size_t len)
93{
94 return store_bridge_parm(d, buf, len, br_set_max_age);
95}
96static DEVICE_ATTR(max_age, S_IRUGO | S_IWUSR, show_max_age, store_max_age);
97
98static ssize_t show_ageing_time(struct device *d,
99 struct device_attribute *attr, char *buf)
100{
101 struct net_bridge *br = to_bridge(d);
102 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
103}
104
105static int set_ageing_time(struct net_bridge *br, unsigned long val)
106{
107 br->ageing_time = clock_t_to_jiffies(val);
108 return 0;
109}
110
111static ssize_t store_ageing_time(struct device *d,
112 struct device_attribute *attr,
113 const char *buf, size_t len)
114{
115 return store_bridge_parm(d, buf, len, set_ageing_time);
116}
117static DEVICE_ATTR(ageing_time, S_IRUGO | S_IWUSR, show_ageing_time,
118 store_ageing_time);
119
120static ssize_t show_stp_state(struct device *d,
121 struct device_attribute *attr, char *buf)
122{
123 struct net_bridge *br = to_bridge(d);
124 return sprintf(buf, "%d\n", br->stp_enabled);
125}
126
127
128static ssize_t store_stp_state(struct device *d,
129 struct device_attribute *attr, const char *buf,
130 size_t len)
131{
132 struct net_bridge *br = to_bridge(d);
133 char *endp;
134 unsigned long val;
135
136 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
137 return -EPERM;
138
139 val = simple_strtoul(buf, &endp, 0);
140 if (endp == buf)
141 return -EINVAL;
142
143 if (!rtnl_trylock())
144 return restart_syscall();
145 br_stp_set_enabled(br, val);
146 rtnl_unlock();
147
148 return len;
149}
150static DEVICE_ATTR(stp_state, S_IRUGO | S_IWUSR, show_stp_state,
151 store_stp_state);
152
153static ssize_t show_group_fwd_mask(struct device *d,
154 struct device_attribute *attr, char *buf)
155{
156 struct net_bridge *br = to_bridge(d);
157 return sprintf(buf, "%#x\n", br->group_fwd_mask);
158}
159
160
161static ssize_t store_group_fwd_mask(struct device *d,
162 struct device_attribute *attr, const char *buf,
163 size_t len)
164{
165 struct net_bridge *br = to_bridge(d);
166 char *endp;
167 unsigned long val;
168
169 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
170 return -EPERM;
171
172 val = simple_strtoul(buf, &endp, 0);
173 if (endp == buf)
174 return -EINVAL;
175
176 if (val & BR_GROUPFWD_RESTRICTED)
177 return -EINVAL;
178
179 br->group_fwd_mask = val;
180
181 return len;
182}
183static DEVICE_ATTR(group_fwd_mask, S_IRUGO | S_IWUSR, show_group_fwd_mask,
184 store_group_fwd_mask);
185
186static ssize_t show_priority(struct device *d, struct device_attribute *attr,
187 char *buf)
188{
189 struct net_bridge *br = to_bridge(d);
190 return sprintf(buf, "%d\n",
191 (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]);
192}
193
194static int set_priority(struct net_bridge *br, unsigned long val)
195{
196 br_stp_set_bridge_priority(br, (u16) val);
197 return 0;
198}
199
200static ssize_t store_priority(struct device *d, struct device_attribute *attr,
201 const char *buf, size_t len)
202{
203 return store_bridge_parm(d, buf, len, set_priority);
204}
205static DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, show_priority, store_priority);
206
207static ssize_t show_root_id(struct device *d, struct device_attribute *attr,
208 char *buf)
209{
210 return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
211}
212static DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);
213
214static ssize_t show_bridge_id(struct device *d, struct device_attribute *attr,
215 char *buf)
216{
217 return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
218}
219static DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);
220
221static ssize_t show_root_port(struct device *d, struct device_attribute *attr,
222 char *buf)
223{
224 return sprintf(buf, "%d\n", to_bridge(d)->root_port);
225}
226static DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);
227
228static ssize_t show_root_path_cost(struct device *d,
229 struct device_attribute *attr, char *buf)
230{
231 return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
232}
233static DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);
234
235static ssize_t show_topology_change(struct device *d,
236 struct device_attribute *attr, char *buf)
237{
238 return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
239}
240static DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);
241
242static ssize_t show_topology_change_detected(struct device *d,
243 struct device_attribute *attr,
244 char *buf)
245{
246 struct net_bridge *br = to_bridge(d);
247 return sprintf(buf, "%d\n", br->topology_change_detected);
248}
249static DEVICE_ATTR(topology_change_detected, S_IRUGO,
250 show_topology_change_detected, NULL);
251
252static ssize_t show_hello_timer(struct device *d,
253 struct device_attribute *attr, char *buf)
254{
255 struct net_bridge *br = to_bridge(d);
256 return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
257}
258static DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);
259
260static ssize_t show_tcn_timer(struct device *d, struct device_attribute *attr,
261 char *buf)
262{
263 struct net_bridge *br = to_bridge(d);
264 return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
265}
266static DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);
267
268static ssize_t show_topology_change_timer(struct device *d,
269 struct device_attribute *attr,
270 char *buf)
271{
272 struct net_bridge *br = to_bridge(d);
273 return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
274}
275static DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer,
276 NULL);
277
278static ssize_t show_gc_timer(struct device *d, struct device_attribute *attr,
279 char *buf)
280{
281 struct net_bridge *br = to_bridge(d);
282 return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer));
283}
284static DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);
285
286static ssize_t show_group_addr(struct device *d,
287 struct device_attribute *attr, char *buf)
288{
289 struct net_bridge *br = to_bridge(d);
290 return sprintf(buf, "%x:%x:%x:%x:%x:%x\n",
291 br->group_addr[0], br->group_addr[1],
292 br->group_addr[2], br->group_addr[3],
293 br->group_addr[4], br->group_addr[5]);
294}
295
296static ssize_t store_group_addr(struct device *d,
297 struct device_attribute *attr,
298 const char *buf, size_t len)
299{
300 struct net_bridge *br = to_bridge(d);
301 u8 new_addr[6];
302 int i;
303
304 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
305 return -EPERM;
306
307 if (sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
308 &new_addr[0], &new_addr[1], &new_addr[2],
309 &new_addr[3], &new_addr[4], &new_addr[5]) != 6)
310 return -EINVAL;
311
312 if (!is_link_local_ether_addr(new_addr))
313 return -EINVAL;
314
315 if (new_addr[5] == 1 ||
316 new_addr[5] == 2 ||
317 new_addr[5] == 3)
318 return -EINVAL;
319
320 spin_lock_bh(&br->lock);
321 for (i = 0; i < 6; i++)
322 br->group_addr[i] = new_addr[i];
323 spin_unlock_bh(&br->lock);
324 return len;
325}
326
327static DEVICE_ATTR(group_addr, S_IRUGO | S_IWUSR,
328 show_group_addr, store_group_addr);
329
330static ssize_t store_flush(struct device *d,
331 struct device_attribute *attr,
332 const char *buf, size_t len)
333{
334 struct net_bridge *br = to_bridge(d);
335
336 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
337 return -EPERM;
338
339 br_fdb_flush(br);
340 return len;
341}
342static DEVICE_ATTR(flush, S_IWUSR, NULL, store_flush);
343
344#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
345static ssize_t show_multicast_router(struct device *d,
346 struct device_attribute *attr, char *buf)
347{
348 struct net_bridge *br = to_bridge(d);
349 return sprintf(buf, "%d\n", br->multicast_router);
350}
351
352static ssize_t store_multicast_router(struct device *d,
353 struct device_attribute *attr,
354 const char *buf, size_t len)
355{
356 return store_bridge_parm(d, buf, len, br_multicast_set_router);
357}
358static DEVICE_ATTR(multicast_router, S_IRUGO | S_IWUSR, show_multicast_router,
359 store_multicast_router);
360
361static ssize_t show_multicast_snooping(struct device *d,
362 struct device_attribute *attr,
363 char *buf)
364{
365 struct net_bridge *br = to_bridge(d);
366 return sprintf(buf, "%d\n", !br->multicast_disabled);
367}
368
369static ssize_t store_multicast_snooping(struct device *d,
370 struct device_attribute *attr,
371 const char *buf, size_t len)
372{
373 return store_bridge_parm(d, buf, len, br_multicast_toggle);
374}
375static DEVICE_ATTR(multicast_snooping, S_IRUGO | S_IWUSR,
376 show_multicast_snooping, store_multicast_snooping);
377
378static ssize_t show_multicast_query_use_ifaddr(struct device *d,
379 struct device_attribute *attr,
380 char *buf)
381{
382 struct net_bridge *br = to_bridge(d);
383 return sprintf(buf, "%d\n", br->multicast_query_use_ifaddr);
384}
385
386static int set_query_use_ifaddr(struct net_bridge *br, unsigned long val)
387{
388 br->multicast_query_use_ifaddr = !!val;
389 return 0;
390}
391
392static ssize_t
393store_multicast_query_use_ifaddr(struct device *d,
394 struct device_attribute *attr,
395 const char *buf, size_t len)
396{
397 return store_bridge_parm(d, buf, len, set_query_use_ifaddr);
398}
399static DEVICE_ATTR(multicast_query_use_ifaddr, S_IRUGO | S_IWUSR,
400 show_multicast_query_use_ifaddr,
401 store_multicast_query_use_ifaddr);
402
403static ssize_t show_multicast_querier(struct device *d,
404 struct device_attribute *attr,
405 char *buf)
406{
407 struct net_bridge *br = to_bridge(d);
408 return sprintf(buf, "%d\n", br->multicast_querier);
409}
410
411static ssize_t store_multicast_querier(struct device *d,
412 struct device_attribute *attr,
413 const char *buf, size_t len)
414{
415 return store_bridge_parm(d, buf, len, br_multicast_set_querier);
416}
417static DEVICE_ATTR(multicast_querier, S_IRUGO | S_IWUSR,
418 show_multicast_querier, store_multicast_querier);
419
420static ssize_t show_hash_elasticity(struct device *d,
421 struct device_attribute *attr, char *buf)
422{
423 struct net_bridge *br = to_bridge(d);
424 return sprintf(buf, "%u\n", br->hash_elasticity);
425}
426
427static int set_elasticity(struct net_bridge *br, unsigned long val)
428{
429 br->hash_elasticity = val;
430 return 0;
431}
432
433static ssize_t store_hash_elasticity(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_elasticity);
438}
439static DEVICE_ATTR(hash_elasticity, S_IRUGO | S_IWUSR, show_hash_elasticity,
440 store_hash_elasticity);
441
442static ssize_t show_hash_max(struct device *d, struct device_attribute *attr,
443 char *buf)
444{
445 struct net_bridge *br = to_bridge(d);
446 return sprintf(buf, "%u\n", br->hash_max);
447}
448
449static ssize_t store_hash_max(struct device *d, struct device_attribute *attr,
450 const char *buf, size_t len)
451{
452 return store_bridge_parm(d, buf, len, br_multicast_set_hash_max);
453}
454static DEVICE_ATTR(hash_max, S_IRUGO | S_IWUSR, show_hash_max,
455 store_hash_max);
456
457static ssize_t show_multicast_last_member_count(struct device *d,
458 struct device_attribute *attr,
459 char *buf)
460{
461 struct net_bridge *br = to_bridge(d);
462 return sprintf(buf, "%u\n", br->multicast_last_member_count);
463}
464
465static int set_last_member_count(struct net_bridge *br, unsigned long val)
466{
467 br->multicast_last_member_count = val;
468 return 0;
469}
470
471static ssize_t store_multicast_last_member_count(struct device *d,
472 struct device_attribute *attr,
473 const char *buf, size_t len)
474{
475 return store_bridge_parm(d, buf, len, set_last_member_count);
476}
477static DEVICE_ATTR(multicast_last_member_count, S_IRUGO | S_IWUSR,
478 show_multicast_last_member_count,
479 store_multicast_last_member_count);
480
481static ssize_t show_multicast_startup_query_count(
482 struct device *d, struct device_attribute *attr, char *buf)
483{
484 struct net_bridge *br = to_bridge(d);
485 return sprintf(buf, "%u\n", br->multicast_startup_query_count);
486}
487
488static int set_startup_query_count(struct net_bridge *br, unsigned long val)
489{
490 br->multicast_startup_query_count = val;
491 return 0;
492}
493
494static ssize_t store_multicast_startup_query_count(
495 struct device *d, struct device_attribute *attr, const char *buf,
496 size_t len)
497{
498 return store_bridge_parm(d, buf, len, set_startup_query_count);
499}
500static DEVICE_ATTR(multicast_startup_query_count, S_IRUGO | S_IWUSR,
501 show_multicast_startup_query_count,
502 store_multicast_startup_query_count);
503
504static ssize_t show_multicast_last_member_interval(
505 struct device *d, struct device_attribute *attr, char *buf)
506{
507 struct net_bridge *br = to_bridge(d);
508 return sprintf(buf, "%lu\n",
509 jiffies_to_clock_t(br->multicast_last_member_interval));
510}
511
512static int set_last_member_interval(struct net_bridge *br, unsigned long val)
513{
514 br->multicast_last_member_interval = clock_t_to_jiffies(val);
515 return 0;
516}
517
518static ssize_t store_multicast_last_member_interval(
519 struct device *d, struct device_attribute *attr, const char *buf,
520 size_t len)
521{
522 return store_bridge_parm(d, buf, len, set_last_member_interval);
523}
524static DEVICE_ATTR(multicast_last_member_interval, S_IRUGO | S_IWUSR,
525 show_multicast_last_member_interval,
526 store_multicast_last_member_interval);
527
528static ssize_t show_multicast_membership_interval(
529 struct device *d, struct device_attribute *attr, char *buf)
530{
531 struct net_bridge *br = to_bridge(d);
532 return sprintf(buf, "%lu\n",
533 jiffies_to_clock_t(br->multicast_membership_interval));
534}
535
536static int set_membership_interval(struct net_bridge *br, unsigned long val)
537{
538 br->multicast_membership_interval = clock_t_to_jiffies(val);
539 return 0;
540}
541
542static ssize_t store_multicast_membership_interval(
543 struct device *d, struct device_attribute *attr, const char *buf,
544 size_t len)
545{
546 return store_bridge_parm(d, buf, len, set_membership_interval);
547}
548static DEVICE_ATTR(multicast_membership_interval, S_IRUGO | S_IWUSR,
549 show_multicast_membership_interval,
550 store_multicast_membership_interval);
551
552static ssize_t show_multicast_querier_interval(struct device *d,
553 struct device_attribute *attr,
554 char *buf)
555{
556 struct net_bridge *br = to_bridge(d);
557 return sprintf(buf, "%lu\n",
558 jiffies_to_clock_t(br->multicast_querier_interval));
559}
560
561static int set_querier_interval(struct net_bridge *br, unsigned long val)
562{
563 br->multicast_querier_interval = clock_t_to_jiffies(val);
564 return 0;
565}
566
567static ssize_t store_multicast_querier_interval(struct device *d,
568 struct device_attribute *attr,
569 const char *buf, size_t len)
570{
571 return store_bridge_parm(d, buf, len, set_querier_interval);
572}
573static DEVICE_ATTR(multicast_querier_interval, S_IRUGO | S_IWUSR,
574 show_multicast_querier_interval,
575 store_multicast_querier_interval);
576
577static ssize_t show_multicast_query_interval(struct device *d,
578 struct device_attribute *attr,
579 char *buf)
580{
581 struct net_bridge *br = to_bridge(d);
582 return sprintf(buf, "%lu\n",
583 jiffies_to_clock_t(br->multicast_query_interval));
584}
585
586static int set_query_interval(struct net_bridge *br, unsigned long val)
587{
588 br->multicast_query_interval = clock_t_to_jiffies(val);
589 return 0;
590}
591
592static ssize_t store_multicast_query_interval(struct device *d,
593 struct device_attribute *attr,
594 const char *buf, size_t len)
595{
596 return store_bridge_parm(d, buf, len, set_query_interval);
597}
598static DEVICE_ATTR(multicast_query_interval, S_IRUGO | S_IWUSR,
599 show_multicast_query_interval,
600 store_multicast_query_interval);
601
602static ssize_t show_multicast_query_response_interval(
603 struct device *d, struct device_attribute *attr, char *buf)
604{
605 struct net_bridge *br = to_bridge(d);
606 return sprintf(
607 buf, "%lu\n",
608 jiffies_to_clock_t(br->multicast_query_response_interval));
609}
610
611static int set_query_response_interval(struct net_bridge *br, unsigned long val)
612{
613 br->multicast_query_response_interval = clock_t_to_jiffies(val);
614 return 0;
615}
616
617static ssize_t store_multicast_query_response_interval(
618 struct device *d, struct device_attribute *attr, const char *buf,
619 size_t len)
620{
621 return store_bridge_parm(d, buf, len, set_query_response_interval);
622}
623static DEVICE_ATTR(multicast_query_response_interval, S_IRUGO | S_IWUSR,
624 show_multicast_query_response_interval,
625 store_multicast_query_response_interval);
626
627static ssize_t show_multicast_startup_query_interval(
628 struct device *d, struct device_attribute *attr, char *buf)
629{
630 struct net_bridge *br = to_bridge(d);
631 return sprintf(
632 buf, "%lu\n",
633 jiffies_to_clock_t(br->multicast_startup_query_interval));
634}
635
636static int set_startup_query_interval(struct net_bridge *br, unsigned long val)
637{
638 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
639 return 0;
640}
641
642static ssize_t store_multicast_startup_query_interval(
643 struct device *d, struct device_attribute *attr, const char *buf,
644 size_t len)
645{
646 return store_bridge_parm(d, buf, len, set_startup_query_interval);
647}
648static DEVICE_ATTR(multicast_startup_query_interval, S_IRUGO | S_IWUSR,
649 show_multicast_startup_query_interval,
650 store_multicast_startup_query_interval);
651#endif
652#ifdef CONFIG_BRIDGE_NETFILTER
653static ssize_t show_nf_call_iptables(
654 struct device *d, struct device_attribute *attr, char *buf)
655{
656 struct net_bridge *br = to_bridge(d);
657 return sprintf(buf, "%u\n", br->nf_call_iptables);
658}
659
660static int set_nf_call_iptables(struct net_bridge *br, unsigned long val)
661{
662 br->nf_call_iptables = val ? true : false;
663 return 0;
664}
665
666static ssize_t store_nf_call_iptables(
667 struct device *d, struct device_attribute *attr, const char *buf,
668 size_t len)
669{
670 return store_bridge_parm(d, buf, len, set_nf_call_iptables);
671}
672static DEVICE_ATTR(nf_call_iptables, S_IRUGO | S_IWUSR,
673 show_nf_call_iptables, store_nf_call_iptables);
674
675static ssize_t show_nf_call_ip6tables(
676 struct device *d, struct device_attribute *attr, char *buf)
677{
678 struct net_bridge *br = to_bridge(d);
679 return sprintf(buf, "%u\n", br->nf_call_ip6tables);
680}
681
682static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val)
683{
684 br->nf_call_ip6tables = val ? true : false;
685 return 0;
686}
687
688static ssize_t store_nf_call_ip6tables(
689 struct device *d, struct device_attribute *attr, const char *buf,
690 size_t len)
691{
692 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables);
693}
694static DEVICE_ATTR(nf_call_ip6tables, S_IRUGO | S_IWUSR,
695 show_nf_call_ip6tables, store_nf_call_ip6tables);
696
697static ssize_t show_nf_call_arptables(
698 struct device *d, struct device_attribute *attr, char *buf)
699{
700 struct net_bridge *br = to_bridge(d);
701 return sprintf(buf, "%u\n", br->nf_call_arptables);
702}
703
704static int set_nf_call_arptables(struct net_bridge *br, unsigned long val)
705{
706 br->nf_call_arptables = val ? true : false;
707 return 0;
708}
709
710static ssize_t store_nf_call_arptables(
711 struct device *d, struct device_attribute *attr, const char *buf,
712 size_t len)
713{
714 return store_bridge_parm(d, buf, len, set_nf_call_arptables);
715}
716static DEVICE_ATTR(nf_call_arptables, S_IRUGO | S_IWUSR,
717 show_nf_call_arptables, store_nf_call_arptables);
718#endif
719#ifdef CONFIG_BRIDGE_VLAN_FILTERING
720static ssize_t show_vlan_filtering(struct device *d,
721 struct device_attribute *attr,
722 char *buf)
723{
724 struct net_bridge *br = to_bridge(d);
725 return sprintf(buf, "%d\n", br->vlan_enabled);
726}
727
728static ssize_t store_vlan_filtering(struct device *d,
729 struct device_attribute *attr,
730 const char *buf, size_t len)
731{
732 return store_bridge_parm(d, buf, len, br_vlan_filter_toggle);
733}
734static DEVICE_ATTR(vlan_filtering, S_IRUGO | S_IWUSR,
735 show_vlan_filtering, store_vlan_filtering);
736#endif
737
738static struct attribute *bridge_attrs[] = {
739 &dev_attr_forward_delay.attr,
740 &dev_attr_hello_time.attr,
741 &dev_attr_max_age.attr,
742 &dev_attr_ageing_time.attr,
743 &dev_attr_stp_state.attr,
744 &dev_attr_group_fwd_mask.attr,
745 &dev_attr_priority.attr,
746 &dev_attr_bridge_id.attr,
747 &dev_attr_root_id.attr,
748 &dev_attr_root_path_cost.attr,
749 &dev_attr_root_port.attr,
750 &dev_attr_topology_change.attr,
751 &dev_attr_topology_change_detected.attr,
752 &dev_attr_hello_timer.attr,
753 &dev_attr_tcn_timer.attr,
754 &dev_attr_topology_change_timer.attr,
755 &dev_attr_gc_timer.attr,
756 &dev_attr_group_addr.attr,
757 &dev_attr_flush.attr,
758#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
759 &dev_attr_multicast_router.attr,
760 &dev_attr_multicast_snooping.attr,
761 &dev_attr_multicast_querier.attr,
762 &dev_attr_multicast_query_use_ifaddr.attr,
763 &dev_attr_hash_elasticity.attr,
764 &dev_attr_hash_max.attr,
765 &dev_attr_multicast_last_member_count.attr,
766 &dev_attr_multicast_startup_query_count.attr,
767 &dev_attr_multicast_last_member_interval.attr,
768 &dev_attr_multicast_membership_interval.attr,
769 &dev_attr_multicast_querier_interval.attr,
770 &dev_attr_multicast_query_interval.attr,
771 &dev_attr_multicast_query_response_interval.attr,
772 &dev_attr_multicast_startup_query_interval.attr,
773#endif
774#ifdef CONFIG_BRIDGE_NETFILTER
775 &dev_attr_nf_call_iptables.attr,
776 &dev_attr_nf_call_ip6tables.attr,
777 &dev_attr_nf_call_arptables.attr,
778#endif
779#ifdef CONFIG_BRIDGE_VLAN_FILTERING
780 &dev_attr_vlan_filtering.attr,
781#endif
782 NULL
783};
784
785static struct attribute_group bridge_group = {
786 .name = SYSFS_BRIDGE_ATTR,
787 .attrs = bridge_attrs,
788};
789
790
791
792
793
794
795
796static ssize_t brforward_read(struct file *filp, struct kobject *kobj,
797 struct bin_attribute *bin_attr,
798 char *buf, loff_t off, size_t count)
799{
800 struct device *dev = to_dev(kobj);
801 struct net_bridge *br = to_bridge(dev);
802 int n;
803
804
805 if (off % sizeof(struct __fdb_entry) != 0)
806 return -EINVAL;
807
808 n = br_fdb_fillbuf(br, buf,
809 count / sizeof(struct __fdb_entry),
810 off / sizeof(struct __fdb_entry));
811
812 if (n > 0)
813 n *= sizeof(struct __fdb_entry);
814
815 return n;
816}
817
818static struct bin_attribute bridge_forward = {
819 .attr = { .name = SYSFS_BRIDGE_FDB,
820 .mode = S_IRUGO, },
821 .read = brforward_read,
822};
823
824
825
826
827
828
829
830
831
832
833
834
835int br_sysfs_addbr(struct net_device *dev)
836{
837 struct kobject *brobj = &dev->dev.kobj;
838 struct net_bridge *br = netdev_priv(dev);
839 int err;
840
841 err = sysfs_create_group(brobj, &bridge_group);
842 if (err) {
843 pr_info("%s: can't create group %s/%s\n",
844 __func__, dev->name, bridge_group.name);
845 goto out1;
846 }
847
848 err = sysfs_create_bin_file(brobj, &bridge_forward);
849 if (err) {
850 pr_info("%s: can't create attribute file %s/%s\n",
851 __func__, dev->name, bridge_forward.attr.name);
852 goto out2;
853 }
854
855 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj);
856 if (!br->ifobj) {
857 pr_info("%s: can't add kobject (directory) %s/%s\n",
858 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR);
859 goto out3;
860 }
861 return 0;
862 out3:
863 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
864 out2:
865 sysfs_remove_group(&dev->dev.kobj, &bridge_group);
866 out1:
867 return err;
868
869}
870
871void br_sysfs_delbr(struct net_device *dev)
872{
873 struct kobject *kobj = &dev->dev.kobj;
874 struct net_bridge *br = netdev_priv(dev);
875
876 kobject_put(br->ifobj);
877 sysfs_remove_bin_file(kobj, &bridge_forward);
878 sysfs_remove_group(kobj, &bridge_group);
879}
880