~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/bridge/br_sysfs_br.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp