Merge branch 'switchdev_spring_cleanup'

Scott Feldman says:

====================
switchdev: spring cleanup

v7:

Address review comments:

 - [Jiri] split the br_setlink and br_dellink reverts into their own patches
 - [Jiri] some parameter cleanup of rocker's memory allocators
 - [Jiri] pass trans mode as formal parameter rather than hanging off of
     rocker_port.

v6:

Address review comments:

 - [Jiri] split a couple of patches into one-logical-change per patch
 - [Joe Perches] revert checkpatch -f changes for wrapped lines with long
     symbols.

v5:

Address review comments:

 - [Jiri] include Jiri's s/swdev/switchdev rename patches up front.
 - [Jiri] squash some patches.  Now setlink/dellink/getlink patches are in
     three parts: new implementation, convert drivers to new, delete old impl.
 - [Jiri] some minor variable renames
 - [Jiri] use BUG_ON rather than WARN when COMMIT phase fails when PREPARE
     phase said it was safe to come into the water.
 - [Simon] rocker: fix a few transaction prepare-commit cases that were wrong.
     This was the bulk of the changes in v5.

v4:

Well, it was a lot of work, but now prepare-commit transaction model is how
davem advises: if prepare fails, abort the transaction.  The driver must do
resource reservations up front in prepare phase and return those resources if
aborting.  Commit phase would use reserved resources.  The good news is the
driver code (for rocker) now handles resource allocation failures better by not
leaving partially device or driver states.  This is a side-effect of the
prepare phase where state isn't modified; only validation of inputs and
resource reservations happen in the prepare phase.  Since we're supporting
setting attrs and add objs across lower devs in the stacked case, we need to
hold rtnl_lock (or ensure rtnl_lock is held) so lower devs don't move on us
during the prepare-commit transaction.  DSA driver code skips the prepare phase
and goes straight for the commit phase since no up-front allocations are done
and no device failures (that could be detected in the prepare phase) can
happen.

Remove NETIF_F_HW_SWITCH_OFFLOAD from rocker and the swdev_attr_set/get
wrappers.  DSA doesn't set NETIF_F_HW_SWITCH_OFFLOAD, so it can't be in
swdev_attr_set/get.  rocker doesn't need it; or rather can't support
NETIF_F_HW_SWITCH_OFFLOAD being set/cleared at run-time after the device
port is already up and offloading L2/L3.  NETIF_F_HW_SWITCH_OFFLOAD is still
left as a feature flag for drivers that can use it.

Drop the renaming patch for netdev_switch_notifier.  Other renames are a
result of moving to the attr get/set or obj add/del model.  Everything
but the netdev_switch_notifier is still prefixed with "swdev_".

v3:

Move to two-phase prepare-commit transaction model for attr set and obj add.
Driver gets a change in prepare phase to NACK transaction if lack of resources
or support in device.

v2:

Address review comments:

 - [Jiri] squash a few related patches
 - [Roopa] don't remove NETIF_F_HW_SWITCH_OFFLOAD
 - [Roopa] address VLAN setlink/dellink
 - [Ronen] print warning is attr set revert fails

Not address:

 - Using something other than "swdev_" prefix
 - Vendor extentions

The patch set grew a bit to not only support port attr get/set but also add
support for port obj add/del.  Example of port objs are VLAN, FDB entries, and
FIB entries.  The VLAN support now allows the swdev driver to get VLAN ranges
and flags like PVID and "untagged".  Sridhar will be adding FDB obj support
in follow-on patch.

v1:

The main theme of this patch set is to cleanup swdev in preparation for
new features or fixes to be added soon.  We have a pretty good idea now how
to handle stacked drivers in swdev, but there where some loose ends.  For
example, if a set failed in the middle of walking the lower devs, we would
leave the system in an undefined state...there was no way to recover back to
the previous state.  Speaking of sets, also recognize a pattern that most
swdev API accesses are gets or sets of port attributes, so go ahead and make
port attr get/set the central swdev API, and convert everything that is
set-ish/get-ish to this new API.

Features/fixes that should follow from this cleanup:

 - solve the duplicate pkt forwarding issue
 - get/set bridge attrs, like ageing_time, from/to device
 - get/set more bridge port attrs from/to device

There are some rename cleanups tagging along at the end, to give swdev
consistent naming.

And finally, some much needed updates to the switchdev.txt documentation to
hopefully capture the state-of-the-art of swdev.  Hopefully, we can do a better
job keeping this document up-to-date.

Tested with rocker, of course, to make sure nothing functional broke.  There
are a couple minor tweaks to DSA code for getting switch ID and setting STP
updates to use new API, but not expecting amy breakage there.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 502 insertions, 160 deletions

