Quelle  br_switchdev.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>
#include <linux/skbuff.h>
#include <net/ip.h>
#include <net/switchdev.h>

#include "br_private.h"

static struct static_key_false br_switchdev_tx_fwd_offload;

static bool nbp_switchdev_can_offload_tx_fwd(const struct net_bridge_port *p,
          const struct sk_buff *skb)
{
 if (!static_branch_unlikely(&br_switchdev_tx_fwd_offload))
  return false;

 if (br_multicast_igmp_type(skb))
  return false;

 return (p->flags & BR_TX_FWD_OFFLOAD) &&
        (p->hwdom != BR_INPUT_SKB_CB(skb)->src_hwdom);
}

bool br_switchdev_frame_uses_tx_fwd_offload(struct sk_buff *skb)
{
 if (!static_branch_unlikely(&br_switchdev_tx_fwd_offload))
  return false;

 return BR_INPUT_SKB_CB(skb)->tx_fwd_offload;
}

void br_switchdev_frame_set_offload_fwd_mark(struct sk_buff *skb)
{
 skb->offload_fwd_mark = br_switchdev_frame_uses_tx_fwd_offload(skb);
}

/* Mark the frame for TX forwarding offload if this egress port supports it */
void nbp_switchdev_frame_mark_tx_fwd_offload(const struct net_bridge_port *p,
          struct sk_buff *skb)
{
 if (nbp_switchdev_can_offload_tx_fwd(p, skb))
  BR_INPUT_SKB_CB(skb)->tx_fwd_offload = true;
}

/* Lazily adds the hwdom of the egress bridge port to the bit mask of hwdoms
 * that the skb has been already forwarded to, to avoid further cloning to
 * other ports in the same hwdom by making nbp_switchdev_allowed_egress()
 * return false.
 */
void nbp_switchdev_frame_mark_tx_fwd_to_hwdom(const struct net_bridge_port *p,
           struct sk_buff *skb)
{
 if (nbp_switchdev_can_offload_tx_fwd(p, skb))
  set_bit(p->hwdom, &BR_INPUT_SKB_CB(skb)->fwd_hwdoms);
}

void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
         struct sk_buff *skb)
{
 if (p->hwdom)
  BR_INPUT_SKB_CB(skb)->src_hwdom = p->hwdom;
}

bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
      const struct sk_buff *skb)
{
 struct br_input_skb_cb *cb = BR_INPUT_SKB_CB(skb);

 return !test_bit(p->hwdom, &cb->fwd_hwdoms) &&
  (!skb->offload_fwd_mark || cb->src_hwdom != p->hwdom);
}

/* Flags that can be offloaded to hardware */
#define BR_PORT_FLAGS_HW_OFFLOAD (BR_LEARNING | BR_FLOOD | BR_PORT_MAB | \
      BR_MCAST_FLOOD | BR_BCAST_FLOOD | BR_PORT_LOCKED | \
      BR_HAIRPIN_MODE | BR_ISOLATED | BR_MULTICAST_TO_UNICAST)

int br_switchdev_set_port_flag(struct net_bridge_port *p,
          unsigned long flags,
          unsigned long mask,
          struct netlink_ext_ack *extack)
{
 struct switchdev_attr attr = {
  .orig_dev = p->dev,
 };
 struct switchdev_notifier_port_attr_info info = {
  .attr = &attr,
 };
 int err;

 mask &= BR_PORT_FLAGS_HW_OFFLOAD;
 if (!mask)
  return 0;

 attr.id = SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS;
 attr.u.brport_flags.val = flags;
 attr.u.brport_flags.mask = mask;

 /* We run from atomic context here */
 err = call_switchdev_notifiers(SWITCHDEV_PORT_ATTR_SET, p->dev,
           &info.info, extack);
 err = notifier_to_errno(err);
 if (err == -EOPNOTSUPP)
  return 0;

 if (err) {
  NL_SET_ERR_MSG_WEAK_MOD(extack,
     "bridge flag offload is not supported");
  return -EOPNOTSUPP;
 }

 attr.id = SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS;
 attr.flags = SWITCHDEV_F_DEFER;

 err = switchdev_port_attr_set(p->dev, &attr, extack);
 if (err) {
  NL_SET_ERR_MSG_WEAK_MOD(extack,
     "error setting offload flag on port");
  return err;
 }

 return 0;
}

