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#include <linux/sched/signal.h>
23
24#include "br_private.h"
25
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 if (!rtnl_trylock())
48 return restart_syscall();
49
50 err = (*set)(br, val);
51 if (!err)
52 netdev_state_change(br->dev);
53 rtnl_unlock();
54
55 return err ? err : len;
56}
57
58
59static ssize_t forward_delay_show(struct device *d,
60 struct device_attribute *attr, char *buf)
61{
62 struct net_bridge *br = to_bridge(d);
63 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay));
64}
65
66static ssize_t forward_delay_store(struct device *d,
67 struct device_attribute *attr,
68 const char *buf, size_t len)
69{
70 return store_bridge_parm(d, buf, len, br_set_forward_delay);
71}
72static DEVICE_ATTR_RW(forward_delay);
73
74static ssize_t hello_time_show(struct device *d, struct device_attribute *attr,
75 char *buf)
76{
77 return sprintf(buf, "%lu\n",
78 jiffies_to_clock_t(to_bridge(d)->hello_time));
79}
80
81static ssize_t hello_time_store(struct device *d,
82 struct device_attribute *attr, const char *buf,
83 size_t len)
84{
85 return store_bridge_parm(d, buf, len, br_set_hello_time);
86}
87static DEVICE_ATTR_RW(hello_time);
88
89static ssize_t max_age_show(struct device *d, struct device_attribute *attr,
90 char *buf)
91{
92 return sprintf(buf, "%lu\n",
93 jiffies_to_clock_t(to_bridge(d)->max_age));
94}
95
96static ssize_t max_age_store(struct device *d, struct device_attribute *attr,
97 const char *buf, size_t len)
98{
99 return store_bridge_parm(d, buf, len, br_set_max_age);
100}
101static DEVICE_ATTR_RW(max_age);
102
103static ssize_t ageing_time_show(struct device *d,
104 struct device_attribute *attr, char *buf)
105{
106 struct net_bridge *br = to_bridge(d);
107 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
108}
109
110static int set_ageing_time(struct net_bridge *br, unsigned long val)
111{
112 return br_set_ageing_time(br, val);
113}
114
115static ssize_t ageing_time_store(struct device *d,
116 struct device_attribute *attr,
117 const char *buf, size_t len)
118{
119 return store_bridge_parm(d, buf, len, set_ageing_time);
120}
121static DEVICE_ATTR_RW(ageing_time);
122
123static ssize_t stp_state_show(struct device *d,
124 struct device_attribute *attr, char *buf)
125{
126 struct net_bridge *br = to_bridge(d);
127 return sprintf(buf, "%d\n", br->stp_enabled);
128}
129
130
131static int set_stp_state(struct net_bridge *br, unsigned long val)
132{
133 br_stp_set_enabled(br, val);
134
135 return 0;
136}
137
138static ssize_t stp_state_store(struct device *d,
139 struct device_attribute *attr, const char *buf,
140 size_t len)
141{
142 return store_bridge_parm(d, buf, len, set_stp_state);
143}
144static DEVICE_ATTR_RW(stp_state);
145
146static ssize_t group_fwd_mask_show(struct device *d,
147 struct device_attribute *attr,
148 char *buf)
149{
150 struct net_bridge *br = to_bridge(d);
151 return sprintf(buf, "%#x\n", br->group_fwd_mask);
152}
153
154static int set_group_fwd_mask(struct net_bridge *br, unsigned long val)
155{
156 if (val & BR_GROUPFWD_RESTRICTED)
157 return -EINVAL;
158
159 br->group_fwd_mask = val;
160
161 return 0;
162}
163
164static ssize_t group_fwd_mask_store(struct device *d,
165 struct device_attribute *attr,
166 const char *buf,
167 size_t len)
168{
169 return store_bridge_parm(d, buf, len, set_group_fwd_mask);
170}
171static DEVICE_ATTR_RW(group_fwd_mask);
172
173static ssize_t priority_show(struct device *d, struct device_attribute *attr,
174 char *buf)
175{
176 struct net_bridge *br = to_bridge(d);
177 return sprintf(buf, "%d\n",
178 (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]);
179}
180
181static int set_priority(struct net_bridge *br, unsigned long val)
182{
183 br_stp_set_bridge_priority(br, (u16) val);
184 return 0;
185}
186
187static ssize_t priority_store(struct device *d, struct device_attribute *attr,
188 const char *buf, size_t len)
189{
190 return store_bridge_parm(d, buf, len, set_priority);
191}
192static DEVICE_ATTR_RW(priority);
193
194static ssize_t root_id_show(struct device *d, struct device_attribute *attr,
195 char *buf)
196{
197 return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
198}
199static DEVICE_ATTR_RO(root_id);
200
201static ssize_t bridge_id_show(struct device *d, struct device_attribute *attr,
202 char *buf)
203{
204 return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
205}
206static DEVICE_ATTR_RO(bridge_id);
207
208static ssize_t root_port_show(struct device *d, struct device_attribute *attr,
209 char *buf)
210{
211 return sprintf(buf, "%d\n", to_bridge(d)->root_port);
212}
213static DEVICE_ATTR_RO(root_port);
214
215static ssize_t root_path_cost_show(struct device *d,
216 struct device_attribute *attr, char *buf)
217{
218 return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
219}
220static DEVICE_ATTR_RO(root_path_cost);
221
222static ssize_t topology_change_show(struct device *d,
223 struct device_attribute *attr, char *buf)
224{
225 return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
226}
227static DEVICE_ATTR_RO(topology_change);
228
229static ssize_t topology_change_detected_show(struct device *d,
230 struct device_attribute *attr,
231 char *buf)
232{
233 struct net_bridge *br = to_bridge(d);
234 return sprintf(buf, "%d\n", br->topology_change_detected);
235}
236static DEVICE_ATTR_RO(topology_change_detected);
237
238static ssize_t hello_timer_show(struct device *d,
239 struct device_attribute *attr, char *buf)
240{
241 struct net_bridge *br = to_bridge(d);
242 return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
243}
244static DEVICE_ATTR_RO(hello_timer);
245
246static ssize_t tcn_timer_show(struct device *d, struct device_attribute *attr,
247 char *buf)
248{
249 struct net_bridge *br = to_bridge(d);
250 return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
251}
252static DEVICE_ATTR_RO(tcn_timer);
253
254static ssize_t topology_change_timer_show(struct device *d,
255 struct device_attribute *attr,
256 char *buf)
257{
258 struct net_bridge *br = to_bridge(d);
259 return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
260}
261static DEVICE_ATTR_RO(topology_change_timer);
262
263static ssize_t gc_timer_show(struct device *d, struct device_attribute *attr,
264 char *buf)
265{
266 struct net_bridge *br = to_bridge(d);
267 return sprintf(buf, "%ld\n", br_timer_value(&br->gc_work.timer));
268}
269static DEVICE_ATTR_RO(gc_timer);
270
271static ssize_t group_addr_show(struct device *d,
272 struct device_attribute *attr, char *buf)
273{
274 struct net_bridge *br = to_bridge(d);
275 return sprintf(buf, "%pM\n", br->group_addr);
276}
277
278static ssize_t group_addr_store(struct device *d,
279 struct device_attribute *attr,
280 const char *buf, size_t len)
281{
282 struct net_bridge *br = to_bridge(d);
283 u8 new_addr[6];
284
285 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
286 return -EPERM;
287
288 if (!mac_pton(buf, new_addr))
289 return -EINVAL;
290
291 if (!is_link_local_ether_addr(new_addr))
292 return -EINVAL;
293
294 if (new_addr[5] == 1 ||
295 new_addr[5] == 2 ||
296 new_addr[5] == 3)
297 return -EINVAL;
298
299 if (!rtnl_trylock())
300 return restart_syscall();
301
302 spin_lock_bh(&br->lock);
303 ether_addr_copy(br->group_addr, new_addr);
304 spin_unlock_bh(&br->lock);
305
306 br->group_addr_set = true;
307 br_recalculate_fwd_mask(br);
308 netdev_state_change(br->dev);
309
310 rtnl_unlock();
311
312 return len;
313}
314
315static DEVICE_ATTR_RW(group_addr);
316
317static int set_flush(struct net_bridge *br, unsigned long val)
318{
319 br_fdb_flush(br);
320 return 0;
321}
322
323static ssize_t flush_store(struct device *d,
324 struct device_attribute *attr,
325 const char *buf, size_t len)
326{
327 return store_bridge_parm(d, buf, len, set_flush);
328}
329static DEVICE_ATTR_WO(flush);
330
331#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
332static ssize_t multicast_router_show(struct device *d,
333 struct device_attribute *attr, char *buf)
334{
335 struct net_bridge *br = to_bridge(d);
336 return sprintf(buf, "%d\n", br->multicast_router);
337}
338
339static ssize_t multicast_router_store(struct device *d,
340 struct device_attribute *attr,
341 const char *buf, size_t len)
342{
343 return store_bridge_parm(d, buf, len, br_multicast_set_router);
344}
345static DEVICE_ATTR_RW(multicast_router);
346
347static ssize_t multicast_snooping_show(struct device *d,
348 struct device_attribute *attr,
349 char *buf)
350{
351 struct net_bridge *br = to_bridge(d);
352 return sprintf(buf, "%d\n", !br->multicast_disabled);
353}
354
355static ssize_t multicast_snooping_store(struct device *d,
356 struct device_attribute *attr,
357 const char *buf, size_t len)
358{
359 return store_bridge_parm(d, buf, len, br_multicast_toggle);
360}
361static DEVICE_ATTR_RW(multicast_snooping);
362
363static ssize_t multicast_query_use_ifaddr_show(struct device *d,
364 struct device_attribute *attr,
365 char *buf)
366{
367 struct net_bridge *br = to_bridge(d);
368 return sprintf(buf, "%d\n", br->multicast_query_use_ifaddr);
369}
370
371static int set_query_use_ifaddr(struct net_bridge *br, unsigned long val)
372{
373 br->multicast_query_use_ifaddr = !!val;
374 return 0;
375}
376
377static ssize_t
378multicast_query_use_ifaddr_store(struct device *d,
379 struct device_attribute *attr,
380 const char *buf, size_t len)
381{
382 return store_bridge_parm(d, buf, len, set_query_use_ifaddr);
383}
384static DEVICE_ATTR_RW(multicast_query_use_ifaddr);
385
386static ssize_t multicast_querier_show(struct device *d,
387 struct device_attribute *attr,
388 char *buf)
389{
390 struct net_bridge *br = to_bridge(d);
391 return sprintf(buf, "%d\n", br->multicast_querier);
392}
393
394static ssize_t multicast_querier_store(struct device *d,
395 struct device_attribute *attr,
396 const char *buf, size_t len)
397{
398 return store_bridge_parm(d, buf, len, br_multicast_set_querier);
399}
400static DEVICE_ATTR_RW(multicast_querier);
401
402static ssize_t hash_elasticity_show(struct device *d,
403 struct device_attribute *attr, char *buf)
404{
405 struct net_bridge *br = to_bridge(d);
406 return sprintf(buf, "%u\n", br->hash_elasticity);
407}
408
409static int set_elasticity(struct net_bridge *br, unsigned long val)
410{
411 br->hash_elasticity = val;
412 return 0;
413}
414
415static ssize_t hash_elasticity_store(struct device *d,
416 struct device_attribute *attr,
417 const char *buf, size_t len)
418{
419 return store_bridge_parm(d, buf, len, set_elasticity);
420}
421static DEVICE_ATTR_RW(hash_elasticity);
422
423static ssize_t hash_max_show(struct device *d, struct device_attribute *attr,
424 char *buf)
425{
426 struct net_bridge *br = to_bridge(d);
427 return sprintf(buf, "%u\n", br->hash_max);
428}
429
430static ssize_t hash_max_store(struct device *d, struct device_attribute *attr,
431 const char *buf, size_t len)
432{
433 return store_bridge_parm(d, buf, len, br_multicast_set_hash_max);
434}
435static DEVICE_ATTR_RW(hash_max);
436
437static ssize_t multicast_igmp_version_show(struct device *d,
438 struct device_attribute *attr,
439 char *buf)
440{
441 struct net_bridge *br = to_bridge(d);
442
443 return sprintf(buf, "%u\n", br->multicast_igmp_version);
444}
445
446static ssize_t multicast_igmp_version_store(struct device *d,
447 struct device_attribute *attr,
448 const char *buf, size_t len)
449{
450 return store_bridge_parm(d, buf, len, br_multicast_set_igmp_version);
451}
452static DEVICE_ATTR_RW(multicast_igmp_version);
453
454static ssize_t multicast_last_member_count_show(struct device *d,
455 struct device_attribute *attr,
456 char *buf)
457{
458 struct net_bridge *br = to_bridge(d);
459 return sprintf(buf, "%u\n", br->multicast_last_member_count);
460}
461
462static int set_last_member_count(struct net_bridge *br, unsigned long val)
463{
464 br->multicast_last_member_count = val;
465 return 0;
466}
467
468static ssize_t multicast_last_member_count_store(struct device *d,
469 struct device_attribute *attr,
470 const char *buf, size_t len)
471{
472 return store_bridge_parm(d, buf, len, set_last_member_count);
473}
474static DEVICE_ATTR_RW(multicast_last_member_count);
475
476static ssize_t multicast_startup_query_count_show(
477 struct device *d, struct device_attribute *attr, char *buf)
478{
479 struct net_bridge *br = to_bridge(d);
480 return sprintf(buf, "%u\n", br->multicast_startup_query_count);
481}
482
483static int set_startup_query_count(struct net_bridge *br, unsigned long val)
484{
485 br->multicast_startup_query_count = val;
486 return 0;
487}
488
489static ssize_t multicast_startup_query_count_store(
490 struct device *d, struct device_attribute *attr, const char *buf,
491 size_t len)
492{
493 return store_bridge_parm(d, buf, len, set_startup_query_count);
494}
495static DEVICE_ATTR_RW(multicast_startup_query_count);
496
497static ssize_t multicast_last_member_interval_show(
498 struct device *d, struct device_attribute *attr, char *buf)
499{
500 struct net_bridge *br = to_bridge(d);
501 return sprintf(buf, "%lu\n",
502 jiffies_to_clock_t(br->multicast_last_member_interval));
503}
504
505static int set_last_member_interval(struct net_bridge *br, unsigned long val)
506{
507 br->multicast_last_member_interval = clock_t_to_jiffies(val);
508 return 0;
509}
510
511static ssize_t multicast_last_member_interval_store(
512 struct device *d, struct device_attribute *attr, const char *buf,
513 size_t len)
514{
515 return store_bridge_parm(d, buf, len, set_last_member_interval);
516}
517static DEVICE_ATTR_RW(multicast_last_member_interval);
518
519static ssize_t multicast_membership_interval_show(
520 struct device *d, struct device_attribute *attr, char *buf)
521{
522 struct net_bridge *br = to_bridge(d);
523 return sprintf(buf, "%lu\n",
524 jiffies_to_clock_t(br->multicast_membership_interval));
525}
526
527static int set_membership_interval(struct net_bridge *br, unsigned long val)
528{
529 br->multicast_membership_interval = clock_t_to_jiffies(val);
530 return 0;
531}
532
533static ssize_t multicast_membership_interval_store(
534 struct device *d, struct device_attribute *attr, const char *buf,
535 size_t len)
536{
537 return store_bridge_parm(d, buf, len, set_membership_interval);
538}
539static DEVICE_ATTR_RW(multicast_membership_interval);
540
541static ssize_t multicast_querier_interval_show(struct device *d,
542 struct device_attribute *attr,
543 char *buf)
544{
545 struct net_bridge *br = to_bridge(d);
546 return sprintf(buf, "%lu\n",
547 jiffies_to_clock_t(br->multicast_querier_interval));
548}
549
550static int set_querier_interval(struct net_bridge *br, unsigned long val)
551{
552 br->multicast_querier_interval = clock_t_to_jiffies(val);
553 return 0;
554}
555
556static ssize_t multicast_querier_interval_store(struct device *d,
557 struct device_attribute *attr,
558 const char *buf, size_t len)
559{
560 return store_bridge_parm(d, buf, len, set_querier_interval);
561}
562static DEVICE_ATTR_RW(multicast_querier_interval);
563
564static ssize_t multicast_query_interval_show(struct device *d,
565 struct device_attribute *attr,
566 char *buf)
567{
568 struct net_bridge *br = to_bridge(d);
569 return sprintf(buf, "%lu\n",
570 jiffies_to_clock_t(br->multicast_query_interval));
571}
572
573static int set_query_interval(struct net_bridge *br, unsigned long val)
574{
575 br->multicast_query_interval = clock_t_to_jiffies(val);
576 return 0;
577}
578
579static ssize_t multicast_query_interval_store(struct device *d,
580 struct device_attribute *attr,
581 const char *buf, size_t len)
582{
583 return store_bridge_parm(d, buf, len, set_query_interval);
584}
585static DEVICE_ATTR_RW(multicast_query_interval);
586
587static ssize_t multicast_query_response_interval_show(
588 struct device *d, struct device_attribute *attr, char *buf)
589{
590 struct net_bridge *br = to_bridge(d);
591 return sprintf(
592 buf, "%lu\n",
593 jiffies_to_clock_t(br->multicast_query_response_interval));
594}
595
596static int set_query_response_interval(struct net_bridge *br, unsigned long val)
597{
598 br->multicast_query_response_interval = clock_t_to_jiffies(val);
599 return 0;
600}
601
602static ssize_t multicast_query_response_interval_store(
603 struct device *d, struct device_attribute *attr, const char *buf,
604 size_t len)
605{
606 return store_bridge_parm(d, buf, len, set_query_response_interval);
607}
608static DEVICE_ATTR_RW(multicast_query_response_interval);
609
610static ssize_t multicast_startup_query_interval_show(
611 struct device *d, struct device_attribute *attr, char *buf)
612{
613 struct net_bridge *br = to_bridge(d);
614 return sprintf(
615 buf, "%lu\n",
616 jiffies_to_clock_t(br->multicast_startup_query_interval));
617}
618
619static int set_startup_query_interval(struct net_bridge *br, unsigned long val)
620{
621 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
622 return 0;
623}
624
625static ssize_t multicast_startup_query_interval_store(
626 struct device *d, struct device_attribute *attr, const char *buf,
627 size_t len)
628{
629 return store_bridge_parm(d, buf, len, set_startup_query_interval);
630}
631static DEVICE_ATTR_RW(multicast_startup_query_interval);
632
633static ssize_t multicast_stats_enabled_show(struct device *d,
634 struct device_attribute *attr,
635 char *buf)
636{
637 struct net_bridge *br = to_bridge(d);
638
639 return sprintf(buf, "%u\n", br->multicast_stats_enabled);
640}
641
642static int set_stats_enabled(struct net_bridge *br, unsigned long val)
643{
644 br->multicast_stats_enabled = !!val;
645 return 0;
646}
647
648static ssize_t multicast_stats_enabled_store(struct device *d,
649 struct device_attribute *attr,
650 const char *buf,
651 size_t len)
652{
653 return store_bridge_parm(d, buf, len, set_stats_enabled);
654}
655static DEVICE_ATTR_RW(multicast_stats_enabled);
656
657#if IS_ENABLED(CONFIG_IPV6)
658static ssize_t multicast_mld_version_show(struct device *d,
659 struct device_attribute *attr,
660 char *buf)
661{
662 struct net_bridge *br = to_bridge(d);
663
664 return sprintf(buf, "%u\n", br->multicast_mld_version);
665}
666
667static ssize_t multicast_mld_version_store(struct device *d,
668 struct device_attribute *attr,
669 const char *buf, size_t len)
670{
671 return store_bridge_parm(d, buf, len, br_multicast_set_mld_version);
672}
673static DEVICE_ATTR_RW(multicast_mld_version);
674#endif
675#endif
676#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
677static ssize_t nf_call_iptables_show(
678 struct device *d, struct device_attribute *attr, char *buf)
679{
680 struct net_bridge *br = to_bridge(d);
681 return sprintf(buf, "%u\n", br->nf_call_iptables);
682}
683
684static int set_nf_call_iptables(struct net_bridge *br, unsigned long val)
685{
686 br->nf_call_iptables = val ? true : false;
687 return 0;
688}
689
690static ssize_t nf_call_iptables_store(
691 struct device *d, struct device_attribute *attr, const char *buf,
692 size_t len)
693{
694 return store_bridge_parm(d, buf, len, set_nf_call_iptables);
695}
696static DEVICE_ATTR_RW(nf_call_iptables);
697
698static ssize_t nf_call_ip6tables_show(
699 struct device *d, struct device_attribute *attr, char *buf)
700{
701 struct net_bridge *br = to_bridge(d);
702 return sprintf(buf, "%u\n", br->nf_call_ip6tables);
703}
704
705static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val)
706{
707 br->nf_call_ip6tables = val ? true : false;
708 return 0;
709}
710
711static ssize_t nf_call_ip6tables_store(
712 struct device *d, struct device_attribute *attr, const char *buf,
713 size_t len)
714{
715 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables);
716}
717static DEVICE_ATTR_RW(nf_call_ip6tables);
718
719static ssize_t nf_call_arptables_show(
720 struct device *d, struct device_attribute *attr, char *buf)
721{
722 struct net_bridge *br = to_bridge(d);
723 return sprintf(buf, "%u\n", br->nf_call_arptables);
724}
725
726static int set_nf_call_arptables(struct net_bridge *br, unsigned long val)
727{
728 br->nf_call_arptables = val ? true : false;
729 return 0;
730}
731
732static ssize_t nf_call_arptables_store(
733 struct device *d, struct device_attribute *attr, const char *buf,
734 size_t len)
735{
736 return store_bridge_parm(d, buf, len, set_nf_call_arptables);
737}
738static DEVICE_ATTR_RW(nf_call_arptables);
739#endif
740#ifdef CONFIG_BRIDGE_VLAN_FILTERING
741static ssize_t vlan_filtering_show(struct device *d,
742 struct device_attribute *attr,
743 char *buf)
744{
745 struct net_bridge *br = to_bridge(d);
746 return sprintf(buf, "%d\n", br->vlan_enabled);
747}
748
749static ssize_t vlan_filtering_store(struct device *d,
750 struct device_attribute *attr,
751 const char *buf, size_t len)
752{
753 return store_bridge_parm(d, buf, len, br_vlan_filter_toggle);
754}
755static DEVICE_ATTR_RW(vlan_filtering);
756
757static ssize_t vlan_protocol_show(struct device *d,
758 struct device_attribute *attr,
759 char *buf)
760{
761 struct net_bridge *br = to_bridge(d);
762 return sprintf(buf, "%#06x\n", ntohs(br->vlan_proto));
763}
764
765static ssize_t vlan_protocol_store(struct device *d,
766 struct device_attribute *attr,
767 const char *buf, size_t len)
768{
769 return store_bridge_parm(d, buf, len, br_vlan_set_proto);
770}
771static DEVICE_ATTR_RW(vlan_protocol);
772
773static ssize_t default_pvid_show(struct device *d,
774 struct device_attribute *attr,
775 char *buf)
776{
777 struct net_bridge *br = to_bridge(d);
778 return sprintf(buf, "%d\n", br->default_pvid);
779}
780
781static ssize_t default_pvid_store(struct device *d,
782 struct device_attribute *attr,
783 const char *buf, size_t len)
784{
785 return store_bridge_parm(d, buf, len, br_vlan_set_default_pvid);
786}
787static DEVICE_ATTR_RW(default_pvid);
788
789static ssize_t vlan_stats_enabled_show(struct device *d,
790 struct device_attribute *attr,
791 char *buf)
792{
793 struct net_bridge *br = to_bridge(d);
794 return sprintf(buf, "%u\n", br->vlan_stats_enabled);
795}
796
797static ssize_t vlan_stats_enabled_store(struct device *d,
798 struct device_attribute *attr,
799 const char *buf, size_t len)
800{
801 return store_bridge_parm(d, buf, len, br_vlan_set_stats);
802}
803static DEVICE_ATTR_RW(vlan_stats_enabled);
804#endif
805
806static struct attribute *bridge_attrs[] = {
807 &dev_attr_forward_delay.attr,
808 &dev_attr_hello_time.attr,
809 &dev_attr_max_age.attr,
810 &dev_attr_ageing_time.attr,
811 &dev_attr_stp_state.attr,
812 &dev_attr_group_fwd_mask.attr,
813 &dev_attr_priority.attr,
814 &dev_attr_bridge_id.attr,
815 &dev_attr_root_id.attr,
816 &dev_attr_root_path_cost.attr,
817 &dev_attr_root_port.attr,
818 &dev_attr_topology_change.attr,
819 &dev_attr_topology_change_detected.attr,
820 &dev_attr_hello_timer.attr,
821 &dev_attr_tcn_timer.attr,
822 &dev_attr_topology_change_timer.attr,
823 &dev_attr_gc_timer.attr,
824 &dev_attr_group_addr.attr,
825 &dev_attr_flush.attr,
826#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
827 &dev_attr_multicast_router.attr,
828 &dev_attr_multicast_snooping.attr,
829 &dev_attr_multicast_querier.attr,
830 &dev_attr_multicast_query_use_ifaddr.attr,
831 &dev_attr_hash_elasticity.attr,
832 &dev_attr_hash_max.attr,
833 &dev_attr_multicast_last_member_count.attr,
834 &dev_attr_multicast_startup_query_count.attr,
835 &dev_attr_multicast_last_member_interval.attr,
836 &dev_attr_multicast_membership_interval.attr,
837 &dev_attr_multicast_querier_interval.attr,
838 &dev_attr_multicast_query_interval.attr,
839 &dev_attr_multicast_query_response_interval.attr,
840 &dev_attr_multicast_startup_query_interval.attr,
841 &dev_attr_multicast_stats_enabled.attr,
842 &dev_attr_multicast_igmp_version.attr,
843#if IS_ENABLED(CONFIG_IPV6)
844 &dev_attr_multicast_mld_version.attr,
845#endif
846#endif
847#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
848 &dev_attr_nf_call_iptables.attr,
849 &dev_attr_nf_call_ip6tables.attr,
850 &dev_attr_nf_call_arptables.attr,
851#endif
852#ifdef CONFIG_BRIDGE_VLAN_FILTERING
853 &dev_attr_vlan_filtering.attr,
854 &dev_attr_vlan_protocol.attr,
855 &dev_attr_default_pvid.attr,
856 &dev_attr_vlan_stats_enabled.attr,
857#endif
858 NULL
859};
860
861static const struct attribute_group bridge_group = {
862 .name = SYSFS_BRIDGE_ATTR,
863 .attrs = bridge_attrs,
864};
865
866
867
868
869
870
871
872static ssize_t brforward_read(struct file *filp, struct kobject *kobj,
873 struct bin_attribute *bin_attr,
874 char *buf, loff_t off, size_t count)
875{
876 struct device *dev = kobj_to_dev(kobj);
877 struct net_bridge *br = to_bridge(dev);
878 int n;
879
880
881 if (off % sizeof(struct __fdb_entry) != 0)
882 return -EINVAL;
883
884 n = br_fdb_fillbuf(br, buf,
885 count / sizeof(struct __fdb_entry),
886 off / sizeof(struct __fdb_entry));
887
888 if (n > 0)
889 n *= sizeof(struct __fdb_entry);
890
891 return n;
892}
893
894static struct bin_attribute bridge_forward = {
895 .attr = { .name = SYSFS_BRIDGE_FDB,
896 .mode = 0444, },
897 .read = brforward_read,
898};
899
900
901
902
903
904
905
906
907
908
909
910
911int br_sysfs_addbr(struct net_device *dev)
912{
913 struct kobject *brobj = &dev->dev.kobj;
914 struct net_bridge *br = netdev_priv(dev);
915 int err;
916
917 err = sysfs_create_group(brobj, &bridge_group);
918 if (err) {
919 pr_info("%s: can't create group %s/%s\n",
920 __func__, dev->name, bridge_group.name);
921 goto out1;
922 }
923
924 err = sysfs_create_bin_file(brobj, &bridge_forward);
925 if (err) {
926 pr_info("%s: can't create attribute file %s/%s\n",
927 __func__, dev->name, bridge_forward.attr.name);
928 goto out2;
929 }
930
931 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj);
932 if (!br->ifobj) {
933 pr_info("%s: can't add kobject (directory) %s/%s\n",
934 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR);
935 err = -ENOMEM;
936 goto out3;
937 }
938 return 0;
939 out3:
940 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
941 out2:
942 sysfs_remove_group(&dev->dev.kobj, &bridge_group);
943 out1:
944 return err;
945
946}
947
948void br_sysfs_delbr(struct net_device *dev)
949{
950 struct kobject *kobj = &dev->dev.kobj;
951 struct net_bridge *br = netdev_priv(dev);
952
953 kobject_put(br->ifobj);
954 sysfs_remove_bin_file(kobj, &bridge_forward);
955 sysfs_remove_group(kobj, &bridge_group);
956}
957