diff --git a/net/switchdev/switchdev.c b/net/switchdev/switchdev.c
index 46568b85c333..65d49d4477b9 100644
--- a/net/switchdev/switchdev.c
+++ b/net/switchdev/switchdev.c
@@ -15,97 +15,328 @@
 #include <linux/mutex.h>
 #include <linux/notifier.h>
 #include <linux/netdevice.h>
+#include <linux/if_bridge.h>
 #include <net/ip_fib.h>
 #include <net/switchdev.h>
 
 /**
- *      netdev_switch_parent_id_get - Get ID of a switch
+ *      switchdev_port_attr_get - Get port attribute
+ *
  *      @dev: port device
- *      @psid: switch ID
+ *      @attr: attribute to get
+ */
+int switchdev_port_attr_get(struct net_device *dev, struct switchdev_attr *attr)
+{
+        const struct switchdev_ops *ops = dev->switchdev_ops;
+        struct net_device *lower_dev;
+        struct list_head *iter;
+        struct switchdev_attr first = {
+                .id = SWITCHDEV_ATTR_UNDEFINED
+        };
+        int err = -EOPNOTSUPP;
+
+        if (ops && ops->switchdev_port_attr_get)
+                return ops->switchdev_port_attr_get(dev, attr);
+
+        if (attr->flags & SWITCHDEV_F_NO_RECURSE)
+                return err;
+
+        /* Switch device port(s) may be stacked under
+         * bond/team/vlan dev, so recurse down to get attr on
+         * each port.  Return -ENODATA if attr values don't
+         * compare across ports.
+         */
+
+        netdev_for_each_lower_dev(dev, lower_dev, iter) {
+                err = switchdev_port_attr_get(lower_dev, attr);
+                if (err)
+                        break;
+                if (first.id == SWITCHDEV_ATTR_UNDEFINED)
+                        first = *attr;
+                else if (memcmp(&first, attr, sizeof(*attr)))
+                        return -ENODATA;
+        }
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(switchdev_port_attr_get);
+
+static int __switchdev_port_attr_set(struct net_device *dev,
+                                     struct switchdev_attr *attr)
+{
+        const struct switchdev_ops *ops = dev->switchdev_ops;
+        struct net_device *lower_dev;
+        struct list_head *iter;
+        int err = -EOPNOTSUPP;
+
+        if (ops && ops->switchdev_port_attr_set)
+                return ops->switchdev_port_attr_set(dev, attr);
+
+        if (attr->flags & SWITCHDEV_F_NO_RECURSE)
+                return err;
+
+        /* Switch device port(s) may be stacked under
+         * bond/team/vlan dev, so recurse down to set attr on
+         * each port.
+         */
+
+        netdev_for_each_lower_dev(dev, lower_dev, iter) {
+                err = __switchdev_port_attr_set(lower_dev, attr);
+                if (err)
+                        break;
+        }
+
+        return err;
+}
+
+struct switchdev_attr_set_work {
+        struct work_struct work;
+        struct net_device *dev;
+        struct switchdev_attr attr;
+};
+
+static void switchdev_port_attr_set_work(struct work_struct *work)
+{
+        struct switchdev_attr_set_work *asw =
+                container_of(work, struct switchdev_attr_set_work, work);
+        int err;
+
+        rtnl_lock();
+        err = switchdev_port_attr_set(asw->dev, &asw->attr);
+        BUG_ON(err);
+        rtnl_unlock();
+
+        dev_put(asw->dev);
+        kfree(work);
+}
+
+static int switchdev_port_attr_set_defer(struct net_device *dev,
+                                         struct switchdev_attr *attr)
+{
+        struct switchdev_attr_set_work *asw;
+
+        asw = kmalloc(sizeof(*asw), GFP_ATOMIC);
+        if (!asw)
+                return -ENOMEM;
+
+        INIT_WORK(&asw->work, switchdev_port_attr_set_work);
+
+        dev_hold(dev);
+        asw->dev = dev;
+        memcpy(&asw->attr, attr, sizeof(asw->attr));
+
+        schedule_work(&asw->work);
+
+        return 0;
+}
+
+/**
+ *      switchdev_port_attr_set - Set port attribute
+ *
+ *      @dev: port device
+ *      @attr: attribute to set
  *
- *      Get ID of a switch this port is part of.
+ *      Use a 2-phase prepare-commit transaction model to ensure
+ *      system is not left in a partially updated state due to
+ *      failure from driver/device.
  */
-int netdev_switch_parent_id_get(struct net_device *dev,
-                                struct netdev_phys_item_id *psid)
+int switchdev_port_attr_set(struct net_device *dev, struct switchdev_attr *attr)
 {
-        const struct swdev_ops *ops = dev->swdev_ops;
+        int err;
+
+        if (!rtnl_is_locked()) {
+                /* Running prepare-commit transaction across stacked
+                 * devices requires nothing moves, so if rtnl_lock is
+                 * not held, schedule a worker thread to hold rtnl_lock
+                 * while setting attr.
+                 */
+
+                return switchdev_port_attr_set_defer(dev, attr);
+        }
 
-        if (!ops || !ops->swdev_parent_id_get)
-                return -EOPNOTSUPP;
-        return ops->swdev_parent_id_get(dev, psid);
+        /* Phase I: prepare for attr set. Driver/device should fail
+         * here if there are going to be issues in the commit phase,
+         * such as lack of resources or support.  The driver/device
+         * should reserve resources needed for the commit phase here,
+         * but should not commit the attr.
+         */
+
+        attr->trans = SWITCHDEV_TRANS_PREPARE;
+        err = __switchdev_port_attr_set(dev, attr);
+        if (err) {
+                /* Prepare phase failed: abort the transaction.  Any
+                 * resources reserved in the prepare phase are
+                 * released.
+                 */
+
+                attr->trans = SWITCHDEV_TRANS_ABORT;
+                __switchdev_port_attr_set(dev, attr);
+
+                return err;
+        }
+
+        /* Phase II: commit attr set.  This cannot fail as a fault
+         * of driver/device.  If it does, it's a bug in the driver/device
+         * because the driver said everythings was OK in phase I.
+         */
+
+        attr->trans = SWITCHDEV_TRANS_COMMIT;
+        err = __switchdev_port_attr_set(dev, attr);
+        BUG_ON(err);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(switchdev_port_attr_set);
+
+int __switchdev_port_obj_add(struct net_device *dev, struct switchdev_obj *obj)
+{
+        const struct switchdev_ops *ops = dev->switchdev_ops;
+        struct net_device *lower_dev;
+        struct list_head *iter;
+        int err = -EOPNOTSUPP;
+
+        if (ops && ops->switchdev_port_obj_add)
+                return ops->switchdev_port_obj_add(dev, obj);
+
+        /* Switch device port(s) may be stacked under
+         * bond/team/vlan dev, so recurse down to add object on
+         * each port.
+         */
+
+        netdev_for_each_lower_dev(dev, lower_dev, iter) {
+                err = __switchdev_port_obj_add(lower_dev, obj);
+                if (err)
+                        break;
+        }
+
+        return err;
 }
-EXPORT_SYMBOL_GPL(netdev_switch_parent_id_get);
 
 /**
- *      netdev_switch_port_stp_update - Notify switch device port of STP
- *                                      state change
+ *      switchdev_port_obj_add - Add port object
+ *
  *      @dev: port device
- *      @state: port STP state
+ *      @obj: object to add
+ *
+ *      Use a 2-phase prepare-commit transaction model to ensure
+ *      system is not left in a partially updated state due to
+ *      failure from driver/device.
+ *
+ *      rtnl_lock must be held.
+ */
+int switchdev_port_obj_add(struct net_device *dev, struct switchdev_obj *obj)
+{
+        int err;
+
+        ASSERT_RTNL();
+
+        /* Phase I: prepare for obj add. Driver/device should fail
+         * here if there are going to be issues in the commit phase,
+         * such as lack of resources or support.  The driver/device
+         * should reserve resources needed for the commit phase here,
+         * but should not commit the obj.
+         */
+
+        obj->trans = SWITCHDEV_TRANS_PREPARE;
+        err = __switchdev_port_obj_add(dev, obj);
+        if (err) {
+                /* Prepare phase failed: abort the transaction.  Any
+                 * resources reserved in the prepare phase are
+                 * released.
+                 */
+
+                obj->trans = SWITCHDEV_TRANS_ABORT;
+                __switchdev_port_obj_add(dev, obj);
+
+                return err;
+        }
+
+        /* Phase II: commit obj add.  This cannot fail as a fault
+         * of driver/device.  If it does, it's a bug in the driver/device
+         * because the driver said everythings was OK in phase I.
+         */
+
+        obj->trans = SWITCHDEV_TRANS_COMMIT;
+        err = __switchdev_port_obj_add(dev, obj);
+        WARN(err, "%s: Commit of object (id=%d) failed.\n", dev->name, obj->id);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(switchdev_port_obj_add);
+
+/**
+ *      switchdev_port_obj_del - Delete port object
  *
- *      Notify switch device port of bridge port STP state change.
+ *      @dev: port device
+ *      @obj: object to delete
  */
-int netdev_switch_port_stp_update(struct net_device *dev, u8 state)
+int switchdev_port_obj_del(struct net_device *dev, struct switchdev_obj *obj)
 {
-        const struct swdev_ops *ops = dev->swdev_ops;
+        const struct switchdev_ops *ops = dev->switchdev_ops;
         struct net_device *lower_dev;
         struct list_head *iter;
         int err = -EOPNOTSUPP;
 
-        if (ops && ops->swdev_port_stp_update)
-                return ops->swdev_port_stp_update(dev, state);
+        if (ops && ops->switchdev_port_obj_del)
+                return ops->switchdev_port_obj_del(dev, obj);
+
+        /* Switch device port(s) may be stacked under
+         * bond/team/vlan dev, so recurse down to delete object on
+         * each port.
+         */
 
         netdev_for_each_lower_dev(dev, lower_dev, iter) {
-                err = netdev_switch_port_stp_update(lower_dev, state);
-                if (err && err != -EOPNOTSUPP)
-                        return err;
+                err = switchdev_port_obj_del(lower_dev, obj);
+                if (err)
+                        break;
         }
 
         return err;
 }
-EXPORT_SYMBOL_GPL(netdev_switch_port_stp_update);
+EXPORT_SYMBOL_GPL(switchdev_port_obj_del);
 
-static DEFINE_MUTEX(netdev_switch_mutex);
-static RAW_NOTIFIER_HEAD(netdev_switch_notif_chain);
+static DEFINE_MUTEX(switchdev_mutex);
+static RAW_NOTIFIER_HEAD(switchdev_notif_chain);
 
 /**
- *      register_netdev_switch_notifier - Register notifier
+ *      register_switchdev_notifier - Register notifier
  *      @nb: notifier_block
  *
  *      Register switch device notifier. This should be used by code
  *      which needs to monitor events happening in particular device.
  *      Return values are same as for atomic_notifier_chain_register().
  */
-int register_netdev_switch_notifier(struct notifier_block *nb)
+int register_switchdev_notifier(struct notifier_block *nb)
 {
         int err;
 
-        mutex_lock(&netdev_switch_mutex);
-        err = raw_notifier_chain_register(&netdev_switch_notif_chain, nb);
-        mutex_unlock(&netdev_switch_mutex);
+        mutex_lock(&switchdev_mutex);
+        err = raw_notifier_chain_register(&switchdev_notif_chain, nb);
+        mutex_unlock(&switchdev_mutex);
         return err;
 }
-EXPORT_SYMBOL_GPL(register_netdev_switch_notifier);
+EXPORT_SYMBOL_GPL(register_switchdev_notifier);
 
 /**
- *      unregister_netdev_switch_notifier - Unregister notifier
+ *      unregister_switchdev_notifier - Unregister notifier
  *      @nb: notifier_block
  *
  *      Unregister switch device notifier.
  *      Return values are same as for atomic_notifier_chain_unregister().
  */
-int unregister_netdev_switch_notifier(struct notifier_block *nb)
+int unregister_switchdev_notifier(struct notifier_block *nb)
 {
         int err;
 
-        mutex_lock(&netdev_switch_mutex);
-        err = raw_notifier_chain_unregister(&netdev_switch_notif_chain, nb);
-        mutex_unlock(&netdev_switch_mutex);
+        mutex_lock(&switchdev_mutex);
+        err = raw_notifier_chain_unregister(&switchdev_notif_chain, nb);
+        mutex_unlock(&switchdev_mutex);
         return err;
 }
-EXPORT_SYMBOL_GPL(unregister_netdev_switch_notifier);
+EXPORT_SYMBOL_GPL(unregister_switchdev_notifier);
 
 /**
- *      call_netdev_switch_notifiers - Call notifiers
+ *      call_switchdev_notifiers - Call notifiers
  *      @val: value passed unmodified to notifier function
  *      @dev: port device
  *      @info: notifier information data
@@ -114,146 +345,241 @@ EXPORT_SYMBOL_GPL(unregister_netdev_switch_notifier);
  *      when it needs to propagate hardware event.
  *      Return values are same as for atomic_notifier_call_chain().
  */
-int call_netdev_switch_notifiers(unsigned long val, struct net_device *dev,
-                                 struct netdev_switch_notifier_info *info)
+int call_switchdev_notifiers(unsigned long val, struct net_device *dev,
+                             struct switchdev_notifier_info *info)
 {
         int err;
 
         info->dev = dev;
-        mutex_lock(&netdev_switch_mutex);
-        err = raw_notifier_call_chain(&netdev_switch_notif_chain, val, info);
-        mutex_unlock(&netdev_switch_mutex);
+        mutex_lock(&switchdev_mutex);
+        err = raw_notifier_call_chain(&switchdev_notif_chain, val, info);
+        mutex_unlock(&switchdev_mutex);
         return err;
 }
-EXPORT_SYMBOL_GPL(call_netdev_switch_notifiers);
+EXPORT_SYMBOL_GPL(call_switchdev_notifiers);
 
 /**
- *      netdev_switch_port_bridge_setlink - Notify switch device port of bridge
- *      port attributes
+ *      switchdev_port_bridge_getlink - Get bridge port attributes
  *
  *      @dev: port device
- *      @nlh: netlink msg with bridge port attributes
- *      @flags: bridge setlink flags
  *
- *      Notify switch device port of bridge port attributes
+ *      Called for SELF on rtnl_bridge_getlink to get bridge port
+ *      attributes.
  */
-int netdev_switch_port_bridge_setlink(struct net_device *dev,
-                                      struct nlmsghdr *nlh, u16 flags)
+int switchdev_port_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
+                                  struct net_device *dev, u32 filter_mask,
+                                  int nlflags)
 {
-        const struct net_device_ops *ops = dev->netdev_ops;
+        struct switchdev_attr attr = {
+                .id = SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
+        };
+        u16 mode = BRIDGE_MODE_UNDEF;
+        u32 mask = BR_LEARNING | BR_LEARNING_SYNC;
+        int err;
 
-        if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
-                return 0;
+        err = switchdev_port_attr_get(dev, &attr);
+        if (err)
+                return err;
+
+        return ndo_dflt_bridge_getlink(skb, pid, seq, dev, mode,
+                                       attr.brport_flags, mask, nlflags);
+}
+EXPORT_SYMBOL_GPL(switchdev_port_bridge_getlink);
+
+static int switchdev_port_br_setflag(struct net_device *dev,
+                                     struct nlattr *nlattr,
+                                     unsigned long brport_flag)
+{
+        struct switchdev_attr attr = {
+                .id = SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
+        };
+        u8 flag = nla_get_u8(nlattr);
+        int err;
+
+        err = switchdev_port_attr_get(dev, &attr);
+        if (err)
+                return err;
 
-        if (!ops->ndo_bridge_setlink)
-                return -EOPNOTSUPP;
+        if (flag)
+                attr.brport_flags |= brport_flag;
+        else
+                attr.brport_flags &= ~brport_flag;
 
-        return ops->ndo_bridge_setlink(dev, nlh, flags);
+        return switchdev_port_attr_set(dev, &attr);
 }
-EXPORT_SYMBOL_GPL(netdev_switch_port_bridge_setlink);
 
-/**
- *      netdev_switch_port_bridge_dellink - Notify switch device port of bridge
- *      port attribute delete
- *
- *      @dev: port device
- *      @nlh: netlink msg with bridge port attributes
- *      @flags: bridge setlink flags
- *
- *      Notify switch device port of bridge port attribute delete
- */
-int netdev_switch_port_bridge_dellink(struct net_device *dev,
-                                      struct nlmsghdr *nlh, u16 flags)
+static const struct nla_policy
+switchdev_port_bridge_policy[IFLA_BRPORT_MAX + 1] = {
+        [IFLA_BRPORT_STATE]             = { .type = NLA_U8 },
+        [IFLA_BRPORT_COST]              = { .type = NLA_U32 },
+        [IFLA_BRPORT_PRIORITY]          = { .type = NLA_U16 },
+        [IFLA_BRPORT_MODE]              = { .type = NLA_U8 },
+        [IFLA_BRPORT_GUARD]             = { .type = NLA_U8 },
+        [IFLA_BRPORT_PROTECT]           = { .type = NLA_U8 },
+        [IFLA_BRPORT_FAST_LEAVE]        = { .type = NLA_U8 },
+        [IFLA_BRPORT_LEARNING]          = { .type = NLA_U8 },
+        [IFLA_BRPORT_LEARNING_SYNC]     = { .type = NLA_U8 },
+        [IFLA_BRPORT_UNICAST_FLOOD]     = { .type = NLA_U8 },
+};
+
+static int switchdev_port_br_setlink_protinfo(struct net_device *dev,
+                                              struct nlattr *protinfo)
 {
-        const struct net_device_ops *ops = dev->netdev_ops;
+        struct nlattr *attr;
+        int rem;
+        int err;
 
-        if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
-                return 0;
+        err = nla_validate_nested(protinfo, IFLA_BRPORT_MAX,
+                                  switchdev_port_bridge_policy);
+        if (err)
+                return err;
+
+        nla_for_each_nested(attr, protinfo, rem) {
+                switch (nla_type(attr)) {
+                case IFLA_BRPORT_LEARNING:
+                        err = switchdev_port_br_setflag(dev, attr,
+                                                        BR_LEARNING);
+                        break;
+                case IFLA_BRPORT_LEARNING_SYNC:
+                        err = switchdev_port_br_setflag(dev, attr,
+                                                        BR_LEARNING_SYNC);
+                        break;
+                default:
+                        err = -EOPNOTSUPP;
+                        break;
+                }
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int switchdev_port_br_afspec(struct net_device *dev,
+                                    struct nlattr *afspec,
+                                    int (*f)(struct net_device *dev,
+                                             struct switchdev_obj *obj))
+{
+        struct nlattr *attr;
+        struct bridge_vlan_info *vinfo;
+        struct switchdev_obj obj = {
+                .id = SWITCHDEV_OBJ_PORT_VLAN,
+        };
+        int rem;
+        int err;
 
-        if (!ops->ndo_bridge_dellink)
-                return -EOPNOTSUPP;
+        nla_for_each_nested(attr, afspec, rem) {
+                if (nla_type(attr) != IFLA_BRIDGE_VLAN_INFO)
+                        continue;
+                if (nla_len(attr) != sizeof(struct bridge_vlan_info))
+                        return -EINVAL;
+                vinfo = nla_data(attr);
+                obj.vlan.flags = vinfo->flags;
+                if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
+                        if (obj.vlan.vid_start)
+                                return -EINVAL;
+                        obj.vlan.vid_start = vinfo->vid;
+                } else if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END) {
+                        if (!obj.vlan.vid_start)
+                                return -EINVAL;
+                        obj.vlan.vid_end = vinfo->vid;
+                        if (obj.vlan.vid_end <= obj.vlan.vid_start)
+                                return -EINVAL;
+                        err = f(dev, &obj);
+                        if (err)
+                                return err;
+                        memset(&obj.vlan, 0, sizeof(obj.vlan));
+                } else {
+                        if (obj.vlan.vid_start)
+                                return -EINVAL;
+                        obj.vlan.vid_start = vinfo->vid;
+                        obj.vlan.vid_end = vinfo->vid;
+                        err = f(dev, &obj);
+                        if (err)
+                                return err;
+                        memset(&obj.vlan, 0, sizeof(obj.vlan));
+                }
+        }
 
-        return ops->ndo_bridge_dellink(dev, nlh, flags);
+        return 0;
 }
-EXPORT_SYMBOL_GPL(netdev_switch_port_bridge_dellink);
 
 /**
- *      ndo_dflt_netdev_switch_port_bridge_setlink - default ndo bridge setlink
- *                                                   op for master devices
+ *      switchdev_port_bridge_setlink - Set bridge port attributes
  *
  *      @dev: port device
- *      @nlh: netlink msg with bridge port attributes
- *      @flags: bridge setlink flags
+ *      @nlh: netlink header
+ *      @flags: netlink flags
  *
- *      Notify master device slaves of bridge port attributes
+ *      Called for SELF on rtnl_bridge_setlink to set bridge port
+ *      attributes.
  */
-int ndo_dflt_netdev_switch_port_bridge_setlink(struct net_device *dev,
-                                               struct nlmsghdr *nlh, u16 flags)
+int switchdev_port_bridge_setlink(struct net_device *dev,
+                                  struct nlmsghdr *nlh, u16 flags)
 {
-        struct net_device *lower_dev;
-        struct list_head *iter;
-        int ret = 0, err = 0;
-
-        if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
-                return ret;
+        struct nlattr *protinfo;
+        struct nlattr *afspec;
+        int err = 0;
 
-        netdev_for_each_lower_dev(dev, lower_dev, iter) {
-                err = netdev_switch_port_bridge_setlink(lower_dev, nlh, flags);
-                if (err && err != -EOPNOTSUPP)
-                        ret = err;
+        protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
+                                   IFLA_PROTINFO);
+        if (protinfo) {
+                err = switchdev_port_br_setlink_protinfo(dev, protinfo);
+                if (err)
+                        return err;
         }
 
-        return ret;
+        afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
+                                 IFLA_AF_SPEC);
+        if (afspec)
+                err = switchdev_port_br_afspec(dev, afspec,
+                                               switchdev_port_obj_add);
+
+        return err;
 }
-EXPORT_SYMBOL_GPL(ndo_dflt_netdev_switch_port_bridge_setlink);
+EXPORT_SYMBOL_GPL(switchdev_port_bridge_setlink);
 
 /**
- *      ndo_dflt_netdev_switch_port_bridge_dellink - default ndo bridge dellink
- *                                                   op for master devices
+ *      switchdev_port_bridge_dellink - Set bridge port attributes
  *
  *      @dev: port device
- *      @nlh: netlink msg with bridge port attributes
- *      @flags: bridge dellink flags
+ *      @nlh: netlink header
+ *      @flags: netlink flags
  *
- *      Notify master device slaves of bridge port attribute deletes
+ *      Called for SELF on rtnl_bridge_dellink to set bridge port
+ *      attributes.
  */
-int ndo_dflt_netdev_switch_port_bridge_dellink(struct net_device *dev,
-                                               struct nlmsghdr *nlh, u16 flags)
+int switchdev_port_bridge_dellink(struct net_device *dev,
+                                  struct nlmsghdr *nlh, u16 flags)
 {
-        struct net_device *lower_dev;
-        struct list_head *iter;
-        int ret = 0, err = 0;
+        struct nlattr *afspec;
 
-        if (!(dev->features & NETIF_F_HW_SWITCH_OFFLOAD))
-                return ret;
+        afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
+                                 IFLA_AF_SPEC);
+        if (afspec)
+                return switchdev_port_br_afspec(dev, afspec,
+                                                switchdev_port_obj_del);
 
-        netdev_for_each_lower_dev(dev, lower_dev, iter) {
-                err = netdev_switch_port_bridge_dellink(lower_dev, nlh, flags);
-                if (err && err != -EOPNOTSUPP)
-                        ret = err;
-        }
-
-        return ret;
+        return 0;
 }