static void br_switchdev_fdb_populate(struct net_bridge *br,
          struct switchdev_notifier_fdb_info *item,
          const struct net_bridge_fdb_entry *fdb,
          const void *ctx)
{
 const struct net_bridge_port *p = READ_ONCE(fdb->dst);

 item->addr = fdb->key.addr.addr;
 item->vid = fdb->key.vlan_id;
 item->added_by_user = test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
 item->offloaded = test_bit(BR_FDB_OFFLOADED, &fdb->flags);
 item->is_local = test_bit(BR_FDB_LOCAL, &fdb->flags);
 item->locked = false;
 item->info.dev = (!p || item->is_local) ? br->dev : p->dev;
 item->info.ctx = ctx;
}

void
br_switchdev_fdb_notify(struct net_bridge *br,
   const struct net_bridge_fdb_entry *fdb, int type)
{
 struct switchdev_notifier_fdb_info item;

 if (test_bit(BR_FDB_LOCKED, &fdb->flags))
  return;

 /* Entries with these flags were created using ndm_state == NUD_REACHABLE,
 * ndm_flags == NTF_MASTER( | NTF_STICKY), ext_flags == 0 by something
 * equivalent to 'bridge fdb add ... master dynamic (sticky)'.
 * Drivers don't know how to deal with these, so don't notify them to
 * avoid confusing them.
 */
 if (test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags) &&
     !test_bit(BR_FDB_STATIC, &fdb->flags) &&
     !test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
  return;

 br_switchdev_fdb_populate(br, &item, fdb, NULL);

 switch (type) {
 case RTM_DELNEIGH:
  call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_DEVICE,
      item.info.dev, &item.info, NULL);
  break;
 case RTM_NEWNEIGH:
  call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_DEVICE,
      item.info.dev, &item.info, NULL);
  break;
 }
}

int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid, u16 flags,
          bool changed, struct netlink_ext_ack *extack)
{
 struct switchdev_obj_port_vlan v = {
  .obj.orig_dev = dev,
  .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
  .flags = flags,
  .vid = vid,
  .changed = changed,
 };

 return switchdev_port_obj_add(dev, &v.obj, extack);
}

int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid)
{
 struct switchdev_obj_port_vlan v = {
  .obj.orig_dev = dev,
  .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
  .vid = vid,
 };

 return switchdev_port_obj_del(dev, &v.obj);
}

static int nbp_switchdev_hwdom_set(struct net_bridge_port *joining)
{
 struct net_bridge *br = joining->br;
 struct net_bridge_port *p;
 int hwdom;

 /* joining is yet to be added to the port list. */
 list_for_each_entry(p, &br->port_list, list) {
  if (netdev_phys_item_id_same(&joining->ppid, &p->ppid)) {
   joining->hwdom = p->hwdom;
   return 0;
  }
 }

 hwdom = find_next_zero_bit(&br->busy_hwdoms, BR_HWDOM_MAX, 1);
 if (hwdom >= BR_HWDOM_MAX)
  return -EBUSY;

 set_bit(hwdom, &br->busy_hwdoms);
 joining->hwdom = hwdom;
 return 0;
}

static void nbp_switchdev_hwdom_put(struct net_bridge_port *leaving)
{
 struct net_bridge *br = leaving->br;
 struct net_bridge_port *p;

 /* leaving is no longer in the port list. */
 list_for_each_entry(p, &br->port_list, list) {
  if (p->hwdom == leaving->hwdom)
   return;
 }

 clear_bit(leaving->hwdom, &br->busy_hwdoms);
}

static int nbp_switchdev_add(struct net_bridge_port *p,
        struct netdev_phys_item_id ppid,
        bool tx_fwd_offload,
        struct netlink_ext_ack *extack)
{
 int err;

 if (p->offload_count) {
  /* Prevent unsupported configurations such as a bridge port
 * which is a bonding interface, and the member ports are from
 * different hardware switches.
 */
  if (!netdev_phys_item_id_same(&p->ppid, &ppid)) {
   NL_SET_ERR_MSG_MOD(extack,
        "Same bridge port cannot be offloaded by two physical switches");
   return -EBUSY;
  }

  /* Tolerate drivers that call switchdev_bridge_port_offload()
 * more than once for the same bridge port, such as when the
 * bridge port is an offloaded bonding/team interface.
 */
  p->offload_count++;

  return 0;
 }

 p->ppid = ppid;
 p->offload_count = 1;

 err = nbp_switchdev_hwdom_set(p);
 if (err)
  return err;

 if (tx_fwd_offload) {
  p->flags |= BR_TX_FWD_OFFLOAD;
  static_branch_inc(&br_switchdev_tx_fwd_offload);
 }

