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
14 static 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
ice_eswitch_br_is_dev_valid(const struct net_device * dev)21 static 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
28 static struct net_device *
ice_eswitch_br_get_uplink_from_lag(struct net_device * lag_dev)29 ice_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
42 static struct ice_esw_br_port *
ice_eswitch_br_netdev_to_port(struct net_device * dev)43 ice_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
69 static void
ice_eswitch_br_ingress_rule_setup(struct ice_adv_rule_info * rule_info,u8 pf_id,u16 vf_vsi_idx)70 ice_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
79 static void
ice_eswitch_br_egress_rule_setup(struct ice_adv_rule_info * rule_info,u16 pf_vsi_idx)80 ice_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
90 static int
ice_eswitch_br_rule_delete(struct ice_hw * hw,struct ice_rule_query_data * rule)91 ice_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
104 static u16
ice_eswitch_br_get_lkups_cnt(u16 vid)105 ice_eswitch_br_get_lkups_cnt(u16 vid)
106 {
107 return ice_eswitch_br_is_vid_valid(vid) ? 2 : 1;
108 }
109
110 static void
ice_eswitch_br_add_vlan_lkup(struct ice_adv_lkup_elem * list,u16 vid)111 ice_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
120 static struct ice_rule_query_data *
ice_eswitch_br_fwd_rule_create(struct ice_hw * hw,int vsi_idx,int port_type,const unsigned char * mac,u16 vid)121 ice_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
173 err_add_rule:
174 kfree(list);
175 err_list_alloc:
176 kfree(rule);
177
178 return ERR_PTR(err);
179 }
180
181 static struct ice_rule_query_data *
ice_eswitch_br_guard_rule_create(struct ice_hw * hw,u16 vsi_idx,const unsigned char * mac,u16 vid)182 ice_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
220 err_add_rule:
221 kfree(list);
222 err_list_alloc:
223 kfree(rule);
224 err_exit:
225 return ERR_PTR(err);
226 }
227
228 static struct ice_esw_br_flow *
ice_eswitch_br_flow_create(struct device * dev,struct ice_hw * hw,int vsi_idx,int port_type,const unsigned char * mac,u16 vid)229 ice_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
264 err_guard_rule:
265 ice_eswitch_br_rule_delete(hw, fwd_rule);
266 err_fwd_rule:
267 kfree(flow);
268
269 return ERR_PTR(err);
270 }
271
272 static struct ice_esw_br_fdb_entry *
ice_eswitch_br_fdb_find(struct ice_esw_br * bridge,const unsigned char * mac,u16 vid)273 ice_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
285 static void
ice_eswitch_br_flow_delete(struct ice_pf * pf,struct ice_esw_br_flow * flow)286 ice_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
304 static struct ice_esw_br_vlan *
ice_esw_br_port_vlan_lookup(struct ice_esw_br * bridge,u16 vsi_idx,u16 vid)305 ice_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
328 static void
ice_eswitch_br_fdb_entry_delete(struct ice_esw_br * bridge,struct ice_esw_br_fdb_entry * fdb_entry)329 ice_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
343 static void
ice_eswitch_br_fdb_offload_notify(struct net_device * dev,const unsigned char * mac,u16 vid,unsigned long val)344 ice_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
357 static void
ice_eswitch_br_fdb_entry_notify_and_cleanup(struct ice_esw_br * bridge,struct ice_esw_br_fdb_entry * entry)358 ice_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
368 static void
ice_eswitch_br_fdb_entry_find_and_delete(struct ice_esw_br * bridge,const unsigned char * mac,u16 vid)369 ice_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
387 static void
ice_eswitch_br_fdb_entry_create(struct net_device * netdev,struct ice_esw_br_port * br_port,bool added_by_user,const unsigned char * mac,u16 vid)388 ice_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
459 err_fdb_insert:
460 ice_eswitch_br_flow_delete(pf, flow);
461 err_add_flow:
462 kfree(fdb_entry);
463 err_exit:
464 dev_err(dev, "Failed to create fdb entry, err: %d\n", err);
465 }
466
467 static void
ice_eswitch_br_fdb_work_dealloc(struct ice_esw_br_fdb_work * fdb_work)468 ice_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
474 static void
ice_eswitch_br_fdb_event_work(struct work_struct * work)475 ice_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
502 err_exit:
503 rtnl_unlock();
504 dev_put(fdb_work->dev);
505 ice_eswitch_br_fdb_work_dealloc(fdb_work);
506 }
507
508 static struct ice_esw_br_fdb_work *
ice_eswitch_br_fdb_work_alloc(struct switchdev_notifier_fdb_info * fdb_info,struct net_device * dev,unsigned long event)509 ice_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
537 static int
ice_eswitch_br_switchdev_event(struct notifier_block * nb,unsigned long event,void * ptr)538 ice_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
ice_eswitch_br_fdb_flush(struct ice_esw_br * bridge)585 static 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
593 static void
ice_eswitch_br_vlan_filtering_set(struct ice_esw_br * bridge,bool enable)594 ice_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
606 static void
ice_eswitch_br_clear_pvid(struct ice_esw_br_port * port)607 ice_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
622 static void
ice_eswitch_br_vlan_cleanup(struct ice_esw_br_port * port,struct ice_esw_br_vlan * vlan)623 ice_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
ice_eswitch_br_port_vlans_flush(struct ice_esw_br_port * port)642 static 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
651 static int
ice_eswitch_br_set_pvid(struct ice_esw_br_port * port,struct ice_esw_br_vlan * vlan)652 ice_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
691 static struct ice_esw_br_vlan *
ice_eswitch_br_vlan_create(u16 vid,u16 flags,struct ice_esw_br_port * port)692 ice_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
724 err_insert:
725 if (port->pvid)
726 ice_eswitch_br_clear_pvid(port);
727 err_set_pvid:
728 kfree(vlan);
729 return ERR_PTR(err);
730 }
731
732 static int
ice_eswitch_br_port_vlan_add(struct ice_esw_br * bridge,u16 vsi_idx,u16 vid,u16 flags,struct netlink_ext_ack * extack)733 ice_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
768 static void
ice_eswitch_br_port_vlan_del(struct ice_esw_br * bridge,u16 vsi_idx,u16 vid)769 ice_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
785 static int
ice_eswitch_br_port_obj_add(struct net_device * netdev,const void * ctx,const struct switchdev_obj * obj,struct netlink_ext_ack * extack)786 ice_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
809 static int
ice_eswitch_br_port_obj_del(struct net_device * netdev,const void * ctx,const struct switchdev_obj * obj)810 ice_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
830 static int
ice_eswitch_br_port_obj_attr_set(struct net_device * netdev,const void * ctx,const struct switchdev_attr * attr,struct netlink_ext_ack * extack)831 ice_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
854 static int
ice_eswitch_br_event_blocking(struct notifier_block * nb,unsigned long event,void * ptr)855 ice_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
884 static void
ice_eswitch_br_port_deinit(struct ice_esw_br * bridge,struct ice_esw_br_port * br_port)885 ice_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 =
900 ice_repr_get(vsi->back, br_port->repr_id);
901
902 if (repr)
903 repr->br_port = NULL;
904 }
905
906 xa_erase(&bridge->ports, br_port->vsi_idx);
907 ice_eswitch_br_port_vlans_flush(br_port);
908 kfree(br_port);
909 }
910
911 static struct ice_esw_br_port *
ice_eswitch_br_port_init(struct ice_esw_br * bridge)912 ice_eswitch_br_port_init(struct ice_esw_br *bridge)
913 {
914 struct ice_esw_br_port *br_port;
915
916 br_port = kzalloc(sizeof(*br_port), GFP_KERNEL);
917 if (!br_port)
918 return ERR_PTR(-ENOMEM);
919
920 xa_init(&br_port->vlans);
921
922 br_port->bridge = bridge;
923
924 return br_port;
925 }
926
927 static int
ice_eswitch_br_vf_repr_port_init(struct ice_esw_br * bridge,struct ice_repr * repr)928 ice_eswitch_br_vf_repr_port_init(struct ice_esw_br *bridge,
929 struct ice_repr *repr)
930 {
931 struct ice_esw_br_port *br_port;
932 int err;
933
934 br_port = ice_eswitch_br_port_init(bridge);
935 if (IS_ERR(br_port))
936 return PTR_ERR(br_port);
937
938 br_port->vsi = repr->src_vsi;
939 br_port->vsi_idx = br_port->vsi->idx;
940 br_port->type = ICE_ESWITCH_BR_VF_REPR_PORT;
941 br_port->repr_id = repr->id;
942 repr->br_port = br_port;
943
944 err = xa_insert(&bridge->ports, br_port->vsi_idx, br_port, GFP_KERNEL);
945 if (err) {
946 ice_eswitch_br_port_deinit(bridge, br_port);
947 return err;
948 }
949
950 return 0;
951 }
952
953 static int
ice_eswitch_br_uplink_port_init(struct ice_esw_br * bridge,struct ice_pf * pf)954 ice_eswitch_br_uplink_port_init(struct ice_esw_br *bridge, struct ice_pf *pf)
955 {
956 struct ice_vsi *vsi = pf->eswitch.uplink_vsi;
957 struct ice_esw_br_port *br_port;
958 int err;
959
960 br_port = ice_eswitch_br_port_init(bridge);
961 if (IS_ERR(br_port))
962 return PTR_ERR(br_port);
963
964 br_port->vsi = vsi;
965 br_port->vsi_idx = br_port->vsi->idx;
966 br_port->type = ICE_ESWITCH_BR_UPLINK_PORT;
967 pf->br_port = br_port;
968
969 err = xa_insert(&bridge->ports, br_port->vsi_idx, br_port, GFP_KERNEL);
970 if (err) {
971 ice_eswitch_br_port_deinit(bridge, br_port);
972 return err;
973 }
974
975 return 0;
976 }
977
978 static void
ice_eswitch_br_ports_flush(struct ice_esw_br * bridge)979 ice_eswitch_br_ports_flush(struct ice_esw_br *bridge)
980 {
981 struct ice_esw_br_port *port;
982 unsigned long i;
983
984 xa_for_each(&bridge->ports, i, port)
985 ice_eswitch_br_port_deinit(bridge, port);
986 }
987
988 static void
ice_eswitch_br_deinit(struct ice_esw_br_offloads * br_offloads,struct ice_esw_br * bridge)989 ice_eswitch_br_deinit(struct ice_esw_br_offloads *br_offloads,
990 struct ice_esw_br *bridge)
991 {
992 if (!bridge)
993 return;
994
995 /* Cleanup all the ports that were added asynchronously
996 * through NETDEV_CHANGEUPPER event.
997 */
998 ice_eswitch_br_ports_flush(bridge);
999 WARN_ON(!xa_empty(&bridge->ports));
1000 xa_destroy(&bridge->ports);
1001 rhashtable_destroy(&bridge->fdb_ht);
1002
1003 br_offloads->bridge = NULL;
1004 kfree(bridge);
1005 }
1006
1007 static struct ice_esw_br *
ice_eswitch_br_init(struct ice_esw_br_offloads * br_offloads,int ifindex)1008 ice_eswitch_br_init(struct ice_esw_br_offloads *br_offloads, int ifindex)
1009 {
1010 struct ice_esw_br *bridge;
1011 int err;
1012
1013 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
1014 if (!bridge)
1015 return ERR_PTR(-ENOMEM);
1016
1017 err = rhashtable_init(&bridge->fdb_ht, &ice_fdb_ht_params);
1018 if (err) {
1019 kfree(bridge);
1020 return ERR_PTR(err);
1021 }
1022
1023 INIT_LIST_HEAD(&bridge->fdb_list);
1024 bridge->br_offloads = br_offloads;
1025 bridge->ifindex = ifindex;
1026 bridge->ageing_time = clock_t_to_jiffies(BR_DEFAULT_AGEING_TIME);
1027 xa_init(&bridge->ports);
1028 br_offloads->bridge = bridge;
1029
1030 return bridge;
1031 }
1032
1033 static struct ice_esw_br *
ice_eswitch_br_get(struct ice_esw_br_offloads * br_offloads,int ifindex,struct netlink_ext_ack * extack)1034 ice_eswitch_br_get(struct ice_esw_br_offloads *br_offloads, int ifindex,
1035 struct netlink_ext_ack *extack)
1036 {
1037 struct ice_esw_br *bridge = br_offloads->bridge;
1038
1039 if (bridge) {
1040 if (bridge->ifindex != ifindex) {
1041 NL_SET_ERR_MSG_MOD(extack,
1042 "Only one bridge is supported per eswitch");
1043 return ERR_PTR(-EOPNOTSUPP);
1044 }
1045 return bridge;
1046 }
1047
1048 /* Create the bridge if it doesn't exist yet */
1049 bridge = ice_eswitch_br_init(br_offloads, ifindex);
1050 if (IS_ERR(bridge))
1051 NL_SET_ERR_MSG_MOD(extack, "Failed to init the bridge");
1052
1053 return bridge;
1054 }
1055
1056 static void
ice_eswitch_br_verify_deinit(struct ice_esw_br_offloads * br_offloads,struct ice_esw_br * bridge)1057 ice_eswitch_br_verify_deinit(struct ice_esw_br_offloads *br_offloads,
1058 struct ice_esw_br *bridge)
1059 {
1060 /* Remove the bridge if it exists and there are no ports left */
1061 if (!bridge || !xa_empty(&bridge->ports))
1062 return;
1063
1064 ice_eswitch_br_deinit(br_offloads, bridge);
1065 }
1066
1067 static int
ice_eswitch_br_port_unlink(struct ice_esw_br_offloads * br_offloads,struct net_device * dev,int ifindex,struct netlink_ext_ack * extack)1068 ice_eswitch_br_port_unlink(struct ice_esw_br_offloads *br_offloads,
1069 struct net_device *dev, int ifindex,
1070 struct netlink_ext_ack *extack)
1071 {
1072 struct ice_esw_br_port *br_port = ice_eswitch_br_netdev_to_port(dev);
1073 struct ice_esw_br *bridge;
1074
1075 if (!br_port) {
1076 NL_SET_ERR_MSG_MOD(extack,
1077 "Port representor is not attached to any bridge");
1078 return -EINVAL;
1079 }
1080
1081 if (br_port->bridge->ifindex != ifindex) {
1082 NL_SET_ERR_MSG_MOD(extack,
1083 "Port representor is attached to another bridge");
1084 return -EINVAL;
1085 }
1086
1087 bridge = br_port->bridge;
1088
1089 trace_ice_eswitch_br_port_unlink(br_port);
1090 ice_eswitch_br_port_deinit(br_port->bridge, br_port);
1091 ice_eswitch_br_verify_deinit(br_offloads, bridge);
1092
1093 return 0;
1094 }
1095
1096 static int
ice_eswitch_br_port_link(struct ice_esw_br_offloads * br_offloads,struct net_device * dev,int ifindex,struct netlink_ext_ack * extack)1097 ice_eswitch_br_port_link(struct ice_esw_br_offloads *br_offloads,
1098 struct net_device *dev, int ifindex,
1099 struct netlink_ext_ack *extack)
1100 {
1101 struct ice_esw_br *bridge;
1102 int err;
1103
1104 if (ice_eswitch_br_netdev_to_port(dev)) {
1105 NL_SET_ERR_MSG_MOD(extack,
1106 "Port is already attached to the bridge");
1107 return -EINVAL;
1108 }
1109
1110 bridge = ice_eswitch_br_get(br_offloads, ifindex, extack);
1111 if (IS_ERR(bridge))
1112 return PTR_ERR(bridge);
1113
1114 if (ice_is_port_repr_netdev(dev)) {
1115 struct ice_repr *repr = ice_netdev_to_repr(dev);
1116
1117 err = ice_eswitch_br_vf_repr_port_init(bridge, repr);
1118 trace_ice_eswitch_br_port_link(repr->br_port);
1119 } else {
1120 struct net_device *ice_dev;
1121 struct ice_pf *pf;
1122
1123 if (netif_is_lag_master(dev))
1124 ice_dev = ice_eswitch_br_get_uplink_from_lag(dev);
1125 else
1126 ice_dev = dev;
1127
1128 if (!ice_dev)
1129 return 0;
1130
1131 pf = ice_netdev_to_pf(ice_dev);
1132
1133 err = ice_eswitch_br_uplink_port_init(bridge, pf);
1134 trace_ice_eswitch_br_port_link(pf->br_port);
1135 }
1136 if (err) {
1137 NL_SET_ERR_MSG_MOD(extack, "Failed to init bridge port");
1138 goto err_port_init;
1139 }
1140
1141 return 0;
1142
1143 err_port_init:
1144 ice_eswitch_br_verify_deinit(br_offloads, bridge);
1145 return err;
1146 }
1147
1148 static int
ice_eswitch_br_port_changeupper(struct notifier_block * nb,void * ptr)1149 ice_eswitch_br_port_changeupper(struct notifier_block *nb, void *ptr)
1150 {
1151 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1152 struct netdev_notifier_changeupper_info *info = ptr;
1153 struct ice_esw_br_offloads *br_offloads;
1154 struct netlink_ext_ack *extack;
1155 struct net_device *upper;
1156
1157 br_offloads = ice_nb_to_br_offloads(nb, netdev_nb);
1158
1159 if (!ice_eswitch_br_is_dev_valid(dev))
1160 return 0;
1161
1162 upper = info->upper_dev;
1163 if (!netif_is_bridge_master(upper))
1164 return 0;
1165
1166 extack = netdev_notifier_info_to_extack(&info->info);
1167
1168 if (info->linking)
1169 return ice_eswitch_br_port_link(br_offloads, dev,
1170 upper->ifindex, extack);
1171 else
1172 return ice_eswitch_br_port_unlink(br_offloads, dev,
1173 upper->ifindex, extack);
1174 }
1175
1176 static int
ice_eswitch_br_port_event(struct notifier_block * nb,unsigned long event,void * ptr)1177 ice_eswitch_br_port_event(struct notifier_block *nb,
1178 unsigned long event, void *ptr)
1179 {
1180 int err = 0;
1181
1182 switch (event) {
1183 case NETDEV_CHANGEUPPER:
1184 err = ice_eswitch_br_port_changeupper(nb, ptr);
1185 break;
1186 }
1187
1188 return notifier_from_errno(err);
1189 }
1190
1191 static void
ice_eswitch_br_offloads_dealloc(struct ice_pf * pf)1192 ice_eswitch_br_offloads_dealloc(struct ice_pf *pf)
1193 {
1194 struct ice_esw_br_offloads *br_offloads = pf->eswitch.br_offloads;
1195
1196 ASSERT_RTNL();
1197
1198 if (!br_offloads)
1199 return;
1200
1201 ice_eswitch_br_deinit(br_offloads, br_offloads->bridge);
1202
1203 pf->eswitch.br_offloads = NULL;
1204 kfree(br_offloads);
1205 }
1206
1207 static struct ice_esw_br_offloads *
ice_eswitch_br_offloads_alloc(struct ice_pf * pf)1208 ice_eswitch_br_offloads_alloc(struct ice_pf *pf)
1209 {
1210 struct ice_esw_br_offloads *br_offloads;
1211
1212 ASSERT_RTNL();
1213
1214 if (pf->eswitch.br_offloads)
1215 return ERR_PTR(-EEXIST);
1216
1217 br_offloads = kzalloc(sizeof(*br_offloads), GFP_KERNEL);
1218 if (!br_offloads)
1219 return ERR_PTR(-ENOMEM);
1220
1221 pf->eswitch.br_offloads = br_offloads;
1222 br_offloads->pf = pf;
1223
1224 return br_offloads;
1225 }
1226
1227 void
ice_eswitch_br_offloads_deinit(struct ice_pf * pf)1228 ice_eswitch_br_offloads_deinit(struct ice_pf *pf)
1229 {
1230 struct ice_esw_br_offloads *br_offloads;
1231
1232 br_offloads = pf->eswitch.br_offloads;
1233 if (!br_offloads)
1234 return;
1235
1236 cancel_delayed_work_sync(&br_offloads->update_work);
1237 unregister_netdevice_notifier(&br_offloads->netdev_nb);
1238 unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
1239 unregister_switchdev_notifier(&br_offloads->switchdev_nb);
1240 destroy_workqueue(br_offloads->wq);
1241 /* Although notifier block is unregistered just before,
1242 * so we don't get any new events, some events might be
1243 * already in progress. Hold the rtnl lock and wait for
1244 * them to finished.
1245 */
1246 rtnl_lock();
1247 ice_eswitch_br_offloads_dealloc(pf);
1248 rtnl_unlock();
1249 }
1250
ice_eswitch_br_update(struct ice_esw_br_offloads * br_offloads)1251 static void ice_eswitch_br_update(struct ice_esw_br_offloads *br_offloads)
1252 {
1253 struct ice_esw_br *bridge = br_offloads->bridge;
1254 struct ice_esw_br_fdb_entry *entry, *tmp;
1255
1256 if (!bridge)
1257 return;
1258
1259 rtnl_lock();
1260 list_for_each_entry_safe(entry, tmp, &bridge->fdb_list, list) {
1261 if (entry->flags & ICE_ESWITCH_BR_FDB_ADDED_BY_USER)
1262 continue;
1263
1264 if (time_is_after_eq_jiffies(entry->last_use +
1265 bridge->ageing_time))
1266 continue;
1267
1268 ice_eswitch_br_fdb_entry_notify_and_cleanup(bridge, entry);
1269 }
1270 rtnl_unlock();
1271 }
1272
ice_eswitch_br_update_work(struct work_struct * work)1273 static void ice_eswitch_br_update_work(struct work_struct *work)
1274 {
1275 struct ice_esw_br_offloads *br_offloads;
1276
1277 br_offloads = ice_work_to_br_offloads(work);
1278
1279 ice_eswitch_br_update(br_offloads);
1280
1281 queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
1282 ICE_ESW_BRIDGE_UPDATE_INTERVAL);
1283 }
1284
1285 int
ice_eswitch_br_offloads_init(struct ice_pf * pf)1286 ice_eswitch_br_offloads_init(struct ice_pf *pf)
1287 {
1288 struct ice_esw_br_offloads *br_offloads;
1289 struct device *dev = ice_pf_to_dev(pf);
1290 int err;
1291
1292 rtnl_lock();
1293 br_offloads = ice_eswitch_br_offloads_alloc(pf);
1294 rtnl_unlock();
1295 if (IS_ERR(br_offloads)) {
1296 dev_err(dev, "Failed to init eswitch bridge\n");
1297 return PTR_ERR(br_offloads);
1298 }
1299
1300 br_offloads->wq = alloc_ordered_workqueue("ice_bridge_wq", 0);
1301 if (!br_offloads->wq) {
1302 err = -ENOMEM;
1303 dev_err(dev, "Failed to allocate bridge workqueue\n");
1304 goto err_alloc_wq;
1305 }
1306
1307 br_offloads->switchdev_nb.notifier_call =
1308 ice_eswitch_br_switchdev_event;
1309 err = register_switchdev_notifier(&br_offloads->switchdev_nb);
1310 if (err) {
1311 dev_err(dev,
1312 "Failed to register switchdev notifier\n");
1313 goto err_reg_switchdev_nb;
1314 }
1315
1316 br_offloads->switchdev_blk.notifier_call =
1317 ice_eswitch_br_event_blocking;
1318 err = register_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
1319 if (err) {
1320 dev_err(dev,
1321 "Failed to register bridge blocking switchdev notifier\n");
1322 goto err_reg_switchdev_blk;
1323 }
1324
1325 br_offloads->netdev_nb.notifier_call = ice_eswitch_br_port_event;
1326 err = register_netdevice_notifier(&br_offloads->netdev_nb);
1327 if (err) {
1328 dev_err(dev,
1329 "Failed to register bridge port event notifier\n");
1330 goto err_reg_netdev_nb;
1331 }
1332
1333 INIT_DELAYED_WORK(&br_offloads->update_work,
1334 ice_eswitch_br_update_work);
1335 queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
1336 ICE_ESW_BRIDGE_UPDATE_INTERVAL);
1337
1338 return 0;
1339
1340 err_reg_netdev_nb:
1341 unregister_switchdev_blocking_notifier(&br_offloads->switchdev_blk);
1342 err_reg_switchdev_blk:
1343 unregister_switchdev_notifier(&br_offloads->switchdev_nb);
1344 err_reg_switchdev_nb:
1345 destroy_workqueue(br_offloads->wq);
1346 err_alloc_wq:
1347 rtnl_lock();
1348 ice_eswitch_br_offloads_dealloc(pf);
1349 rtnl_unlock();
1350
1351 return err;
1352 }
1353