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