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