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