 return 0;
}

static void nbp_switchdev_del(struct net_bridge_port *p)
{
 if (WARN_ON(!p->offload_count))
  return;

 p->offload_count--;

 if (p->offload_count)
  return;

 if (p->hwdom)
  nbp_switchdev_hwdom_put(p);

 if (p->flags & BR_TX_FWD_OFFLOAD) {
  p->flags &= ~BR_TX_FWD_OFFLOAD;
  static_branch_dec(&br_switchdev_tx_fwd_offload);
 }
}

static int
br_switchdev_fdb_replay_one(struct net_bridge *br, struct notifier_block *nb,
       const struct net_bridge_fdb_entry *fdb,
       unsigned long action, const void *ctx)
{
 struct switchdev_notifier_fdb_info item;
 int err;

 br_switchdev_fdb_populate(br, &item, fdb, ctx);

 err = nb->notifier_call(nb, action, &item);
 return notifier_to_errno(err);
}

static int
br_switchdev_fdb_replay(const struct net_device *br_dev, const void *ctx,
   bool adding, struct notifier_block *nb)
{
 struct net_bridge_fdb_entry *fdb;
 struct net_bridge *br;
 unsigned long action;
 int err = 0;

 if (!nb)
  return 0;

 if (!netif_is_bridge_master(br_dev))
  return -EINVAL;

 br = netdev_priv(br_dev);

 if (adding)
  action = SWITCHDEV_FDB_ADD_TO_DEVICE;
 else
  action = SWITCHDEV_FDB_DEL_TO_DEVICE;

 rcu_read_lock();

 hlist_for_each_entry_rcu(fdb, &br->fdb_list, fdb_node) {
  err = br_switchdev_fdb_replay_one(br, nb, fdb, action, ctx);
  if (err)
   break;
 }

 rcu_read_unlock();

 return err;
}

static int br_switchdev_vlan_attr_replay(struct net_device *br_dev,
      const void *ctx,
      struct notifier_block *nb,
      struct netlink_ext_ack *extack)
{
 struct switchdev_notifier_port_attr_info attr_info = {
  .info = {
   .dev = br_dev,
   .extack = extack,
   .ctx = ctx,
  },
 };
 struct net_bridge *br = netdev_priv(br_dev);
 struct net_bridge_vlan_group *vg;
 struct switchdev_attr attr;
 struct net_bridge_vlan *v;
 int err;

 attr_info.attr = &attr;
 attr.orig_dev = br_dev;

 vg = br_vlan_group(br);
 if (!vg)
  return 0;

 list_for_each_entry(v, &vg->vlan_list, vlist) {
  if (v->msti) {
   attr.id = SWITCHDEV_ATTR_ID_VLAN_MSTI;
   attr.u.vlan_msti.vid = v->vid;
   attr.u.vlan_msti.msti = v->msti;

   err = nb->notifier_call(nb, SWITCHDEV_PORT_ATTR_SET,
      &attr_info);
   err = notifier_to_errno(err);
   if (err)
    return err;
  }
 }

 return 0;
}

static int
br_switchdev_vlan_replay_one(struct notifier_block *nb,
        struct net_device *dev,
        struct switchdev_obj_port_vlan *vlan,
        const void *ctx, unsigned long action,
        struct netlink_ext_ack *extack)
{
 struct switchdev_notifier_port_obj_info obj_info = {
  .info = {
   .dev = dev,
   .extack = extack,
   .ctx = ctx,
  },
  .obj = &vlan->obj,
 };
 int err;

 err = nb->notifier_call(nb, action, &obj_info);
 return notifier_to_errno(err);
}

static int br_switchdev_vlan_replay_group(struct notifier_block *nb,
       struct net_device *dev,
       struct net_bridge_vlan_group *vg,
       const void *ctx, unsigned long action,
       struct netlink_ext_ack *extack)
{
 struct net_bridge_vlan *v;
 int err = 0;
 u16 pvid;

 if (!vg)
  return 0;

 pvid = br_get_pvid(vg);

 list_for_each_entry(v, &vg->vlan_list, vlist) {
  struct switchdev_obj_port_vlan vlan = {
   .obj.orig_dev = dev,
   .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
   .flags = br_vlan_flags(v, pvid),
   .vid = v->vid,
  };

  if (!br_vlan_should_use(v))
   continue;

  err = br_switchdev_vlan_replay_one(nb, dev, &vlan, ctx,
         action, extack);
  if (err)
   return err;
 }

