1// SPDX-License-Identifier: GPL-2.0 2/* Copyright (C) 2023, Intel Corporation. */ 3 4#include "ice.h" 5#include "ice_eswitch_br.h" 6#include "ice_repr.h" 7#include "ice_switch.h" 8#include "ice_vlan.h" 9#include "ice_vf_vsi_vlan_ops.h" 10#include "ice_trace.h" 11 12#define ICE_ESW_BRIDGE_UPDATE_INTERVAL msecs_to_jiffies(1000) 13 14static const struct rhashtable_params ice_fdb_ht_params = { 15 .key_offset = offsetof(struct ice_esw_br_fdb_entry, data), 16 .key_len = sizeof(struct ice_esw_br_fdb_data), 17 .head_offset = offsetof(struct ice_esw_br_fdb_entry, ht_node), 18 .automatic_shrinking = true, 19}; 20 21static bool ice_eswitch_br_is_dev_valid(const struct net_device *dev) 22{ 23 /* Accept only PF netdev, PRs and LAG */ 24 return ice_is_port_repr_netdev(dev) || netif_is_ice(dev) || 25 netif_is_lag_master(dev); 26} 27 28static struct net_device * 29ice_eswitch_br_get_uplink_from_lag(struct net_device *lag_dev) 30{ 31 struct net_device *lower; 32 struct list_head *iter; 33 34 netdev_for_each_lower_dev(lag_dev, lower, iter) { 35 if (netif_is_ice(lower)) 36 return lower; 37 } 38 39 return NULL; 40} 41 42static struct ice_esw_br_port * 43ice_eswitch_br_netdev_to_port(struct net_device *dev) 44{ 45 if (ice_is_port_repr_netdev(dev)) { 46 struct ice_repr *repr = ice_netdev_to_repr(dev); 47 48 return repr->br_port; 49 } else if (netif_is_ice(dev) || netif_is_lag_master(dev)) { 50 struct net_device *ice_dev; 51 struct ice_pf *pf; 52 53 if (netif_is_lag_master(dev)) 54 ice_dev = ice_eswitch_br_get_uplink_from_lag(dev); 55 else 56 ice_dev = dev; 57 58 if (!ice_dev) 59 return NULL; 60 61 pf = ice_netdev_to_pf(ice_dev); 62 63 return pf->br_port; 64 } 65 66 return NULL; 67} 68 69static void 70ice_eswitch_br_ingress_rule_setup(struct ice_adv_rule_info *rule_info, 71 u8 pf_id, u16 vf_vsi_idx) 72{ 73 rule_info->sw_act.vsi_handle = vf_vsi_idx; 74 rule_info->sw_act.flag |= ICE_FLTR_RX; 75 rule_info->sw_act.src = pf_id; 76 rule_info->priority = 2; 77} 78 79static void 80ice_eswitch_br_egress_rule_setup(struct ice_adv_rule_info *rule_info, 81 u16 pf_vsi_idx) 82{ 83 rule_info->sw_act.vsi_handle = pf_vsi_idx; 84 rule_info->sw_act.flag |= ICE_FLTR_TX; 85 rule_info->flags_info.act = ICE_SINGLE_ACT_LAN_ENABLE; 86 rule_info->flags_info.act_valid = true; 87 rule_info->priority = 2; 88} 89 90static int 91ice_eswitch_br_rule_delete(struct ice_hw *hw, struct ice_rule_query_data *rule) 92{ 93 int err; 94 95 if (!rule) 96 return -EINVAL; 97 98 err = ice_rem_adv_rule_by_id(hw, rule); 99 kfree(rule); 100 101 return err; 102} 103 104static u16 105ice_eswitch_br_get_lkups_cnt(u16 vid) 106{ 107 return ice_eswitch_br_is_vid_valid(vid) ? 2 : 1; 108} 109 110static void 111ice_eswitch_br_add_vlan_lkup(struct ice_adv_lkup_elem *list, u16 vid) 112{ 113 if (ice_eswitch_br_is_vid_valid(vid)) { 114 list[1].type = ICE_VLAN_OFOS; 115 list[1].h_u.vlan_hdr.vlan = cpu_to_be16(vid & VLAN_VID_MASK); 116 list[1].m_u.vlan_hdr.vlan = cpu_to_be16(0xFFFF); 117 } 118} 119 120static struct ice_rule_query_data * 121ice_eswitch_br_fwd_rule_create(struct ice_hw *hw, int vsi_idx, int port_type, 122 const unsigned char *mac, u16 vid) 123{ 124 struct ice_adv_rule_info rule_info = { 0 }; 125 struct ice_rule_query_data *rule; 126 struct ice_adv_lkup_elem *list; 127 u16 lkups_cnt; 128 int err; 129 130 lkups_cnt = ice_eswitch_br_get_lkups_cnt(vid); 131 132 rule = kzalloc(sizeof(*rule), GFP_KERNEL); 133 if (!rule) 134 return ERR_PTR(-ENOMEM); 135 136 list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC); 137 if (!list) { 138 err = -ENOMEM; 139 goto err_list_alloc; 140 } 141 142 switch (port_type) { 143 case ICE_ESWITCH_BR_UPLINK_PORT: 144 ice_eswitch_br_egress_rule_setup(&rule_info, vsi_idx); 145 break; 146 case ICE_ESWITCH_BR_VF_REPR_PORT: 147 ice_eswitch_br_ingress_rule_setup(&rule_info, hw->pf_id, 148 vsi_idx); 149 break; 150 default: 151 err = -EINVAL; 152 goto err_add_rule; 153 } 154 155 list[0].type = ICE_MAC_OFOS; 156 ether_addr_copy(list[0].h_u.eth_hdr.dst_addr, mac); 157 eth_broadcast_addr(list[0].m_u.eth_hdr.dst_addr); 158 159 ice_eswitch_br_add_vlan_lkup(list, vid); 160 161 rule_info.need_pass_l2 = true; 162 163 rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI; 164 165 err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, rule); 166 if (err) 167 goto err_add_rule; 168 169 kfree(list); 170 171 return rule; 172 173err_add_rule: 174 kfree(list); 175err_list_alloc: 176 kfree(rule); 177 178 return ERR_PTR(err); 179} 180 181static struct ice_rule_query_data * 182ice_eswitch_br_guard_rule_create(struct ice_hw *hw, u16 vsi_idx, 183 const unsigned char *mac, u16 vid) 184{ 185 struct ice_adv_rule_info rule_info = { 0 }; 186 struct ice_rule_query_data *rule; 187 struct ice_adv_lkup_elem *list; 188 int err = -ENOMEM; 189 u16 lkups_cnt; 190 191 lkups_cnt = ice_eswitch_br_get_lkups_cnt(vid); 192 193 rule = kzalloc(sizeof(*rule), GFP_KERNEL); 194 if (!rule) 195 goto err_exit; 196 197 list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC); 198 if (!list) 199 goto err_list_alloc; 200 201 list[0].type = ICE_MAC_OFOS; 202 ether_addr_copy(list[0].h_u.eth_hdr.src_addr, mac); 203 eth_broadcast_addr(list[0].m_u.eth_hdr.src_addr); 204 205 ice_eswitch_br_add_vlan_lkup(list, vid); 206 207 rule_info.allow_pass_l2 = true; 208 rule_info.sw_act.vsi_handle = vsi_idx; 209 rule_info.sw_act.fltr_act = ICE_NOP; 210 rule_info.priority = 2; 211 212 err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, rule); 213 if (err) 214 goto err_add_rule; 215 216 kfree(list); 217 218 return rule; 219 220err_add_rule: 221 kfree(list); 222err_list_alloc: 223 kfree(rule); 224err_exit: 225 return ERR_PTR(err); 226} 227 228static struct ice_esw_br_flow * 229ice_eswitch_br_flow_create(struct device *dev, struct ice_hw *hw, int vsi_idx, 230 int port_type, const unsigned char *mac, u16 vid) 231{ 232 struct ice_rule_query_data *fwd_rule, *guard_rule; 233 struct ice_esw_br_flow *flow; 234 int err; 235 236 flow = kzalloc(sizeof(*flow), GFP_KERNEL); 237 if (!flow) 238 return ERR_PTR(-ENOMEM); 239 240 fwd_rule = ice_eswitch_br_fwd_rule_create(hw, vsi_idx, port_type, mac, 241 vid); 242 err = PTR_ERR_OR_ZERO(fwd_rule); 243 if (err) { 244 dev_err(dev, "Failed to create eswitch bridge %sgress forward rule, err: %d\n", 245 port_type == ICE_ESWITCH_BR_UPLINK_PORT ? "e" : "in", 246 err); 247 goto err_fwd_rule; 248 } 249 250 guard_rule = ice_eswitch_br_guard_rule_create(hw, vsi_idx, mac, vid); 251 err = PTR_ERR_OR_ZERO(guard_rule); 252 if (err) { 253 dev_err(dev, "Failed to create eswitch bridge %sgress guard rule, err: %d\n", 254 port_type == ICE_ESWITCH_BR_UPLINK_PORT ? "e" : "in", 255 err); 256 goto err_guard_rule; 257 } 258 259 flow->fwd_rule = fwd_rule; 260 flow->guard_rule = guard_rule; 261 262 return flow; 263 264err_guard_rule: 265 ice_eswitch_br_rule_delete(hw, fwd_rule); 266err_fwd_rule: 267 kfree(flow); 268 269 return ERR_PTR(err); 270} 271 272static struct ice_esw_br_fdb_entry * 273ice_eswitch_br_fdb_find(struct ice_esw_br *bridge, const unsigned char *mac, 274 u16 vid) 275{ 276 struct ice_esw_br_fdb_data data = { 277 .vid = vid, 278 }; 279 280 ether_addr_copy(data.addr, mac); 281 return rhashtable_lookup_fast(&bridge->fdb_ht, &data, 282 ice_fdb_ht_params); 283} 284 285static void 286ice_eswitch_br_flow_delete(struct ice_pf *pf, struct ice_esw_br_flow *flow) 287{ 288 struct device *dev = ice_pf_to_dev(pf); 289 int err; 290 291 err = ice_eswitch_br_rule_delete(&pf->hw, flow->fwd_rule); 292 if (err) 293 dev_err(dev, "Failed to delete FDB forward rule, err: %d\n", 294 err); 295 296 err = ice_eswitch_br_rule_delete(&pf->hw, flow->guard_rule); 297 if (err) 298 dev_err(dev, "Failed to delete FDB guard rule, err: %d\n", 299 err); 300 301 kfree(flow); 302} 303 304static struct ice_esw_br_vlan * 305ice_esw_br_port_vlan_lookup(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid) 306{ 307 struct ice_pf *pf = bridge->br_offloads->pf; 308 struct device *dev = ice_pf_to_dev(pf); 309 struct ice_esw_br_port *port; 310 struct ice_esw_br_vlan *vlan; 311 312 port = xa_load(&bridge->ports, vsi_idx); 313 if (!port) { 314 dev_info(dev, "Bridge port lookup failed (vsi=%u)\n", vsi_idx); 315 return ERR_PTR(-EINVAL); 316 } 317 318 vlan = xa_load(&port->vlans, vid); 319 if (!vlan) { 320 dev_info(dev, "Bridge port vlan metadata lookup failed (vsi=%u)\n", 321 vsi_idx); 322 return ERR_PTR(-EINVAL); 323 } 324 325 return vlan; 326} 327 328static void 329ice_eswitch_br_fdb_entry_delete(struct ice_esw_br *bridge, 330 struct ice_esw_br_fdb_entry *fdb_entry) 331{ 332 struct ice_pf *pf = bridge->br_offloads->pf; 333 334 rhashtable_remove_fast(&bridge->fdb_ht, &fdb_entry->ht_node, 335 ice_fdb_ht_params); 336 list_del(&fdb_entry->list); 337 338 ice_eswitch_br_flow_delete(pf, fdb_entry->flow); 339 340 kfree(fdb_entry); 341} 342 343static void 344ice_eswitch_br_fdb_offload_notify(struct net_device *dev, 345 const unsigned char *mac, u16 vid, 346 unsigned long val) 347{ 348 struct switchdev_notifier_fdb_info fdb_info = { 349 .addr = mac, 350 .vid = vid, 351 .offloaded = true, 352 }; 353 354 call_switchdev_notifiers(val, dev, &fdb_info.info, NULL); 355} 356 357static void 358ice_eswitch_br_fdb_entry_notify_and_cleanup(struct ice_esw_br *bridge, 359 struct ice_esw_br_fdb_entry *entry) 360{ 361 if (!(entry->flags & ICE_ESWITCH_BR_FDB_ADDED_BY_USER)) 362 ice_eswitch_br_fdb_offload_notify(entry->dev, entry->data.addr, 363 entry->data.vid, 364 SWITCHDEV_FDB_DEL_TO_BRIDGE); 365 ice_eswitch_br_fdb_entry_delete(bridge, entry); 366} 367 368static void 369ice_eswitch_br_fdb_entry_find_and_delete(struct ice_esw_br *bridge, 370 const unsigned char *mac, u16 vid) 371{ 372 struct ice_pf *pf = bridge->br_offloads->pf; 373 struct ice_esw_br_fdb_entry *fdb_entry; 374 struct device *dev = ice_pf_to_dev(pf); 375 376 fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid); 377 if (!fdb_entry) { 378 dev_err(dev, "FDB entry with mac: %pM and vid: %u not found\n", 379 mac, vid); 380 return; 381 } 382 383 trace_ice_eswitch_br_fdb_entry_find_and_delete(fdb_entry); 384 ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry); 385} 386 387static void 388ice_eswitch_br_fdb_entry_create(struct net_device *netdev, 389 struct ice_esw_br_port *br_port, 390 bool added_by_user, 391 const unsigned char *mac, u16 vid) 392{ 393 struct ice_esw_br *bridge = br_port->bridge; 394 struct ice_pf *pf = bridge->br_offloads->pf; 395 struct device *dev = ice_pf_to_dev(pf); 396 struct ice_esw_br_fdb_entry *fdb_entry; 397 struct ice_esw_br_flow *flow; 398 struct ice_esw_br_vlan *vlan; 399 struct ice_hw *hw = &pf->hw; 400 unsigned long event; 401 int err; 402 403 /* untagged filtering is not yet supported */ 404 if (!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING) && vid) 405 return; 406 407 if ((bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING)) { 408 vlan = ice_esw_br_port_vlan_lookup(bridge, br_port->vsi_idx, 409 vid); 410 if (IS_ERR(vlan)) { 411 dev_err(dev, "Failed to find vlan lookup, err: %ld\n", 412 PTR_ERR(vlan)); 413 return; 414 } 415 } 416 417 fdb_entry = ice_eswitch_br_fdb_find(bridge, mac, vid); 418 if (fdb_entry) 419 ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, fdb_entry); 420 421 fdb_entry = kzalloc(sizeof(*fdb_entry), GFP_KERNEL); 422 if (!fdb_entry) { 423 err = -ENOMEM; 424 goto err_exit; 425 } 426 427 flow = ice_eswitch_br_flow_create(dev, hw, br_port->vsi_idx, 428 br_port->type, mac, vid); 429 if (IS_ERR(flow)) { 430 err = PTR_ERR(flow); 431 goto err_add_flow; 432 } 433 434 ether_addr_copy(fdb_entry->data.addr, mac); 435 fdb_entry->data.vid = vid; 436 fdb_entry->br_port = br_port; 437 fdb_entry->flow = flow; 438 fdb_entry->dev = netdev; 439 fdb_entry->last_use = jiffies; 440 event = SWITCHDEV_FDB_ADD_TO_BRIDGE; 441 442 if (added_by_user) { 443 fdb_entry->flags |= ICE_ESWITCH_BR_FDB_ADDED_BY_USER; 444 event = SWITCHDEV_FDB_OFFLOADED; 445 } 446 447 err = rhashtable_insert_fast(&bridge->fdb_ht, &fdb_entry->ht_node, 448 ice_fdb_ht_params); 449 if (err) 450 goto err_fdb_insert; 451 452 list_add(&fdb_entry->list, &bridge->fdb_list); 453 trace_ice_eswitch_br_fdb_entry_create(fdb_entry); 454 455 ice_eswitch_br_fdb_offload_notify(netdev, mac, vid, event); 456 457 return; 458 459err_fdb_insert: 460 ice_eswitch_br_flow_delete(pf, flow); 461err_add_flow: 462 kfree(fdb_entry); 463err_exit: 464 dev_err(dev, "Failed to create fdb entry, err: %d\n", err); 465} 466 467static void 468ice_eswitch_br_fdb_work_dealloc(struct ice_esw_br_fdb_work *fdb_work) 469{ 470 kfree(fdb_work->fdb_info.addr); 471 kfree(fdb_work); 472} 473 474static void 475ice_eswitch_br_fdb_event_work(struct work_struct *work) 476{ 477 struct ice_esw_br_fdb_work *fdb_work = ice_work_to_fdb_work(work); 478 bool added_by_user = fdb_work->fdb_info.added_by_user; 479 const unsigned char *mac = fdb_work->fdb_info.addr; 480 u16 vid = fdb_work->fdb_info.vid; 481 struct ice_esw_br_port *br_port; 482 483 rtnl_lock(); 484 485 br_port = ice_eswitch_br_netdev_to_port(fdb_work->dev); 486 if (!br_port) 487 goto err_exit; 488 489 switch (fdb_work->event) { 490 case SWITCHDEV_FDB_ADD_TO_DEVICE: 491 ice_eswitch_br_fdb_entry_create(fdb_work->dev, br_port, 492 added_by_user, mac, vid); 493 break; 494 case SWITCHDEV_FDB_DEL_TO_DEVICE: 495 ice_eswitch_br_fdb_entry_find_and_delete(br_port->bridge, 496 mac, vid); 497 break; 498 default: 499 goto err_exit; 500 } 501 502err_exit: 503 rtnl_unlock(); 504 dev_put(fdb_work->dev); 505 ice_eswitch_br_fdb_work_dealloc(fdb_work); 506} 507 508static struct ice_esw_br_fdb_work * 509ice_eswitch_br_fdb_work_alloc(struct switchdev_notifier_fdb_info *fdb_info, 510 struct net_device *dev, 511 unsigned long event) 512{ 513 struct ice_esw_br_fdb_work *work; 514 unsigned char *mac; 515 516 work = kzalloc(sizeof(*work), GFP_ATOMIC); 517 if (!work) 518 return ERR_PTR(-ENOMEM); 519 520 INIT_WORK(&work->work, ice_eswitch_br_fdb_event_work); 521 memcpy(&work->fdb_info, fdb_info, sizeof(work->fdb_info)); 522 523 mac = kzalloc(ETH_ALEN, GFP_ATOMIC); 524 if (!mac) { 525 kfree(work); 526 return ERR_PTR(-ENOMEM); 527 } 528 529 ether_addr_copy(mac, fdb_info->addr); 530 work->fdb_info.addr = mac; 531 work->event = event; 532 work->dev = dev; 533 534 return work; 535} 536 537static int 538ice_eswitch_br_switchdev_event(struct notifier_block *nb, 539 unsigned long event, void *ptr) 540{ 541 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 542 struct switchdev_notifier_fdb_info *fdb_info; 543 struct switchdev_notifier_info *info = ptr; 544 struct ice_esw_br_offloads *br_offloads; 545 struct ice_esw_br_fdb_work *work; 546 struct netlink_ext_ack *extack; 547 struct net_device *upper; 548 549 br_offloads = ice_nb_to_br_offloads(nb, switchdev_nb); 550 extack = switchdev_notifier_info_to_extack(ptr); 551 552 upper = netdev_master_upper_dev_get_rcu(dev); 553 if (!upper) 554 return NOTIFY_DONE; 555 556 if (!netif_is_bridge_master(upper)) 557 return NOTIFY_DONE; 558 559 if (!ice_eswitch_br_is_dev_valid(dev)) 560 return NOTIFY_DONE; 561 562 if (!ice_eswitch_br_netdev_to_port(dev)) 563 return NOTIFY_DONE; 564 565 switch (event) { 566 case SWITCHDEV_FDB_ADD_TO_DEVICE: 567 case SWITCHDEV_FDB_DEL_TO_DEVICE: 568 fdb_info = container_of(info, typeof(*fdb_info), info); 569 570 work = ice_eswitch_br_fdb_work_alloc(fdb_info, dev, event); 571 if (IS_ERR(work)) { 572 NL_SET_ERR_MSG_MOD(extack, "Failed to init switchdev fdb work"); 573 return notifier_from_errno(PTR_ERR(work)); 574 } 575 dev_hold(dev); 576 577 queue_work(br_offloads->wq, &work->work); 578 break; 579 default: 580 break; 581 } 582 return NOTIFY_DONE; 583} 584 585static void ice_eswitch_br_fdb_flush(struct ice_esw_br *bridge) 586{ 587 struct ice_esw_br_fdb_entry *entry, *tmp; 588 589 list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list) 590 ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry); 591} 592 593static void 594ice_eswitch_br_vlan_filtering_set(struct ice_esw_br *bridge, bool enable) 595{ 596 if (enable == !!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING)) 597 return; 598 599 ice_eswitch_br_fdb_flush(bridge); 600 if (enable) 601 bridge->flags |= ICE_ESWITCH_BR_VLAN_FILTERING; 602 else 603 bridge->flags &= ~ICE_ESWITCH_BR_VLAN_FILTERING; 604} 605 606static void 607ice_eswitch_br_clear_pvid(struct ice_esw_br_port *port) 608{ 609 struct ice_vlan port_vlan = ICE_VLAN(ETH_P_8021Q, port->pvid, 0); 610 struct ice_vsi_vlan_ops *vlan_ops; 611 612 vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi); 613 614 vlan_ops->del_vlan(port->vsi, &port_vlan); 615 vlan_ops->clear_port_vlan(port->vsi); 616 617 ice_vf_vsi_disable_port_vlan(port->vsi); 618 619 port->pvid = 0; 620} 621 622static void 623ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port, 624 struct ice_esw_br_vlan *vlan) 625{ 626 struct ice_esw_br_fdb_entry *fdb_entry, *tmp; 627 struct ice_esw_br *bridge = port->bridge; 628 629 trace_ice_eswitch_br_vlan_cleanup(vlan); 630 631 list_for_each_entry_safe(fdb_entry, tmp, &bridge->fdb_list, list) { 632 if (vlan->vid == fdb_entry->data.vid) 633 ice_eswitch_br_fdb_entry_delete(bridge, fdb_entry); 634 } 635 636 xa_erase(&port->vlans, vlan->vid); 637 if (port->pvid == vlan->vid) 638 ice_eswitch_br_clear_pvid(port); 639 kfree(vlan); 640} 641 642static void ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port *port) 643{ 644 struct ice_esw_br_vlan *vlan; 645 unsigned long index; 646 647 xa_for_each(&port->vlans, index, vlan) 648 ice_eswitch_br_vlan_cleanup(port, vlan); 649} 650 651static int 652ice_eswitch_br_set_pvid(struct ice_esw_br_port *port, 653 struct ice_esw_br_vlan *vlan) 654{ 655 struct ice_vlan port_vlan = ICE_VLAN(ETH_P_8021Q, vlan->vid, 0); 656 struct device *dev = ice_pf_to_dev(port->vsi->back); 657 struct ice_vsi_vlan_ops *vlan_ops; 658 int err; 659 660 if (port->pvid == vlan->vid || vlan->vid == 1) 661 return 0; 662 663 /* Setting port vlan on uplink isn't supported by hw */ 664 if (port->type == ICE_ESWITCH_BR_UPLINK_PORT) 665 return -EOPNOTSUPP; 666 667 if (port->pvid) { 668 dev_info(dev, 669 "Port VLAN (vsi=%u, vid=%u) already exists on the port, remove it before adding new one\n", 670 port->vsi_idx, port->pvid); 671 return -EEXIST; 672 } 673 674 ice_vf_vsi_enable_port_vlan(port->vsi); 675 676 vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi); 677 err = vlan_ops->set_port_vlan(port->vsi, &port_vlan); 678 if (err) 679 return err; 680 681 err = vlan_ops->add_vlan(port->vsi, &port_vlan); 682 if (err) 683 return err; 684 685 ice_eswitch_br_port_vlans_flush(port); 686 port->pvid = vlan->vid; 687 688 return 0; 689} 690 691static struct ice_esw_br_vlan * 692ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port) 693{ 694 struct device *dev = ice_pf_to_dev(port->vsi->back); 695 struct ice_esw_br_vlan *vlan; 696 int err; 697 698 vlan = kzalloc(sizeof(*vlan), GFP_KERNEL); 699 if (!vlan) 700 return ERR_PTR(-ENOMEM); 701 702 vlan->vid = vid; 703 vlan->flags = flags; 704 if ((flags & BRIDGE_VLAN_INFO_PVID) && 705 (flags & BRIDGE_VLAN_INFO_UNTAGGED)) { 706 err = ice_eswitch_br_set_pvid(port, vlan); 707 if (err) 708 goto err_set_pvid; 709 } else if ((flags & BRIDGE_VLAN_INFO_PVID) || 710 (flags & BRIDGE_VLAN_INFO_UNTAGGED)) { 711 dev_info(dev, "VLAN push and pop are supported only simultaneously\n"); 712 err = -EOPNOTSUPP; 713 goto err_set_pvid; 714 } 715 716 err = xa_insert(&port->vlans, vlan->vid, vlan, GFP_KERNEL); 717 if (err) 718 goto err_insert; 719 720 trace_ice_eswitch_br_vlan_create(vlan); 721 722 return vlan; 723 724err_insert: 725 if (port->pvid) 726 ice_eswitch_br_clear_pvid(port); 727err_set_pvid: 728 kfree(vlan); 729 return ERR_PTR(err); 730} 731 732static int 733ice_eswitch_br_port_vlan_add(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid, 734 u16 flags, struct netlink_ext_ack *extack) 735{ 736 struct ice_esw_br_port *port; 737 struct ice_esw_br_vlan *vlan; 738 739 port = xa_load(&bridge->ports, vsi_idx); 740 if (!port) 741 return -EINVAL; 742 743 if (port->pvid) { 744 dev_info(ice_pf_to_dev(port->vsi->back), 745 "Port VLAN (vsi=%u, vid=%d) exists on the port, remove it to add trunk VLANs\n", 746 port->vsi_idx, port->pvid); 747 return -EEXIST; 748 } 749 750 vlan = xa_load(&port->vlans, vid); 751 if (vlan) { 752 if (vlan->flags == flags) 753 return 0; 754 755 ice_eswitch_br_vlan_cleanup(port, vlan); 756 } 757 758 vlan = ice_eswitch_br_vlan_create(vid, flags, port); 759 if (IS_ERR(vlan)) { 760 NL_SET_ERR_MSG_FMT_MOD(extack, "Failed to create VLAN entry, vid: %u, vsi: %u", 761 vid, vsi_idx); 762 return PTR_ERR(vlan); 763 } 764 765 return 0; 766} 767 768static void 769ice_eswitch_br_port_vlan_del(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid) 770{ 771 struct ice_esw_br_port *port; 772 struct ice_esw_br_vlan *vlan; 773 774 port = xa_load(&bridge->ports, vsi_idx); 775 if (!port) 776 return; 777 778 vlan = xa_load(&port->vlans, vid); 779 if (!vlan) 780 return; 781 782 ice_eswitch_br_vlan_cleanup(port, vlan); 783} 784 785static int 786ice_eswitch_br_port_obj_add(struct net_device *netdev, const void *ctx, 787 const struct switchdev_obj *obj, 788 struct netlink_ext_ack *extack) 789{ 790 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev); 791 struct switchdev_obj_port_vlan *vlan; 792 int err; 793 794 if (!br_port) 795 return -EINVAL; 796 797 switch (obj->id) { 798 case SWITCHDEV_OBJ_ID_PORT_VLAN: 799 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 800 err = ice_eswitch_br_port_vlan_add(br_port->bridge, 801 br_port->vsi_idx, vlan->vid, 802 vlan->flags, extack); 803 return err; 804 default: 805 return -EOPNOTSUPP; 806 } 807} 808 809static int 810ice_eswitch_br_port_obj_del(struct net_device *netdev, const void *ctx, 811 const struct switchdev_obj *obj) 812{ 813 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev); 814 struct switchdev_obj_port_vlan *vlan; 815 816 if (!br_port) 817 return -EINVAL; 818 819 switch (obj->id) { 820 case SWITCHDEV_OBJ_ID_PORT_VLAN: 821 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 822 ice_eswitch_br_port_vlan_del(br_port->bridge, br_port->vsi_idx, 823 vlan->vid); 824 return 0; 825 default: 826 return -EOPNOTSUPP; 827 } 828} 829 830static int 831ice_eswitch_br_port_obj_attr_set(struct net_device *netdev, const void *ctx, 832 const struct switchdev_attr *attr, 833 struct netlink_ext_ack *extack) 834{ 835 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev); 836 837 if (!br_port) 838 return -EINVAL; 839 840 switch (attr->id) { 841 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 842 ice_eswitch_br_vlan_filtering_set(br_port->bridge, 843 attr->u.vlan_filtering); 844 return 0; 845 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 846 br_port->bridge->ageing_time = 847 clock_t_to_jiffies(attr->u.ageing_time); 848 return 0; 849 default: 850 return -EOPNOTSUPP; 851 } 852} 853 854static int 855ice_eswitch_br_event_blocking(struct notifier_block *nb, unsigned long event, 856 void *ptr) 857{ 858 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 859 int err; 860 861 switch (event) { 862 case SWITCHDEV_PORT_OBJ_ADD: 863 err = switchdev_handle_port_obj_add(dev, ptr, 864 ice_eswitch_br_is_dev_valid, 865 ice_eswitch_br_port_obj_add); 866 break; 867 case SWITCHDEV_PORT_OBJ_DEL: 868 err = switchdev_handle_port_obj_del(dev, ptr, 869 ice_eswitch_br_is_dev_valid, 870 ice_eswitch_br_port_obj_del); 871 break; 872 case SWITCHDEV_PORT_ATTR_SET: 873 err = switchdev_handle_port_attr_set(dev, ptr, 874 ice_eswitch_br_is_dev_valid, 875 ice_eswitch_br_port_obj_attr_set); 876 break; 877 default: 878 err = 0; 879 } 880 881 return notifier_from_errno(err); 882} 883 884static void 885ice_eswitch_br_port_deinit(struct ice_esw_br *bridge, 886 struct ice_esw_br_port *br_port) 887{ 888 struct ice_esw_br_fdb_entry *fdb_entry, *tmp; 889 struct ice_vsi *vsi = br_port->vsi; 890 891 list_for_each_entry_safe(fdb_entry, tmp, &bridge->fdb_list, list) { 892 if (br_port == fdb_entry->br_port) 893 ice_eswitch_br_fdb_entry_delete(bridge, fdb_entry); 894 } 895 896 if (br_port->type == ICE_ESWITCH_BR_UPLINK_PORT && vsi->back) { 897 vsi->back->br_port = NULL; 898 } else { 899 struct ice_repr *repr = ice_repr_get_by_vsi(vsi); 900 901 if (repr) 902 repr->br_port = NULL; 903 } 904 905 xa_erase(&bridge->ports, br_port->vsi_idx); 906 ice_eswitch_br_port_vlans_flush(br_port); 907 kfree(br_port); 908} 909 910static struct ice_esw_br_port * 911ice_eswitch_br_port_init(struct ice_esw_br *bridge) 912{ 913 struct ice_esw_br_port *br_port; 914 915 br_port = kzalloc(sizeof(*br_port), GFP_KERNEL); 916 if (!br_port) 917 return ERR_PTR(-ENOMEM); 918 919 xa_init(&br_port->vlans); 920 921 br_port->bridge = bridge; 922 923 return br_port; 924} 925 926static int 927ice_eswitch_br_vf_repr_port_init(struct ice_esw_br *bridge, 928 struct ice_repr *repr) 929{ 930 struct ice_esw_br_port *br_port; 931 int err; 932 933 br_port = ice_eswitch_br_port_init(bridge); 934 if (IS_ERR(br_port)) 935 return PTR_ERR(br_port); 936 937 br_port->vsi = repr->src_vsi; 938 br_port->vsi_idx = br_port->vsi->idx; 939 br_port->type = ICE_ESWITCH_BR_VF_REPR_PORT; 940 repr->br_port = br_port; 941 942 err = xa_insert(&bridge->ports, br_port->vsi_idx, br_port, GFP_KERNEL); 943 if (err) { 944 ice_eswitch_br_port_deinit(bridge, br_port); 945 return err; 946 } 947 948 return 0; 949} 950 951static int 952ice_eswitch_br_uplink_port_init(struct ice_esw_br *bridge, struct ice_pf *pf) 953{ 954 struct ice_vsi *vsi = pf->eswitch.uplink_vsi; 955 struct ice_esw_br_port *br_port; 956 int err; 957 958 br_port = ice_eswitch_br_port_init(bridge); 959 if (IS_ERR(br_port)) 960 return PTR_ERR(br_port); 961 962 br_port->vsi = vsi; 963 br_port->vsi_idx = br_port->vsi->idx; 964 br_port->type = ICE_ESWITCH_BR_UPLINK_PORT; 965 pf->br_port = br_port; 966 967 err = xa_insert(&bridge->ports, br_port->vsi_idx, br_port, GFP_KERNEL); 968 if (err) { 969 ice_eswitch_br_port_deinit(bridge, br_port); 970 return err; 971 } 972 973 return 0; 974} 975 976static void 977ice_eswitch_br_ports_flush(struct ice_esw_br *bridge) 978{ 979 struct ice_esw_br_port *port; 980 unsigned long i; 981 982 xa_for_each(&bridge->ports, i, port) 983 ice_eswitch_br_port_deinit(bridge, port); 984} 985 986static void 987ice_eswitch_br_deinit(struct ice_esw_br_offloads *br_offloads, 988 struct ice_esw_br *bridge) 989{ 990 if (!bridge) 991 return; 992 993 /* Cleanup all the ports that were added asynchronously 994 * through NETDEV_CHANGEUPPER event. 995 */ 996 ice_eswitch_br_ports_flush(bridge); 997 WARN_ON(!xa_empty(&bridge->ports)); 998 xa_destroy(&bridge->ports); 999 rhashtable_destroy(&bridge->fdb_ht); 1000 1001 br_offloads->bridge = NULL; 1002 kfree(bridge); 1003} 1004 1005static struct ice_esw_br * 1006ice_eswitch_br_init(struct ice_esw_br_offloads *br_offloads, int ifindex) 1007{ 1008 struct ice_esw_br *bridge; 1009 int err; 1010 1011 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); 1012 if (!bridge) 1013 return ERR_PTR(-ENOMEM); 1014 1015 err = rhashtable_init(&bridge->fdb_ht, &ice_fdb_ht_params); 1016 if (err) { 1017 kfree(bridge); 1018 return ERR_PTR(err); 1019 } 1020 1021 INIT_LIST_HEAD(&bridge->fdb_list); 1022 bridge->br_offloads = br_offloads; 1023 bridge->ifindex = ifindex; 1024 bridge->ageing_time = clock_t_to_jiffies(BR_DEFAULT_AGEING_TIME); 1025 xa_init(&bridge->ports); 1026 br_offloads->bridge = bridge; 1027 1028 return bridge; 1029} 1030 1031static struct ice_esw_br * 1032ice_eswitch_br_get(struct ice_esw_br_offloads *br_offloads, int ifindex, 1033 struct netlink_ext_ack *extack) 1034{ 1035 struct ice_esw_br *bridge = br_offloads->bridge; 1036 1037 if (bridge) { 1038 if (bridge->ifindex != ifindex) { 1039 NL_SET_ERR_MSG_MOD(extack, 1040 "Only one bridge is supported per eswitch"); 1041 return ERR_PTR(-EOPNOTSUPP); 1042 } 1043 return bridge; 1044 } 1045 1046 /* Create the bridge if it doesn't exist yet */ 1047 bridge = ice_eswitch_br_init(br_offloads, ifindex); 1048 if (IS_ERR(bridge)) 1049 NL_SET_ERR_MSG_MOD(extack, "Failed to init the bridge"); 1050 1051 return bridge; 1052} 1053 1054static void 1055ice_eswitch_br_verify_deinit(struct ice_esw_br_offloads *br_offloads, 1056 struct ice_esw_br *bridge) 1057{ 1058 /* Remove the bridge if it exists and there are no ports left */ 1059 if (!bridge || !xa_empty(&bridge->ports)) 1060 return; 1061 1062 ice_eswitch_br_deinit(br_offloads, bridge); 1063} 1064 1065static int 1066ice_eswitch_br_port_unlink(struct ice_esw_br_offloads *br_offloads, 1067 struct net_device *dev, int ifindex, 1068 struct netlink_ext_ack *extack) 1069{ 1070 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(dev); 1071 struct ice_esw_br *bridge; 1072 1073 if (!br_port) { 1074 NL_SET_ERR_MSG_MOD(extack, 1075 "Port representor is not attached to any bridge"); 1076 return -EINVAL; 1077 } 1078 1079 if (br_port->bridge->ifindex != ifindex) { 1080 NL_SET_ERR_MSG_MOD(extack, 1081 "Port representor is attached to another bridge"); 1082 return -EINVAL; 1083 } 1084 1085 bridge = br_port->bridge; 1086 1087 trace_ice_eswitch_br_port_unlink(br_port); 1088 ice_eswitch_br_port_deinit(br_port->bridge, br_port); 1089 ice_eswitch_br_verify_deinit(br_offloads, bridge); 1090 1091 return 0; 1092} 1093 1094static int 1095ice_eswitch_br_port_link(struct ice_esw_br_offloads *br_offloads, 1096 struct net_device *dev, int ifindex, 1097 struct netlink_ext_ack *extack) 1098{ 1099 struct ice_esw_br *bridge; 1100 int err; 1101 1102 if (ice_eswitch_br_netdev_to_port(dev)) { 1103 NL_SET_ERR_MSG_MOD(extack, 1104 "Port is already attached to the bridge"); 1105 return -EINVAL; 1106 } 1107 1108 bridge = ice_eswitch_br_get(br_offloads, ifindex, extack); 1109 if (IS_ERR(bridge)) 1110 return PTR_ERR(bridge); 1111 1112 if (ice_is_port_repr_netdev(dev)) { 1113 struct ice_repr *repr = ice_netdev_to_repr(dev); 1114 1115 err = ice_eswitch_br_vf_repr_port_init(bridge, repr); 1116 trace_ice_eswitch_br_port_link(repr->br_port); 1117 } else { 1118 struct net_device *ice_dev; 1119 struct ice_pf *pf; 1120 1121 if (netif_is_lag_master(dev)) 1122 ice_dev = ice_eswitch_br_get_uplink_from_lag(dev); 1123 else 1124 ice_dev = dev; 1125 1126 if (!ice_dev) 1127 return 0; 1128 1129 pf = ice_netdev_to_pf(ice_dev); 1130 1131 err = ice_eswitch_br_uplink_port_init(bridge, pf); 1132 trace_ice_eswitch_br_port_link(pf->br_port); 1133 } 1134 if (err) { 1135 NL_SET_ERR_MSG_MOD(extack, "Failed to init bridge port"); 1136 goto err_port_init; 1137 } 1138 1139 return 0; 1140 1141err_port_init: 1142 ice_eswitch_br_verify_deinit(br_offloads, bridge); 1143 return err; 1144} 1145 1146static int 1147ice_eswitch_br_port_changeupper(struct notifier_block *nb, void *ptr) 1148{ 1149 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1150 struct netdev_notifier_changeupper_info *info = ptr; 1151 struct ice_esw_br_offloads *br_offloads; 1152 struct netlink_ext_ack *extack; 1153 struct net_device *upper; 1154 1155 br_offloads = ice_nb_to_br_offloads(nb, netdev_nb); 1156 1157 if (!ice_eswitch_br_is_dev_valid(dev)) 1158 return 0; 1159 1160 upper = info->upper_dev; 1161 if (!netif_is_bridge_master(upper)) 1162 return 0; 1163 1164 extack = netdev_notifier_info_to_extack(&info->info); 1165 1166 if (info->linking) 1167 return ice_eswitch_br_port_link(br_offloads, dev, 1168 upper->ifindex, extack); 1169 else 1170 return ice_eswitch_br_port_unlink(br_offloads, dev, 1171 upper->ifindex, extack); 1172} 1173 1174static int 1175ice_eswitch_br_port_event(struct notifier_block *nb, 1176 unsigned long event, void *ptr) 1177{ 1178 int err = 0; 1179 1180 switch (event) { 1181 case NETDEV_CHANGEUPPER: 1182 err = ice_eswitch_br_port_changeupper(nb, ptr); 1183 break; 1184 } 1185 1186 return notifier_from_errno(err); 1187} 1188 1189static void 1190ice_eswitch_br_offloads_dealloc(struct ice_pf *pf) 1191{ 1192 struct ice_esw_br_offloads *br_offloads = pf->eswitch.br_offloads; 1193 1194 ASSERT_RTNL(); 1195 1196 if (!br_offloads) 1197 return; 1198 1199 ice_eswitch_br_deinit(br_offloads, br_offloads->bridge); 1200 1201 pf->eswitch.br_offloads = NULL; 1202 kfree(br_offloads); 1203} 1204 1205static struct ice_esw_br_offloads * 1206ice_eswitch_br_offloads_alloc(struct ice_pf *pf) 1207{ 1208 struct ice_esw_br_offloads *br_offloads; 1209 1210 ASSERT_RTNL(); 1211 1212 if (pf->eswitch.br_offloads) 1213 return ERR_PTR(-EEXIST); 1214 1215 br_offloads = kzalloc(sizeof(*br_offloads), GFP_KERNEL); 1216 if (!br_offloads) 1217 return ERR_PTR(-ENOMEM); 1218 1219 pf->eswitch.br_offloads = br_offloads; 1220 br_offloads->pf = pf; 1221 1222 return br_offloads; 1223} 1224 1225void 1226ice_eswitch_br_offloads_deinit(struct ice_pf *pf) 1227{ 1228 struct ice_esw_br_offloads *br_offloads; 1229 1230 br_offloads = pf->eswitch.br_offloads; 1231 if (!br_offloads) 1232 return; 1233 1234 cancel_delayed_work_sync(&br_offloads->update_work); 1235 unregister_netdevice_notifier(&br_offloads->netdev_nb); 1236 unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk); 1237 unregister_switchdev_notifier(&br_offloads->switchdev_nb); 1238 destroy_workqueue(br_offloads->wq); 1239 /* Although notifier block is unregistered just before, 1240 * so we don't get any new events, some events might be 1241 * already in progress. Hold the rtnl lock and wait for 1242 * them to finished. 1243 */ 1244 rtnl_lock(); 1245 ice_eswitch_br_offloads_dealloc(pf); 1246 rtnl_unlock(); 1247} 1248 1249static void ice_eswitch_br_update(struct ice_esw_br_offloads *br_offloads) 1250{ 1251 struct ice_esw_br *bridge = br_offloads->bridge; 1252 struct ice_esw_br_fdb_entry *entry, *tmp; 1253 1254 if (!bridge) 1255 return; 1256 1257 rtnl_lock(); 1258 list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list) { 1259 if (entry->flags & ICE_ESWITCH_BR_FDB_ADDED_BY_USER) 1260 continue; 1261 1262 if (time_is_after_eq_jiffies(entry->last_use + 1263 bridge->ageing_time)) 1264 continue; 1265 1266 ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry); 1267 } 1268 rtnl_unlock(); 1269} 1270 1271static void ice_eswitch_br_update_work(struct work_struct *work) 1272{ 1273 struct ice_esw_br_offloads *br_offloads; 1274 1275 br_offloads = ice_work_to_br_offloads(work); 1276 1277 ice_eswitch_br_update(br_offloads); 1278 1279 queue_delayed_work(br_offloads->wq, &br_offloads->update_work, 1280 ICE_ESW_BRIDGE_UPDATE_INTERVAL); 1281} 1282 1283int 1284ice_eswitch_br_offloads_init(struct ice_pf *pf) 1285{ 1286 struct ice_esw_br_offloads *br_offloads; 1287 struct device *dev = ice_pf_to_dev(pf); 1288 int err; 1289 1290 rtnl_lock(); 1291 br_offloads = ice_eswitch_br_offloads_alloc(pf); 1292 rtnl_unlock(); 1293 if (IS_ERR(br_offloads)) { 1294 dev_err(dev, "Failed to init eswitch bridge\n"); 1295 return PTR_ERR(br_offloads); 1296 } 1297 1298 br_offloads->wq = alloc_ordered_workqueue("ice_bridge_wq", 0); 1299 if (!br_offloads->wq) { 1300 err = -ENOMEM; 1301 dev_err(dev, "Failed to allocate bridge workqueue\n"); 1302 goto err_alloc_wq; 1303 } 1304 1305 br_offloads->switchdev_nb.notifier_call = 1306 ice_eswitch_br_switchdev_event; 1307 err = register_switchdev_notifier(&br_offloads->switchdev_nb); 1308 if (err) { 1309 dev_err(dev, 1310 "Failed to register switchdev notifier\n"); 1311 goto err_reg_switchdev_nb; 1312 } 1313 1314 br_offloads->switchdev_blk.notifier_call = 1315 ice_eswitch_br_event_blocking; 1316 err = register_switchdev_blocking_notifier(&br_offloads->switchdev_blk); 1317 if (err) { 1318 dev_err(dev, 1319 "Failed to register bridge blocking switchdev notifier\n"); 1320 goto err_reg_switchdev_blk; 1321 } 1322 1323 br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event; 1324 err = register_netdevice_notifier(&br_offloads->netdev_nb); 1325 if (err) { 1326 dev_err(dev, 1327 "Failed to register bridge port event notifier\n"); 1328 goto err_reg_netdev_nb; 1329 } 1330 1331 INIT_DELAYED_WORK(&br_offloads->update_work, 1332 ice_eswitch_br_update_work); 1333 queue_delayed_work(br_offloads->wq, &br_offloads->update_work, 1334 ICE_ESW_BRIDGE_UPDATE_INTERVAL); 1335 1336 return 0; 1337 1338err_reg_netdev_nb: 1339 unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk); 1340err_reg_switchdev_blk: 1341 unregister_switchdev_notifier(&br_offloads->switchdev_nb); 1342err_reg_switchdev_nb: 1343 destroy_workqueue(br_offloads->wq); 1344err_alloc_wq: 1345 rtnl_lock(); 1346 ice_eswitch_br_offloads_dealloc(pf); 1347 rtnl_unlock(); 1348 1349 return err; 1350} 1351