1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
2 /* Copyright (c) 2021 Mellanox Technologies. */
3
4 #include <linux/netdevice.h>
5 #include <linux/if_bridge.h>
6 #include <net/netevent.h>
7 #include <net/switchdev.h>
8 #include "bridge.h"
9 #include "esw/bridge.h"
10 #include "en_rep.h"
11
12 #define MLX5_ESW_BRIDGE_UPDATE_INTERVAL 1000
13
14 struct mlx5_bridge_switchdev_fdb_work {
15 struct work_struct work;
16 struct switchdev_notifier_fdb_info fdb_info;
17 struct net_device *dev;
18 struct mlx5_esw_bridge_offloads *br_offloads;
19 bool add;
20 };
21
mlx5_esw_bridge_dev_same_esw(struct net_device * dev,struct mlx5_eswitch * esw)22 static bool mlx5_esw_bridge_dev_same_esw(struct net_device *dev, struct mlx5_eswitch *esw)
23 {
24 struct mlx5e_priv *priv = netdev_priv(dev);
25
26 return esw == priv->mdev->priv.eswitch;
27 }
28
mlx5_esw_bridge_dev_same_hw(struct net_device * dev,struct mlx5_eswitch * esw)29 static bool mlx5_esw_bridge_dev_same_hw(struct net_device *dev, struct mlx5_eswitch *esw)
30 {
31 struct mlx5e_priv *priv = netdev_priv(dev);
32 struct mlx5_core_dev *mdev, *esw_mdev;
33 u64 system_guid, esw_system_guid;
34
35 mdev = priv->mdev;
36 esw_mdev = esw->dev;
37
38 system_guid = mlx5_query_nic_system_image_guid(mdev);
39 esw_system_guid = mlx5_query_nic_system_image_guid(esw_mdev);
40
41 return system_guid == esw_system_guid;
42 }
43
44 static struct net_device *
mlx5_esw_bridge_lag_rep_get(struct net_device * dev,struct mlx5_eswitch * esw)45 mlx5_esw_bridge_lag_rep_get(struct net_device *dev, struct mlx5_eswitch *esw)
46 {
47 struct net_device *lower;
48 struct list_head *iter;
49
50 netdev_for_each_lower_dev(dev, lower, iter) {
51 struct mlx5_core_dev *mdev;
52 struct mlx5e_priv *priv;
53
54 if (!mlx5e_eswitch_rep(lower))
55 continue;
56
57 priv = netdev_priv(lower);
58 mdev = priv->mdev;
59 if (mlx5_lag_is_shared_fdb(mdev) && mlx5_esw_bridge_dev_same_esw(lower, esw))
60 return lower;
61 }
62
63 return NULL;
64 }
65
66 static struct net_device *
mlx5_esw_bridge_rep_vport_num_vhca_id_get(struct net_device * dev,struct mlx5_eswitch * esw,u16 * vport_num,u16 * esw_owner_vhca_id)67 mlx5_esw_bridge_rep_vport_num_vhca_id_get(struct net_device *dev, struct mlx5_eswitch *esw,
68 u16 *vport_num, u16 *esw_owner_vhca_id)
69 {
70 struct mlx5e_rep_priv *rpriv;
71 struct mlx5e_priv *priv;
72
73 if (netif_is_lag_master(dev))
74 dev = mlx5_esw_bridge_lag_rep_get(dev, esw);
75
76 if (!dev || !mlx5e_eswitch_rep(dev) || !mlx5_esw_bridge_dev_same_hw(dev, esw))
77 return NULL;
78
79 priv = netdev_priv(dev);
80
81 if (!priv->mdev->priv.eswitch->br_offloads)
82 return NULL;
83
84 rpriv = priv->ppriv;
85 *vport_num = rpriv->rep->vport;
86 *esw_owner_vhca_id = MLX5_CAP_GEN(priv->mdev, vhca_id);
87 return dev;
88 }
89
90 static struct net_device *
mlx5_esw_bridge_lower_rep_vport_num_vhca_id_get(struct net_device * dev,struct mlx5_eswitch * esw,u16 * vport_num,u16 * esw_owner_vhca_id)91 mlx5_esw_bridge_lower_rep_vport_num_vhca_id_get(struct net_device *dev, struct mlx5_eswitch *esw,
92 u16 *vport_num, u16 *esw_owner_vhca_id)
93 {
94 struct net_device *lower_dev;
95 struct list_head *iter;
96
97 if (netif_is_lag_master(dev) || mlx5e_eswitch_rep(dev))
98 return mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, esw, vport_num,
99 esw_owner_vhca_id);
100
101 netdev_for_each_lower_dev(dev, lower_dev, iter) {
102 struct net_device *rep;
103
104 if (netif_is_bridge_master(lower_dev))
105 continue;
106
107 rep = mlx5_esw_bridge_lower_rep_vport_num_vhca_id_get(lower_dev, esw, vport_num,
108 esw_owner_vhca_id);
109 if (rep)
110 return rep;
111 }
112
113 return NULL;
114 }
115
mlx5_esw_bridge_is_local(struct net_device * dev,struct net_device * rep,struct mlx5_eswitch * esw)116 static bool mlx5_esw_bridge_is_local(struct net_device *dev, struct net_device *rep,
117 struct mlx5_eswitch *esw)
118 {
119 struct mlx5_core_dev *mdev;
120 struct mlx5e_priv *priv;
121
122 if (!mlx5_esw_bridge_dev_same_esw(rep, esw))
123 return false;
124
125 priv = netdev_priv(rep);
126 mdev = priv->mdev;
127 if (netif_is_lag_master(dev))
128 return mlx5_lag_is_shared_fdb(mdev) && mlx5_lag_is_master(mdev);
129 return true;
130 }
131
mlx5_esw_bridge_port_changeupper(struct notifier_block * nb,void * ptr)132 static int mlx5_esw_bridge_port_changeupper(struct notifier_block *nb, void *ptr)
133 {
134 struct mlx5_esw_bridge_offloads *br_offloads = container_of(nb,
135 struct mlx5_esw_bridge_offloads,
136 netdev_nb);
137 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
138 struct netdev_notifier_changeupper_info *info = ptr;
139 struct net_device *upper = info->upper_dev, *rep;
140 struct mlx5_eswitch *esw = br_offloads->esw;
141 u16 vport_num, esw_owner_vhca_id;
142 struct netlink_ext_ack *extack;
143 int err = 0;
144
145 if (!netif_is_bridge_master(upper))
146 return 0;
147
148 rep = mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, esw, &vport_num, &esw_owner_vhca_id);
149 if (!rep)
150 return 0;
151
152 extack = netdev_notifier_info_to_extack(&info->info);
153
154 if (mlx5_esw_bridge_is_local(dev, rep, esw))
155 err = info->linking ?
156 mlx5_esw_bridge_vport_link(upper, vport_num, esw_owner_vhca_id,
157 br_offloads, extack) :
158 mlx5_esw_bridge_vport_unlink(upper, vport_num, esw_owner_vhca_id,
159 br_offloads, extack);
160 else if (mlx5_esw_bridge_dev_same_hw(rep, esw))
161 err = info->linking ?
162 mlx5_esw_bridge_vport_peer_link(upper, vport_num, esw_owner_vhca_id,
163 br_offloads, extack) :
164 mlx5_esw_bridge_vport_peer_unlink(upper, vport_num, esw_owner_vhca_id,
165 br_offloads, extack);
166
167 return err;
168 }
169
170 static int
mlx5_esw_bridge_changeupper_validate_netdev(void * ptr)171 mlx5_esw_bridge_changeupper_validate_netdev(void *ptr)
172 {
173 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
174 struct netdev_notifier_changeupper_info *info = ptr;
175 struct net_device *upper = info->upper_dev;
176 struct net_device *lower;
177 struct list_head *iter;
178
179 if (!netif_is_bridge_master(upper) || !netif_is_lag_master(dev))
180 return 0;
181
182 netdev_for_each_lower_dev(dev, lower, iter) {
183 struct mlx5_core_dev *mdev;
184 struct mlx5e_priv *priv;
185
186 if (!mlx5e_eswitch_rep(lower))
187 continue;
188
189 priv = netdev_priv(lower);
190 mdev = priv->mdev;
191 if (!mlx5_lag_is_active(mdev))
192 return -EAGAIN;
193 if (!mlx5_lag_is_shared_fdb(mdev))
194 return -EOPNOTSUPP;
195 }
196
197 return 0;
198 }
199
mlx5_esw_bridge_switchdev_port_event(struct notifier_block * nb,unsigned long event,void * ptr)200 static int mlx5_esw_bridge_switchdev_port_event(struct notifier_block *nb,
201 unsigned long event, void *ptr)
202 {
203 int err = 0;
204
205 switch (event) {
206 case NETDEV_PRECHANGEUPPER:
207 err = mlx5_esw_bridge_changeupper_validate_netdev(ptr);
208 break;
209
210 case NETDEV_CHANGEUPPER:
211 err = mlx5_esw_bridge_port_changeupper(nb, ptr);
212 break;
213 }
214
215 return notifier_from_errno(err);
216 }
217
218 static int
mlx5_esw_bridge_port_obj_add(struct net_device * dev,struct switchdev_notifier_port_obj_info * port_obj_info,struct mlx5_esw_bridge_offloads * br_offloads)219 mlx5_esw_bridge_port_obj_add(struct net_device *dev,
220 struct switchdev_notifier_port_obj_info *port_obj_info,
221 struct mlx5_esw_bridge_offloads *br_offloads)
222 {
223 struct netlink_ext_ack *extack = switchdev_notifier_info_to_extack(&port_obj_info->info);
224 const struct switchdev_obj *obj = port_obj_info->obj;
225 const struct switchdev_obj_port_vlan *vlan;
226 const struct switchdev_obj_port_mdb *mdb;
227 u16 vport_num, esw_owner_vhca_id;
228 int err;
229
230 if (!mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, br_offloads->esw, &vport_num,
231 &esw_owner_vhca_id))
232 return 0;
233
234 port_obj_info->handled = true;
235
236 switch (obj->id) {
237 case SWITCHDEV_OBJ_ID_PORT_VLAN:
238 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
239 err = mlx5_esw_bridge_port_vlan_add(vport_num, esw_owner_vhca_id, vlan->vid,
240 vlan->flags, br_offloads, extack);
241 break;
242 case SWITCHDEV_OBJ_ID_PORT_MDB:
243 mdb = SWITCHDEV_OBJ_PORT_MDB(obj);
244 err = mlx5_esw_bridge_port_mdb_add(dev, vport_num, esw_owner_vhca_id, mdb->addr,
245 mdb->vid, br_offloads, extack);
246 break;
247 default:
248 return -EOPNOTSUPP;
249 }
250 return err;
251 }
252
253 static int
mlx5_esw_bridge_port_obj_del(struct net_device * dev,struct switchdev_notifier_port_obj_info * port_obj_info,struct mlx5_esw_bridge_offloads * br_offloads)254 mlx5_esw_bridge_port_obj_del(struct net_device *dev,
255 struct switchdev_notifier_port_obj_info *port_obj_info,
256 struct mlx5_esw_bridge_offloads *br_offloads)
257 {
258 const struct switchdev_obj *obj = port_obj_info->obj;
259 const struct switchdev_obj_port_vlan *vlan;
260 const struct switchdev_obj_port_mdb *mdb;
261 u16 vport_num, esw_owner_vhca_id;
262
263 if (!mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, br_offloads->esw, &vport_num,
264 &esw_owner_vhca_id))
265 return 0;
266
267 port_obj_info->handled = true;
268
269 switch (obj->id) {
270 case SWITCHDEV_OBJ_ID_PORT_VLAN:
271 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
272 mlx5_esw_bridge_port_vlan_del(vport_num, esw_owner_vhca_id, vlan->vid, br_offloads);
273 break;
274 case SWITCHDEV_OBJ_ID_PORT_MDB:
275 mdb = SWITCHDEV_OBJ_PORT_MDB(obj);
276 mlx5_esw_bridge_port_mdb_del(dev, vport_num, esw_owner_vhca_id, mdb->addr, mdb->vid,
277 br_offloads);
278 break;
279 default:
280 return -EOPNOTSUPP;
281 }
282 return 0;
283 }
284
285 static int
mlx5_esw_bridge_port_obj_attr_set(struct net_device * dev,struct switchdev_notifier_port_attr_info * port_attr_info,struct mlx5_esw_bridge_offloads * br_offloads)286 mlx5_esw_bridge_port_obj_attr_set(struct net_device *dev,
287 struct switchdev_notifier_port_attr_info *port_attr_info,
288 struct mlx5_esw_bridge_offloads *br_offloads)
289 {
290 struct netlink_ext_ack *extack = switchdev_notifier_info_to_extack(&port_attr_info->info);
291 const struct switchdev_attr *attr = port_attr_info->attr;
292 u16 vport_num, esw_owner_vhca_id;
293 int err = 0;
294
295 if (!mlx5_esw_bridge_lower_rep_vport_num_vhca_id_get(dev, br_offloads->esw, &vport_num,
296 &esw_owner_vhca_id))
297 return 0;
298
299 port_attr_info->handled = true;
300
301 switch (attr->id) {
302 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
303 if (attr->u.brport_flags.mask & ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD)) {
304 NL_SET_ERR_MSG_MOD(extack, "Flag is not supported");
305 err = -EINVAL;
306 }
307 break;
308 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
309 break;
310 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
311 err = mlx5_esw_bridge_ageing_time_set(vport_num, esw_owner_vhca_id,
312 attr->u.ageing_time, br_offloads);
313 break;
314 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
315 err = mlx5_esw_bridge_vlan_filtering_set(vport_num, esw_owner_vhca_id,
316 attr->u.vlan_filtering, br_offloads);
317 break;
318 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_PROTOCOL:
319 err = mlx5_esw_bridge_vlan_proto_set(vport_num,
320 esw_owner_vhca_id,
321 attr->u.vlan_protocol,
322 br_offloads);
323 break;
324 case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
325 err = mlx5_esw_bridge_mcast_set(vport_num, esw_owner_vhca_id,
326 !attr->u.mc_disabled, br_offloads);
327 break;
328 default:
329 err = -EOPNOTSUPP;
330 }
331
332 return err;
333 }
334
mlx5_esw_bridge_event_blocking(struct notifier_block * nb,unsigned long event,void * ptr)335 static int mlx5_esw_bridge_event_blocking(struct notifier_block *nb,
336 unsigned long event, void *ptr)
337 {
338 struct mlx5_esw_bridge_offloads *br_offloads = container_of(nb,
339 struct mlx5_esw_bridge_offloads,
340 nb_blk);
341 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
342 int err;
343
344 switch (event) {
345 case SWITCHDEV_PORT_OBJ_ADD:
346 err = mlx5_esw_bridge_port_obj_add(dev, ptr, br_offloads);
347 break;
348 case SWITCHDEV_PORT_OBJ_DEL:
349 err = mlx5_esw_bridge_port_obj_del(dev, ptr, br_offloads);
350 break;
351 case SWITCHDEV_PORT_ATTR_SET:
352 err = mlx5_esw_bridge_port_obj_attr_set(dev, ptr, br_offloads);
353 break;
354 default:
355 err = 0;
356 }
357
358 return notifier_from_errno(err);
359 }
360
361 static void
mlx5_esw_bridge_cleanup_switchdev_fdb_work(struct mlx5_bridge_switchdev_fdb_work * fdb_work)362 mlx5_esw_bridge_cleanup_switchdev_fdb_work(struct mlx5_bridge_switchdev_fdb_work *fdb_work)
363 {
364 dev_put(fdb_work->dev);
365 kfree(fdb_work->fdb_info.addr);
366 kfree(fdb_work);
367 }
368
mlx5_esw_bridge_switchdev_fdb_event_work(struct work_struct * work)369 static void mlx5_esw_bridge_switchdev_fdb_event_work(struct work_struct *work)
370 {
371 struct mlx5_bridge_switchdev_fdb_work *fdb_work =
372 container_of(work, struct mlx5_bridge_switchdev_fdb_work, work);
373 struct switchdev_notifier_fdb_info *fdb_info =
374 &fdb_work->fdb_info;
375 struct mlx5_esw_bridge_offloads *br_offloads =
376 fdb_work->br_offloads;
377 struct net_device *dev = fdb_work->dev;
378 u16 vport_num, esw_owner_vhca_id;
379
380 rtnl_lock();
381
382 if (!mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, br_offloads->esw, &vport_num,
383 &esw_owner_vhca_id))
384 goto out;
385
386 if (fdb_work->add)
387 mlx5_esw_bridge_fdb_create(dev, vport_num, esw_owner_vhca_id, br_offloads,
388 fdb_info);
389 else
390 mlx5_esw_bridge_fdb_remove(dev, vport_num, esw_owner_vhca_id, br_offloads,
391 fdb_info);
392
393 out:
394 rtnl_unlock();
395 mlx5_esw_bridge_cleanup_switchdev_fdb_work(fdb_work);
396 }
397
398 static struct mlx5_bridge_switchdev_fdb_work *
mlx5_esw_bridge_init_switchdev_fdb_work(struct net_device * dev,bool add,struct switchdev_notifier_fdb_info * fdb_info,struct mlx5_esw_bridge_offloads * br_offloads)399 mlx5_esw_bridge_init_switchdev_fdb_work(struct net_device *dev, bool add,
400 struct switchdev_notifier_fdb_info *fdb_info,
401 struct mlx5_esw_bridge_offloads *br_offloads)
402 {
403 struct mlx5_bridge_switchdev_fdb_work *work;
404 u8 *addr;
405
406 work = kzalloc(sizeof(*work), GFP_ATOMIC);
407 if (!work)
408 return ERR_PTR(-ENOMEM);
409
410 INIT_WORK(&work->work, mlx5_esw_bridge_switchdev_fdb_event_work);
411 memcpy(&work->fdb_info, fdb_info, sizeof(work->fdb_info));
412
413 addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
414 if (!addr) {
415 kfree(work);
416 return ERR_PTR(-ENOMEM);
417 }
418 ether_addr_copy(addr, fdb_info->addr);
419 work->fdb_info.addr = addr;
420
421 dev_hold(dev);
422 work->dev = dev;
423 work->br_offloads = br_offloads;
424 work->add = add;
425 return work;
426 }
427
mlx5_esw_bridge_switchdev_event(struct notifier_block * nb,unsigned long event,void * ptr)428 static int mlx5_esw_bridge_switchdev_event(struct notifier_block *nb,
429 unsigned long event, void *ptr)
430 {
431 struct mlx5_esw_bridge_offloads *br_offloads = container_of(nb,
432 struct mlx5_esw_bridge_offloads,
433 nb);
434 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
435 struct switchdev_notifier_fdb_info *fdb_info;
436 struct mlx5_bridge_switchdev_fdb_work *work;
437 struct mlx5_eswitch *esw = br_offloads->esw;
438 struct switchdev_notifier_info *info = ptr;
439 u16 vport_num, esw_owner_vhca_id;
440 struct net_device *upper, *rep;
441
442 if (event == SWITCHDEV_PORT_ATTR_SET) {
443 int err = mlx5_esw_bridge_port_obj_attr_set(dev, ptr, br_offloads);
444
445 return notifier_from_errno(err);
446 }
447
448 upper = netdev_master_upper_dev_get_rcu(dev);
449 if (!upper)
450 return NOTIFY_DONE;
451 if (!netif_is_bridge_master(upper))
452 return NOTIFY_DONE;
453
454 rep = mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, esw, &vport_num, &esw_owner_vhca_id);
455 if (!rep)
456 return NOTIFY_DONE;
457
458 switch (event) {
459 case SWITCHDEV_FDB_ADD_TO_BRIDGE:
460 fdb_info = container_of(info,
461 struct switchdev_notifier_fdb_info,
462 info);
463 mlx5_esw_bridge_fdb_update_used(dev, vport_num, esw_owner_vhca_id, br_offloads,
464 fdb_info);
465 break;
466 case SWITCHDEV_FDB_DEL_TO_BRIDGE:
467 /* only handle the event on peers */
468 if (mlx5_esw_bridge_is_local(dev, rep, esw))
469 break;
470
471 fdb_info = container_of(info,
472 struct switchdev_notifier_fdb_info,
473 info);
474 /* Mark for deletion to prevent the update wq task from
475 * spuriously refreshing the entry which would mark it again as
476 * offloaded in SW bridge. After this fallthrough to regular
477 * async delete code.
478 */
479 mlx5_esw_bridge_fdb_mark_deleted(dev, vport_num, esw_owner_vhca_id, br_offloads,
480 fdb_info);
481 fallthrough;
482 case SWITCHDEV_FDB_ADD_TO_DEVICE:
483 case SWITCHDEV_FDB_DEL_TO_DEVICE:
484 fdb_info = container_of(info,
485 struct switchdev_notifier_fdb_info,
486 info);
487
488 work = mlx5_esw_bridge_init_switchdev_fdb_work(dev,
489 event == SWITCHDEV_FDB_ADD_TO_DEVICE,
490 fdb_info,
491 br_offloads);
492 if (IS_ERR(work)) {
493 WARN_ONCE(1, "Failed to init switchdev work, err=%ld",
494 PTR_ERR(work));
495 return notifier_from_errno(PTR_ERR(work));
496 }
497
498 queue_work(br_offloads->wq, &work->work);
499 break;
500 default:
501 break;
502 }
503 return NOTIFY_DONE;
504 }
505
mlx5_esw_bridge_update_work(struct work_struct * work)506 static void mlx5_esw_bridge_update_work(struct work_struct *work)
507 {
508 struct mlx5_esw_bridge_offloads *br_offloads = container_of(work,
509 struct mlx5_esw_bridge_offloads,
510 update_work.work);
511
512 rtnl_lock();
513 mlx5_esw_bridge_update(br_offloads);
514 rtnl_unlock();
515
516 queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
517 msecs_to_jiffies(MLX5_ESW_BRIDGE_UPDATE_INTERVAL));
518 }
519
mlx5e_rep_bridge_init(struct mlx5e_priv * priv)520 void mlx5e_rep_bridge_init(struct mlx5e_priv *priv)
521 {
522 struct mlx5_esw_bridge_offloads *br_offloads;
523 struct mlx5_core_dev *mdev = priv->mdev;
524 struct mlx5_eswitch *esw =
525 mdev->priv.eswitch;
526 int err;
527
528 rtnl_lock();
529 br_offloads = mlx5_esw_bridge_init(esw);
530 rtnl_unlock();
531 if (IS_ERR(br_offloads)) {
532 esw_warn(mdev, "Failed to init esw bridge (err=%ld)\n", PTR_ERR(br_offloads));
533 return;
534 }
535
536 br_offloads->wq = alloc_ordered_workqueue("mlx5_bridge_wq", 0);
537 if (!br_offloads->wq) {
538 esw_warn(mdev, "Failed to allocate bridge offloads workqueue\n");
539 goto err_alloc_wq;
540 }
541
542 br_offloads->nb.notifier_call = mlx5_esw_bridge_switchdev_event;
543 err = register_switchdev_notifier(&br_offloads->nb);
544 if (err) {
545 esw_warn(mdev, "Failed to register switchdev notifier (err=%d)\n", err);
546 goto err_register_swdev;
547 }
548
549 br_offloads->nb_blk.notifier_call = mlx5_esw_bridge_event_blocking;
550 err = register_switchdev_blocking_notifier(&br_offloads->nb_blk);
551 if (err) {
552 esw_warn(mdev, "Failed to register blocking switchdev notifier (err=%d)\n", err);
553 goto err_register_swdev_blk;
554 }
555
556 br_offloads->netdev_nb.notifier_call = mlx5_esw_bridge_switchdev_port_event;
557 err = register_netdevice_notifier_net(&init_net, &br_offloads->netdev_nb);
558 if (err) {
559 esw_warn(mdev, "Failed to register bridge offloads netdevice notifier (err=%d)\n",
560 err);
561 goto err_register_netdev;
562 }
563 INIT_DELAYED_WORK(&br_offloads->update_work, mlx5_esw_bridge_update_work);
564 queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
565 msecs_to_jiffies(MLX5_ESW_BRIDGE_UPDATE_INTERVAL));
566 return;
567
568 err_register_netdev:
569 unregister_switchdev_blocking_notifier(&br_offloads->nb_blk);
570 err_register_swdev_blk:
571 unregister_switchdev_notifier(&br_offloads->nb);
572 err_register_swdev:
573 destroy_workqueue(br_offloads->wq);
574 err_alloc_wq:
575 rtnl_lock();
576 mlx5_esw_bridge_cleanup(esw);
577 rtnl_unlock();
578 }
579
mlx5e_rep_bridge_cleanup(struct mlx5e_priv * priv)580 void mlx5e_rep_bridge_cleanup(struct mlx5e_priv *priv)
581 {
582 struct mlx5_esw_bridge_offloads *br_offloads;
583 struct mlx5_core_dev *mdev = priv->mdev;
584 struct mlx5_eswitch *esw =
585 mdev->priv.eswitch;
586
587 br_offloads = esw->br_offloads;
588 if (!br_offloads)
589 return;
590
591 cancel_delayed_work_sync(&br_offloads->update_work);
592 unregister_netdevice_notifier_net(&init_net, &br_offloads->netdev_nb);
593 unregister_switchdev_blocking_notifier(&br_offloads->nb_blk);
594 unregister_switchdev_notifier(&br_offloads->nb);
595 destroy_workqueue(br_offloads->wq);
596 rtnl_lock();
597 mlx5_esw_bridge_cleanup(esw);
598 rtnl_unlock();
599 }
600