 return 0;
}

static int br_switchdev_vlan_replay(struct net_device *br_dev,
        const void *ctx, bool adding,
        struct notifier_block *nb,
        struct netlink_ext_ack *extack)
{
 struct net_bridge *br = netdev_priv(br_dev);
 struct net_bridge_port *p;
 unsigned long action;
 int err;

 ASSERT_RTNL();

 if (!nb)
  return 0;

 if (!netif_is_bridge_master(br_dev))
  return -EINVAL;

 if (adding)
  action = SWITCHDEV_PORT_OBJ_ADD;
 else
  action = SWITCHDEV_PORT_OBJ_DEL;

 err = br_switchdev_vlan_replay_group(nb, br_dev, br_vlan_group(br),
          ctx, action, extack);
 if (err)
  return err;

 list_for_each_entry(p, &br->port_list, list) {
  struct net_device *dev = p->dev;

  err = br_switchdev_vlan_replay_group(nb, dev,
           nbp_vlan_group(p),
           ctx, action, extack);
  if (err)
   return err;
 }

 if (adding) {
  err = br_switchdev_vlan_attr_replay(br_dev, ctx, nb, extack);
  if (err)
   return err;
 }

 return 0;
}

#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
struct br_switchdev_mdb_complete_info {
 struct net_bridge_port *port;
 struct br_ip ip;
};

static void br_switchdev_mdb_complete(struct net_device *dev, int err, void *priv)
{
 struct br_switchdev_mdb_complete_info *data = priv;
 struct net_bridge_port_group __rcu **pp;
 struct net_bridge_port_group *p;
 struct net_bridge_mdb_entry *mp;
 struct net_bridge_port *port = data->port;
 struct net_bridge *br = port->br;
 u8 old_flags;

 if (err == -EOPNOTSUPP)
  goto out_free;

 spin_lock_bh(&br->multicast_lock);
 mp = br_mdb_ip_get(br, &data->ip);
 if (!mp)
  goto out;
 for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL;
      pp = &p->next) {
  if (p->key.port != port)
   continue;

  old_flags = p->flags;
  br_multicast_set_pg_offload_flags(p, !err);
  if (br_mdb_should_notify(br, old_flags ^ p->flags))
   br_mdb_flag_change_notify(br->dev, mp, p);
 }
out:
 spin_unlock_bh(&br->multicast_lock);
out_free:
 kfree(priv);
}

static void br_switchdev_mdb_populate(struct switchdev_obj_port_mdb *mdb,
          const struct net_bridge_mdb_entry *mp)
{
 if (mp->addr.proto == htons(ETH_P_IP))
  ip_eth_mc_map(mp->addr.dst.ip4, mdb->addr);
#if IS_ENABLED(CONFIG_IPV6)
 else if (mp->addr.proto == htons(ETH_P_IPV6))
  ipv6_eth_mc_map(&mp->addr.dst.ip6, mdb->addr);
#endif
 else
  ether_addr_copy(mdb->addr, mp->addr.dst.mac_addr);

 mdb->vid = mp->addr.vid;
}

static void br_switchdev_host_mdb_one(struct net_device *dev,
          struct net_device *lower_dev,
          struct net_bridge_mdb_entry *mp,
          int type)
{
 struct switchdev_obj_port_mdb mdb = {
  .obj = {
   .id = SWITCHDEV_OBJ_ID_HOST_MDB,
   .flags = SWITCHDEV_F_DEFER,
   .orig_dev = dev,
  },
 };

 br_switchdev_mdb_populate(&mdb, mp);

 switch (type) {
 case RTM_NEWMDB:
  switchdev_port_obj_add(lower_dev, &mdb.obj, NULL);
  break;
 case RTM_DELMDB:
  switchdev_port_obj_del(lower_dev, &mdb.obj);
  break;
 }
}

static void br_switchdev_host_mdb(struct net_device *dev,
      struct net_bridge_mdb_entry *mp, int type)
{
 struct net_device *lower_dev;
 struct list_head *iter;

 netdev_for_each_lower_dev(dev, lower_dev, iter)
  br_switchdev_host_mdb_one(dev, lower_dev, mp, type);
}

static int
br_switchdev_mdb_replay_one(struct notifier_block *nb, struct net_device *dev,
       const struct switchdev_obj_port_mdb *mdb,
       unsigned long action, const void *ctx,
       struct netlink_ext_ack *extack)
{
 struct switchdev_notifier_port_obj_info obj_info = {
  .info = {
   .dev = dev,
   .extack = extack,
   .ctx = ctx,
  },
  .obj = &mdb->obj,
 };
 int err;

