This source file includes following definitions.
- store_bridge_parm
- forward_delay_show
- forward_delay_store
- hello_time_show
- hello_time_store
- max_age_show
- max_age_store
- ageing_time_show
- set_ageing_time
- ageing_time_store
- stp_state_show
- set_stp_state
- stp_state_store
- group_fwd_mask_show
- set_group_fwd_mask
- group_fwd_mask_store
- priority_show
- set_priority
- priority_store
- root_id_show
- bridge_id_show
- root_port_show
- root_path_cost_show
- topology_change_show
- topology_change_detected_show
- hello_timer_show
- tcn_timer_show
- topology_change_timer_show
- gc_timer_show
- group_addr_show
- group_addr_store
- set_flush
- flush_store
- no_linklocal_learn_show
- set_no_linklocal_learn
- no_linklocal_learn_store
- multicast_router_show
- multicast_router_store
- multicast_snooping_show
- multicast_snooping_store
- multicast_query_use_ifaddr_show
- set_query_use_ifaddr
- multicast_query_use_ifaddr_store
- multicast_querier_show
- multicast_querier_store
- hash_elasticity_show
- set_elasticity
- hash_elasticity_store
- hash_max_show
- set_hash_max
- hash_max_store
- multicast_igmp_version_show
- multicast_igmp_version_store
- multicast_last_member_count_show
- set_last_member_count
- multicast_last_member_count_store
- multicast_startup_query_count_show
- set_startup_query_count
- multicast_startup_query_count_store
- multicast_last_member_interval_show
- set_last_member_interval
- multicast_last_member_interval_store
- multicast_membership_interval_show
- set_membership_interval
- multicast_membership_interval_store
- multicast_querier_interval_show
- set_querier_interval
- multicast_querier_interval_store
- multicast_query_interval_show
- set_query_interval
- multicast_query_interval_store
- multicast_query_response_interval_show
- set_query_response_interval
- multicast_query_response_interval_store
- multicast_startup_query_interval_show
- set_startup_query_interval
- multicast_startup_query_interval_store
- multicast_stats_enabled_show
- set_stats_enabled
- multicast_stats_enabled_store
- multicast_mld_version_show
- multicast_mld_version_store
- nf_call_iptables_show
- set_nf_call_iptables
- nf_call_iptables_store
- nf_call_ip6tables_show
- set_nf_call_ip6tables
- nf_call_ip6tables_store
- nf_call_arptables_show
- set_nf_call_arptables
- nf_call_arptables_store
- vlan_filtering_show
- vlan_filtering_store
- vlan_protocol_show
- vlan_protocol_store
- default_pvid_show
- default_pvid_store
- vlan_stats_enabled_show
- vlan_stats_enabled_store
- vlan_stats_per_port_show
- vlan_stats_per_port_store
- brforward_read
- br_sysfs_addbr
- br_sysfs_delbr
1
2
3
4
5
6
7
8
9
10 #include <linux/capability.h>
11 #include <linux/kernel.h>
12 #include <linux/netdevice.h>
13 #include <linux/etherdevice.h>
14 #include <linux/if_bridge.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/spinlock.h>
17 #include <linux/times.h>
18 #include <linux/sched/signal.h>
19
20 #include "br_private.h"
21
22 #define to_bridge(cd) ((struct net_bridge *)netdev_priv(to_net_dev(cd)))
23
24
25
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 ||
291 new_addr[5] == 2 ||
292 new_addr[5] == 3)
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
911
912
913
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
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
945
946
947
948
949
950
951
952
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 }