net/bridge/br_sysfs_if.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Sysfs attributes of bridge ports
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/if_bridge.h>
0014 #include <linux/rtnetlink.h>
0015 #include <linux/spinlock.h>
0016 #include <linux/sched/signal.h>
0017
0018 #include "br_private.h"
0019
0020 /* IMPORTANT: new bridge port options must be added with netlink support only
0021  *            please do not add new sysfs entries
0022  */
0023
0024 struct brport_attribute {
0025     struct attribute    attr;
0026     ssize_t (*show)(struct net_bridge_port *, char *);
0027     int (*store)(struct net_bridge_port *, unsigned long);
0028     int (*store_raw)(struct net_bridge_port *, char *);
0029 };
0030
0031 #define BRPORT_ATTR_RAW(_name, _mode, _show, _store)            \
0032 const struct brport_attribute brport_attr_##_name = {           \
0033     .attr       = {.name = __stringify(_name),          \
0034                .mode = _mode },             \
0035     .show       = _show,                    \
0036     .store_raw  = _store,                   \
0037 };
0038
0039 #define BRPORT_ATTR(_name, _mode, _show, _store)        \
0040 const struct brport_attribute brport_attr_##_name = {           \
0041     .attr = {.name = __stringify(_name),            \
0042          .mode = _mode },               \
0043     .show   = _show,                    \
0044     .store  = _store,                   \
0045 };
0046
0047 #define BRPORT_ATTR_FLAG(_name, _mask)              \
0048 static ssize_t show_##_name(struct net_bridge_port *p, char *buf) \
0049 {                               \
0050     return sprintf(buf, "%d\n", !!(p->flags & _mask));  \
0051 }                               \
0052 static int store_##_name(struct net_bridge_port *p, unsigned long v) \
0053 {                               \
0054     return store_flag(p, v, _mask);             \
0055 }                               \
0056 static BRPORT_ATTR(_name, 0644,                 \
0057            show_##_name, store_##_name)
0058
0059 static int store_flag(struct net_bridge_port *p, unsigned long v,
0060               unsigned long mask)
0061 {
0062     struct netlink_ext_ack extack = {0};
0063     unsigned long flags = p->flags;
0064     int err;
0065
0066     if (v)
0067         flags |= mask;
0068     else
0069         flags &= ~mask;
0070
0071     if (flags != p->flags) {
0072         err = br_switchdev_set_port_flag(p, flags, mask, &extack);
0073         if (err) {
0074             netdev_err(p->dev, "%s\n", extack._msg);
0075             return err;
0076         }
0077
0078         p->flags = flags;
0079         br_port_flags_change(p, mask);
0080     }
0081     return 0;
0082 }
0083
0084 static ssize_t show_path_cost(struct net_bridge_port *p, char *buf)
0085 {
0086     return sprintf(buf, "%d\n", p->path_cost);
0087 }
0088
0089 static BRPORT_ATTR(path_cost, 0644,
0090            show_path_cost, br_stp_set_path_cost);
0091
0092 static ssize_t show_priority(struct net_bridge_port *p, char *buf)
0093 {
0094     return sprintf(buf, "%d\n", p->priority);
0095 }
0096
0097 static BRPORT_ATTR(priority, 0644,
0098              show_priority, br_stp_set_port_priority);
0099
0100 static ssize_t show_designated_root(struct net_bridge_port *p, char *buf)
0101 {
0102     return br_show_bridge_id(buf, &p->designated_root);
0103 }
0104 static BRPORT_ATTR(designated_root, 0444, show_designated_root, NULL);
0105
0106 static ssize_t show_designated_bridge(struct net_bridge_port *p, char *buf)
0107 {
0108     return br_show_bridge_id(buf, &p->designated_bridge);
0109 }
0110 static BRPORT_ATTR(designated_bridge, 0444, show_designated_bridge, NULL);
0111
0112 static ssize_t show_designated_port(struct net_bridge_port *p, char *buf)
0113 {
0114     return sprintf(buf, "%d\n", p->designated_port);
0115 }
0116 static BRPORT_ATTR(designated_port, 0444, show_designated_port, NULL);
0117
0118 static ssize_t show_designated_cost(struct net_bridge_port *p, char *buf)
0119 {
0120     return sprintf(buf, "%d\n", p->designated_cost);
0121 }
0122 static BRPORT_ATTR(designated_cost, 0444, show_designated_cost, NULL);
0123
0124 static ssize_t show_port_id(struct net_bridge_port *p, char *buf)
0125 {
0126     return sprintf(buf, "0x%x\n", p->port_id);
0127 }
0128 static BRPORT_ATTR(port_id, 0444, show_port_id, NULL);
0129
0130 static ssize_t show_port_no(struct net_bridge_port *p, char *buf)
0131 {
0132     return sprintf(buf, "0x%x\n", p->port_no);
0133 }
0134
0135 static BRPORT_ATTR(port_no, 0444, show_port_no, NULL);
0136
0137 static ssize_t show_change_ack(struct net_bridge_port *p, char *buf)
0138 {
0139     return sprintf(buf, "%d\n", p->topology_change_ack);
0140 }
0141 static BRPORT_ATTR(change_ack, 0444, show_change_ack, NULL);
0142
0143 static ssize_t show_config_pending(struct net_bridge_port *p, char *buf)
0144 {
0145     return sprintf(buf, "%d\n", p->config_pending);
0146 }
0147 static BRPORT_ATTR(config_pending, 0444, show_config_pending, NULL);
0148
0149 static ssize_t show_port_state(struct net_bridge_port *p, char *buf)
0150 {
0151     return sprintf(buf, "%d\n", p->state);
0152 }
0153 static BRPORT_ATTR(state, 0444, show_port_state, NULL);
0154
0155 static ssize_t show_message_age_timer(struct net_bridge_port *p,
0156                         char *buf)
0157 {
0158     return sprintf(buf, "%ld\n", br_timer_value(&p->message_age_timer));
0159 }
0160 static BRPORT_ATTR(message_age_timer, 0444, show_message_age_timer, NULL);
0161
0162 static ssize_t show_forward_delay_timer(struct net_bridge_port *p,
0163                         char *buf)
0164 {
0165     return sprintf(buf, "%ld\n", br_timer_value(&p->forward_delay_timer));
0166 }
0167 static BRPORT_ATTR(forward_delay_timer, 0444, show_forward_delay_timer, NULL);
0168
0169 static ssize_t show_hold_timer(struct net_bridge_port *p,
0170                         char *buf)
0171 {
0172     return sprintf(buf, "%ld\n", br_timer_value(&p->hold_timer));
0173 }
0174 static BRPORT_ATTR(hold_timer, 0444, show_hold_timer, NULL);
0175
0176 static int store_flush(struct net_bridge_port *p, unsigned long v)
0177 {
0178     br_fdb_delete_by_port(p->br, p, 0, 0); // Don't delete local entry
0179     return 0;
0180 }
0181 static BRPORT_ATTR(flush, 0200, NULL, store_flush);
0182
0183 static ssize_t show_group_fwd_mask(struct net_bridge_port *p, char *buf)
0184 {
0185     return sprintf(buf, "%#x\n", p->group_fwd_mask);
0186 }
0187
0188 static int store_group_fwd_mask(struct net_bridge_port *p,
0189                 unsigned long v)
0190 {
0191     if (v & BR_GROUPFWD_MACPAUSE)
0192         return -EINVAL;
0193     p->group_fwd_mask = v;
0194
0195     return 0;
0196 }
0197 static BRPORT_ATTR(group_fwd_mask, 0644, show_group_fwd_mask,
0198            store_group_fwd_mask);
0199
0200 static ssize_t show_backup_port(struct net_bridge_port *p, char *buf)
0201 {
0202     struct net_bridge_port *backup_p;
0203     int ret = 0;
0204
0205     rcu_read_lock();
0206     backup_p = rcu_dereference(p->backup_port);
0207     if (backup_p)
0208         ret = sprintf(buf, "%s\n", backup_p->dev->name);
0209     rcu_read_unlock();
0210
0211     return ret;
0212 }
0213
0214 static int store_backup_port(struct net_bridge_port *p, char *buf)
0215 {
0216     struct net_device *backup_dev = NULL;
0217     char *nl = strchr(buf, '\n');
0218
0219     if (nl)
0220         *nl = '\0';
0221
0222     if (strlen(buf) > 0) {
0223         backup_dev = __dev_get_by_name(dev_net(p->dev), buf);
0224         if (!backup_dev)
0225             return -ENOENT;
0226     }
0227
0228     return nbp_backup_change(p, backup_dev);
0229 }
0230 static BRPORT_ATTR_RAW(backup_port, 0644, show_backup_port, store_backup_port);
0231
0232 BRPORT_ATTR_FLAG(hairpin_mode, BR_HAIRPIN_MODE);
0233 BRPORT_ATTR_FLAG(bpdu_guard, BR_BPDU_GUARD);
0234 BRPORT_ATTR_FLAG(root_block, BR_ROOT_BLOCK);
0235 BRPORT_ATTR_FLAG(learning, BR_LEARNING);
0236 BRPORT_ATTR_FLAG(unicast_flood, BR_FLOOD);
0237 BRPORT_ATTR_FLAG(proxyarp, BR_PROXYARP);
0238 BRPORT_ATTR_FLAG(proxyarp_wifi, BR_PROXYARP_WIFI);
0239 BRPORT_ATTR_FLAG(multicast_flood, BR_MCAST_FLOOD);
0240 BRPORT_ATTR_FLAG(broadcast_flood, BR_BCAST_FLOOD);
0241 BRPORT_ATTR_FLAG(neigh_suppress, BR_NEIGH_SUPPRESS);
0242 BRPORT_ATTR_FLAG(isolated, BR_ISOLATED);
0243
0244 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
0245 static ssize_t show_multicast_router(struct net_bridge_port *p, char *buf)
0246 {
0247     return sprintf(buf, "%d\n", p->multicast_ctx.multicast_router);
0248 }
0249
0250 static int store_multicast_router(struct net_bridge_port *p,
0251                       unsigned long v)
0252 {
0253     return br_multicast_set_port_router(&p->multicast_ctx, v);
0254 }
0255 static BRPORT_ATTR(multicast_router, 0644, show_multicast_router,
0256            store_multicast_router);
0257
0258 BRPORT_ATTR_FLAG(multicast_fast_leave, BR_MULTICAST_FAST_LEAVE);
0259 BRPORT_ATTR_FLAG(multicast_to_unicast, BR_MULTICAST_TO_UNICAST);
0260 #endif
0261
0262 static const struct brport_attribute *brport_attrs[] = {
0263     &brport_attr_path_cost,
0264     &brport_attr_priority,
0265     &brport_attr_port_id,
0266     &brport_attr_port_no,
0267     &brport_attr_designated_root,
0268     &brport_attr_designated_bridge,
0269     &brport_attr_designated_port,
0270     &brport_attr_designated_cost,
0271     &brport_attr_state,
0272     &brport_attr_change_ack,
0273     &brport_attr_config_pending,
0274     &brport_attr_message_age_timer,
0275     &brport_attr_forward_delay_timer,
0276     &brport_attr_hold_timer,
0277     &brport_attr_flush,
0278     &brport_attr_hairpin_mode,
0279     &brport_attr_bpdu_guard,
0280     &brport_attr_root_block,
0281     &brport_attr_learning,
0282     &brport_attr_unicast_flood,
0283 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
0284     &brport_attr_multicast_router,
0285     &brport_attr_multicast_fast_leave,
0286     &brport_attr_multicast_to_unicast,
0287 #endif
0288     &brport_attr_proxyarp,
0289     &brport_attr_proxyarp_wifi,
0290     &brport_attr_multicast_flood,
0291     &brport_attr_broadcast_flood,
0292     &brport_attr_group_fwd_mask,
0293     &brport_attr_neigh_suppress,
0294     &brport_attr_isolated,
0295     &brport_attr_backup_port,
0296     NULL
0297 };
0298
0299 #define to_brport_attr(_at) container_of(_at, struct brport_attribute, attr)
0300
0301 static ssize_t brport_show(struct kobject *kobj,
0302                struct attribute *attr, char *buf)
0303 {
0304     struct brport_attribute *brport_attr = to_brport_attr(attr);
0305     struct net_bridge_port *p = kobj_to_brport(kobj);
0306
0307     if (!brport_attr->show)
0308         return -EINVAL;
0309
0310     return brport_attr->show(p, buf);
0311 }
0312
0313 static ssize_t brport_store(struct kobject *kobj,
0314                 struct attribute *attr,
0315                 const char *buf, size_t count)
0316 {
0317     struct brport_attribute *brport_attr = to_brport_attr(attr);
0318     struct net_bridge_port *p = kobj_to_brport(kobj);
0319     ssize_t ret = -EINVAL;
0320     unsigned long val;
0321     char *endp;
0322
0323     if (!ns_capable(dev_net(p->dev)->user_ns, CAP_NET_ADMIN))
0324         return -EPERM;
0325
0326     if (!rtnl_trylock())
0327         return restart_syscall();
0328
0329     if (brport_attr->store_raw) {
0330         char *buf_copy;
0331
0332         buf_copy = kstrndup(buf, count, GFP_KERNEL);
0333         if (!buf_copy) {
0334             ret = -ENOMEM;
0335             goto out_unlock;
0336         }
0337         spin_lock_bh(&p->br->lock);
0338         ret = brport_attr->store_raw(p, buf_copy);
0339         spin_unlock_bh(&p->br->lock);
0340         kfree(buf_copy);
0341     } else if (brport_attr->store) {
0342         val = simple_strtoul(buf, &endp, 0);
0343         if (endp == buf)
0344             goto out_unlock;
0345         spin_lock_bh(&p->br->lock);
0346         ret = brport_attr->store(p, val);
0347         spin_unlock_bh(&p->br->lock);
0348     }
0349
0350     if (!ret) {
0351         br_ifinfo_notify(RTM_NEWLINK, NULL, p);
0352         ret = count;
0353     }
0354 out_unlock:
0355     rtnl_unlock();
0356
0357     return ret;
0358 }
0359
0360 const struct sysfs_ops brport_sysfs_ops = {
0361     .show = brport_show,
0362     .store = brport_store,
0363 };
0364
0365 /*
0366  * Add sysfs entries to ethernet device added to a bridge.
0367  * Creates a brport subdirectory with bridge attributes.
0368  * Puts symlink in bridge's brif subdirectory
0369  */
0370 int br_sysfs_addif(struct net_bridge_port *p)
0371 {
0372     struct net_bridge *br = p->br;
0373     const struct brport_attribute **a;
0374     int err;
0375
0376     err = sysfs_create_link(&p->kobj, &br->dev->dev.kobj,
0377                 SYSFS_BRIDGE_PORT_LINK);
0378     if (err)
0379         return err;
0380
0381     for (a = brport_attrs; *a; ++a) {
0382         err = sysfs_create_file(&p->kobj, &((*a)->attr));
0383         if (err)
0384             return err;
0385     }
0386
0387     strlcpy(p->sysfs_name, p->dev->name, IFNAMSIZ);
0388     return sysfs_create_link(br->ifobj, &p->kobj, p->sysfs_name);
0389 }
0390
0391 /* Rename bridge's brif symlink */
0392 int br_sysfs_renameif(struct net_bridge_port *p)
0393 {
0394     struct net_bridge *br = p->br;
0395     int err;
0396
0397     /* If a rename fails, the rollback will cause another
0398      * rename call with the existing name.
0399      */
0400     if (!strncmp(p->sysfs_name, p->dev->name, IFNAMSIZ))
0401         return 0;
0402
0403     err = sysfs_rename_link(br->ifobj, &p->kobj,
0404                 p->sysfs_name, p->dev->name);
0405     if (err)
0406         netdev_notice(br->dev, "unable to rename link %s to %s",
0407                   p->sysfs_name, p->dev->name);
0408     else
0409         strlcpy(p->sysfs_name, p->dev->name, IFNAMSIZ);
0410
0411     return err;
0412 }