 err = nb->notifier_call(nb, action, &obj_info);
 return notifier_to_errno(err);
}

static int br_switchdev_mdb_queue_one(struct list_head *mdb_list,
          struct net_device *dev,
          unsigned long action,
          enum switchdev_obj_id id,
          const struct net_bridge_mdb_entry *mp,
          struct net_device *orig_dev)
{
 struct switchdev_obj_port_mdb mdb = {
  .obj = {
   .id = id,
   .orig_dev = orig_dev,
  },
 };
 struct switchdev_obj_port_mdb *pmdb;

 br_switchdev_mdb_populate(&mdb, mp);

 if (action == SWITCHDEV_PORT_OBJ_ADD &&
     switchdev_port_obj_act_is_deferred(dev, action, &mdb.obj)) {
  /* This event is already in the deferred queue of
 * events, so this replay must be elided, lest the
 * driver receives duplicate events for it. This can
 * only happen when replaying additions, since
 * modifications are always immediately visible in
 * br->mdb_list, whereas actual event delivery may be
 * delayed.
 */
  return 0;
 }

 pmdb = kmemdup(&mdb, sizeof(mdb), GFP_ATOMIC);
 if (!pmdb)
  return -ENOMEM;

 list_add_tail(&pmdb->obj.list, mdb_list);
 return 0;
}

void br_switchdev_mdb_notify(struct net_device *dev,
        struct net_bridge_mdb_entry *mp,
        struct net_bridge_port_group *pg,
        int type)
{
 struct br_switchdev_mdb_complete_info *complete_info;
 struct switchdev_obj_port_mdb mdb = {
  .obj = {
   .id = SWITCHDEV_OBJ_ID_PORT_MDB,
   .flags = SWITCHDEV_F_DEFER,
  },
 };

 if (!pg)
  return br_switchdev_host_mdb(dev, mp, type);

 br_switchdev_mdb_populate(&mdb, mp);

 mdb.obj.orig_dev = pg->key.port->dev;
 switch (type) {
 case RTM_NEWMDB:
  complete_info = kmalloc(sizeof(*complete_info), GFP_ATOMIC);
  if (!complete_info)
   break;
  complete_info->port = pg->key.port;
  complete_info->ip = mp->addr;
  mdb.obj.complete_priv = complete_info;
  mdb.obj.complete = br_switchdev_mdb_complete;
  if (switchdev_port_obj_add(pg->key.port->dev, &mdb.obj, NULL))
   kfree(complete_info);
  break;
 case RTM_DELMDB:
  switchdev_port_obj_del(pg->key.port->dev, &mdb.obj);
  break;
 }
}
#endif

static int
br_switchdev_mdb_replay(struct net_device *br_dev, struct net_device *dev,
   const void *ctx, bool adding, struct notifier_block *nb,
   struct netlink_ext_ack *extack)
{
#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 const struct net_bridge_mdb_entry *mp;
 struct switchdev_obj *obj, *tmp;
 struct net_bridge *br;
 unsigned long action;
 LIST_HEAD(mdb_list);
 int err = 0;

 ASSERT_RTNL();

 if (!nb)
  return 0;

 if (!netif_is_bridge_master(br_dev) || !netif_is_bridge_port(dev))
  return -EINVAL;

 br = netdev_priv(br_dev);

 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
  return 0;

 if (adding)
  action = SWITCHDEV_PORT_OBJ_ADD;
 else
  action = SWITCHDEV_PORT_OBJ_DEL;

 /* br_switchdev_mdb_queue_one() will take care to not queue a
 * replay of an event that is already pending in the switchdev
 * deferred queue. In order to safely determine that, there
 * must be no new deferred MDB notifications enqueued for the
 * duration of the MDB scan. Therefore, grab the write-side
 * lock to avoid racing with any concurrent IGMP/MLD snooping.
 */
 spin_lock_bh(&br->multicast_lock);