-EXPORT_SYMBOL_GPL(ndo_dflt_netdev_switch_port_bridge_dellink);
+EXPORT_SYMBOL_GPL(switchdev_port_bridge_dellink);
 
-static struct net_device *netdev_switch_get_lowest_dev(struct net_device *dev)
+static struct net_device *switchdev_get_lowest_dev(struct net_device *dev)
 {
-        const struct swdev_ops *ops = dev->swdev_ops;
+        const struct switchdev_ops *ops = dev->switchdev_ops;
         struct net_device *lower_dev;
         struct net_device *port_dev;
         struct list_head *iter;
 
         /* Recusively search down until we find a sw port dev.
-         * (A sw port dev supports swdev_parent_id_get).
+         * (A sw port dev supports switchdev_port_attr_get).
          */
 
-        if (dev->features & NETIF_F_HW_SWITCH_OFFLOAD &&
-            ops && ops->swdev_parent_id_get)
+        if (ops && ops->switchdev_port_attr_get)
                 return dev;
 
         netdev_for_each_lower_dev(dev, lower_dev, iter) {
-                port_dev = netdev_switch_get_lowest_dev(lower_dev);
+                port_dev = switchdev_get_lowest_dev(lower_dev);
                 if (port_dev)
                         return port_dev;
         }
@@ -261,10 +587,12 @@ static struct net_device *netdev_switch_get_lowest_dev(struct net_device *dev)
         return NULL;
 }
 
