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