 hlist_for_each_entry(mp, &br->mdb_list, mdb_node) {
  struct net_bridge_port_group __rcu * const *pp;
  const struct net_bridge_port_group *p;

  if (mp->host_joined) {
   err = br_switchdev_mdb_queue_one(&mdb_list, dev, action,
        SWITCHDEV_OBJ_ID_HOST_MDB,
        mp, br_dev);
   if (err) {
    spin_unlock_bh(&br->multicast_lock);
    goto out_free_mdb;
   }
  }

  for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL;
       pp = &p->next) {
   if (p->key.port->dev != dev)
    continue;

   err = br_switchdev_mdb_queue_one(&mdb_list, dev, action,
        SWITCHDEV_OBJ_ID_PORT_MDB,
        mp, dev);
   if (err) {
    spin_unlock_bh(&br->multicast_lock);
    goto out_free_mdb;
   }
  }
 }

 spin_unlock_bh(&br->multicast_lock);

 list_for_each_entry(obj, &mdb_list, list) {
  err = br_switchdev_mdb_replay_one(nb, dev,
        SWITCHDEV_OBJ_PORT_MDB(obj),
        action, ctx, extack);
  if (err == -EOPNOTSUPP)
   err = 0;
  if (err)
   goto out_free_mdb;
 }

out_free_mdb:
 list_for_each_entry_safe(obj, tmp, &mdb_list, list) {
  list_del(&obj->list);
  kfree(SWITCHDEV_OBJ_PORT_MDB(obj));
 }

 if (err)
  return err;
#endif

 return 0;
}

static int nbp_switchdev_sync_objs(struct net_bridge_port *p, const void *ctx,
       struct notifier_block *atomic_nb,
       struct notifier_block *blocking_nb,
       struct netlink_ext_ack *extack)
{
 struct net_device *br_dev = p->br->dev;
 struct net_device *dev = p->dev;
 int err;

 err = br_switchdev_vlan_replay(br_dev, ctx, true, blocking_nb, extack);
 if (err && err != -EOPNOTSUPP)
  return err;

 err = br_switchdev_mdb_replay(br_dev, dev, ctx, true, blocking_nb,
          extack);
 if (err) {
  /* -EOPNOTSUPP not propagated from MDB replay. */
  return err;
 }

 err = br_switchdev_fdb_replay(br_dev, ctx, true, atomic_nb);
 if (err && err != -EOPNOTSUPP)
  return err;

 return 0;
}

static void nbp_switchdev_unsync_objs(struct net_bridge_port *p,
          const void *ctx,
          struct notifier_block *atomic_nb,
          struct notifier_block *blocking_nb)
{
 struct net_device *br_dev = p->br->dev;
 struct net_device *dev = p->dev;

 br_switchdev_fdb_replay(br_dev, ctx, false, atomic_nb);

 br_switchdev_mdb_replay(br_dev, dev, ctx, false, blocking_nb, NULL);

 br_switchdev_vlan_replay(br_dev, ctx, false, blocking_nb, NULL);

 /* Make sure that the device leaving this bridge has seen all
 * relevant events before it is disassociated. In the normal
 * case, when the device is directly attached to the bridge,
 * this is covered by del_nbp(). If the association was indirect
 * however, e.g. via a team or bond, and the device is leaving
 * that intermediate device, then the bridge port remains in
 * place.
 */
 switchdev_deferred_process();
}

/* Let the bridge know that this port is offloaded, so that it can assign a
 * switchdev hardware domain to it.
 */
int br_switchdev_port_offload(struct net_bridge_port *p,
         struct net_device *dev, const void *ctx,
         struct notifier_block *atomic_nb,
         struct notifier_block *blocking_nb,
         bool tx_fwd_offload,
         struct netlink_ext_ack *extack)
{
 struct netdev_phys_item_id ppid;
 int err;

 err = netif_get_port_parent_id(dev, &ppid, false);
 if (err)
  return err;

 err = nbp_switchdev_add(p, ppid, tx_fwd_offload, extack);
 if (err)
  return err;

 err = nbp_switchdev_sync_objs(p, ctx, atomic_nb, blocking_nb, extack);
 if (err)
  goto out_switchdev_del;

 return 0;

out_switchdev_del:
 nbp_switchdev_del(p);

 return err;
}

void br_switchdev_port_unoffload(struct net_bridge_port *p, const void *ctx,
     struct notifier_block *atomic_nb,
     struct notifier_block *blocking_nb)
{
 nbp_switchdev_unsync_objs(p, ctx, atomic_nb, blocking_nb);

 nbp_switchdev_del(p);
}

int br_switchdev_port_replay(struct net_bridge_port *p,
        struct net_device *dev, const void *ctx,
        struct notifier_block *atomic_nb,
        struct notifier_block *blocking_nb,
        struct netlink_ext_ack *extack)
{
 return nbp_switchdev_sync_objs(p, ctx, atomic_nb, blocking_nb, extack);
}