-static struct net_device *netdev_switch_get_dev_by_nhs(struct fib_info *fi)
+static struct net_device *switchdev_get_dev_by_nhs(struct fib_info *fi)
 {
-        struct netdev_phys_item_id psid;
-        struct netdev_phys_item_id prev_psid;
+        struct switchdev_attr attr = {
+                .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
+        };
+        struct switchdev_attr prev_attr;
         struct net_device *dev = NULL;
         int nhsel;
 
@@ -276,28 +604,29 @@ static struct net_device *netdev_switch_get_dev_by_nhs(struct fib_info *fi)
                 if (!nh->nh_dev)
                         return NULL;
 
-                dev = netdev_switch_get_lowest_dev(nh->nh_dev);
+                dev = switchdev_get_lowest_dev(nh->nh_dev);
                 if (!dev)
                         return NULL;
 
-                if (netdev_switch_parent_id_get(dev, &psid))
+                if (switchdev_port_attr_get(dev, &attr))
                         return NULL;
 
                 if (nhsel > 0) {
-                        if (prev_psid.id_len != psid.id_len)
+                        if (prev_attr.ppid.id_len != attr.ppid.id_len)
                                 return NULL;
-                        if (memcmp(prev_psid.id, psid.id, psid.id_len))
+                        if (memcmp(prev_attr.ppid.id, attr.ppid.id,
+                                   attr.ppid.id_len))
                                 return NULL;
                 }
 
-                prev_psid = psid;
+                prev_attr = attr;
         }
 
         return dev;
 }
 
 /**
- *      netdev_switch_fib_ipv4_add - Add IPv4 route entry to switch
+ *      switchdev_fib_ipv4_add - Add IPv4 route entry to switch
  *
  *      @dst: route's IPv4 destination address
  *      @dst_len: destination address length (prefix length)
@@ -309,11 +638,22 @@ static struct net_device *netdev_switch_get_dev_by_nhs(struct fib_info *fi)
  *
  *      Add IPv4 route entry to switch device.
  */
