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, "%x:%x:%x:%x:%x:%x\n",
276 br->group_addr[0], br->group_addr[1],
277 br->group_addr[2], br->group_addr[3],
278 br->group_addr[4], br->group_addr[5]);
279}
280
281static ssize_t group_addr_store(struct device *d,
282 struct device_attribute *attr,
283 const char *buf, size_t len)
284{
285 struct net_bridge *br = to_bridge(d);
286 u8 new_addr[6];
287 int i;
288
289 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
290 return -EPERM;
291
292 if (sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
293 &new_addr[0], &new_addr[1], &new_addr[2],
294 &new_addr[3], &new_addr[4], &new_addr[5]) != 6)
295 return -EINVAL;
296
297 if (!is_link_local_ether_addr(new_addr))
298 return -EINVAL;
299
300 if (new_addr[5] == 1 ||
301 new_addr[5] == 2 ||
302 new_addr[5] == 3)
303 return -EINVAL;
304
305 if (!rtnl_trylock())
306 return restart_syscall();
307
308 spin_lock_bh(&br->lock);
309 for (i = 0; i < 6; i++)
310 br->group_addr[i] = new_addr[i];
311 spin_unlock_bh(&br->lock);
312
313 br->group_addr_set = true;
314 br_recalculate_fwd_mask(br);
315 netdev_state_change(br->dev);
316
317 rtnl_unlock();
318
319 return len;
320}
321
322static DEVICE_ATTR_RW(group_addr);
323
324static int set_flush(struct net_bridge *br, unsigned long val)
325{
326 br_fdb_flush(br);
327 return 0;
328}
329
330static ssize_t flush_store(struct device *d,
331 struct device_attribute *attr,
332 const char *buf, size_t len)
333{
334 return store_bridge_parm(d, buf, len, set_flush);
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_igmp_version_show(struct device *d,
445 struct device_attribute *attr,
446 char *buf)
447{
448 struct net_bridge *br = to_bridge(d);
449
450 return sprintf(buf, "%u\n", br->multicast_igmp_version);
451}
452
453static ssize_t multicast_igmp_version_store(struct device *d,
454 struct device_attribute *attr,
455 const char *buf, size_t len)
456{
457 return store_bridge_parm(d, buf, len, br_multicast_set_igmp_version);
458}
459static DEVICE_ATTR_RW(multicast_igmp_version);
460
461static ssize_t multicast_last_member_count_show(struct device *d,
462 struct device_attribute *attr,
463 char *buf)
464{
465 struct net_bridge *br = to_bridge(d);
466 return sprintf(buf, "%u\n", br->multicast_last_member_count);
467}
468
469static int set_last_member_count(struct net_bridge *br, unsigned long val)
470{
471 br->multicast_last_member_count = val;
472 return 0;
473}
474
475static ssize_t multicast_last_member_count_store(struct device *d,
476 struct device_attribute *attr,
477 const char *buf, size_t len)
478{
479 return store_bridge_parm(d, buf, len, set_last_member_count);
480}
481static DEVICE_ATTR_RW(multicast_last_member_count);
482
483static ssize_t multicast_startup_query_count_show(
484 struct device *d, struct device_attribute *attr, char *buf)
485{
486 struct net_bridge *br = to_bridge(d);
487 return sprintf(buf, "%u\n", br->multicast_startup_query_count);
488}
489
490static int set_startup_query_count(struct net_bridge *br, unsigned long val)
491{
492 br->multicast_startup_query_count = val;
493 return 0;
494}
495
496static ssize_t multicast_startup_query_count_store(
497 struct device *d, struct device_attribute *attr, const char *buf,
498 size_t len)
499{
500 return store_bridge_parm(d, buf, len, set_startup_query_count);
501}
502static DEVICE_ATTR_RW(multicast_startup_query_count);
503
504static ssize_t multicast_last_member_interval_show(
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 multicast_last_member_interval_store(
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_RW(multicast_last_member_interval);
525
526static ssize_t multicast_membership_interval_show(
527 struct device *d, struct device_attribute *attr, char *buf)
528{
529 struct net_bridge *br = to_bridge(d);
530 return sprintf(buf, "%lu\n",
531 jiffies_to_clock_t(br->multicast_membership_interval));
532}
533
534static int set_membership_interval(struct net_bridge *br, unsigned long val)
535{
536 br->multicast_membership_interval = clock_t_to_jiffies(val);
537 return 0;
538}
539
540static ssize_t multicast_membership_interval_store(
541 struct device *d, struct device_attribute *attr, const char *buf,
542 size_t len)
543{
544 return store_bridge_parm(d, buf, len, set_membership_interval);
545}
546static DEVICE_ATTR_RW(multicast_membership_interval);
547
548static ssize_t multicast_querier_interval_show(struct device *d,
549 struct device_attribute *attr,
550 char *buf)
551{
552 struct net_bridge *br = to_bridge(d);
553 return sprintf(buf, "%lu\n",
554 jiffies_to_clock_t(br->multicast_querier_interval));
555}
556
557static int set_querier_interval(struct net_bridge *br, unsigned long val)
558{
559 br->multicast_querier_interval = clock_t_to_jiffies(val);
560 return 0;
561}
562
563static ssize_t multicast_querier_interval_store(struct device *d,
564 struct device_attribute *attr,
565 const char *buf, size_t len)
566{
567 return store_bridge_parm(d, buf, len, set_querier_interval);
568}
569static DEVICE_ATTR_RW(multicast_querier_interval);
570
571static ssize_t multicast_query_interval_show(struct device *d,
572 struct device_attribute *attr,
573 char *buf)
574{
575 struct net_bridge *br = to_bridge(d);
576 return sprintf(buf, "%lu\n",
577 jiffies_to_clock_t(br->multicast_query_interval));
578}
579
580static int set_query_interval(struct net_bridge *br, unsigned long val)
581{
582 br->multicast_query_interval = clock_t_to_jiffies(val);
583 return 0;
584}
585
586static ssize_t multicast_query_interval_store(struct device *d,
587 struct device_attribute *attr,
588 const char *buf, size_t len)
589{
590 return store_bridge_parm(d, buf, len, set_query_interval);
591}
592static DEVICE_ATTR_RW(multicast_query_interval);
593
594static ssize_t multicast_query_response_interval_show(
595 struct device *d, struct device_attribute *attr, char *buf)
596{
597 struct net_bridge *br = to_bridge(d);
598 return sprintf(
599 buf, "%lu\n",
600 jiffies_to_clock_t(br->multicast_query_response_interval));
601}
602
603static int set_query_response_interval(struct net_bridge *br, unsigned long val)
604{
605 br->multicast_query_response_interval = clock_t_to_jiffies(val);
606 return 0;
607}
608
609static ssize_t multicast_query_response_interval_store(
610 struct device *d, struct device_attribute *attr, const char *buf,
611 size_t len)
612{
613 return store_bridge_parm(d, buf, len, set_query_response_interval);
614}
615static DEVICE_ATTR_RW(multicast_query_response_interval);
616
617static ssize_t multicast_startup_query_interval_show(
618 struct device *d, struct device_attribute *attr, char *buf)
619{
620 struct net_bridge *br = to_bridge(d);
621 return sprintf(
622 buf, "%lu\n",
623 jiffies_to_clock_t(br->multicast_startup_query_interval));
624}
625
626static int set_startup_query_interval(struct net_bridge *br, unsigned long val)
627{
628 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
629 return 0;
630}
631
632static ssize_t multicast_startup_query_interval_store(
633 struct device *d, struct device_attribute *attr, const char *buf,
634 size_t len)
635{
636 return store_bridge_parm(d, buf, len, set_startup_query_interval);
637}
638static DEVICE_ATTR_RW(multicast_startup_query_interval);
639
640static ssize_t multicast_stats_enabled_show(struct device *d,
641 struct device_attribute *attr,
642 char *buf)
643{
644 struct net_bridge *br = to_bridge(d);
645
646 return sprintf(buf, "%u\n", br->multicast_stats_enabled);
647}
648
649static int set_stats_enabled(struct net_bridge *br, unsigned long val)
650{
651 br->multicast_stats_enabled = !!val;
652 return 0;
653}
654
655static ssize_t multicast_stats_enabled_store(struct device *d,
656 struct device_attribute *attr,
657 const char *buf,
658 size_t len)
659{
660 return store_bridge_parm(d, buf, len, set_stats_enabled);
661}
662static DEVICE_ATTR_RW(multicast_stats_enabled);
663
664#if IS_ENABLED(CONFIG_IPV6)
665static ssize_t multicast_mld_version_show(struct device *d,
666 struct device_attribute *attr,
667 char *buf)
668{
669 struct net_bridge *br = to_bridge(d);
670
671 return sprintf(buf, "%u\n", br->multicast_mld_version);
672}
673
674static ssize_t multicast_mld_version_store(struct device *d,
675 struct device_attribute *attr,
676 const char *buf, size_t len)
677{
678 return store_bridge_parm(d, buf, len, br_multicast_set_mld_version);
679}
680static DEVICE_ATTR_RW(multicast_mld_version);
681#endif
682#endif
683#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
684static ssize_t nf_call_iptables_show(
685 struct device *d, struct device_attribute *attr, char *buf)
686{
687 struct net_bridge *br = to_bridge(d);
688 return sprintf(buf, "%u\n", br->nf_call_iptables);
689}
690
691static int set_nf_call_iptables(struct net_bridge *br, unsigned long val)
692{
693 br->nf_call_iptables = val ? true : false;
694 return 0;
695}
696
697static ssize_t nf_call_iptables_store(
698 struct device *d, struct device_attribute *attr, const char *buf,
699 size_t len)
700{
701 return store_bridge_parm(d, buf, len, set_nf_call_iptables);
702}
703static DEVICE_ATTR_RW(nf_call_iptables);
704
705static ssize_t nf_call_ip6tables_show(
706 struct device *d, struct device_attribute *attr, char *buf)
707{
708 struct net_bridge *br = to_bridge(d);
709 return sprintf(buf, "%u\n", br->nf_call_ip6tables);
710}
711
712static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val)
713{
714 br->nf_call_ip6tables = val ? true : false;
715 return 0;
716}
717
718static ssize_t nf_call_ip6tables_store(
719 struct device *d, struct device_attribute *attr, const char *buf,
720 size_t len)
721{
722 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables);
723}
724static DEVICE_ATTR_RW(nf_call_ip6tables);
725
726static ssize_t nf_call_arptables_show(
727 struct device *d, struct device_attribute *attr, char *buf)
728{
729 struct net_bridge *br = to_bridge(d);
730 return sprintf(buf, "%u\n", br->nf_call_arptables);
731}
732
733static int set_nf_call_arptables(struct net_bridge *br, unsigned long val)
734{
735 br->nf_call_arptables = val ? true : false;
736 return 0;
737}
738
739static ssize_t nf_call_arptables_store(
740 struct device *d, struct device_attribute *attr, const char *buf,
741 size_t len)
742{
743 return store_bridge_parm(d, buf, len, set_nf_call_arptables);
744}
745static DEVICE_ATTR_RW(nf_call_arptables);
746#endif
747#ifdef CONFIG_BRIDGE_VLAN_FILTERING
748static ssize_t vlan_filtering_show(struct device *d,
749 struct device_attribute *attr,
750 char *buf)
751{
752 struct net_bridge *br = to_bridge(d);
753 return sprintf(buf, "%d\n", br->vlan_enabled);
754}
755
756static ssize_t vlan_filtering_store(struct device *d,
757 struct device_attribute *attr,
758 const char *buf, size_t len)
759{
760 return store_bridge_parm(d, buf, len, br_vlan_filter_toggle);
761}
762static DEVICE_ATTR_RW(vlan_filtering);
763
764static ssize_t vlan_protocol_show(struct device *d,
765 struct device_attribute *attr,
766 char *buf)
767{
768 struct net_bridge *br = to_bridge(d);
769 return sprintf(buf, "%#06x\n", ntohs(br->vlan_proto));
770}
771
772static ssize_t vlan_protocol_store(struct device *d,
773 struct device_attribute *attr,
774 const char *buf, size_t len)
775{
776 return store_bridge_parm(d, buf, len, br_vlan_set_proto);
777}
778static DEVICE_ATTR_RW(vlan_protocol);
779
780static ssize_t default_pvid_show(struct device *d,
781 struct device_attribute *attr,
782 char *buf)
783{
784 struct net_bridge *br = to_bridge(d);
785 return sprintf(buf, "%d\n", br->default_pvid);
786}
787
788static ssize_t default_pvid_store(struct device *d,
789 struct device_attribute *attr,
790 const char *buf, size_t len)
791{
792 return store_bridge_parm(d, buf, len, br_vlan_set_default_pvid);
793}
794static DEVICE_ATTR_RW(default_pvid);
795
796static ssize_t vlan_stats_enabled_show(struct device *d,
797 struct device_attribute *attr,
798 char *buf)
799{
800 struct net_bridge *br = to_bridge(d);
801 return sprintf(buf, "%u\n", br->vlan_stats_enabled);
802}
803
804static ssize_t vlan_stats_enabled_store(struct device *d,
805 struct device_attribute *attr,
806 const char *buf, size_t len)
807{
808 return store_bridge_parm(d, buf, len, br_vlan_set_stats);
809}
810static DEVICE_ATTR_RW(vlan_stats_enabled);
811#endif
812
813static struct attribute *bridge_attrs[] = {
814 &dev_attr_forward_delay.attr,
815 &dev_attr_hello_time.attr,
816 &dev_attr_max_age.attr,
817 &dev_attr_ageing_time.attr,
818 &dev_attr_stp_state.attr,
819 &dev_attr_group_fwd_mask.attr,
820 &dev_attr_priority.attr,
821 &dev_attr_bridge_id.attr,
822 &dev_attr_root_id.attr,
823 &dev_attr_root_path_cost.attr,
824 &dev_attr_root_port.attr,
825 &dev_attr_topology_change.attr,
826 &dev_attr_topology_change_detected.attr,
827 &dev_attr_hello_timer.attr,
828 &dev_attr_tcn_timer.attr,
829 &dev_attr_topology_change_timer.attr,
830 &dev_attr_gc_timer.attr,
831 &dev_attr_group_addr.attr,
832 &dev_attr_flush.attr,
833#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
834 &dev_attr_multicast_router.attr,
835 &dev_attr_multicast_snooping.attr,
836 &dev_attr_multicast_querier.attr,
837 &dev_attr_multicast_query_use_ifaddr.attr,
838 &dev_attr_hash_elasticity.attr,
839 &dev_attr_hash_max.attr,
840 &dev_attr_multicast_last_member_count.attr,
841 &dev_attr_multicast_startup_query_count.attr,
842 &dev_attr_multicast_last_member_interval.attr,
843 &dev_attr_multicast_membership_interval.attr,
844 &dev_attr_multicast_querier_interval.attr,
845 &dev_attr_multicast_query_interval.attr,
846 &dev_attr_multicast_query_response_interval.attr,
847 &dev_attr_multicast_startup_query_interval.attr,
848 &dev_attr_multicast_stats_enabled.attr,
849 &dev_attr_multicast_igmp_version.attr,
850#if IS_ENABLED(CONFIG_IPV6)
851 &dev_attr_multicast_mld_version.attr,
852#endif
853#endif
854#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
855 &dev_attr_nf_call_iptables.attr,
856 &dev_attr_nf_call_ip6tables.attr,
857 &dev_attr_nf_call_arptables.attr,
858#endif
859#ifdef CONFIG_BRIDGE_VLAN_FILTERING
860 &dev_attr_vlan_filtering.attr,
861 &dev_attr_vlan_protocol.attr,
862 &dev_attr_default_pvid.attr,
863 &dev_attr_vlan_stats_enabled.attr,
864#endif
865 NULL
866};
867
868static const struct attribute_group bridge_group = {
869 .name = SYSFS_BRIDGE_ATTR,
870 .attrs = bridge_attrs,
871};
872
873
874
875
876
877
878
879static ssize_t brforward_read(struct file *filp, struct kobject *kobj,
880 struct bin_attribute *bin_attr,
881 char *buf, loff_t off, size_t count)
882{
883 struct device *dev = kobj_to_dev(kobj);
884 struct net_bridge *br = to_bridge(dev);
885 int n;
886
887
888 if (off % sizeof(struct __fdb_entry) != 0)
889 return -EINVAL;
890
891 n = br_fdb_fillbuf(br, buf,
892 count / sizeof(struct __fdb_entry),
893 off / sizeof(struct __fdb_entry));
894
895 if (n > 0)
896 n *= sizeof(struct __fdb_entry);
897
898 return n;
899}
900
901static struct bin_attribute bridge_forward = {
902 .attr = { .name = SYSFS_BRIDGE_FDB,
903 .mode = S_IRUGO, },
904 .read = brforward_read,
905};
906
907
908
909
910
911
912
913
914
915
916
917
918int br_sysfs_addbr(struct net_device *dev)
919{
920 struct kobject *brobj = &dev->dev.kobj;
921 struct net_bridge *br = netdev_priv(dev);
922 int err;
923
924 err = sysfs_create_group(brobj, &bridge_group);
925 if (err) {
926 pr_info("%s: can't create group %s/%s\n",
927 __func__, dev->name, bridge_group.name);
928 goto out1;
929 }
930
931 err = sysfs_create_bin_file(brobj, &bridge_forward);
932 if (err) {
933 pr_info("%s: can't create attribute file %s/%s\n",
934 __func__, dev->name, bridge_forward.attr.name);
935 goto out2;
936 }
937
938 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj);
939 if (!br->ifobj) {
940 pr_info("%s: can't add kobject (directory) %s/%s\n",
941 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR);
942 err = -ENOMEM;
943 goto out3;
944 }
945 return 0;
946 out3:
947 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
948 out2:
949 sysfs_remove_group(&dev->dev.kobj, &bridge_group);
950 out1:
951 return err;
952
953}
954
955void br_sysfs_delbr(struct net_device *dev)
956{
957 struct kobject *kobj = &dev->dev.kobj;
958 struct net_bridge *br = netdev_priv(dev);
959
960 kobject_put(br->ifobj);
961 sysfs_remove_bin_file(kobj, &bridge_forward);
962 sysfs_remove_group(kobj, &bridge_group);
963}
964
