Commit 134ef238 authored by Vladimir Oltean's avatar Vladimir Oltean Committed by David S. Miller

net: dsa: add explicit support for host bridge VLANs

Currently, DSA programs VLANs on shared (DSA and CPU) ports each time it
does so on user ports. This is good for basic functionality but has
several limitations:

- the VLAN group which must reach the CPU may be radically different
  from the VLAN group that must be autonomously forwarded by the switch.
  In other words, the admin may want to isolate noisy stations and avoid
  traffic from them going to the control processor of the switch, where
  it would just waste useless cycles. The bridge already supports
  independent control of VLAN groups on bridge ports and on the bridge
  itself, and when VLAN-aware, it will drop packets in software anyway
  if their VID isn't added as a 'self' entry towards the bridge device.

- Replaying host FDB entries may depend, for some drivers like mv88e6xxx,
  on replaying the host VLANs as well. The 2 VLAN groups are
  approximately the same in most regular cases, but there are corner
  cases when timing matters, and DSA's approximation of replicating
  VLANs on shared ports simply does not work.

- If a user makes the bridge (implicitly the CPU port) join a VLAN by
  accident, there is no way for the CPU port to isolate itself from that
  noisy VLAN except by rebooting the system. This is because for each
  VLAN added on a user port, DSA will add it on shared ports too, but
  for each VLAN deletion on a user port, it will remain installed on
  shared ports, since DSA has no good indication of whether the VLAN is
  still in use or not.

Now that the bridge driver emits well-balanced SWITCHDEV_OBJ_ID_PORT_VLAN
addition and removal events, DSA has a simple and straightforward task
of separating the bridge port VLANs (these have an orig_dev which is a
DSA slave interface, or a LAG interface) from the host VLANs (these have
an orig_dev which is a bridge interface), and to keep a simple reference
count of each VID on each shared port.

Forwarding VLANs must be installed on the bridge ports and on all DSA
ports interconnecting them. We don't have a good view of the exact
topology, so we simply install forwarding VLANs on all DSA ports, which
is what has been done until now.

Host VLANs must be installed primarily on the dedicated CPU port of each
bridge port. More subtly, they must also be installed on upstream-facing
and downstream-facing DSA ports that are connecting the bridge ports and
the CPU. This ensures that the mv88e6xxx's problem (VID of host FDB
entry may be absent from VTU) is still addressed even if that switch is
in a cross-chip setup, and it has no local CPU port.

Therefore:
- user ports contain only bridge port (forwarding) VLANs, and no
  refcounting is necessary
- DSA ports contain both forwarding and host VLANs. Refcounting is
  necessary among these 2 types.
