Loading...
Note: File does not exist in v4.6.
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
585void ice_eswitch_br_fdb_flush(struct ice_esw_br *bridge)
586{
587 struct ice_esw_br_fdb_entry *entry, *tmp;
588
589 if (!bridge)
590 return;
591
592 list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list)
593 ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry);
594}
595
596static void
597ice_eswitch_br_vlan_filtering_set(struct ice_esw_br *bridge, bool enable)
598{
599 if (enable == !!(bridge->flags & ICE_ESWITCH_BR_VLAN_FILTERING))
600 return;
601
602 ice_eswitch_br_fdb_flush(bridge);
603 if (enable)
604 bridge->flags |= ICE_ESWITCH_BR_VLAN_FILTERING;
605 else
606 bridge->flags &= ~ICE_ESWITCH_BR_VLAN_FILTERING;
607}
608
609static void
610ice_eswitch_br_clear_pvid(struct ice_esw_br_port *port)
611{
612 struct ice_vlan port_vlan = ICE_VLAN(ETH_P_8021Q, port->pvid, 0);
613 struct ice_vsi_vlan_ops *vlan_ops;
614
615 vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi);
616
617 vlan_ops->del_vlan(port->vsi, &port_vlan);
618 vlan_ops->clear_port_vlan(port->vsi);
619
620 ice_vf_vsi_disable_port_vlan(port->vsi);
621
622 port->pvid = 0;
623}
624
625static void
626ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port *port,
627 struct ice_esw_br_vlan *vlan)
628{
629 struct ice_esw_br_fdb_entry *fdb_entry, *tmp;
630 struct ice_esw_br *bridge = port->bridge;
631
632 trace_ice_eswitch_br_vlan_cleanup(vlan);
633
634 list_for_each_entry_safe(fdb_entry, tmp, &bridge->fdb_list, list) {
635 if (vlan->vid == fdb_entry->data.vid)
636 ice_eswitch_br_fdb_entry_delete(bridge, fdb_entry);
637 }
638
639 xa_erase(&port->vlans, vlan->vid);
640 if (port->pvid == vlan->vid)
641 ice_eswitch_br_clear_pvid(port);
642 kfree(vlan);
643}
644
645static void ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port *port)
646{
647 struct ice_esw_br_vlan *vlan;
648 unsigned long index;
649
650 xa_for_each(&port->vlans, index, vlan)
651 ice_eswitch_br_vlan_cleanup(port, vlan);
652}
653
654static int
655ice_eswitch_br_set_pvid(struct ice_esw_br_port *port,
656 struct ice_esw_br_vlan *vlan)
657{
658 struct ice_vlan port_vlan = ICE_VLAN(ETH_P_8021Q, vlan->vid, 0);
659 struct device *dev = ice_pf_to_dev(port->vsi->back);
660 struct ice_vsi_vlan_ops *vlan_ops;
661 int err;
662
663 if (port->pvid == vlan->vid || vlan->vid == 1)
664 return 0;
665
666 /* Setting port vlan on uplink isn't supported by hw */
667 if (port->type == ICE_ESWITCH_BR_UPLINK_PORT)
668 return -EOPNOTSUPP;
669
670 if (port->pvid) {
671 dev_info(dev,
672 "Port VLAN (vsi=%u, vid=%u) already exists on the port, remove it before adding new one\n",
673 port->vsi_idx, port->pvid);
674 return -EEXIST;
675 }
676
677 ice_vf_vsi_enable_port_vlan(port->vsi);
678
679 vlan_ops = ice_get_compat_vsi_vlan_ops(port->vsi);
680 err = vlan_ops->set_port_vlan(port->vsi, &port_vlan);
681 if (err)
682 return err;
683
684 err = vlan_ops->add_vlan(port->vsi, &port_vlan);
685 if (err)
686 return err;
687
688 ice_eswitch_br_port_vlans_flush(port);
689 port->pvid = vlan->vid;
690
691 return 0;
692}
693
694static struct ice_esw_br_vlan *
695ice_eswitch_br_vlan_create(u16 vid, u16 flags, struct ice_esw_br_port *port)
696{
697 struct device *dev = ice_pf_to_dev(port->vsi->back);
698 struct ice_esw_br_vlan *vlan;
699 int err;
700
701 vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
702 if (!vlan)
703 return ERR_PTR(-ENOMEM);
704
705 vlan->vid = vid;
706 vlan->flags = flags;
707 if ((flags & BRIDGE_VLAN_INFO_PVID) &&
708 (flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
709 err = ice_eswitch_br_set_pvid(port, vlan);
710 if (err)
711 goto err_set_pvid;
712 } else if ((flags & BRIDGE_VLAN_INFO_PVID) ||
713 (flags & BRIDGE_VLAN_INFO_UNTAGGED)) {
714 dev_info(dev, "VLAN push and pop are supported only simultaneously\n");
715 err = -EOPNOTSUPP;
716 goto err_set_pvid;
717 }
718
719 err = xa_insert(&port->vlans, vlan->vid, vlan, GFP_KERNEL);
720 if (err)
721 goto err_insert;
722
723 trace_ice_eswitch_br_vlan_create(vlan);
724
725 return vlan;
726
727err_insert:
728 if (port->pvid)
729 ice_eswitch_br_clear_pvid(port);
730err_set_pvid:
731 kfree(vlan);
732 return ERR_PTR(err);
733}
734
735static int
736ice_eswitch_br_port_vlan_add(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid,
737 u16 flags, struct netlink_ext_ack *extack)
738{
739 struct ice_esw_br_port *port;
740 struct ice_esw_br_vlan *vlan;
741
742 port = xa_load(&bridge->ports, vsi_idx);
743 if (!port)
744 return -EINVAL;
745
746 if (port->pvid) {
747 dev_info(ice_pf_to_dev(port->vsi->back),
748 "Port VLAN (vsi=%u, vid=%d) exists on the port, remove it to add trunk VLANs\n",
749 port->vsi_idx, port->pvid);
750 return -EEXIST;
751 }
752
753 vlan = xa_load(&port->vlans, vid);
754 if (vlan) {
755 if (vlan->flags == flags)
756 return 0;
757
758 ice_eswitch_br_vlan_cleanup(port, vlan);
759 }
760
761 vlan = ice_eswitch_br_vlan_create(vid, flags, port);
762 if (IS_ERR(vlan)) {
763 NL_SET_ERR_MSG_FMT_MOD(extack, "Failed to create VLAN entry, vid: %u, vsi: %u",
764 vid, vsi_idx);
765 return PTR_ERR(vlan);
766 }
767
768 return 0;
769}
770
771static void
772ice_eswitch_br_port_vlan_del(struct ice_esw_br *bridge, u16 vsi_idx, u16 vid)
773{
774 struct ice_esw_br_port *port;
775 struct ice_esw_br_vlan *vlan;
776
777 port = xa_load(&bridge->ports, vsi_idx);
778 if (!port)
779 return;
780
781 vlan = xa_load(&port->vlans, vid);
782 if (!vlan)
783 return;
784
785 ice_eswitch_br_vlan_cleanup(port, vlan);
786}
787
788static int
789ice_eswitch_br_port_obj_add(struct net_device *netdev, const void *ctx,
790 const struct switchdev_obj *obj,
791 struct netlink_ext_ack *extack)
792{
793 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
794 struct switchdev_obj_port_vlan *vlan;
795 int err;
796
797 if (!br_port)
798 return -EINVAL;
799
800 switch (obj->id) {
801 case SWITCHDEV_OBJ_ID_PORT_VLAN:
802 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
803 err = ice_eswitch_br_port_vlan_add(br_port->bridge,
804 br_port->vsi_idx, vlan->vid,
805 vlan->flags, extack);
806 return err;
807 default:
808 return -EOPNOTSUPP;
809 }
810}
811
812static int
813ice_eswitch_br_port_obj_del(struct net_device *netdev, const void *ctx,
814 const struct switchdev_obj *obj)
815{
816 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
817 struct switchdev_obj_port_vlan *vlan;
818
819 if (!br_port)
820 return -EINVAL;
821
822 switch (obj->id) {
823 case SWITCHDEV_OBJ_ID_PORT_VLAN:
824 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
825 ice_eswitch_br_port_vlan_del(br_port->bridge, br_port->vsi_idx,
826 vlan->vid);
827 return 0;
828 default:
829 return -EOPNOTSUPP;
830 }
831}
832
833static int
834ice_eswitch_br_port_obj_attr_set(struct net_device *netdev, const void *ctx,
835 const struct switchdev_attr *attr,
836 struct netlink_ext_ack *extack)
837{
838 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(netdev);
839
840 if (!br_port)
841 return -EINVAL;
842
843 switch (attr->id) {
844 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
845 ice_eswitch_br_vlan_filtering_set(br_port->bridge,
846 attr->u.vlan_filtering);
847 return 0;
848 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
849 br_port->bridge->ageing_time =
850 clock_t_to_jiffies(attr->u.ageing_time);
851 return 0;
852 default:
853 return -EOPNOTSUPP;
854 }
855}
856
857static int
858ice_eswitch_br_event_blocking(struct notifier_block *nb, unsigned long event,
859 void *ptr)
860{
861 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
862 int err;
863
864 switch (event) {
865 case SWITCHDEV_PORT_OBJ_ADD:
866 err = switchdev_handle_port_obj_add(dev, ptr,
867 ice_eswitch_br_is_dev_valid,
868 ice_eswitch_br_port_obj_add);
869 break;
870 case SWITCHDEV_PORT_OBJ_DEL:
871 err = switchdev_handle_port_obj_del(dev, ptr,
872 ice_eswitch_br_is_dev_valid,
873 ice_eswitch_br_port_obj_del);
874 break;
875 case SWITCHDEV_PORT_ATTR_SET:
876 err = switchdev_handle_port_attr_set(dev, ptr,
877 ice_eswitch_br_is_dev_valid,
878 ice_eswitch_br_port_obj_attr_set);
879 break;
880 default:
881 err = 0;
882 }
883
884 return notifier_from_errno(err);
885}
886
887static void
888ice_eswitch_br_port_deinit(struct ice_esw_br *bridge,
889 struct ice_esw_br_port *br_port)
890{
891 struct ice_esw_br_fdb_entry *fdb_entry, *tmp;
892 struct ice_vsi *vsi = br_port->vsi;
893
894 list_for_each_entry_safe(fdb_entry, tmp, &bridge->fdb_list, list) {
895 if (br_port == fdb_entry->br_port)
896 ice_eswitch_br_fdb_entry_delete(bridge, fdb_entry);
897 }
898
899 if (br_port->type == ICE_ESWITCH_BR_UPLINK_PORT && vsi->back) {
900 vsi->back->br_port = NULL;
901 } else {
902 struct ice_repr *repr =
903 ice_repr_get(vsi->back, br_port->repr_id);
904
905 if (repr)
906 repr->br_port = NULL;
907 }
908
909 xa_erase(&bridge->ports, br_port->vsi_idx);
910 ice_eswitch_br_port_vlans_flush(br_port);
911 kfree(br_port);
912}
913
914static struct ice_esw_br_port *
915ice_eswitch_br_port_init(struct ice_esw_br *bridge)
916{
917 struct ice_esw_br_port *br_port;
918
919 br_port = kzalloc(sizeof(*br_port), GFP_KERNEL);
920 if (!br_port)
921 return ERR_PTR(-ENOMEM);
922
923 xa_init(&br_port->vlans);
924
925 br_port->bridge = bridge;
926
927 return br_port;
928}
929
930static int
931ice_eswitch_br_vf_repr_port_init(struct ice_esw_br *bridge,
932 struct ice_repr *repr)
933{
934 struct ice_esw_br_port *br_port;
935 int err;
936
937 br_port = ice_eswitch_br_port_init(bridge);
938 if (IS_ERR(br_port))
939 return PTR_ERR(br_port);
940
941 br_port->vsi = repr->src_vsi;
942 br_port->vsi_idx = br_port->vsi->idx;
943 br_port->type = ICE_ESWITCH_BR_VF_REPR_PORT;
944 br_port->repr_id = repr->id;
945 repr->br_port = br_port;
946
947 err = xa_insert(&bridge->ports, br_port->vsi_idx, br_port, GFP_KERNEL);
948 if (err) {
949 ice_eswitch_br_port_deinit(bridge, br_port);
950 return err;
951 }
952
953 return 0;
954}
955
956static int
957ice_eswitch_br_uplink_port_init(struct ice_esw_br *bridge, struct ice_pf *pf)
958{
959 struct ice_vsi *vsi = pf->eswitch.uplink_vsi;
960 struct ice_esw_br_port *br_port;
961 int err;
962
963 br_port = ice_eswitch_br_port_init(bridge);
964 if (IS_ERR(br_port))
965 return PTR_ERR(br_port);
966
967 br_port->vsi = vsi;
968 br_port->vsi_idx = br_port->vsi->idx;
969 br_port->type = ICE_ESWITCH_BR_UPLINK_PORT;
970 pf->br_port = br_port;
971
972 err = xa_insert(&bridge->ports, br_port->vsi_idx, br_port, GFP_KERNEL);
973 if (err) {
974 ice_eswitch_br_port_deinit(bridge, br_port);
975 return err;
976 }
977
978 return 0;
979}
980
981static void
982ice_eswitch_br_ports_flush(struct ice_esw_br *bridge)
983{
984 struct ice_esw_br_port *port;
985 unsigned long i;
986
987 xa_for_each(&bridge->ports, i, port)
988 ice_eswitch_br_port_deinit(bridge, port);
989}
990
991static void
992ice_eswitch_br_deinit(struct ice_esw_br_offloads *br_offloads,
993 struct ice_esw_br *bridge)
994{
995 if (!bridge)
996 return;
997
998 /* Cleanup all the ports that were added asynchronously
999 * through NETDEV_CHANGEUPPER event.
1000 */
1001 ice_eswitch_br_ports_flush(bridge);
1002 WARN_ON(!xa_empty(&bridge->ports));
1003 xa_destroy(&bridge->ports);
1004 rhashtable_destroy(&bridge->fdb_ht);
1005
1006 br_offloads->bridge = NULL;
1007 kfree(bridge);
1008}
1009
1010static struct ice_esw_br *
1011ice_eswitch_br_init(struct ice_esw_br_offloads *br_offloads, int ifindex)
1012{
1013 struct ice_esw_br *bridge;
1014 int err;
1015
1016 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
1017 if (!bridge)
1018 return ERR_PTR(-ENOMEM);
1019
1020 err = rhashtable_init(&bridge->fdb_ht, &ice_fdb_ht_params);
1021 if (err) {
1022 kfree(bridge);
1023 return ERR_PTR(err);
1024 }
1025
1026 INIT_LIST_HEAD(&bridge->fdb_list);
1027 bridge->br_offloads = br_offloads;
1028 bridge->ifindex = ifindex;
1029 bridge->ageing_time = clock_t_to_jiffies(BR_DEFAULT_AGEING_TIME);
1030 xa_init(&bridge->ports);
1031 br_offloads->bridge = bridge;
1032
1033 return bridge;
1034}
1035
1036static struct ice_esw_br *
1037ice_eswitch_br_get(struct ice_esw_br_offloads *br_offloads, int ifindex,
1038 struct netlink_ext_ack *extack)
1039{
1040 struct ice_esw_br *bridge = br_offloads->bridge;
1041
1042 if (bridge) {
1043 if (bridge->ifindex != ifindex) {
1044 NL_SET_ERR_MSG_MOD(extack,
1045 "Only one bridge is supported per eswitch");
1046 return ERR_PTR(-EOPNOTSUPP);
1047 }
1048 return bridge;
1049 }
1050
1051 /* Create the bridge if it doesn't exist yet */
1052 bridge = ice_eswitch_br_init(br_offloads, ifindex);
1053 if (IS_ERR(bridge))
1054 NL_SET_ERR_MSG_MOD(extack, "Failed to init the bridge");
1055
1056 return bridge;
1057}
1058
1059static void
1060ice_eswitch_br_verify_deinit(struct ice_esw_br_offloads *br_offloads,
1061 struct ice_esw_br *bridge)
1062{
1063 /* Remove the bridge if it exists and there are no ports left */
1064 if (!bridge || !xa_empty(&bridge->ports))
1065 return;
1066
1067 ice_eswitch_br_deinit(br_offloads, bridge);
1068}
1069
1070static int
1071ice_eswitch_br_port_unlink(struct ice_esw_br_offloads *br_offloads,
1072 struct net_device *dev, int ifindex,
1073 struct netlink_ext_ack *extack)
1074{
1075 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(dev);
1076 struct ice_esw_br *bridge;
1077
1078 if (!br_port) {
1079 NL_SET_ERR_MSG_MOD(extack,
1080 "Port representor is not attached to any bridge");
1081 return -EINVAL;
1082 }
1083
1084 if (br_port->bridge->ifindex != ifindex) {
1085 NL_SET_ERR_MSG_MOD(extack,
1086 "Port representor is attached to another bridge");
1087 return -EINVAL;
1088 }
1089
1090 bridge = br_port->bridge;
1091
1092 trace_ice_eswitch_br_port_unlink(br_port);
1093 ice_eswitch_br_port_deinit(br_port->bridge, br_port);
1094 ice_eswitch_br_verify_deinit(br_offloads, bridge);
1095
1096 return 0;
1097}
1098
1099static int
1100ice_eswitch_br_port_link(struct ice_esw_br_offloads *br_offloads,
1101 struct net_device *dev, int ifindex,
1102 struct netlink_ext_ack *extack)
1103{
1104 struct ice_esw_br *bridge;
1105 int err;
1106
1107 if (ice_eswitch_br_netdev_to_port(dev)) {
1108 NL_SET_ERR_MSG_MOD(extack,
1109 "Port is already attached to the bridge");
1110 return -EINVAL;
1111 }
1112
1113 bridge = ice_eswitch_br_get(br_offloads, ifindex, extack);
1114 if (IS_ERR(bridge))
1115 return PTR_ERR(bridge);
1116
1117 if (ice_is_port_repr_netdev(dev)) {
1118 struct ice_repr *repr = ice_netdev_to_repr(dev);
1119
1120 err = ice_eswitch_br_vf_repr_port_init(bridge, repr);
1121 trace_ice_eswitch_br_port_link(repr->br_port);
1122 } else {
1123 struct net_device *ice_dev;
1124 struct ice_pf *pf;
1125
1126 if (netif_is_lag_master(dev))
1127 ice_dev = ice_eswitch_br_get_uplink_from_lag(dev);
1128 else
1129 ice_dev = dev;
1130
1131 if (!ice_dev)
1132 return 0;
1133
1134 pf = ice_netdev_to_pf(ice_dev);
1135
1136 err = ice_eswitch_br_uplink_port_init(bridge, pf);
1137 trace_ice_eswitch_br_port_link(pf->br_port);
1138 }
1139 if (err) {
1140 NL_SET_ERR_MSG_MOD(extack, "Failed to init bridge port");
1141 goto err_port_init;
1142 }
1143
1144 return 0;
1145
1146err_port_init:
1147 ice_eswitch_br_verify_deinit(br_offloads, bridge);
1148 return err;
1149}
1150
1151static int
1152ice_eswitch_br_port_changeupper(struct notifier_block *nb, void *ptr)
1153{
1154 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1155 struct netdev_notifier_changeupper_info *info = ptr;
1156 struct ice_esw_br_offloads *br_offloads;
1157 struct netlink_ext_ack *extack;
1158 struct net_device *upper;
1159
1160 br_offloads = ice_nb_to_br_offloads(nb, netdev_nb);
1161
1162 if (!ice_eswitch_br_is_dev_valid(dev))
1163 return 0;
1164
1165 upper = info->upper_dev;
1166 if (!netif_is_bridge_master(upper))
1167 return 0;
1168
1169 extack = netdev_notifier_info_to_extack(&info->info);
1170
1171 if (info->linking)
1172 return ice_eswitch_br_port_link(br_offloads, dev,
1173 upper->ifindex, extack);
1174 else
1175 return ice_eswitch_br_port_unlink(br_offloads, dev,
1176 upper->ifindex, extack);
1177}
1178
1179static int
1180ice_eswitch_br_port_event(struct notifier_block *nb,
1181 unsigned long event, void *ptr)
1182{
1183 int err = 0;
1184
1185 switch (event) {
1186 case NETDEV_CHANGEUPPER:
1187 err = ice_eswitch_br_port_changeupper(nb, ptr);
1188 break;
1189 }
1190
1191 return notifier_from_errno(err);
1192}
1193
1194static void
1195ice_eswitch_br_offloads_dealloc(struct ice_pf *pf)
1196{
1197 struct ice_esw_br_offloads *br_offloads = pf->eswitch.br_offloads;
1198
1199 ASSERT_RTNL();
1200
1201 if (!br_offloads)
1202 return;
1203
1204 ice_eswitch_br_deinit(br_offloads, br_offloads->bridge);
1205
1206 pf->eswitch.br_offloads = NULL;
1207 kfree(br_offloads);
1208}
1209
1210static struct ice_esw_br_offloads *
1211ice_eswitch_br_offloads_alloc(struct ice_pf *pf)
1212{
1213 struct ice_esw_br_offloads *br_offloads;
1214
1215 ASSERT_RTNL();
1216
1217 if (pf->eswitch.br_offloads)
1218 return ERR_PTR(-EEXIST);
1219
1220 br_offloads = kzalloc(sizeof(*br_offloads), GFP_KERNEL);
1221 if (!br_offloads)
1222 return ERR_PTR(-ENOMEM);
1223
1224 pf->eswitch.br_offloads = br_offloads;
1225 br_offloads->pf = pf;
1226
1227 return br_offloads;
1228}
1229
1230void
1231ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
1232{
1233 struct ice_esw_br_offloads *br_offloads;
1234
1235 br_offloads = pf->eswitch.br_offloads;
1236 if (!br_offloads)
1237 return;
1238
1239 cancel_delayed_work_sync(&br_offloads->update_work);
1240 unregister_netdevice_notifier(&br_offloads->netdev_nb);
1241 unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
1242 unregister_switchdev_notifier(&br_offloads->switchdev_nb);
1243 destroy_workqueue(br_offloads->wq);
1244 /* Although notifier block is unregistered just before,
1245 * so we don't get any new events, some events might be
1246 * already in progress. Hold the rtnl lock and wait for
1247 * them to finished.
1248 */
1249 rtnl_lock();
1250 ice_eswitch_br_offloads_dealloc(pf);
1251 rtnl_unlock();
1252}
1253
1254static void ice_eswitch_br_update(struct ice_esw_br_offloads *br_offloads)
1255{
1256 struct ice_esw_br *bridge = br_offloads->bridge;
1257 struct ice_esw_br_fdb_entry *entry, *tmp;
1258
1259 if (!bridge)
1260 return;
1261
1262 rtnl_lock();
1263 list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list) {
1264 if (entry->flags & ICE_ESWITCH_BR_FDB_ADDED_BY_USER)
1265 continue;
1266
1267 if (time_is_after_eq_jiffies(entry->last_use +
1268 bridge->ageing_time))
1269 continue;
1270
1271 ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry);
1272 }
1273 rtnl_unlock();
1274}
1275
1276static void ice_eswitch_br_update_work(struct work_struct *work)
1277{
1278 struct ice_esw_br_offloads *br_offloads;
1279
1280 br_offloads = ice_work_to_br_offloads(work);
1281
1282 ice_eswitch_br_update(br_offloads);
1283
1284 queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
1285 ICE_ESW_BRIDGE_UPDATE_INTERVAL);
1286}
1287
1288int
1289ice_eswitch_br_offloads_init(struct ice_pf *pf)
1290{
1291 struct ice_esw_br_offloads *br_offloads;
1292 struct device *dev = ice_pf_to_dev(pf);
1293 int err;
1294
1295 rtnl_lock();
1296 br_offloads = ice_eswitch_br_offloads_alloc(pf);
1297 rtnl_unlock();
1298 if (IS_ERR(br_offloads)) {
1299 dev_err(dev, "Failed to init eswitch bridge\n");
1300 return PTR_ERR(br_offloads);
1301 }
1302
1303 br_offloads->wq = alloc_ordered_workqueue("ice_bridge_wq", 0);
1304 if (!br_offloads->wq) {
1305 err = -ENOMEM;
1306 dev_err(dev, "Failed to allocate bridge workqueue\n");
1307 goto err_alloc_wq;
1308 }
1309
1310 br_offloads->switchdev_nb.notifier_call =
1311 ice_eswitch_br_switchdev_event;
1312 err = register_switchdev_notifier(&br_offloads->switchdev_nb);
1313 if (err) {
1314 dev_err(dev,
1315 "Failed to register switchdev notifier\n");
1316 goto err_reg_switchdev_nb;
1317 }
1318
1319 br_offloads->switchdev_blk.notifier_call =
1320 ice_eswitch_br_event_blocking;
1321 err = register_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
1322 if (err) {
1323 dev_err(dev,
1324 "Failed to register bridge blocking switchdev notifier\n");
1325 goto err_reg_switchdev_blk;
1326 }
1327
1328 br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
1329 err = register_netdevice_notifier(&br_offloads->netdev_nb);
1330 if (err) {
1331 dev_err(dev,
1332 "Failed to register bridge port event notifier\n");
1333 goto err_reg_netdev_nb;
1334 }
1335
1336 INIT_DELAYED_WORK(&br_offloads->update_work,
1337 ice_eswitch_br_update_work);
1338 queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
1339 ICE_ESW_BRIDGE_UPDATE_INTERVAL);
1340
1341 return 0;
1342
1343err_reg_netdev_nb:
1344 unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
1345err_reg_switchdev_blk:
1346 unregister_switchdev_notifier(&br_offloads->switchdev_nb);
1347err_reg_switchdev_nb:
1348 destroy_workqueue(br_offloads->wq);
1349err_alloc_wq:
1350 rtnl_lock();
1351 ice_eswitch_br_offloads_dealloc(pf);
1352 rtnl_unlock();
1353
1354 return err;
1355}