-int netdev_switch_fib_ipv4_add(u32 dst, int dst_len, struct fib_info *fi,
-                               u8 tos, u8 type, u32 nlflags, u32 tb_id)
+int switchdev_fib_ipv4_add(u32 dst, int dst_len, struct fib_info *fi,
+                           u8 tos, u8 type, u32 nlflags, u32 tb_id)
 {
+        struct switchdev_obj fib_obj = {
+                .id = SWITCHDEV_OBJ_IPV4_FIB,
+                .ipv4_fib = {
+                        .dst = htonl(dst),
+                        .dst_len = dst_len,
+                        .fi = fi,
+                        .tos = tos,
+                        .type = type,
+                        .nlflags = nlflags,
+                        .tb_id = tb_id,
+                },
+        };
         struct net_device *dev;
-        const struct swdev_ops *ops;
         int err = 0;
 
         /* Don't offload route if using custom ip rules or if
@@ -328,25 +668,20 @@ int netdev_switch_fib_ipv4_add(u32 dst, int dst_len, struct fib_info *fi,
         if (fi->fib_net->ipv4.fib_offload_disabled)
                 return 0;
 
-        dev = netdev_switch_get_dev_by_nhs(fi);
+        dev = switchdev_get_dev_by_nhs(fi);
         if (!dev)
                 return 0;
-        ops = dev->swdev_ops;
-
-        if (ops->swdev_fib_ipv4_add) {
-                err = ops->swdev_fib_ipv4_add(dev, htonl(dst), dst_len,
-                                              fi, tos, type, nlflags,
-                                              tb_id);
-                if (!err)
-                        fi->fib_flags |= RTNH_F_EXTERNAL;
-        }
+
+        err = switchdev_port_obj_add(dev, &fib_obj);
+        if (!err)
+                fi->fib_flags |= RTNH_F_EXTERNAL;
 
         return err;
 }
-EXPORT_SYMBOL_GPL(netdev_switch_fib_ipv4_add);
+EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_add);
 
 /**
- *      netdev_switch_fib_ipv4_del - Delete IPv4 route entry from switch
+ *      switchdev_fib_ipv4_del - Delete IPv4 route entry from switch
  *
  *      @dst: route's IPv4 destination address
  *      @dst_len: destination address length (prefix length)
@@ -357,38 +692,45 @@ EXPORT_SYMBOL_GPL(netdev_switch_fib_ipv4_add);
  *
  *      Delete IPv4 route entry from switch device.
  */
-int netdev_switch_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
-                               u8 tos, u8 type, u32 tb_id)
+int switchdev_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
+                           u8 tos, u8 type, u32 tb_id)
 {
+        struct switchdev_obj fib_obj = {
+                .id = SWITCHDEV_OBJ_IPV4_FIB,
+                .ipv4_fib = {
+                        .dst = htonl(dst),
+                        .dst_len = dst_len,
+                        .fi = fi,
+                        .tos = tos,
+                        .type = type,
+                        .nlflags = 0,
+                        .tb_id = tb_id,
+                },
+        };
         struct net_device *dev;
-        const struct swdev_ops *ops;
         int err = 0;
 
         if (!(fi->fib_flags & RTNH_F_EXTERNAL))
                 return 0;
 
-        dev = netdev_switch_get_dev_by_nhs(fi);
+        dev = switchdev_get_dev_by_nhs(fi);
         if (!dev)
                 return 0;
-        ops = dev->swdev_ops;
 
-        if (ops->swdev_fib_ipv4_del) {
-                err = ops->swdev_fib_ipv4_del(dev, htonl(dst), dst_len,
-                                              fi, tos, type, tb_id);
-                if (!err)
-                        fi->fib_flags &= ~RTNH_F_EXTERNAL;
-        }
+        err = switchdev_port_obj_del(dev, &fib_obj);
+        if (!err)
+                fi->fib_flags &= ~RTNH_F_EXTERNAL;
 
         return err;
 }
-EXPORT_SYMBOL_GPL(netdev_switch_fib_ipv4_del);
+EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_del);
 
 /**
- *      netdev_switch_fib_ipv4_abort - Abort an IPv4 FIB operation
+ *      switchdev_fib_ipv4_abort - Abort an IPv4 FIB operation
  *
  *      @fi: route FIB info structure
  */
-void netdev_switch_fib_ipv4_abort(struct fib_info *fi)
+void switchdev_fib_ipv4_abort(struct fib_info *fi)
 {
         /* There was a problem installing this route to the offload
          * device.  For now, until we come up with more refined
@@ -401,4 +743,4 @@ void netdev_switch_fib_ipv4_abort(struct fib_info *fi)
         fib_flush_external(fi->fib_net);
         fi->fib_net->ipv4.fib_offload_disabled = true;
 }
-EXPORT_SYMBOL_GPL(netdev_switch_fib_ipv4_abort);
+EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_abort);