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