- CPU ports contain only host VLANs. Refcounting is also necessary.
Signed-off-by: default avatarVladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent c4076cdd
...@@ -312,6 +312,10 @@ struct dsa_port { ...@@ -312,6 +312,10 @@ struct dsa_port {
struct mutex addr_lists_lock; struct mutex addr_lists_lock;
struct list_head fdbs; struct list_head fdbs;
struct list_head mdbs; struct list_head mdbs;
/* List of VLANs that CPU and DSA ports are members of. */
struct mutex vlans_lock;
struct list_head vlans;
}; };
/* TODO: ideally DSA ports would have a single dp->link_dp member, /* TODO: ideally DSA ports would have a single dp->link_dp member,
...@@ -332,6 +336,12 @@ struct dsa_mac_addr { ...@@ -332,6 +336,12 @@ struct dsa_mac_addr {
struct list_head list; struct list_head list;
}; };
struct dsa_vlan {
u16 vid;
refcount_t refcount;
struct list_head list;
};
struct dsa_switch { struct dsa_switch {
struct device *dev; struct device *dev;
......
...@@ -453,8 +453,10 @@ static int dsa_port_setup(struct dsa_port *dp) ...@@ -453,8 +453,10 @@ static int dsa_port_setup(struct dsa_port *dp)
return 0; return 0;
mutex_init(&dp->addr_lists_lock); mutex_init(&dp->addr_lists_lock);
mutex_init(&dp->vlans_lock);
INIT_LIST_HEAD(&dp->fdbs); INIT_LIST_HEAD(&dp->fdbs);
INIT_LIST_HEAD(&dp->mdbs); INIT_LIST_HEAD(&dp->mdbs);
INIT_LIST_HEAD(&dp->vlans);
if (ds->ops->port_setup) { if (ds->ops->port_setup) {
err = ds->ops->port_setup(ds, dp->index); err = ds->ops->port_setup(ds, dp->index);
......
...@@ -34,6 +34,8 @@ enum { ...@@ -34,6 +34,8 @@ enum {
DSA_NOTIFIER_HOST_MDB_DEL, DSA_NOTIFIER_HOST_MDB_DEL,
DSA_NOTIFIER_VLAN_ADD, DSA_NOTIFIER_VLAN_ADD,
DSA_NOTIFIER_VLAN_DEL, DSA_NOTIFIER_VLAN_DEL,
DSA_NOTIFIER_HOST_VLAN_ADD,
DSA_NOTIFIER_HOST_VLAN_DEL,
DSA_NOTIFIER_MTU, DSA_NOTIFIER_MTU,
DSA_NOTIFIER_TAG_PROTO, DSA_NOTIFIER_TAG_PROTO,
DSA_NOTIFIER_TAG_PROTO_CONNECT, DSA_NOTIFIER_TAG_PROTO_CONNECT,
...@@ -234,6 +236,11 @@ int dsa_port_vlan_add(struct dsa_port *dp, ...@@ -234,6 +236,11 @@ int dsa_port_vlan_add(struct dsa_port *dp,
struct netlink_ext_ack *extack); struct netlink_ext_ack *extack);
int dsa_port_vlan_del(struct dsa_port *dp, int dsa_port_vlan_del(struct dsa_port *dp,
const struct switchdev_obj_port_vlan *vlan); const struct switchdev_obj_port_vlan *vlan);
int dsa_port_host_vlan_add(struct dsa_port *dp,
const struct switchdev_obj_port_vlan *vlan,
struct netlink_ext_ack *extack);
int dsa_port_host_vlan_del(struct dsa_port *dp,
const struct switchdev_obj_port_vlan *vlan);
int dsa_port_mrp_add(const struct dsa_port *dp, int dsa_port_mrp_add(const struct dsa_port *dp,
const struct switchdev_obj_mrp *mrp); const struct switchdev_obj_mrp *mrp);
int dsa_port_mrp_del(const struct dsa_port *dp, int dsa_port_mrp_del(const struct dsa_port *dp,
......
...@@ -904,6 +904,48 @@ int dsa_port_vlan_del(struct dsa_port *dp, ...@@ -904,6 +904,48 @@ int dsa_port_vlan_del(struct dsa_port *dp,
return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info); return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
} }
int dsa_port_host_vlan_add(struct dsa_port *dp,
const struct switchdev_obj_port_vlan *vlan,
struct netlink_ext_ack *extack)
{
struct dsa_notifier_vlan_info info = {
.sw_index = dp->ds->index,
.port = dp->index,
.vlan = vlan,
.extack = extack,
};
struct dsa_port *cpu_dp = dp->cpu_dp;
int err;
err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_ADD, &info);
if (err && err != -EOPNOTSUPP)
return err;
vlan_vid_add(cpu_dp->master, htons(ETH_P_8021Q), vlan->vid);
return err;
}
int dsa_port_host_vlan_del(struct dsa_port *dp,
const struct switchdev_obj_port_vlan *vlan)
{
struct dsa_notifier_vlan_info info = {
.sw_index = dp->ds->index,
.port = dp->index,
.vlan = vlan,
};
struct dsa_port *cpu_dp = dp->cpu_dp;
int err;
err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_DEL, &info);
if (err && err != -EOPNOTSUPP)
return err;
vlan_vid_del(cpu_dp->master, htons(ETH_P_8021Q), vlan->vid);
return err;
}
int dsa_port_mrp_add(const struct dsa_port *dp, int dsa_port_mrp_add(const struct dsa_port *dp,
const struct switchdev_obj_mrp *mrp) const struct switchdev_obj_mrp *mrp)
{ {
......
...@@ -348,9 +348,8 @@ static int dsa_slave_vlan_add(struct net_device *dev, ...@@ -348,9 +348,8 @@ static int dsa_slave_vlan_add(struct net_device *dev,
const struct switchdev_obj *obj, const struct switchdev_obj *obj,
struct netlink_ext_ack *extack) struct netlink_ext_ack *extack)
{ {
struct net_device *master = dsa_slave_to_master(dev);
struct dsa_port *dp = dsa_slave_to_port(dev); struct dsa_port *dp = dsa_slave_to_port(dev);
struct switchdev_obj_port_vlan vlan; struct switchdev_obj_port_vlan *vlan;
int err; int err;
if (dsa_port_skip_vlan_configuration(dp)) { if (dsa_port_skip_vlan_configuration(dp)) {
...@@ -358,14 +357,14 @@ static int dsa_slave_vlan_add(struct net_device *dev, ...@@ -358,14 +357,14 @@ static int dsa_slave_vlan_add(struct net_device *dev,
return 0; return 0;
} }
vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj); vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
/* Deny adding a bridge VLAN when there is already an 802.1Q upper with /* Deny adding a bridge VLAN when there is already an 802.1Q upper with
* the same VID. * the same VID.
*/ */
if (br_vlan_enabled(dsa_port_bridge_dev_get(dp))) { if (br_vlan_enabled(dsa_port_bridge_dev_get(dp))) {
rcu_read_lock(); rcu_read_lock();
err = dsa_slave_vlan_check_for_8021q_uppers(dev, &vlan); err = dsa_slave_vlan_check_for_8021q_uppers(dev, vlan);
rcu_read_unlock(); rcu_read_unlock();
if (err) { if (err) {
NL_SET_ERR_MSG_MOD(extack, NL_SET_ERR_MSG_MOD(extack,
...@@ -374,21 +373,29 @@ static int dsa_slave_vlan_add(struct net_device *dev, ...@@ -374,21 +373,29 @@ static int dsa_slave_vlan_add(struct net_device *dev,
} }
} }
err = dsa_port_vlan_add(dp, &vlan, extack); return dsa_port_vlan_add(dp, vlan, extack);
if (err) }
return err;
/* We need the dedicated CPU port to be a member of the VLAN as well. static int dsa_slave_host_vlan_add(struct net_device *dev,
* Even though drivers often handle CPU membership in special ways, const struct switchdev_obj *obj,
struct netlink_ext_ack *extack)
{
struct dsa_port *dp = dsa_slave_to_port(dev);
struct switchdev_obj_port_vlan vlan;
if (dsa_port_skip_vlan_configuration(dp)) {
NL_SET_ERR_MSG_MOD(extack, "skipping configuration of VLAN");
return 0;
}
vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj);
/* Even though drivers often handle CPU membership in special ways,
* it doesn't make sense to program a PVID, so clear this flag. * it doesn't make sense to program a PVID, so clear this flag.
*/ */
vlan.flags &= ~BRIDGE_VLAN_INFO_PVID; vlan.flags &= ~BRIDGE_VLAN_INFO_PVID;
err = dsa_port_vlan_add(dp->cpu_dp, &vlan, extack); return dsa_port_host_vlan_add(dp, &vlan, extack);
if (err)
return err;
return vlan_vid_add(master, htons(ETH_P_8021Q), vlan.vid);
} }
static int dsa_slave_port_obj_add(struct net_device *dev, const void *ctx, static int dsa_slave_port_obj_add(struct net_device *dev, const void *ctx,
...@@ -415,10 +422,17 @@ static int dsa_slave_port_obj_add(struct net_device *dev, const void *ctx, ...@@ -415,10 +422,17 @@ static int dsa_slave_port_obj_add(struct net_device *dev, const void *ctx,
err = dsa_port_host_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); err = dsa_port_host_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
break; break;
case SWITCHDEV_OBJ_ID_PORT_VLAN: case SWITCHDEV_OBJ_ID_PORT_VLAN:
if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev)) if (netif_is_bridge_master(obj->orig_dev)) {
return -EOPNOTSUPP; if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
return -EOPNOTSUPP;
err = dsa_slave_host_vlan_add(dev, obj, extack);
} else {
if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev))
return -EOPNOTSUPP;
err = dsa_slave_vlan_add(dev, obj, extack); err = dsa_slave_vlan_add(dev, obj, extack);
}
break; break;
case SWITCHDEV_OBJ_ID_MRP: case SWITCHDEV_OBJ_ID_MRP:
if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev)) if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
...@@ -444,26 +458,29 @@ static int dsa_slave_port_obj_add(struct net_device *dev, const void *ctx, ...@@ -444,26 +458,29 @@ static int dsa_slave_port_obj_add(struct net_device *dev, const void *ctx,
static int dsa_slave_vlan_del(struct net_device *dev, static int dsa_slave_vlan_del(struct net_device *dev,
const struct switchdev_obj *obj) const struct switchdev_obj *obj)
{ {
struct net_device *master = dsa_slave_to_master(dev);
struct dsa_port *dp = dsa_slave_to_port(dev); struct dsa_port *dp = dsa_slave_to_port(dev);
struct switchdev_obj_port_vlan *vlan; struct switchdev_obj_port_vlan *vlan;
int err;
if (dsa_port_skip_vlan_configuration(dp)) if (dsa_port_skip_vlan_configuration(dp))
return 0; return 0;
vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
/* Do not deprogram the CPU port as it may be shared with other user return dsa_port_vlan_del(dp, vlan);
* ports which can be members of this VLAN as well. }
*/
err = dsa_port_vlan_del(dp, vlan);
if (err)
return err;
vlan_vid_del(master, htons(ETH_P_8021Q), vlan->vid); static int dsa_slave_host_vlan_del(struct net_device *dev,
const struct switchdev_obj *obj)
{
struct dsa_port *dp = dsa_slave_to_port(dev);
struct switchdev_obj_port_vlan *vlan;
return 0; if (dsa_port_skip_vlan_configuration(dp))
return 0;
vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
return dsa_port_host_vlan_del(dp, vlan);
} }
static int dsa_slave_port_obj_del(struct net_device *dev, const void *ctx, static int dsa_slave_port_obj_del(struct net_device *dev, const void *ctx,
...@@ -489,10 +506,17 @@ static int dsa_slave_port_obj_del(struct net_device *dev, const void *ctx, ...@@ -489,10 +506,17 @@ static int dsa_slave_port_obj_del(struct net_device *dev, const void *ctx,
err = dsa_port_host_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); err = dsa_port_host_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj));
break; break;
case SWITCHDEV_OBJ_ID_PORT_VLAN: case SWITCHDEV_OBJ_ID_PORT_VLAN:
if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev)) if (netif_is_bridge_master(obj->orig_dev)) {
return -EOPNOTSUPP; if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
return -EOPNOTSUPP;
err = dsa_slave_vlan_del(dev, obj); err = dsa_slave_host_vlan_del(dev, obj);
} else {
if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev))
return -EOPNOTSUPP;
err = dsa_slave_vlan_del(dev, obj);
}
break; break;
case SWITCHDEV_OBJ_ID_MRP: case SWITCHDEV_OBJ_ID_MRP:
if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev)) if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev))
...@@ -1347,7 +1371,6 @@ static int dsa_slave_get_ts_info(struct net_device *dev, ...@@ -1347,7 +1371,6 @@ static int dsa_slave_get_ts_info(struct net_device *dev,
static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto, static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
u16 vid) u16 vid)
{ {
struct net_device *master = dsa_slave_to_master(dev);
struct dsa_port *dp = dsa_slave_to_port(dev); struct dsa_port *dp = dsa_slave_to_port(dev);
struct switchdev_obj_port_vlan vlan = { struct switchdev_obj_port_vlan vlan = {
.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
...@@ -1367,7 +1390,7 @@ static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto, ...@@ -1367,7 +1390,7 @@ static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
} }
/* And CPU port... */ /* And CPU port... */
ret = dsa_port_vlan_add(dp->cpu_dp, &vlan, &extack); ret = dsa_port_host_vlan_add(dp, &vlan, &extack);
if (ret) { if (ret) {
if (extack._msg) if (extack._msg)
netdev_err(dev, "CPU port %d: %s\n", dp->cpu_dp->index, netdev_err(dev, "CPU port %d: %s\n", dp->cpu_dp->index,
...@@ -1375,13 +1398,12 @@ static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto, ...@@ -1375,13 +1398,12 @@ static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
return ret; return ret;
} }
return vlan_vid_add(master, proto, vid); return 0;
} }
static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
u16 vid) u16 vid)
{ {
struct net_device *master = dsa_slave_to_master(dev);
struct dsa_port *dp = dsa_slave_to_port(dev); struct dsa_port *dp = dsa_slave_to_port(dev);
struct switchdev_obj_port_vlan vlan = { struct switchdev_obj_port_vlan vlan = {
.vid = vid, .vid = vid,
...@@ -1390,16 +1412,11 @@ static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, ...@@ -1390,16 +1412,11 @@ static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
}; };
int err; int err;
/* Do not deprogram the CPU port as it may be shared with other user
* ports which can be members of this VLAN as well.
*/
err = dsa_port_vlan_del(dp, &vlan); err = dsa_port_vlan_del(dp, &vlan);
if (err) if (err)
return err; return err;
vlan_vid_del(master, proto, vid); return dsa_port_host_vlan_del(dp, &vlan);
return 0;
} }
static int dsa_slave_restore_vlan(struct net_device *vdev, int vid, void *arg) static int dsa_slave_restore_vlan(struct net_device *vdev, int vid, void *arg)
......
...@@ -558,6 +558,7 @@ static int dsa_switch_host_mdb_del(struct dsa_switch *ds, ...@@ -558,6 +558,7 @@ static int dsa_switch_host_mdb_del(struct dsa_switch *ds,
return err; return err;
} }
/* Port VLANs match on the targeted port and on all DSA ports */
static bool dsa_port_vlan_match(struct dsa_port *dp, static bool dsa_port_vlan_match(struct dsa_port *dp,
struct dsa_notifier_vlan_info *info) struct dsa_notifier_vlan_info *info)
{ {
...@@ -570,6 +571,126 @@ static bool dsa_port_vlan_match(struct dsa_port *dp, ...@@ -570,6 +571,126 @@ static bool dsa_port_vlan_match(struct dsa_port *dp,
return false; return false;
} }
/* Host VLANs match on the targeted port's CPU port, and on all DSA ports
* (upstream and downstream) of that switch and its upstream switches.
*/
static bool dsa_port_host_vlan_match(struct dsa_port *dp,
struct dsa_notifier_vlan_info *info)
{
struct dsa_port *targeted_dp, *cpu_dp;
struct dsa_switch *targeted_ds;
targeted_ds = dsa_switch_find(dp->ds->dst->index, info->sw_index);
targeted_dp = dsa_to_port(targeted_ds, info->port);
cpu_dp = targeted_dp->cpu_dp;
if (dsa_switch_is_upstream_of(dp->ds, targeted_ds))
return dsa_port_is_dsa(dp) || dp == cpu_dp;
return false;
}
static struct dsa_vlan *dsa_vlan_find(struct list_head *vlan_list,
const struct switchdev_obj_port_vlan *vlan)
{
struct dsa_vlan *v;
list_for_each_entry(v, vlan_list, list)
if (v->vid == vlan->vid)
return v;
return NULL;
}
static int dsa_port_do_vlan_add(struct dsa_port *dp,
const struct switchdev_obj_port_vlan *vlan,
struct netlink_ext_ack *extack)
{
struct dsa_switch *ds = dp->ds;
int port = dp->index;
struct dsa_vlan *v;
int err = 0;
/* No need to bother with refcounting for user ports. */
if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
return ds->ops->port_vlan_add(ds, port, vlan, extack);
/* No need to propagate on shared ports the existing VLANs that were
* re-notified after just the flags have changed. This would cause a
* refcount bump which we need to avoid, since it unbalances the
* additions with the deletions.
*/
if (vlan->changed)
return 0;
mutex_lock(&dp->vlans_lock);
v = dsa_vlan_find(&dp->vlans, vlan);
if (v) {
refcount_inc(&v->refcount);
goto out;
}
v = kzalloc(sizeof(*v), GFP_KERNEL);
if (!v) {
err = -ENOMEM;
goto out;
}
err = ds->ops->port_vlan_add(ds, port, vlan, extack);
if (err) {
kfree(v);
goto out;
}
v->vid = vlan->vid;
refcount_set(&v->refcount, 1);
list_add_tail(&v->list, &dp->vlans);
out:
mutex_unlock(&dp->vlans_lock);
return err;
}
static int dsa_port_do_vlan_del(struct dsa_port *dp,
const struct switchdev_obj_port_vlan *vlan)
{
struct dsa_switch *ds = dp->ds;
int port = dp->index;
struct dsa_vlan *v;
int err = 0;
/* No need to bother with refcounting for user ports */
if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
return ds->ops->port_vlan_del(ds, port, vlan);
mutex_lock(&dp->vlans_lock);
v = dsa_vlan_find(&dp->vlans, vlan);
if (!v) {
err = -ENOENT;
goto out;
}
if (!refcount_dec_and_test(&v->refcount))
goto out;
err = ds->ops->port_vlan_del(ds, port, vlan);
if (err) {
refcount_set(&v->refcount, 1);
goto out;
}
list_del(&v->list);
kfree(v);
out:
mutex_unlock(&dp->vlans_lock);
return err;
}
static int dsa_switch_vlan_add(struct dsa_switch *ds, static int dsa_switch_vlan_add(struct dsa_switch *ds,
struct dsa_notifier_vlan_info *info) struct dsa_notifier_vlan_info *info)
{ {
...@@ -581,8 +702,8 @@ static int dsa_switch_vlan_add(struct dsa_switch *ds, ...@@ -581,8 +702,8 @@ static int dsa_switch_vlan_add(struct dsa_switch *ds,
dsa_switch_for_each_port(dp, ds) { dsa_switch_for_each_port(dp, ds) {
if (dsa_port_vlan_match(dp, info)) { if (dsa_port_vlan_match(dp, info)) {
err = ds->ops->port_vlan_add(ds, dp->index, info->vlan, err = dsa_port_do_vlan_add(dp, info->vlan,
info->extack); info->extack);
if (err) if (err)
return err; return err;
} }
...@@ -594,15 +715,61 @@ static int dsa_switch_vlan_add(struct dsa_switch *ds, ...@@ -594,15 +715,61 @@ static int dsa_switch_vlan_add(struct dsa_switch *ds,
static int dsa_switch_vlan_del(struct dsa_switch *ds, static int dsa_switch_vlan_del(struct dsa_switch *ds,
struct dsa_notifier_vlan_info *info) struct dsa_notifier_vlan_info *info)
{ {
struct dsa_port *dp;
int err;
if (!ds->ops->port_vlan_del) if (!ds->ops->port_vlan_del)
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (ds->index == info->sw_index) dsa_switch_for_each_port(dp, ds) {
return ds->ops->port_vlan_del(ds, info->port, info->vlan); if (dsa_port_vlan_match(dp, info)) {
err = dsa_port_do_vlan_del(dp, info->vlan);
if (err)
return err;
}
}
return 0;
}
static int dsa_switch_host_vlan_add(struct dsa_switch *ds,
struct dsa_notifier_vlan_info *info)
{
struct dsa_port *dp;
int err;
if (!ds->ops->port_vlan_add)
return -EOPNOTSUPP;
dsa_switch_for_each_port(dp, ds) {
if (dsa_port_host_vlan_match(dp, info)) {
err = dsa_port_do_vlan_add(dp, info->vlan,
info->extack);
if (err)
return err;
}
}
return 0;
}
static int dsa_switch_host_vlan_del(struct dsa_switch *ds,
struct dsa_notifier_vlan_info *info)
{
struct dsa_port *dp;
int err;
if (!ds->ops->port_vlan_del)
return -EOPNOTSUPP;
dsa_switch_for_each_port(dp, ds) {
if (dsa_port_host_vlan_match(dp, info)) {
err = dsa_port_do_vlan_del(dp, info->vlan);
if (err)
return err;
}
}
/* Do not deprogram the DSA links as they may be used as conduit
* for other VLAN members in the fabric.
*/
return 0; return 0;
} }
...@@ -764,6 +931,12 @@ static int dsa_switch_event(struct notifier_block *nb, ...@@ -764,6 +931,12 @@ static int dsa_switch_event(struct notifier_block *nb,
case DSA_NOTIFIER_VLAN_DEL: case DSA_NOTIFIER_VLAN_DEL:
err = dsa_switch_vlan_del(ds, info); err = dsa_switch_vlan_del(ds, info);
break; break;
case DSA_NOTIFIER_HOST_VLAN_ADD:
err = dsa_switch_host_vlan_add(ds, info);
break;
case DSA_NOTIFIER_HOST_VLAN_DEL:
err = dsa_switch_host_vlan_del(ds, info);
break;
case DSA_NOTIFIER_MTU: case DSA_NOTIFIER_MTU:
err = dsa_switch_mtu(ds, info); err = dsa_switch_mtu(ds, info);
break; break;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment