net/bridge/br_switchdev.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/kernel.h>
   3 #include <linux/list.h>
   4 #include <linux/netdevice.h>
   5 #include <linux/rtnetlink.h>
   6 #include <linux/skbuff.h>
   7 #include <net/ip.h>
   8 #include <net/switchdev.h>
   9
  10 #include "br_private.h"
  11
  12 static struct static_key_false br_switchdev_tx_fwd_offload;
  13
  14 static bool nbp_switchdev_can_offload_tx_fwd(const struct net_bridge_port *p,
  15                                              const struct sk_buff *skb)
  16 {
  17         if (!static_branch_unlikely(&br_switchdev_tx_fwd_offload))
  18                 return false;
  19
  20         return (p->flags & BR_TX_FWD_OFFLOAD) &&
  21                (p->hwdom != BR_INPUT_SKB_CB(skb)->src_hwdom);
  22 }
  23
  24 bool br_switchdev_frame_uses_tx_fwd_offload(struct sk_buff *skb)
  25 {
  26         if (!static_branch_unlikely(&br_switchdev_tx_fwd_offload))
  27                 return false;
  28
  29         return BR_INPUT_SKB_CB(skb)->tx_fwd_offload;
  30 }
  31
  32 void br_switchdev_frame_set_offload_fwd_mark(struct sk_buff *skb)
  33 {
  34         skb->offload_fwd_mark = br_switchdev_frame_uses_tx_fwd_offload(skb);
  35 }
  36
  37 /* Mark the frame for TX forwarding offload if this egress port supports it */
  38 void nbp_switchdev_frame_mark_tx_fwd_offload(const struct net_bridge_port *p,
  39                                              struct sk_buff *skb)
  40 {
  41         if (nbp_switchdev_can_offload_tx_fwd(p, skb))
  42                 BR_INPUT_SKB_CB(skb)->tx_fwd_offload = true;
  43 }
  44
  45 /* Lazily adds the hwdom of the egress bridge port to the bit mask of hwdoms
  46  * that the skb has been already forwarded to, to avoid further cloning to
  47  * other ports in the same hwdom by making nbp_switchdev_allowed_egress()
  48  * return false.
  49  */
  50 void nbp_switchdev_frame_mark_tx_fwd_to_hwdom(const struct net_bridge_port *p,
  51                                               struct sk_buff *skb)
  52 {
  53         if (nbp_switchdev_can_offload_tx_fwd(p, skb))
  54                 set_bit(p->hwdom, &BR_INPUT_SKB_CB(skb)->fwd_hwdoms);
  55 }
  56
  57 void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
  58                               struct sk_buff *skb)
  59 {
  60         if (p->hwdom)
  61                 BR_INPUT_SKB_CB(skb)->src_hwdom = p->hwdom;
  62 }
  63
  64 bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
  65                                   const struct sk_buff *skb)
  66 {
  67         struct br_input_skb_cb *cb = BR_INPUT_SKB_CB(skb);
  68
  69         return !test_bit(p->hwdom, &cb->fwd_hwdoms) &&
  70                 (!skb->offload_fwd_mark || cb->src_hwdom != p->hwdom);
  71 }
  72
  73 /* Flags that can be offloaded to hardware */
  74 #define BR_PORT_FLAGS_HW_OFFLOAD (BR_LEARNING | BR_FLOOD | \
  75                                   BR_MCAST_FLOOD | BR_BCAST_FLOOD | BR_PORT_LOCKED | \
  76                                   BR_HAIRPIN_MODE | BR_ISOLATED | BR_MULTICAST_TO_UNICAST)
  77
  78 int br_switchdev_set_port_flag(struct net_bridge_port *p,
  79                                unsigned long flags,
  80                                unsigned long mask,
  81                                struct netlink_ext_ack *extack)
  82 {
  83         struct switchdev_attr attr = {
  84                 .orig_dev = p->dev,
  85         };
  86         struct switchdev_notifier_port_attr_info info = {
  87                 .attr = &attr,
  88         };
  89         int err;
  90
  91         mask &= BR_PORT_FLAGS_HW_OFFLOAD;
  92         if (!mask)
  93                 return 0;
  94
  95         attr.id = SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS;
  96         attr.u.brport_flags.val = flags;
  97         attr.u.brport_flags.mask = mask;
  98
  99         /* We run from atomic context here */
 100         err = call_switchdev_notifiers(SWITCHDEV_PORT_ATTR_SET, p->dev,
 101                                        &info.info, extack);
 102         err = notifier_to_errno(err);
 103         if (err == -EOPNOTSUPP)
 104                 return 0;
 105
 106         if (err) {
 107                 if (extack && !extack->_msg)
 108                         NL_SET_ERR_MSG_MOD(extack,
 109                                            "bridge flag offload is not supported");
 110                 return -EOPNOTSUPP;
 111         }
 112
 113         attr.id = SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS;
 114         attr.flags = SWITCHDEV_F_DEFER;
 115
 116         err = switchdev_port_attr_set(p->dev, &attr, extack);
 117         if (err) {
 118                 if (extack && !extack->_msg)
 119                         NL_SET_ERR_MSG_MOD(extack,
 120                                            "error setting offload flag on port");
 121                 return err;
 122         }
 123
 124         return 0;
 125 }
 126
 127 static void br_switchdev_fdb_populate(struct net_bridge *br,
 128                                       struct switchdev_notifier_fdb_info *item,
 129                                       const struct net_bridge_fdb_entry *fdb,
 130                                       const void *ctx)
 131 {
 132         const struct net_bridge_port *p = READ_ONCE(fdb->dst);
 133
 134         item->addr = fdb->key.addr.addr;
 135         item->vid = fdb->key.vlan_id;
 136         item->added_by_user = test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
 137         item->offloaded = test_bit(BR_FDB_OFFLOADED, &fdb->flags);
 138         item->is_local = test_bit(BR_FDB_LOCAL, &fdb->flags);
 139         item->info.dev = (!p || item->is_local) ? br->dev : p->dev;
 140         item->info.ctx = ctx;
 141 }
 142
 143 void
 144 br_switchdev_fdb_notify(struct net_bridge *br,
 145                         const struct net_bridge_fdb_entry *fdb, int type)
 146 {
 147         struct switchdev_notifier_fdb_info item;
 148
 149         /* Entries with these flags were created using ndm_state == NUD_REACHABLE,
 150          * ndm_flags == NTF_MASTER( | NTF_STICKY), ext_flags == 0 by something
 151          * equivalent to 'bridge fdb add ... master dynamic (sticky)'.
 152          * Drivers don't know how to deal with these, so don't notify them to
 153          * avoid confusing them.
 154          */
 155         if (test_bit(BR_FDB_ADDED_BY_USER, &fdb->flags) &&
 156             !test_bit(BR_FDB_STATIC, &fdb->flags) &&
 157             !test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
 158                 return;
 159
 160         br_switchdev_fdb_populate(br, &item, fdb, NULL);
 161
 162         switch (type) {
 163         case RTM_DELNEIGH:
 164                 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_DEVICE,
 165                                          item.info.dev, &item.info, NULL);
 166                 break;
 167         case RTM_NEWNEIGH:
 168                 call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_DEVICE,
 169                                          item.info.dev, &item.info, NULL);
 170                 break;
 171         }
 172 }
 173
 174 int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid, u16 flags,
 175                                bool changed, struct netlink_ext_ack *extack)
 176 {
 177         struct switchdev_obj_port_vlan v = {
 178                 .obj.orig_dev = dev,
 179                 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
 180                 .flags = flags,
 181                 .vid = vid,
 182                 .changed = changed,
 183         };
 184
 185         return switchdev_port_obj_add(dev, &v.obj, extack);
 186 }
 187
 188 int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid)
 189 {
 190         struct switchdev_obj_port_vlan v = {
 191                 .obj.orig_dev = dev,
 192                 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
 193                 .vid = vid,
 194         };
 195
 196         return switchdev_port_obj_del(dev, &v.obj);
 197 }
 198
 199 static int nbp_switchdev_hwdom_set(struct net_bridge_port *joining)
 200 {
 201         struct net_bridge *br = joining->br;
 202         struct net_bridge_port *p;
 203         int hwdom;
 204
 205         /* joining is yet to be added to the port list. */
 206         list_for_each_entry(p, &br->port_list, list) {
 207                 if (netdev_phys_item_id_same(&joining->ppid, &p->ppid)) {
 208                         joining->hwdom = p->hwdom;
 209                         return 0;
 210                 }
 211         }
 212
 213         hwdom = find_next_zero_bit(&br->busy_hwdoms, BR_HWDOM_MAX, 1);
 214         if (hwdom >= BR_HWDOM_MAX)
 215                 return -EBUSY;
 216
 217         set_bit(hwdom, &br->busy_hwdoms);
 218         joining->hwdom = hwdom;
 219         return 0;
 220 }
 221
 222 static void nbp_switchdev_hwdom_put(struct net_bridge_port *leaving)
 223 {
 224         struct net_bridge *br = leaving->br;
 225         struct net_bridge_port *p;
 226
 227         /* leaving is no longer in the port list. */
 228         list_for_each_entry(p, &br->port_list, list) {
 229                 if (p->hwdom == leaving->hwdom)
 230                         return;
 231         }
 232
 233         clear_bit(leaving->hwdom, &br->busy_hwdoms);
 234 }
 235
 236 static int nbp_switchdev_add(struct net_bridge_port *p,
 237                              struct netdev_phys_item_id ppid,
 238                              bool tx_fwd_offload,
 239                              struct netlink_ext_ack *extack)
 240 {
 241         int err;
 242
 243         if (p->offload_count) {
 244                 /* Prevent unsupported configurations such as a bridge port
 245                  * which is a bonding interface, and the member ports are from
 246                  * different hardware switches.
 247                  */
 248                 if (!netdev_phys_item_id_same(&p->ppid, &ppid)) {
 249                         NL_SET_ERR_MSG_MOD(extack,
 250                                            "Same bridge port cannot be offloaded by two physical switches");
 251                         return -EBUSY;
 252                 }
 253
 254                 /* Tolerate drivers that call switchdev_bridge_port_offload()
 255                  * more than once for the same bridge port, such as when the
 256                  * bridge port is an offloaded bonding/team interface.
 257                  */
 258                 p->offload_count++;
 259
 260                 return 0;
 261         }
 262
 263         p->ppid = ppid;
 264         p->offload_count = 1;
 265
 266         err = nbp_switchdev_hwdom_set(p);
 267         if (err)
 268                 return err;
 269
 270         if (tx_fwd_offload) {
 271                 p->flags |= BR_TX_FWD_OFFLOAD;
 272                 static_branch_inc(&br_switchdev_tx_fwd_offload);
 273         }
 274
 275         return 0;
 276 }
 277
 278 static void nbp_switchdev_del(struct net_bridge_port *p)
 279 {
 280         if (WARN_ON(!p->offload_count))
 281                 return;
 282
 283         p->offload_count--;
 284
 285         if (p->offload_count)
 286                 return;
 287
 288         if (p->hwdom)
 289                 nbp_switchdev_hwdom_put(p);
 290
 291         if (p->flags & BR_TX_FWD_OFFLOAD) {
 292                 p->flags &= ~BR_TX_FWD_OFFLOAD;
 293                 static_branch_dec(&br_switchdev_tx_fwd_offload);
 294         }
 295 }
 296
 297 static int
 298 br_switchdev_fdb_replay_one(struct net_bridge *br, struct notifier_block *nb,
 299                             const struct net_bridge_fdb_entry *fdb,
 300                             unsigned long action, const void *ctx)
 301 {
 302         struct switchdev_notifier_fdb_info item;
 303         int err;
 304
 305         br_switchdev_fdb_populate(br, &item, fdb, ctx);
 306
 307         err = nb->notifier_call(nb, action, &item);
 308         return notifier_to_errno(err);
 309 }
 310
 311 static int
 312 br_switchdev_fdb_replay(const struct net_device *br_dev, const void *ctx,
 313                         bool adding, struct notifier_block *nb)
 314 {
 315         struct net_bridge_fdb_entry *fdb;
 316         struct net_bridge *br;
 317         unsigned long action;
 318         int err = 0;
 319
 320         if (!nb)
 321                 return 0;
 322
 323         if (!netif_is_bridge_master(br_dev))
 324                 return -EINVAL;
 325
 326         br = netdev_priv(br_dev);
 327
 328         if (adding)
 329                 action = SWITCHDEV_FDB_ADD_TO_DEVICE;
 330         else
 331                 action = SWITCHDEV_FDB_DEL_TO_DEVICE;
 332
 333         rcu_read_lock();
 334
 335         hlist_for_each_entry_rcu(fdb, &br->fdb_list, fdb_node) {
 336                 err = br_switchdev_fdb_replay_one(br, nb, fdb, action, ctx);
 337                 if (err)
 338                         break;
 339         }
 340
 341         rcu_read_unlock();
 342
 343         return err;
 344 }
 345
 346 static int br_switchdev_vlan_attr_replay(struct net_device *br_dev,
 347                                          const void *ctx,
 348                                          struct notifier_block *nb,
 349                                          struct netlink_ext_ack *extack)
 350 {
 351         struct switchdev_notifier_port_attr_info attr_info = {
 352                 .info = {
 353                         .dev = br_dev,
 354                         .extack = extack,
 355                         .ctx = ctx,
 356                 },
 357         };
 358         struct net_bridge *br = netdev_priv(br_dev);
 359         struct net_bridge_vlan_group *vg;
 360         struct switchdev_attr attr;
 361         struct net_bridge_vlan *v;
 362         int err;
 363
 364         attr_info.attr = &attr;
 365         attr.orig_dev = br_dev;
 366
 367         vg = br_vlan_group(br);
 368         if (!vg)
 369                 return 0;
 370
 371         list_for_each_entry(v, &vg->vlan_list, vlist) {
 372                 if (v->msti) {
 373                         attr.id = SWITCHDEV_ATTR_ID_VLAN_MSTI;
 374                         attr.u.vlan_msti.vid = v->vid;
 375                         attr.u.vlan_msti.msti = v->msti;
 376
 377                         err = nb->notifier_call(nb, SWITCHDEV_PORT_ATTR_SET,
 378                                                 &attr_info);
 379                         err = notifier_to_errno(err);
 380                         if (err)
 381                                 return err;
 382                 }
 383         }
 384
 385         return 0;
 386 }
 387
 388 static int
 389 br_switchdev_vlan_replay_one(struct notifier_block *nb,
 390                              struct net_device *dev,
 391                              struct switchdev_obj_port_vlan *vlan,
 392                              const void *ctx, unsigned long action,
 393                              struct netlink_ext_ack *extack)
 394 {
 395         struct switchdev_notifier_port_obj_info obj_info = {
 396                 .info = {
 397                         .dev = dev,
 398                         .extack = extack,
 399                         .ctx = ctx,
 400                 },
 401                 .obj = &vlan->obj,
 402         };
 403         int err;
 404
 405         err = nb->notifier_call(nb, action, &obj_info);
 406         return notifier_to_errno(err);
 407 }
 408
 409 static int br_switchdev_vlan_replay_group(struct notifier_block *nb,
 410                                           struct net_device *dev,
 411                                           struct net_bridge_vlan_group *vg,
 412                                           const void *ctx, unsigned long action,
 413                                           struct netlink_ext_ack *extack)
 414 {
 415         struct net_bridge_vlan *v;
 416         int err = 0;
 417         u16 pvid;
 418
 419         if (!vg)
 420                 return 0;
 421
 422         pvid = br_get_pvid(vg);
 423
 424         list_for_each_entry(v, &vg->vlan_list, vlist) {
 425                 struct switchdev_obj_port_vlan vlan = {
 426                         .obj.orig_dev = dev,
 427                         .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
 428                         .flags = br_vlan_flags(v, pvid),
 429                         .vid = v->vid,
 430                 };
 431
 432                 if (!br_vlan_should_use(v))
 433                         continue;
 434
 435                 err = br_switchdev_vlan_replay_one(nb, dev, &vlan, ctx,
 436                                                    action, extack);
 437                 if (err)
 438                         return err;
 439         }
 440
 441         return 0;
 442 }
 443
 444 static int br_switchdev_vlan_replay(struct net_device *br_dev,
 445                                     const void *ctx, bool adding,
 446                                     struct notifier_block *nb,
 447                                     struct netlink_ext_ack *extack)
 448 {
 449         struct net_bridge *br = netdev_priv(br_dev);
 450         struct net_bridge_port *p;
 451         unsigned long action;
 452         int err;
 453
 454         ASSERT_RTNL();
 455
 456         if (!nb)
 457                 return 0;
 458
 459         if (!netif_is_bridge_master(br_dev))
 460                 return -EINVAL;
 461
 462         if (adding)
 463                 action = SWITCHDEV_PORT_OBJ_ADD;
 464         else
 465                 action = SWITCHDEV_PORT_OBJ_DEL;
 466
 467         err = br_switchdev_vlan_replay_group(nb, br_dev, br_vlan_group(br),
 468                                              ctx, action, extack);
 469         if (err)
 470                 return err;
 471
 472         list_for_each_entry(p, &br->port_list, list) {
 473                 struct net_device *dev = p->dev;
 474
 475                 err = br_switchdev_vlan_replay_group(nb, dev,
 476                                                      nbp_vlan_group(p),
 477                                                      ctx, action, extack);
 478                 if (err)
 479                         return err;
 480         }
 481
 482         if (adding) {
 483                 err = br_switchdev_vlan_attr_replay(br_dev, ctx, nb, extack);
 484                 if (err)
 485                         return err;
 486         }
 487
 488         return 0;
 489 }
 490
 491 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 492 struct br_switchdev_mdb_complete_info {
 493         struct net_bridge_port *port;
 494         struct br_ip ip;
 495 };
 496
 497 static void br_switchdev_mdb_complete(struct net_device *dev, int err, void *priv)
 498 {
 499         struct br_switchdev_mdb_complete_info *data = priv;
 500         struct net_bridge_port_group __rcu **pp;
 501         struct net_bridge_port_group *p;
 502         struct net_bridge_mdb_entry *mp;
 503         struct net_bridge_port *port = data->port;
 504         struct net_bridge *br = port->br;
 505
 506         if (err)
 507                 goto err;
 508
 509         spin_lock_bh(&br->multicast_lock);
 510         mp = br_mdb_ip_get(br, &data->ip);
 511         if (!mp)
 512                 goto out;
 513         for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL;
 514              pp = &p->next) {
 515                 if (p->key.port != port)
 516                         continue;
 517                 p->flags |= MDB_PG_FLAGS_OFFLOAD;
 518         }
 519 out:
 520         spin_unlock_bh(&br->multicast_lock);
 521 err:
 522         kfree(priv);
 523 }
 524
 525 static void br_switchdev_mdb_populate(struct switchdev_obj_port_mdb *mdb,
 526                                       const struct net_bridge_mdb_entry *mp)
 527 {
 528         if (mp->addr.proto == htons(ETH_P_IP))
 529                 ip_eth_mc_map(mp->addr.dst.ip4, mdb->addr);
 530 #if IS_ENABLED(CONFIG_IPV6)
 531         else if (mp->addr.proto == htons(ETH_P_IPV6))
 532                 ipv6_eth_mc_map(&mp->addr.dst.ip6, mdb->addr);
 533 #endif
 534         else
 535                 ether_addr_copy(mdb->addr, mp->addr.dst.mac_addr);
 536
 537         mdb->vid = mp->addr.vid;
 538 }
 539
 540 static void br_switchdev_host_mdb_one(struct net_device *dev,
 541                                       struct net_device *lower_dev,
 542                                       struct net_bridge_mdb_entry *mp,
 543                                       int type)
 544 {
 545         struct switchdev_obj_port_mdb mdb = {
 546                 .obj = {
 547                         .id = SWITCHDEV_OBJ_ID_HOST_MDB,
 548                         .flags = SWITCHDEV_F_DEFER,
 549                         .orig_dev = dev,
 550                 },
 551         };
 552
 553         br_switchdev_mdb_populate(&mdb, mp);
 554
 555         switch (type) {
 556         case RTM_NEWMDB:
 557                 switchdev_port_obj_add(lower_dev, &mdb.obj, NULL);
 558                 break;
 559         case RTM_DELMDB:
 560                 switchdev_port_obj_del(lower_dev, &mdb.obj);
 561                 break;
 562         }
 563 }
 564
 565 static void br_switchdev_host_mdb(struct net_device *dev,
 566                                   struct net_bridge_mdb_entry *mp, int type)
 567 {
 568         struct net_device *lower_dev;
 569         struct list_head *iter;
 570
 571         netdev_for_each_lower_dev(dev, lower_dev, iter)
 572                 br_switchdev_host_mdb_one(dev, lower_dev, mp, type);
 573 }
 574
 575 static int
 576 br_switchdev_mdb_replay_one(struct notifier_block *nb, struct net_device *dev,
 577                             const struct switchdev_obj_port_mdb *mdb,
 578                             unsigned long action, const void *ctx,
 579                             struct netlink_ext_ack *extack)
 580 {
 581         struct switchdev_notifier_port_obj_info obj_info = {
 582                 .info = {
 583                         .dev = dev,
 584                         .extack = extack,
 585                         .ctx = ctx,
 586                 },
 587                 .obj = &mdb->obj,
 588         };
 589         int err;
 590
 591         err = nb->notifier_call(nb, action, &obj_info);
 592         return notifier_to_errno(err);
 593 }
 594
 595 static int br_switchdev_mdb_queue_one(struct list_head *mdb_list,
 596                                       enum switchdev_obj_id id,
 597                                       const struct net_bridge_mdb_entry *mp,
 598                                       struct net_device *orig_dev)
 599 {
 600         struct switchdev_obj_port_mdb *mdb;
 601
 602         mdb = kzalloc(sizeof(*mdb), GFP_ATOMIC);
 603         if (!mdb)
 604                 return -ENOMEM;
 605
 606         mdb->obj.id = id;
 607         mdb->obj.orig_dev = orig_dev;
 608         br_switchdev_mdb_populate(mdb, mp);
 609         list_add_tail(&mdb->obj.list, mdb_list);
 610
 611         return 0;
 612 }
 613
 614 void br_switchdev_mdb_notify(struct net_device *dev,
 615                              struct net_bridge_mdb_entry *mp,
 616                              struct net_bridge_port_group *pg,
 617                              int type)
 618 {
 619         struct br_switchdev_mdb_complete_info *complete_info;
 620         struct switchdev_obj_port_mdb mdb = {
 621                 .obj = {
 622                         .id = SWITCHDEV_OBJ_ID_PORT_MDB,
 623                         .flags = SWITCHDEV_F_DEFER,
 624                 },
 625         };
 626
 627         if (!pg)
 628                 return br_switchdev_host_mdb(dev, mp, type);
 629
 630         br_switchdev_mdb_populate(&mdb, mp);
 631
 632         mdb.obj.orig_dev = pg->key.port->dev;
 633         switch (type) {
 634         case RTM_NEWMDB:
 635                 complete_info = kmalloc(sizeof(*complete_info), GFP_ATOMIC);
 636                 if (!complete_info)
 637                         break;
 638                 complete_info->port = pg->key.port;
 639                 complete_info->ip = mp->addr;
 640                 mdb.obj.complete_priv = complete_info;
 641                 mdb.obj.complete = br_switchdev_mdb_complete;
 642                 if (switchdev_port_obj_add(pg->key.port->dev, &mdb.obj, NULL))
 643                         kfree(complete_info);
 644                 break;
 645         case RTM_DELMDB:
 646                 switchdev_port_obj_del(pg->key.port->dev, &mdb.obj);
 647                 break;
 648         }
 649 }
 650 #endif
 651
 652 static int
 653 br_switchdev_mdb_replay(struct net_device *br_dev, struct net_device *dev,
 654                         const void *ctx, bool adding, struct notifier_block *nb,
 655                         struct netlink_ext_ack *extack)
 656 {
 657 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 658         const struct net_bridge_mdb_entry *mp;
 659         struct switchdev_obj *obj, *tmp;
 660         struct net_bridge *br;
 661         unsigned long action;
 662         LIST_HEAD(mdb_list);
 663         int err = 0;
 664
 665         ASSERT_RTNL();
 666
 667         if (!nb)
 668                 return 0;
 669
 670         if (!netif_is_bridge_master(br_dev) || !netif_is_bridge_port(dev))
 671                 return -EINVAL;
 672
 673         br = netdev_priv(br_dev);
 674
 675         if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
 676                 return 0;
 677
 678         /* We cannot walk over br->mdb_list protected just by the rtnl_mutex,
 679          * because the write-side protection is br->multicast_lock. But we
 680          * need to emulate the [ blocking ] calling context of a regular
 681          * switchdev event, so since both br->multicast_lock and RCU read side
 682          * critical sections are atomic, we have no choice but to pick the RCU
 683          * read side lock, queue up all our events, leave the critical section
 684          * and notify switchdev from blocking context.
 685          */
 686         rcu_read_lock();
 687
 688         hlist_for_each_entry_rcu(mp, &br->mdb_list, mdb_node) {
 689                 struct net_bridge_port_group __rcu * const *pp;
 690                 const struct net_bridge_port_group *p;
 691
 692                 if (mp->host_joined) {
 693                         err = br_switchdev_mdb_queue_one(&mdb_list,
 694                                                          SWITCHDEV_OBJ_ID_HOST_MDB,
 695                                                          mp, br_dev);
 696                         if (err) {
 697                                 rcu_read_unlock();
 698                                 goto out_free_mdb;
 699                         }
 700                 }
 701
 702                 for (pp = &mp->ports; (p = rcu_dereference(*pp)) != NULL;
 703                      pp = &p->next) {
 704                         if (p->key.port->dev != dev)
 705                                 continue;
 706
 707                         err = br_switchdev_mdb_queue_one(&mdb_list,
 708                                                          SWITCHDEV_OBJ_ID_PORT_MDB,
 709                                                          mp, dev);
 710                         if (err) {
 711                                 rcu_read_unlock();
 712                                 goto out_free_mdb;
 713                         }
 714                 }
 715         }
 716
 717         rcu_read_unlock();
 718
 719         if (adding)
 720                 action = SWITCHDEV_PORT_OBJ_ADD;
 721         else
 722                 action = SWITCHDEV_PORT_OBJ_DEL;
 723
 724         list_for_each_entry(obj, &mdb_list, list) {
 725                 err = br_switchdev_mdb_replay_one(nb, dev,
 726                                                   SWITCHDEV_OBJ_PORT_MDB(obj),
 727                                                   action, ctx, extack);
 728                 if (err)
 729                         goto out_free_mdb;
 730         }
 731
 732 out_free_mdb:
 733         list_for_each_entry_safe(obj, tmp, &mdb_list, list) {
 734                 list_del(&obj->list);
 735                 kfree(SWITCHDEV_OBJ_PORT_MDB(obj));
 736         }
 737
 738         if (err)
 739                 return err;
 740 #endif
 741
 742         return 0;
 743 }
 744
 745 static int nbp_switchdev_sync_objs(struct net_bridge_port *p, const void *ctx,
 746                                    struct notifier_block *atomic_nb,
 747                                    struct notifier_block *blocking_nb,
 748                                    struct netlink_ext_ack *extack)
 749 {
 750         struct net_device *br_dev = p->br->dev;
 751         struct net_device *dev = p->dev;
 752         int err;
 753
 754         err = br_switchdev_vlan_replay(br_dev, ctx, true, blocking_nb, extack);
 755         if (err && err != -EOPNOTSUPP)
 756                 return err;
 757
 758         err = br_switchdev_mdb_replay(br_dev, dev, ctx, true, blocking_nb,
 759                                       extack);
 760         if (err && err != -EOPNOTSUPP)
 761                 return err;
 762
 763         err = br_switchdev_fdb_replay(br_dev, ctx, true, atomic_nb);
 764         if (err && err != -EOPNOTSUPP)
 765                 return err;
 766
 767         return 0;
 768 }
 769
 770 static void nbp_switchdev_unsync_objs(struct net_bridge_port *p,
 771                                       const void *ctx,
 772                                       struct notifier_block *atomic_nb,
 773                                       struct notifier_block *blocking_nb)
 774 {
 775         struct net_device *br_dev = p->br->dev;
 776         struct net_device *dev = p->dev;
 777
 778         br_switchdev_fdb_replay(br_dev, ctx, false, atomic_nb);
 779
 780         br_switchdev_mdb_replay(br_dev, dev, ctx, false, blocking_nb, NULL);
 781
 782         br_switchdev_vlan_replay(br_dev, ctx, false, blocking_nb, NULL);
 783 }
 784
 785 /* Let the bridge know that this port is offloaded, so that it can assign a
 786  * switchdev hardware domain to it.
 787  */
 788 int br_switchdev_port_offload(struct net_bridge_port *p,
 789                               struct net_device *dev, const void *ctx,
 790                               struct notifier_block *atomic_nb,
 791                               struct notifier_block *blocking_nb,
 792                               bool tx_fwd_offload,
 793                               struct netlink_ext_ack *extack)
 794 {
 795         struct netdev_phys_item_id ppid;
 796         int err;
 797
 798         err = dev_get_port_parent_id(dev, &ppid, false);
 799         if (err)
 800                 return err;
 801
 802         err = nbp_switchdev_add(p, ppid, tx_fwd_offload, extack);
 803         if (err)
 804                 return err;
 805
 806         err = nbp_switchdev_sync_objs(p, ctx, atomic_nb, blocking_nb, extack);
 807         if (err)
 808                 goto out_switchdev_del;
 809
 810         return 0;
 811
 812 out_switchdev_del:
 813         nbp_switchdev_del(p);
 814
 815         return err;
 816 }
 817
 818 void br_switchdev_port_unoffload(struct net_bridge_port *p, const void *ctx,
 819                                  struct notifier_block *atomic_nb,
 820                                  struct notifier_block *blocking_nb)
 821 {
 822         nbp_switchdev_unsync_objs(p, ctx, atomic_nb, blocking_nb);
 823
 824         nbp_switchdev_del(p);
 825 }