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