xref: /linux/net/bridge/br_sysfs_br.c (revision c411ed854584a71b0e86ac3019b60e4789d88086)
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 #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  * Common code for storing bridge parameters.
30  */
31 static 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 
59 static 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 
66 static 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 }
72 static DEVICE_ATTR_RW(forward_delay);
73 
74 static 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 
81 static 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 }
87 static DEVICE_ATTR_RW(hello_time);
88 
89 static 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 
96 static 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 }
101 static DEVICE_ATTR_RW(max_age);
102 
103 static 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 
110 static int set_ageing_time(struct net_bridge *br, unsigned long val)
111 {
112 	return br_set_ageing_time(br, val);
113 }
114 
115 static 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 }
121 static DEVICE_ATTR_RW(ageing_time);
122 
123 static 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 
131 static 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 
138 static 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 }
144 static DEVICE_ATTR_RW(stp_state);
145 
146 static 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 
154 static 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 
164 static 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 }
171 static DEVICE_ATTR_RW(group_fwd_mask);
172 
173 static 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 
181 static 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 
187 static 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 }
192 static DEVICE_ATTR_RW(priority);
193 
194 static 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 }
199 static DEVICE_ATTR_RO(root_id);
200 
201 static 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 }
206 static DEVICE_ATTR_RO(bridge_id);
207 
208 static 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 }
213 static DEVICE_ATTR_RO(root_port);
214 
215 static 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 }
220 static DEVICE_ATTR_RO(root_path_cost);
221 
222 static 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 }
227 static DEVICE_ATTR_RO(topology_change);
228 
229 static 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 }
236 static DEVICE_ATTR_RO(topology_change_detected);
237 
238 static 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 }
244 static DEVICE_ATTR_RO(hello_timer);
245 
246 static 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 }
252 static DEVICE_ATTR_RO(tcn_timer);
253 
254 static 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 }
261 static DEVICE_ATTR_RO(topology_change_timer);
262 
263 static 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 }
269 static DEVICE_ATTR_RO(gc_timer);
270 
271 static 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 
281 static 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 ||		/* 802.3x Pause address */
301 	    new_addr[5] == 2 ||		/* 802.3ad Slow protocols */
302 	    new_addr[5] == 3)		/* 802.1X PAE address */
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 
322 static DEVICE_ATTR_RW(group_addr);
323 
324 static int set_flush(struct net_bridge *br, unsigned long val)
325 {
326 	br_fdb_flush(br);
327 	return 0;
328 }
329 
330 static 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 }
336 static DEVICE_ATTR_WO(flush);
337 
338 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
339 static 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 
346 static 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 }
352 static DEVICE_ATTR_RW(multicast_router);
353 
354 static 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 
362 static 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 }
368 static DEVICE_ATTR_RW(multicast_snooping);
369 
370 static 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 
378 static 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 
384 static ssize_t
385 multicast_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 }
391 static DEVICE_ATTR_RW(multicast_query_use_ifaddr);
392 
393 static 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 
401 static 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 }
407 static DEVICE_ATTR_RW(multicast_querier);
408 
409 static 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 
416 static int set_elasticity(struct net_bridge *br, unsigned long val)
417 {
418 	br->hash_elasticity = val;
419 	return 0;
420 }
421 
422 static 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 }
428 static DEVICE_ATTR_RW(hash_elasticity);
429 
430 static 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 
437 static 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 }
442 static DEVICE_ATTR_RW(hash_max);
443 
444 static 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 
453 static 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 }
459 static DEVICE_ATTR_RW(multicast_igmp_version);
460 
461 static 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 
469 static 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 
475 static 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 }
481 static DEVICE_ATTR_RW(multicast_last_member_count);
482 
483 static 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 
490 static 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 
496 static 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 }
502 static DEVICE_ATTR_RW(multicast_startup_query_count);
503 
504 static 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 
512 static 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 
518 static 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 }
524 static DEVICE_ATTR_RW(multicast_last_member_interval);
525 
526 static 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 
534 static 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 
540 static 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 }
546 static DEVICE_ATTR_RW(multicast_membership_interval);
547 
548 static 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 
557 static 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 
563 static 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 }
569 static DEVICE_ATTR_RW(multicast_querier_interval);
570 
571 static 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 
580 static 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 
586 static 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 }
592 static DEVICE_ATTR_RW(multicast_query_interval);
593 
594 static 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 
603 static 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 
609 static 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 }
615 static DEVICE_ATTR_RW(multicast_query_response_interval);
616 
617 static 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 
626 static 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 
632 static 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 }
638 static DEVICE_ATTR_RW(multicast_startup_query_interval);
639 
640 static 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 
649 static int set_stats_enabled(struct net_bridge *br, unsigned long val)
650 {
651 	br->multicast_stats_enabled = !!val;
652 	return 0;
653 }
654 
655 static 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 }
662 static DEVICE_ATTR_RW(multicast_stats_enabled);
663 
664 #if IS_ENABLED(CONFIG_IPV6)
665 static 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 
674 static 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 }
680 static DEVICE_ATTR_RW(multicast_mld_version);
681 #endif
682 #endif
683 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
684 static 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 
691 static 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 
697 static 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 }
703 static DEVICE_ATTR_RW(nf_call_iptables);
704 
705 static 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 
712 static 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 
718 static 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 }
724 static DEVICE_ATTR_RW(nf_call_ip6tables);
725 
726 static 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 
733 static 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 
739 static 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 }
745 static DEVICE_ATTR_RW(nf_call_arptables);
746 #endif
747 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
748 static 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 
756 static 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 }
762 static DEVICE_ATTR_RW(vlan_filtering);
763 
764 static 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 
772 static 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 }
778 static DEVICE_ATTR_RW(vlan_protocol);
779 
780 static 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 
788 static 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 }
794 static DEVICE_ATTR_RW(default_pvid);
795 
796 static 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 
804 static 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 }
810 static DEVICE_ATTR_RW(vlan_stats_enabled);
811 #endif
812 
813 static 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 
868 static const struct attribute_group bridge_group = {
869 	.name = SYSFS_BRIDGE_ATTR,
870 	.attrs = bridge_attrs,
871 };
872 
873 /*
874  * Export the forwarding information table as a binary file
875  * The records are struct __fdb_entry.
876  *
877  * Returns the number of bytes read.
878  */
879 static 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 	/* must read whole records */
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 
901 static struct bin_attribute bridge_forward = {
902 	.attr = { .name = SYSFS_BRIDGE_FDB,
903 		  .mode = S_IRUGO, },
904 	.read = brforward_read,
905 };
906 
907 /*
908  * Add entries in sysfs onto the existing network class device
909  * for the bridge.
910  *   Adds a attribute group "bridge" containing tuning parameters.
911  *   Binary attribute containing the forward table
912  *   Sub directory to hold links to interfaces.
913  *
914  * Note: the ifobj exists only to be a subdirectory
915  *   to hold links.  The ifobj exists in same data structure
916  *   as it's parent the bridge so reference counting works.
917  */
918 int 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 
955 void 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