Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Sysfs attributes of bridge
0004  *  Linux ethernet bridge
0005  *
0006  *  Authors:
0007  *  Stephen Hemminger       <shemminger@osdl.org>
0008  */
0009 
0010 #include <linux/capability.h>
0011 #include <linux/kernel.h>
0012 #include <linux/netdevice.h>
0013 #include <linux/etherdevice.h>
0014 #include <linux/if_bridge.h>
0015 #include <linux/rtnetlink.h>
0016 #include <linux/spinlock.h>
0017 #include <linux/times.h>
0018 #include <linux/sched/signal.h>
0019 
0020 #include "br_private.h"
0021 
0022 /* IMPORTANT: new bridge options must be added with netlink support only
0023  *            please do not add new sysfs entries
0024  */
0025 
0026 #define to_bridge(cd)   ((struct net_bridge *)netdev_priv(to_net_dev(cd)))
0027 
0028 /*
0029  * Common code for storing bridge parameters.
0030  */
0031 static ssize_t store_bridge_parm(struct device *d,
0032                  const char *buf, size_t len,
0033                  int (*set)(struct net_bridge *br, unsigned long val,
0034                         struct netlink_ext_ack *extack))
0035 {
0036     struct net_bridge *br = to_bridge(d);
0037     struct netlink_ext_ack extack = {0};
0038     unsigned long val;
0039     int err;
0040 
0041     if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
0042         return -EPERM;
0043 
0044     err = kstrtoul(buf, 0, &val);
0045     if (err != 0)
0046         return err;
0047 
0048     if (!rtnl_trylock())
0049         return restart_syscall();
0050 
0051     err = (*set)(br, val, &extack);
0052     if (!err)
0053         netdev_state_change(br->dev);
0054     if (extack._msg) {
0055         if (err)
0056             br_err(br, "%s\n", extack._msg);
0057         else
0058             br_warn(br, "%s\n", extack._msg);
0059     }
0060     rtnl_unlock();
0061 
0062     return err ? err : len;
0063 }
0064 
0065 
0066 static ssize_t forward_delay_show(struct device *d,
0067                   struct device_attribute *attr, char *buf)
0068 {
0069     struct net_bridge *br = to_bridge(d);
0070     return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay));
0071 }
0072 
0073 static int set_forward_delay(struct net_bridge *br, unsigned long val,
0074                  struct netlink_ext_ack *extack)
0075 {
0076     return br_set_forward_delay(br, val);
0077 }
0078 
0079 static ssize_t forward_delay_store(struct device *d,
0080                    struct device_attribute *attr,
0081                    const char *buf, size_t len)
0082 {
0083     return store_bridge_parm(d, buf, len, set_forward_delay);
0084 }
0085 static DEVICE_ATTR_RW(forward_delay);
0086 
0087 static ssize_t hello_time_show(struct device *d, struct device_attribute *attr,
0088                    char *buf)
0089 {
0090     return sprintf(buf, "%lu\n",
0091                jiffies_to_clock_t(to_bridge(d)->hello_time));
0092 }
0093 
0094 static int set_hello_time(struct net_bridge *br, unsigned long val,
0095               struct netlink_ext_ack *extack)
0096 {
0097     return br_set_hello_time(br, val);
0098 }
0099 
0100 static ssize_t hello_time_store(struct device *d,
0101                 struct device_attribute *attr, const char *buf,
0102                 size_t len)
0103 {
0104     return store_bridge_parm(d, buf, len, set_hello_time);
0105 }
0106 static DEVICE_ATTR_RW(hello_time);
0107 
0108 static ssize_t max_age_show(struct device *d, struct device_attribute *attr,
0109                 char *buf)
0110 {
0111     return sprintf(buf, "%lu\n",
0112                jiffies_to_clock_t(to_bridge(d)->max_age));
0113 }
0114 
0115 static int set_max_age(struct net_bridge *br, unsigned long val,
0116                struct netlink_ext_ack *extack)
0117 {
0118     return br_set_max_age(br, val);
0119 }
0120 
0121 static ssize_t max_age_store(struct device *d, struct device_attribute *attr,
0122                  const char *buf, size_t len)
0123 {
0124     return store_bridge_parm(d, buf, len, set_max_age);
0125 }
0126 static DEVICE_ATTR_RW(max_age);
0127 
0128 static ssize_t ageing_time_show(struct device *d,
0129                 struct device_attribute *attr, char *buf)
0130 {
0131     struct net_bridge *br = to_bridge(d);
0132     return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
0133 }
0134 
0135 static int set_ageing_time(struct net_bridge *br, unsigned long val,
0136                struct netlink_ext_ack *extack)
0137 {
0138     return br_set_ageing_time(br, val);
0139 }
0140 
0141 static ssize_t ageing_time_store(struct device *d,
0142                  struct device_attribute *attr,
0143                  const char *buf, size_t len)
0144 {
0145     return store_bridge_parm(d, buf, len, set_ageing_time);
0146 }
0147 static DEVICE_ATTR_RW(ageing_time);
0148 
0149 static ssize_t stp_state_show(struct device *d,
0150                   struct device_attribute *attr, char *buf)
0151 {
0152     struct net_bridge *br = to_bridge(d);
0153     return sprintf(buf, "%d\n", br->stp_enabled);
0154 }
0155 
0156 
0157 static int set_stp_state(struct net_bridge *br, unsigned long val,
0158              struct netlink_ext_ack *extack)
0159 {
0160     return br_stp_set_enabled(br, val, extack);
0161 }
0162 
0163 static ssize_t stp_state_store(struct device *d,
0164                    struct device_attribute *attr, const char *buf,
0165                    size_t len)
0166 {
0167     return store_bridge_parm(d, buf, len, set_stp_state);
0168 }
0169 static DEVICE_ATTR_RW(stp_state);
0170 
0171 static ssize_t group_fwd_mask_show(struct device *d,
0172                    struct device_attribute *attr,
0173                    char *buf)
0174 {
0175     struct net_bridge *br = to_bridge(d);
0176     return sprintf(buf, "%#x\n", br->group_fwd_mask);
0177 }
0178 
0179 static int set_group_fwd_mask(struct net_bridge *br, unsigned long val,
0180                   struct netlink_ext_ack *extack)
0181 {
0182     if (val & BR_GROUPFWD_RESTRICTED)
0183         return -EINVAL;
0184 
0185     br->group_fwd_mask = val;
0186 
0187     return 0;
0188 }
0189 
0190 static ssize_t group_fwd_mask_store(struct device *d,
0191                     struct device_attribute *attr,
0192                     const char *buf,
0193                     size_t len)
0194 {
0195     return store_bridge_parm(d, buf, len, set_group_fwd_mask);
0196 }
0197 static DEVICE_ATTR_RW(group_fwd_mask);
0198 
0199 static ssize_t priority_show(struct device *d, struct device_attribute *attr,
0200                  char *buf)
0201 {
0202     struct net_bridge *br = to_bridge(d);
0203     return sprintf(buf, "%d\n",
0204                (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]);
0205 }
0206 
0207 static int set_priority(struct net_bridge *br, unsigned long val,
0208             struct netlink_ext_ack *extack)
0209 {
0210     br_stp_set_bridge_priority(br, (u16) val);
0211     return 0;
0212 }
0213 
0214 static ssize_t priority_store(struct device *d, struct device_attribute *attr,
0215                   const char *buf, size_t len)
0216 {
0217     return store_bridge_parm(d, buf, len, set_priority);
0218 }
0219 static DEVICE_ATTR_RW(priority);
0220 
0221 static ssize_t root_id_show(struct device *d, struct device_attribute *attr,
0222                 char *buf)
0223 {
0224     return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
0225 }
0226 static DEVICE_ATTR_RO(root_id);
0227 
0228 static ssize_t bridge_id_show(struct device *d, struct device_attribute *attr,
0229                   char *buf)
0230 {
0231     return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
0232 }
0233 static DEVICE_ATTR_RO(bridge_id);
0234 
0235 static ssize_t root_port_show(struct device *d, struct device_attribute *attr,
0236                   char *buf)
0237 {
0238     return sprintf(buf, "%d\n", to_bridge(d)->root_port);
0239 }
0240 static DEVICE_ATTR_RO(root_port);
0241 
0242 static ssize_t root_path_cost_show(struct device *d,
0243                    struct device_attribute *attr, char *buf)
0244 {
0245     return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
0246 }
0247 static DEVICE_ATTR_RO(root_path_cost);
0248 
0249 static ssize_t topology_change_show(struct device *d,
0250                     struct device_attribute *attr, char *buf)
0251 {
0252     return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
0253 }
0254 static DEVICE_ATTR_RO(topology_change);
0255 
0256 static ssize_t topology_change_detected_show(struct device *d,
0257                          struct device_attribute *attr,
0258                          char *buf)
0259 {
0260     struct net_bridge *br = to_bridge(d);
0261     return sprintf(buf, "%d\n", br->topology_change_detected);
0262 }
0263 static DEVICE_ATTR_RO(topology_change_detected);
0264 
0265 static ssize_t hello_timer_show(struct device *d,
0266                 struct device_attribute *attr, char *buf)
0267 {
0268     struct net_bridge *br = to_bridge(d);
0269     return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
0270 }
0271 static DEVICE_ATTR_RO(hello_timer);
0272 
0273 static ssize_t tcn_timer_show(struct device *d, struct device_attribute *attr,
0274                   char *buf)
0275 {
0276     struct net_bridge *br = to_bridge(d);
0277     return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
0278 }
0279 static DEVICE_ATTR_RO(tcn_timer);
0280 
0281 static ssize_t topology_change_timer_show(struct device *d,
0282                       struct device_attribute *attr,
0283                       char *buf)
0284 {
0285     struct net_bridge *br = to_bridge(d);
0286     return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
0287 }
0288 static DEVICE_ATTR_RO(topology_change_timer);
0289 
0290 static ssize_t gc_timer_show(struct device *d, struct device_attribute *attr,
0291                  char *buf)
0292 {
0293     struct net_bridge *br = to_bridge(d);
0294     return sprintf(buf, "%ld\n", br_timer_value(&br->gc_work.timer));
0295 }
0296 static DEVICE_ATTR_RO(gc_timer);
0297 
0298 static ssize_t group_addr_show(struct device *d,
0299                    struct device_attribute *attr, char *buf)
0300 {
0301     struct net_bridge *br = to_bridge(d);
0302     return sprintf(buf, "%pM\n", br->group_addr);
0303 }
0304 
0305 static ssize_t group_addr_store(struct device *d,
0306                 struct device_attribute *attr,
0307                 const char *buf, size_t len)
0308 {
0309     struct net_bridge *br = to_bridge(d);
0310     u8 new_addr[6];
0311 
0312     if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
0313         return -EPERM;
0314 
0315     if (!mac_pton(buf, new_addr))
0316         return -EINVAL;
0317 
0318     if (!is_link_local_ether_addr(new_addr))
0319         return -EINVAL;
0320 
0321     if (new_addr[5] == 1 ||     /* 802.3x Pause address */
0322         new_addr[5] == 2 ||     /* 802.3ad Slow protocols */
0323         new_addr[5] == 3)       /* 802.1X PAE address */
0324         return -EINVAL;
0325 
0326     if (!rtnl_trylock())
0327         return restart_syscall();
0328 
0329     spin_lock_bh(&br->lock);
0330     ether_addr_copy(br->group_addr, new_addr);
0331     spin_unlock_bh(&br->lock);
0332 
0333     br_opt_toggle(br, BROPT_GROUP_ADDR_SET, true);
0334     br_recalculate_fwd_mask(br);
0335     netdev_state_change(br->dev);
0336 
0337     rtnl_unlock();
0338 
0339     return len;
0340 }
0341 
0342 static DEVICE_ATTR_RW(group_addr);
0343 
0344 static int set_flush(struct net_bridge *br, unsigned long val,
0345              struct netlink_ext_ack *extack)
0346 {
0347     struct net_bridge_fdb_flush_desc desc = {
0348         .flags_mask = BR_FDB_STATIC
0349     };
0350 
0351     br_fdb_flush(br, &desc);
0352     return 0;
0353 }
0354 
0355 static ssize_t flush_store(struct device *d,
0356                struct device_attribute *attr,
0357                const char *buf, size_t len)
0358 {
0359     return store_bridge_parm(d, buf, len, set_flush);
0360 }
0361 static DEVICE_ATTR_WO(flush);
0362 
0363 static ssize_t no_linklocal_learn_show(struct device *d,
0364                        struct device_attribute *attr,
0365                        char *buf)
0366 {
0367     struct net_bridge *br = to_bridge(d);
0368     return sprintf(buf, "%d\n", br_boolopt_get(br, BR_BOOLOPT_NO_LL_LEARN));
0369 }
0370 
0371 static int set_no_linklocal_learn(struct net_bridge *br, unsigned long val,
0372                   struct netlink_ext_ack *extack)
0373 {
0374     return br_boolopt_toggle(br, BR_BOOLOPT_NO_LL_LEARN, !!val, extack);
0375 }
0376 
0377 static ssize_t no_linklocal_learn_store(struct device *d,
0378                     struct device_attribute *attr,
0379                     const char *buf, size_t len)
0380 {
0381     return store_bridge_parm(d, buf, len, set_no_linklocal_learn);
0382 }
0383 static DEVICE_ATTR_RW(no_linklocal_learn);
0384 
0385 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
0386 static ssize_t multicast_router_show(struct device *d,
0387                      struct device_attribute *attr, char *buf)
0388 {
0389     struct net_bridge *br = to_bridge(d);
0390     return sprintf(buf, "%d\n", br->multicast_ctx.multicast_router);
0391 }
0392 
0393 static int set_multicast_router(struct net_bridge *br, unsigned long val,
0394                 struct netlink_ext_ack *extack)
0395 {
0396     return br_multicast_set_router(&br->multicast_ctx, val);
0397 }
0398 
0399 static ssize_t multicast_router_store(struct device *d,
0400                       struct device_attribute *attr,
0401                       const char *buf, size_t len)
0402 {
0403     return store_bridge_parm(d, buf, len, set_multicast_router);
0404 }
0405 static DEVICE_ATTR_RW(multicast_router);
0406 
0407 static ssize_t multicast_snooping_show(struct device *d,
0408                        struct device_attribute *attr,
0409                        char *buf)
0410 {
0411     struct net_bridge *br = to_bridge(d);
0412     return sprintf(buf, "%d\n", br_opt_get(br, BROPT_MULTICAST_ENABLED));
0413 }
0414 
0415 static ssize_t multicast_snooping_store(struct device *d,
0416                     struct device_attribute *attr,
0417                     const char *buf, size_t len)
0418 {
0419     return store_bridge_parm(d, buf, len, br_multicast_toggle);
0420 }
0421 static DEVICE_ATTR_RW(multicast_snooping);
0422 
0423 static ssize_t multicast_query_use_ifaddr_show(struct device *d,
0424                            struct device_attribute *attr,
0425                            char *buf)
0426 {
0427     struct net_bridge *br = to_bridge(d);
0428     return sprintf(buf, "%d\n",
0429                br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR));
0430 }
0431 
0432 static int set_query_use_ifaddr(struct net_bridge *br, unsigned long val,
0433                 struct netlink_ext_ack *extack)
0434 {
0435     br_opt_toggle(br, BROPT_MULTICAST_QUERY_USE_IFADDR, !!val);
0436     return 0;
0437 }
0438 
0439 static ssize_t
0440 multicast_query_use_ifaddr_store(struct device *d,
0441                  struct device_attribute *attr,
0442                  const char *buf, size_t len)
0443 {
0444     return store_bridge_parm(d, buf, len, set_query_use_ifaddr);
0445 }
0446 static DEVICE_ATTR_RW(multicast_query_use_ifaddr);
0447 
0448 static ssize_t multicast_querier_show(struct device *d,
0449                       struct device_attribute *attr,
0450                       char *buf)
0451 {
0452     struct net_bridge *br = to_bridge(d);
0453     return sprintf(buf, "%d\n", br->multicast_ctx.multicast_querier);
0454 }
0455 
0456 static int set_multicast_querier(struct net_bridge *br, unsigned long val,
0457                  struct netlink_ext_ack *extack)
0458 {
0459     return br_multicast_set_querier(&br->multicast_ctx, val);
0460 }
0461 
0462 static ssize_t multicast_querier_store(struct device *d,
0463                        struct device_attribute *attr,
0464                        const char *buf, size_t len)
0465 {
0466     return store_bridge_parm(d, buf, len, set_multicast_querier);
0467 }
0468 static DEVICE_ATTR_RW(multicast_querier);
0469 
0470 static ssize_t hash_elasticity_show(struct device *d,
0471                     struct device_attribute *attr, char *buf)
0472 {
0473     return sprintf(buf, "%u\n", RHT_ELASTICITY);
0474 }
0475 
0476 static int set_elasticity(struct net_bridge *br, unsigned long val,
0477               struct netlink_ext_ack *extack)
0478 {
0479     /* 16 is RHT_ELASTICITY */
0480     NL_SET_ERR_MSG_MOD(extack,
0481                "the hash_elasticity option has been deprecated and is always 16");
0482     return 0;
0483 }
0484 
0485 static ssize_t hash_elasticity_store(struct device *d,
0486                      struct device_attribute *attr,
0487                      const char *buf, size_t len)
0488 {
0489     return store_bridge_parm(d, buf, len, set_elasticity);
0490 }
0491 static DEVICE_ATTR_RW(hash_elasticity);
0492 
0493 static ssize_t hash_max_show(struct device *d, struct device_attribute *attr,
0494                  char *buf)
0495 {
0496     struct net_bridge *br = to_bridge(d);
0497     return sprintf(buf, "%u\n", br->hash_max);
0498 }
0499 
0500 static int set_hash_max(struct net_bridge *br, unsigned long val,
0501             struct netlink_ext_ack *extack)
0502 {
0503     br->hash_max = val;
0504     return 0;
0505 }
0506 
0507 static ssize_t hash_max_store(struct device *d, struct device_attribute *attr,
0508                   const char *buf, size_t len)
0509 {
0510     return store_bridge_parm(d, buf, len, set_hash_max);
0511 }
0512 static DEVICE_ATTR_RW(hash_max);
0513 
0514 static ssize_t multicast_igmp_version_show(struct device *d,
0515                        struct device_attribute *attr,
0516                        char *buf)
0517 {
0518     struct net_bridge *br = to_bridge(d);
0519 
0520     return sprintf(buf, "%u\n", br->multicast_ctx.multicast_igmp_version);
0521 }
0522 
0523 static int set_multicast_igmp_version(struct net_bridge *br, unsigned long val,
0524                       struct netlink_ext_ack *extack)
0525 {
0526     return br_multicast_set_igmp_version(&br->multicast_ctx, val);
0527 }
0528 
0529 static ssize_t multicast_igmp_version_store(struct device *d,
0530                         struct device_attribute *attr,
0531                         const char *buf, size_t len)
0532 {
0533     return store_bridge_parm(d, buf, len, set_multicast_igmp_version);
0534 }
0535 static DEVICE_ATTR_RW(multicast_igmp_version);
0536 
0537 static ssize_t multicast_last_member_count_show(struct device *d,
0538                         struct device_attribute *attr,
0539                         char *buf)
0540 {
0541     struct net_bridge *br = to_bridge(d);
0542     return sprintf(buf, "%u\n", br->multicast_ctx.multicast_last_member_count);
0543 }
0544 
0545 static int set_last_member_count(struct net_bridge *br, unsigned long val,
0546                  struct netlink_ext_ack *extack)
0547 {
0548     br->multicast_ctx.multicast_last_member_count = val;
0549     return 0;
0550 }
0551 
0552 static ssize_t multicast_last_member_count_store(struct device *d,
0553                          struct device_attribute *attr,
0554                          const char *buf, size_t len)
0555 {
0556     return store_bridge_parm(d, buf, len, set_last_member_count);
0557 }
0558 static DEVICE_ATTR_RW(multicast_last_member_count);
0559 
0560 static ssize_t multicast_startup_query_count_show(
0561     struct device *d, struct device_attribute *attr, char *buf)
0562 {
0563     struct net_bridge *br = to_bridge(d);
0564     return sprintf(buf, "%u\n", br->multicast_ctx.multicast_startup_query_count);
0565 }
0566 
0567 static int set_startup_query_count(struct net_bridge *br, unsigned long val,
0568                    struct netlink_ext_ack *extack)
0569 {
0570     br->multicast_ctx.multicast_startup_query_count = val;
0571     return 0;
0572 }
0573 
0574 static ssize_t multicast_startup_query_count_store(
0575     struct device *d, struct device_attribute *attr, const char *buf,
0576     size_t len)
0577 {
0578     return store_bridge_parm(d, buf, len, set_startup_query_count);
0579 }
0580 static DEVICE_ATTR_RW(multicast_startup_query_count);
0581 
0582 static ssize_t multicast_last_member_interval_show(
0583     struct device *d, struct device_attribute *attr, char *buf)
0584 {
0585     struct net_bridge *br = to_bridge(d);
0586     return sprintf(buf, "%lu\n",
0587                jiffies_to_clock_t(br->multicast_ctx.multicast_last_member_interval));
0588 }
0589 
0590 static int set_last_member_interval(struct net_bridge *br, unsigned long val,
0591                     struct netlink_ext_ack *extack)
0592 {
0593     br->multicast_ctx.multicast_last_member_interval = clock_t_to_jiffies(val);
0594     return 0;
0595 }
0596 
0597 static ssize_t multicast_last_member_interval_store(
0598     struct device *d, struct device_attribute *attr, const char *buf,
0599     size_t len)
0600 {
0601     return store_bridge_parm(d, buf, len, set_last_member_interval);
0602 }
0603 static DEVICE_ATTR_RW(multicast_last_member_interval);
0604 
0605 static ssize_t multicast_membership_interval_show(
0606     struct device *d, struct device_attribute *attr, char *buf)
0607 {
0608     struct net_bridge *br = to_bridge(d);
0609     return sprintf(buf, "%lu\n",
0610                jiffies_to_clock_t(br->multicast_ctx.multicast_membership_interval));
0611 }
0612 
0613 static int set_membership_interval(struct net_bridge *br, unsigned long val,
0614                    struct netlink_ext_ack *extack)
0615 {
0616     br->multicast_ctx.multicast_membership_interval = clock_t_to_jiffies(val);
0617     return 0;
0618 }
0619 
0620 static ssize_t multicast_membership_interval_store(
0621     struct device *d, struct device_attribute *attr, const char *buf,
0622     size_t len)
0623 {
0624     return store_bridge_parm(d, buf, len, set_membership_interval);
0625 }
0626 static DEVICE_ATTR_RW(multicast_membership_interval);
0627 
0628 static ssize_t multicast_querier_interval_show(struct device *d,
0629                            struct device_attribute *attr,
0630                            char *buf)
0631 {
0632     struct net_bridge *br = to_bridge(d);
0633     return sprintf(buf, "%lu\n",
0634                jiffies_to_clock_t(br->multicast_ctx.multicast_querier_interval));
0635 }
0636 
0637 static int set_querier_interval(struct net_bridge *br, unsigned long val,
0638                 struct netlink_ext_ack *extack)
0639 {
0640     br->multicast_ctx.multicast_querier_interval = clock_t_to_jiffies(val);
0641     return 0;
0642 }
0643 
0644 static ssize_t multicast_querier_interval_store(struct device *d,
0645                         struct device_attribute *attr,
0646                         const char *buf, size_t len)
0647 {
0648     return store_bridge_parm(d, buf, len, set_querier_interval);
0649 }
0650 static DEVICE_ATTR_RW(multicast_querier_interval);
0651 
0652 static ssize_t multicast_query_interval_show(struct device *d,
0653                          struct device_attribute *attr,
0654                          char *buf)
0655 {
0656     struct net_bridge *br = to_bridge(d);
0657     return sprintf(buf, "%lu\n",
0658                jiffies_to_clock_t(br->multicast_ctx.multicast_query_interval));
0659 }
0660 
0661 static int set_query_interval(struct net_bridge *br, unsigned long val,
0662                   struct netlink_ext_ack *extack)
0663 {
0664     br_multicast_set_query_intvl(&br->multicast_ctx, val);
0665     return 0;
0666 }
0667 
0668 static ssize_t multicast_query_interval_store(struct device *d,
0669                           struct device_attribute *attr,
0670                           const char *buf, size_t len)
0671 {
0672     return store_bridge_parm(d, buf, len, set_query_interval);
0673 }
0674 static DEVICE_ATTR_RW(multicast_query_interval);
0675 
0676 static ssize_t multicast_query_response_interval_show(
0677     struct device *d, struct device_attribute *attr, char *buf)
0678 {
0679     struct net_bridge *br = to_bridge(d);
0680     return sprintf(
0681         buf, "%lu\n",
0682         jiffies_to_clock_t(br->multicast_ctx.multicast_query_response_interval));
0683 }
0684 
0685 static int set_query_response_interval(struct net_bridge *br, unsigned long val,
0686                        struct netlink_ext_ack *extack)
0687 {
0688     br->multicast_ctx.multicast_query_response_interval = clock_t_to_jiffies(val);
0689     return 0;
0690 }
0691 
0692 static ssize_t multicast_query_response_interval_store(
0693     struct device *d, struct device_attribute *attr, const char *buf,
0694     size_t len)
0695 {
0696     return store_bridge_parm(d, buf, len, set_query_response_interval);
0697 }
0698 static DEVICE_ATTR_RW(multicast_query_response_interval);
0699 
0700 static ssize_t multicast_startup_query_interval_show(
0701     struct device *d, struct device_attribute *attr, char *buf)
0702 {
0703     struct net_bridge *br = to_bridge(d);
0704     return sprintf(
0705         buf, "%lu\n",
0706         jiffies_to_clock_t(br->multicast_ctx.multicast_startup_query_interval));
0707 }
0708 
0709 static int set_startup_query_interval(struct net_bridge *br, unsigned long val,
0710                       struct netlink_ext_ack *extack)
0711 {
0712     br_multicast_set_startup_query_intvl(&br->multicast_ctx, val);
0713     return 0;
0714 }
0715 
0716 static ssize_t multicast_startup_query_interval_store(
0717     struct device *d, struct device_attribute *attr, const char *buf,
0718     size_t len)
0719 {
0720     return store_bridge_parm(d, buf, len, set_startup_query_interval);
0721 }
0722 static DEVICE_ATTR_RW(multicast_startup_query_interval);
0723 
0724 static ssize_t multicast_stats_enabled_show(struct device *d,
0725                         struct device_attribute *attr,
0726                         char *buf)
0727 {
0728     struct net_bridge *br = to_bridge(d);
0729 
0730     return sprintf(buf, "%d\n",
0731                br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED));
0732 }
0733 
0734 static int set_stats_enabled(struct net_bridge *br, unsigned long val,
0735                  struct netlink_ext_ack *extack)
0736 {
0737     br_opt_toggle(br, BROPT_MULTICAST_STATS_ENABLED, !!val);
0738     return 0;
0739 }
0740 
0741 static ssize_t multicast_stats_enabled_store(struct device *d,
0742                          struct device_attribute *attr,
0743                          const char *buf,
0744                          size_t len)
0745 {
0746     return store_bridge_parm(d, buf, len, set_stats_enabled);
0747 }
0748 static DEVICE_ATTR_RW(multicast_stats_enabled);
0749 
0750 #if IS_ENABLED(CONFIG_IPV6)
0751 static ssize_t multicast_mld_version_show(struct device *d,
0752                       struct device_attribute *attr,
0753                       char *buf)
0754 {
0755     struct net_bridge *br = to_bridge(d);
0756 
0757     return sprintf(buf, "%u\n", br->multicast_ctx.multicast_mld_version);
0758 }
0759 
0760 static int set_multicast_mld_version(struct net_bridge *br, unsigned long val,
0761                      struct netlink_ext_ack *extack)
0762 {
0763     return br_multicast_set_mld_version(&br->multicast_ctx, val);
0764 }
0765 
0766 static ssize_t multicast_mld_version_store(struct device *d,
0767                        struct device_attribute *attr,
0768                        const char *buf, size_t len)
0769 {
0770     return store_bridge_parm(d, buf, len, set_multicast_mld_version);
0771 }
0772 static DEVICE_ATTR_RW(multicast_mld_version);
0773 #endif
0774 #endif
0775 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
0776 static ssize_t nf_call_iptables_show(
0777     struct device *d, struct device_attribute *attr, char *buf)
0778 {
0779     struct net_bridge *br = to_bridge(d);
0780     return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_IPTABLES));
0781 }
0782 
0783 static int set_nf_call_iptables(struct net_bridge *br, unsigned long val,
0784                 struct netlink_ext_ack *extack)
0785 {
0786     br_opt_toggle(br, BROPT_NF_CALL_IPTABLES, !!val);
0787     return 0;
0788 }
0789 
0790 static ssize_t nf_call_iptables_store(
0791     struct device *d, struct device_attribute *attr, const char *buf,
0792     size_t len)
0793 {
0794     return store_bridge_parm(d, buf, len, set_nf_call_iptables);
0795 }
0796 static DEVICE_ATTR_RW(nf_call_iptables);
0797 
0798 static ssize_t nf_call_ip6tables_show(
0799     struct device *d, struct device_attribute *attr, char *buf)
0800 {
0801     struct net_bridge *br = to_bridge(d);
0802     return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_IP6TABLES));
0803 }
0804 
0805 static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val,
0806                  struct netlink_ext_ack *extack)
0807 {
0808     br_opt_toggle(br, BROPT_NF_CALL_IP6TABLES, !!val);
0809     return 0;
0810 }
0811 
0812 static ssize_t nf_call_ip6tables_store(
0813     struct device *d, struct device_attribute *attr, const char *buf,
0814     size_t len)
0815 {
0816     return store_bridge_parm(d, buf, len, set_nf_call_ip6tables);
0817 }
0818 static DEVICE_ATTR_RW(nf_call_ip6tables);
0819 
0820 static ssize_t nf_call_arptables_show(
0821     struct device *d, struct device_attribute *attr, char *buf)
0822 {
0823     struct net_bridge *br = to_bridge(d);
0824     return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_ARPTABLES));
0825 }
0826 
0827 static int set_nf_call_arptables(struct net_bridge *br, unsigned long val,
0828                  struct netlink_ext_ack *extack)
0829 {
0830     br_opt_toggle(br, BROPT_NF_CALL_ARPTABLES, !!val);
0831     return 0;
0832 }
0833 
0834 static ssize_t nf_call_arptables_store(
0835     struct device *d, struct device_attribute *attr, const char *buf,
0836     size_t len)
0837 {
0838     return store_bridge_parm(d, buf, len, set_nf_call_arptables);
0839 }
0840 static DEVICE_ATTR_RW(nf_call_arptables);
0841 #endif
0842 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
0843 static ssize_t vlan_filtering_show(struct device *d,
0844                    struct device_attribute *attr,
0845                    char *buf)
0846 {
0847     struct net_bridge *br = to_bridge(d);
0848     return sprintf(buf, "%d\n", br_opt_get(br, BROPT_VLAN_ENABLED));
0849 }
0850 
0851 static ssize_t vlan_filtering_store(struct device *d,
0852                     struct device_attribute *attr,
0853                     const char *buf, size_t len)
0854 {
0855     return store_bridge_parm(d, buf, len, br_vlan_filter_toggle);
0856 }
0857 static DEVICE_ATTR_RW(vlan_filtering);
0858 
0859 static ssize_t vlan_protocol_show(struct device *d,
0860                   struct device_attribute *attr,
0861                   char *buf)
0862 {
0863     struct net_bridge *br = to_bridge(d);
0864     return sprintf(buf, "%#06x\n", ntohs(br->vlan_proto));
0865 }
0866 
0867 static ssize_t vlan_protocol_store(struct device *d,
0868                    struct device_attribute *attr,
0869                    const char *buf, size_t len)
0870 {
0871     return store_bridge_parm(d, buf, len, br_vlan_set_proto);
0872 }
0873 static DEVICE_ATTR_RW(vlan_protocol);
0874 
0875 static ssize_t default_pvid_show(struct device *d,
0876                  struct device_attribute *attr,
0877                  char *buf)
0878 {
0879     struct net_bridge *br = to_bridge(d);
0880     return sprintf(buf, "%d\n", br->default_pvid);
0881 }
0882 
0883 static ssize_t default_pvid_store(struct device *d,
0884                   struct device_attribute *attr,
0885                   const char *buf, size_t len)
0886 {
0887     return store_bridge_parm(d, buf, len, br_vlan_set_default_pvid);
0888 }
0889 static DEVICE_ATTR_RW(default_pvid);
0890 
0891 static ssize_t vlan_stats_enabled_show(struct device *d,
0892                        struct device_attribute *attr,
0893                        char *buf)
0894 {
0895     struct net_bridge *br = to_bridge(d);
0896     return sprintf(buf, "%u\n", br_opt_get(br, BROPT_VLAN_STATS_ENABLED));
0897 }
0898 
0899 static int set_vlan_stats_enabled(struct net_bridge *br, unsigned long val,
0900                   struct netlink_ext_ack *extack)
0901 {
0902     return br_vlan_set_stats(br, val);
0903 }
0904 
0905 static ssize_t vlan_stats_enabled_store(struct device *d,
0906                     struct device_attribute *attr,
0907                     const char *buf, size_t len)
0908 {
0909     return store_bridge_parm(d, buf, len, set_vlan_stats_enabled);
0910 }
0911 static DEVICE_ATTR_RW(vlan_stats_enabled);
0912 
0913 static ssize_t vlan_stats_per_port_show(struct device *d,
0914                     struct device_attribute *attr,
0915                     char *buf)
0916 {
0917     struct net_bridge *br = to_bridge(d);
0918     return sprintf(buf, "%u\n", br_opt_get(br, BROPT_VLAN_STATS_PER_PORT));
0919 }
0920 
0921 static int set_vlan_stats_per_port(struct net_bridge *br, unsigned long val,
0922                    struct netlink_ext_ack *extack)
0923 {
0924     return br_vlan_set_stats_per_port(br, val);
0925 }
0926 
0927 static ssize_t vlan_stats_per_port_store(struct device *d,
0928                      struct device_attribute *attr,
0929                      const char *buf, size_t len)
0930 {
0931     return store_bridge_parm(d, buf, len, set_vlan_stats_per_port);
0932 }
0933 static DEVICE_ATTR_RW(vlan_stats_per_port);
0934 #endif
0935 
0936 static struct attribute *bridge_attrs[] = {
0937     &dev_attr_forward_delay.attr,
0938     &dev_attr_hello_time.attr,
0939     &dev_attr_max_age.attr,
0940     &dev_attr_ageing_time.attr,
0941     &dev_attr_stp_state.attr,
0942     &dev_attr_group_fwd_mask.attr,
0943     &dev_attr_priority.attr,
0944     &dev_attr_bridge_id.attr,
0945     &dev_attr_root_id.attr,
0946     &dev_attr_root_path_cost.attr,
0947     &dev_attr_root_port.attr,
0948     &dev_attr_topology_change.attr,
0949     &dev_attr_topology_change_detected.attr,
0950     &dev_attr_hello_timer.attr,
0951     &dev_attr_tcn_timer.attr,
0952     &dev_attr_topology_change_timer.attr,
0953     &dev_attr_gc_timer.attr,
0954     &dev_attr_group_addr.attr,
0955     &dev_attr_flush.attr,
0956     &dev_attr_no_linklocal_learn.attr,
0957 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
0958     &dev_attr_multicast_router.attr,
0959     &dev_attr_multicast_snooping.attr,
0960     &dev_attr_multicast_querier.attr,
0961     &dev_attr_multicast_query_use_ifaddr.attr,
0962     &dev_attr_hash_elasticity.attr,
0963     &dev_attr_hash_max.attr,
0964     &dev_attr_multicast_last_member_count.attr,
0965     &dev_attr_multicast_startup_query_count.attr,
0966     &dev_attr_multicast_last_member_interval.attr,
0967     &dev_attr_multicast_membership_interval.attr,
0968     &dev_attr_multicast_querier_interval.attr,
0969     &dev_attr_multicast_query_interval.attr,
0970     &dev_attr_multicast_query_response_interval.attr,
0971     &dev_attr_multicast_startup_query_interval.attr,
0972     &dev_attr_multicast_stats_enabled.attr,
0973     &dev_attr_multicast_igmp_version.attr,
0974 #if IS_ENABLED(CONFIG_IPV6)
0975     &dev_attr_multicast_mld_version.attr,
0976 #endif
0977 #endif
0978 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
0979     &dev_attr_nf_call_iptables.attr,
0980     &dev_attr_nf_call_ip6tables.attr,
0981     &dev_attr_nf_call_arptables.attr,
0982 #endif
0983 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
0984     &dev_attr_vlan_filtering.attr,
0985     &dev_attr_vlan_protocol.attr,
0986     &dev_attr_default_pvid.attr,
0987     &dev_attr_vlan_stats_enabled.attr,
0988     &dev_attr_vlan_stats_per_port.attr,
0989 #endif
0990     NULL
0991 };
0992 
0993 static const struct attribute_group bridge_group = {
0994     .name = SYSFS_BRIDGE_ATTR,
0995     .attrs = bridge_attrs,
0996 };
0997 
0998 /*
0999  * Export the forwarding information table as a binary file
1000  * The records are struct __fdb_entry.
1001  *
1002  * Returns the number of bytes read.
1003  */
1004 static ssize_t brforward_read(struct file *filp, struct kobject *kobj,
1005                   struct bin_attribute *bin_attr,
1006                   char *buf, loff_t off, size_t count)
1007 {
1008     struct device *dev = kobj_to_dev(kobj);
1009     struct net_bridge *br = to_bridge(dev);
1010     int n;
1011 
1012     /* must read whole records */
1013     if (off % sizeof(struct __fdb_entry) != 0)
1014         return -EINVAL;
1015 
1016     n =  br_fdb_fillbuf(br, buf,
1017                 count / sizeof(struct __fdb_entry),
1018                 off / sizeof(struct __fdb_entry));
1019 
1020     if (n > 0)
1021         n *= sizeof(struct __fdb_entry);
1022 
1023     return n;
1024 }
1025 
1026 static struct bin_attribute bridge_forward = {
1027     .attr = { .name = SYSFS_BRIDGE_FDB,
1028           .mode = 0444, },
1029     .read = brforward_read,
1030 };
1031 
1032 /*
1033  * Add entries in sysfs onto the existing network class device
1034  * for the bridge.
1035  *   Adds a attribute group "bridge" containing tuning parameters.
1036  *   Binary attribute containing the forward table
1037  *   Sub directory to hold links to interfaces.
1038  *
1039  * Note: the ifobj exists only to be a subdirectory
1040  *   to hold links.  The ifobj exists in same data structure
1041  *   as it's parent the bridge so reference counting works.
1042  */
1043 int br_sysfs_addbr(struct net_device *dev)
1044 {
1045     struct kobject *brobj = &dev->dev.kobj;
1046     struct net_bridge *br = netdev_priv(dev);
1047     int err;
1048 
1049     err = sysfs_create_group(brobj, &bridge_group);
1050     if (err) {
1051         pr_info("%s: can't create group %s/%s\n",
1052             __func__, dev->name, bridge_group.name);
1053         goto out1;
1054     }
1055 
1056     err = sysfs_create_bin_file(brobj, &bridge_forward);
1057     if (err) {
1058         pr_info("%s: can't create attribute file %s/%s\n",
1059             __func__, dev->name, bridge_forward.attr.name);
1060         goto out2;
1061     }
1062 
1063     br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj);
1064     if (!br->ifobj) {
1065         pr_info("%s: can't add kobject (directory) %s/%s\n",
1066             __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR);
1067         err = -ENOMEM;
1068         goto out3;
1069     }
1070     return 0;
1071  out3:
1072     sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
1073  out2:
1074     sysfs_remove_group(&dev->dev.kobj, &bridge_group);
1075  out1:
1076     return err;
1077 
1078 }
1079 
1080 void br_sysfs_delbr(struct net_device *dev)
1081 {
1082     struct kobject *kobj = &dev->dev.kobj;
1083     struct net_bridge *br = netdev_priv(dev);
1084 
1085     kobject_put(br->ifobj);
1086     sysfs_remove_bin_file(kobj, &bridge_forward);
1087     sysfs_remove_group(kobj, &bridge_group);
1088 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!