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