1
2
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
14struct 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
22static 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
29static 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
44static struct net_device *
45mlx5_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
66static struct net_device *
67mlx5_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 rpriv = priv->ppriv;
81 *vport_num = rpriv->rep->vport;
82 *esw_owner_vhca_id = MLX5_CAP_GEN(priv->mdev, vhca_id);
83 return dev;
84}
85
86static struct net_device *
87mlx5_esw_bridge_lower_rep_vport_num_vhca_id_get(struct net_device *dev, struct mlx5_eswitch *esw,
88 u16 *vport_num, u16 *esw_owner_vhca_id)
89{
90 struct net_device *lower_dev;
91 struct list_head *iter;
92
93 if (netif_is_lag_master(dev) || mlx5e_eswitch_rep(dev))
94 return mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, esw, vport_num,
95 esw_owner_vhca_id);
96
97 netdev_for_each_lower_dev(dev, lower_dev, iter) {
98 struct net_device *rep;
99
100 if (netif_is_bridge_master(lower_dev))
101 continue;
102
103 rep = mlx5_esw_bridge_lower_rep_vport_num_vhca_id_get(lower_dev, esw, vport_num,
104 esw_owner_vhca_id);
105 if (rep)
106 return rep;
107 }
108
109 return NULL;
110}
111
112static bool mlx5_esw_bridge_is_local(struct net_device *dev, struct net_device *rep,
113 struct mlx5_eswitch *esw)
114{
115 struct mlx5_core_dev *mdev;
116 struct mlx5e_priv *priv;
117
118 if (!mlx5_esw_bridge_dev_same_esw(rep, esw))
119 return false;
120
121 priv = netdev_priv(rep);
122 mdev = priv->mdev;
123 if (netif_is_lag_master(dev))
124 return mlx5_lag_is_shared_fdb(mdev) && mlx5_lag_is_master(mdev);
125 return true;
126}
127
128static int mlx5_esw_bridge_port_changeupper(struct notifier_block *nb, void *ptr)
129{
130 struct mlx5_esw_bridge_offloads *br_offloads = container_of(nb,
131 struct mlx5_esw_bridge_offloads,
132 netdev_nb);
133 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
134 struct netdev_notifier_changeupper_info *info = ptr;
135 struct net_device *upper = info->upper_dev, *rep;
136 struct mlx5_eswitch *esw = br_offloads->esw;
137 u16 vport_num, esw_owner_vhca_id;
138 struct netlink_ext_ack *extack;
139 int ifindex = upper->ifindex;
140 int err = 0;
141
142 if (!netif_is_bridge_master(upper))
143 return 0;
144
145 rep = mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, esw, &vport_num, &esw_owner_vhca_id);
146 if (!rep)
147 return 0;
148
149 extack = netdev_notifier_info_to_extack(&info->info);
150
151 if (mlx5_esw_bridge_is_local(dev, rep, esw))
152 err = info->linking ?
153 mlx5_esw_bridge_vport_link(ifindex, vport_num, esw_owner_vhca_id,
154 br_offloads, extack) :
155 mlx5_esw_bridge_vport_unlink(ifindex, vport_num, esw_owner_vhca_id,
156 br_offloads, extack);
157 else if (mlx5_esw_bridge_dev_same_hw(rep, esw))
158 err = info->linking ?
159 mlx5_esw_bridge_vport_peer_link(ifindex, vport_num, esw_owner_vhca_id,
160 br_offloads, extack) :
161 mlx5_esw_bridge_vport_peer_unlink(ifindex, vport_num, esw_owner_vhca_id,
162 br_offloads, extack);
163
164 return err;
165}
166
167static int mlx5_esw_bridge_switchdev_port_event(struct notifier_block *nb,
168 unsigned long event, void *ptr)
169{
170 int err = 0;
171
172 switch (event) {
173 case NETDEV_PRECHANGEUPPER:
174 break;
175
176 case NETDEV_CHANGEUPPER:
177 err = mlx5_esw_bridge_port_changeupper(nb, ptr);
178 break;
179 }
180
181 return notifier_from_errno(err);
182}
183
184static int
185mlx5_esw_bridge_port_obj_add(struct net_device *dev,
186 struct switchdev_notifier_port_obj_info *port_obj_info,
187 struct mlx5_esw_bridge_offloads *br_offloads)
188{
189 struct netlink_ext_ack *extack = switchdev_notifier_info_to_extack(&port_obj_info->info);
190 const struct switchdev_obj *obj = port_obj_info->obj;
191 const struct switchdev_obj_port_vlan *vlan;
192 u16 vport_num, esw_owner_vhca_id;
193 int err;
194
195 if (!mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, br_offloads->esw, &vport_num,
196 &esw_owner_vhca_id))
197 return 0;
198
199 port_obj_info->handled = true;
200
201 switch (obj->id) {
202 case SWITCHDEV_OBJ_ID_PORT_VLAN:
203 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
204 err = mlx5_esw_bridge_port_vlan_add(vport_num, esw_owner_vhca_id, vlan->vid,
205 vlan->flags, br_offloads, extack);
206 break;
207 default:
208 return -EOPNOTSUPP;
209 }
210 return err;
211}
212
213static int
214mlx5_esw_bridge_port_obj_del(struct net_device *dev,
215 struct switchdev_notifier_port_obj_info *port_obj_info,
216 struct mlx5_esw_bridge_offloads *br_offloads)
217{
218 const struct switchdev_obj *obj = port_obj_info->obj;
219 const struct switchdev_obj_port_vlan *vlan;
220 u16 vport_num, esw_owner_vhca_id;
221
222 if (!mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, br_offloads->esw, &vport_num,
223 &esw_owner_vhca_id))
224 return 0;
225
226 port_obj_info->handled = true;
227
228 switch (obj->id) {
229 case SWITCHDEV_OBJ_ID_PORT_VLAN:
230 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
231 mlx5_esw_bridge_port_vlan_del(vport_num, esw_owner_vhca_id, vlan->vid, br_offloads);
232 break;
233 default:
234 return -EOPNOTSUPP;
235 }
236 return 0;
237}
238
239static int
240mlx5_esw_bridge_port_obj_attr_set(struct net_device *dev,
241 struct switchdev_notifier_port_attr_info *port_attr_info,
242 struct mlx5_esw_bridge_offloads *br_offloads)
243{
244 struct netlink_ext_ack *extack = switchdev_notifier_info_to_extack(&port_attr_info->info);
245 const struct switchdev_attr *attr = port_attr_info->attr;
246 u16 vport_num, esw_owner_vhca_id;
247 int err = 0;
248
249 if (!mlx5_esw_bridge_lower_rep_vport_num_vhca_id_get(dev, br_offloads->esw, &vport_num,
250 &esw_owner_vhca_id))
251 return 0;
252
253 port_attr_info->handled = true;
254
255 switch (attr->id) {
256 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
257 if (attr->u.brport_flags.mask & ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD)) {
258 NL_SET_ERR_MSG_MOD(extack, "Flag is not supported");
259 err = -EINVAL;
260 }
261 break;
262 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
263 break;
264 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
265 err = mlx5_esw_bridge_ageing_time_set(vport_num, esw_owner_vhca_id,
266 attr->u.ageing_time, br_offloads);
267 break;
268 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
269 err = mlx5_esw_bridge_vlan_filtering_set(vport_num, esw_owner_vhca_id,
270 attr->u.vlan_filtering, br_offloads);
271 break;
272 default:
273 err = -EOPNOTSUPP;
274 }
275
276 return err;
277}
278
279static int mlx5_esw_bridge_event_blocking(struct notifier_block *nb,
280 unsigned long event, void *ptr)
281{
282 struct mlx5_esw_bridge_offloads *br_offloads = container_of(nb,
283 struct mlx5_esw_bridge_offloads,
284 nb_blk);
285 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
286 int err;
287
288 switch (event) {
289 case SWITCHDEV_PORT_OBJ_ADD:
290 err = mlx5_esw_bridge_port_obj_add(dev, ptr, br_offloads);
291 break;
292 case SWITCHDEV_PORT_OBJ_DEL:
293 err = mlx5_esw_bridge_port_obj_del(dev, ptr, br_offloads);
294 break;
295 case SWITCHDEV_PORT_ATTR_SET:
296 err = mlx5_esw_bridge_port_obj_attr_set(dev, ptr, br_offloads);
297 break;
298 default:
299 err = 0;
300 }
301
302 return notifier_from_errno(err);
303}
304
305static void
306mlx5_esw_bridge_cleanup_switchdev_fdb_work(struct mlx5_bridge_switchdev_fdb_work *fdb_work)
307{
308 dev_put(fdb_work->dev);
309 kfree(fdb_work->fdb_info.addr);
310 kfree(fdb_work);
311}
312
313static void mlx5_esw_bridge_switchdev_fdb_event_work(struct work_struct *work)
314{
315 struct mlx5_bridge_switchdev_fdb_work *fdb_work =
316 container_of(work, struct mlx5_bridge_switchdev_fdb_work, work);
317 struct switchdev_notifier_fdb_info *fdb_info =
318 &fdb_work->fdb_info;
319 struct mlx5_esw_bridge_offloads *br_offloads =
320 fdb_work->br_offloads;
321 struct net_device *dev = fdb_work->dev;
322 u16 vport_num, esw_owner_vhca_id;
323
324 rtnl_lock();
325
326 if (!mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, br_offloads->esw, &vport_num,
327 &esw_owner_vhca_id))
328 goto out;
329
330 if (fdb_work->add)
331 mlx5_esw_bridge_fdb_create(dev, vport_num, esw_owner_vhca_id, br_offloads,
332 fdb_info);
333 else
334 mlx5_esw_bridge_fdb_remove(dev, vport_num, esw_owner_vhca_id, br_offloads,
335 fdb_info);
336
337out:
338 rtnl_unlock();
339 mlx5_esw_bridge_cleanup_switchdev_fdb_work(fdb_work);
340}
341
342static struct mlx5_bridge_switchdev_fdb_work *
343mlx5_esw_bridge_init_switchdev_fdb_work(struct net_device *dev, bool add,
344 struct switchdev_notifier_fdb_info *fdb_info,
345 struct mlx5_esw_bridge_offloads *br_offloads)
346{
347 struct mlx5_bridge_switchdev_fdb_work *work;
348 u8 *addr;
349
350 work = kzalloc(sizeof(*work), GFP_ATOMIC);
351 if (!work)
352 return ERR_PTR(-ENOMEM);
353
354 INIT_WORK(&work->work, mlx5_esw_bridge_switchdev_fdb_event_work);
355 memcpy(&work->fdb_info, fdb_info, sizeof(work->fdb_info));
356
357 addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
358 if (!addr) {
359 kfree(work);
360 return ERR_PTR(-ENOMEM);
361 }
362 ether_addr_copy(addr, fdb_info->addr);
363 work->fdb_info.addr = addr;
364
365 dev_hold(dev);
366 work->dev = dev;
367 work->br_offloads = br_offloads;
368 work->add = add;
369 return work;
370}
371
372static int mlx5_esw_bridge_switchdev_event(struct notifier_block *nb,
373 unsigned long event, void *ptr)
374{
375 struct mlx5_esw_bridge_offloads *br_offloads = container_of(nb,
376 struct mlx5_esw_bridge_offloads,
377 nb);
378 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
379 struct switchdev_notifier_fdb_info *fdb_info;
380 struct mlx5_bridge_switchdev_fdb_work *work;
381 struct mlx5_eswitch *esw = br_offloads->esw;
382 struct switchdev_notifier_info *info = ptr;
383 u16 vport_num, esw_owner_vhca_id;
384 struct net_device *upper, *rep;
385
386 if (event == SWITCHDEV_PORT_ATTR_SET) {
387 int err = mlx5_esw_bridge_port_obj_attr_set(dev, ptr, br_offloads);
388
389 return notifier_from_errno(err);
390 }
391
392 upper = netdev_master_upper_dev_get_rcu(dev);
393 if (!upper)
394 return NOTIFY_DONE;
395 if (!netif_is_bridge_master(upper))
396 return NOTIFY_DONE;
397
398 rep = mlx5_esw_bridge_rep_vport_num_vhca_id_get(dev, esw, &vport_num, &esw_owner_vhca_id);
399 if (!rep)
400 return NOTIFY_DONE;
401
402 switch (event) {
403 case SWITCHDEV_FDB_ADD_TO_BRIDGE:
404
405 if (!mlx5_esw_bridge_is_local(dev, rep, esw))
406 break;
407
408 fdb_info = container_of(info,
409 struct switchdev_notifier_fdb_info,
410 info);
411 mlx5_esw_bridge_fdb_update_used(dev, vport_num, esw_owner_vhca_id, br_offloads,
412 fdb_info);
413 break;
414 case SWITCHDEV_FDB_DEL_TO_BRIDGE:
415
416 if (mlx5_esw_bridge_is_local(dev, rep, esw))
417 break;
418 fallthrough;
419 case SWITCHDEV_FDB_ADD_TO_DEVICE:
420 case SWITCHDEV_FDB_DEL_TO_DEVICE:
421 fdb_info = container_of(info,
422 struct switchdev_notifier_fdb_info,
423 info);
424
425 work = mlx5_esw_bridge_init_switchdev_fdb_work(dev,
426 event == SWITCHDEV_FDB_ADD_TO_DEVICE,
427 fdb_info,
428 br_offloads);
429 if (IS_ERR(work)) {
430 WARN_ONCE(1, "Failed to init switchdev work, err=%ld",
431 PTR_ERR(work));
432 return notifier_from_errno(PTR_ERR(work));
433 }
434
435 queue_work(br_offloads->wq, &work->work);
436 break;
437 default:
438 break;
439 }
440 return NOTIFY_DONE;
441}
442
443static void mlx5_esw_bridge_update_work(struct work_struct *work)
444{
445 struct mlx5_esw_bridge_offloads *br_offloads = container_of(work,
446 struct mlx5_esw_bridge_offloads,
447 update_work.work);
448
449 rtnl_lock();
450 mlx5_esw_bridge_update(br_offloads);
451 rtnl_unlock();
452
453 queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
454 msecs_to_jiffies(MLX5_ESW_BRIDGE_UPDATE_INTERVAL));
455}
456
457void mlx5e_rep_bridge_init(struct mlx5e_priv *priv)
458{
459 struct mlx5_esw_bridge_offloads *br_offloads;
460 struct mlx5_core_dev *mdev = priv->mdev;
461 struct mlx5_eswitch *esw =
462 mdev->priv.eswitch;
463 int err;
464
465 rtnl_lock();
466 br_offloads = mlx5_esw_bridge_init(esw);
467 rtnl_unlock();
468 if (IS_ERR(br_offloads)) {
469 esw_warn(mdev, "Failed to init esw bridge (err=%ld)\n", PTR_ERR(br_offloads));
470 return;
471 }
472
473 br_offloads->wq = alloc_ordered_workqueue("mlx5_bridge_wq", 0);
474 if (!br_offloads->wq) {
475 esw_warn(mdev, "Failed to allocate bridge offloads workqueue\n");
476 goto err_alloc_wq;
477 }
478
479 br_offloads->nb.notifier_call = mlx5_esw_bridge_switchdev_event;
480 err = register_switchdev_notifier(&br_offloads->nb);
481 if (err) {
482 esw_warn(mdev, "Failed to register switchdev notifier (err=%d)\n", err);
483 goto err_register_swdev;
484 }
485
486 br_offloads->nb_blk.notifier_call = mlx5_esw_bridge_event_blocking;
487 err = register_switchdev_blocking_notifier(&br_offloads->nb_blk);
488 if (err) {
489 esw_warn(mdev, "Failed to register blocking switchdev notifier (err=%d)\n", err);
490 goto err_register_swdev_blk;
491 }
492
493 br_offloads->netdev_nb.notifier_call = mlx5_esw_bridge_switchdev_port_event;
494 err = register_netdevice_notifier(&br_offloads->netdev_nb);
495 if (err) {
496 esw_warn(mdev, "Failed to register bridge offloads netdevice notifier (err=%d)\n",
497 err);
498 goto err_register_netdev;
499 }
500 INIT_DELAYED_WORK(&br_offloads->update_work, mlx5_esw_bridge_update_work);
501 queue_delayed_work(br_offloads->wq, &br_offloads->update_work,
502 msecs_to_jiffies(MLX5_ESW_BRIDGE_UPDATE_INTERVAL));
503 return;
504
505err_register_netdev:
506 unregister_switchdev_blocking_notifier(&br_offloads->nb_blk);
507err_register_swdev_blk:
508 unregister_switchdev_notifier(&br_offloads->nb);
509err_register_swdev:
510 destroy_workqueue(br_offloads->wq);
511err_alloc_wq:
512 mlx5_esw_bridge_cleanup(esw);
513}
514
515void mlx5e_rep_bridge_cleanup(struct mlx5e_priv *priv)
516{
517 struct mlx5_esw_bridge_offloads *br_offloads;
518 struct mlx5_core_dev *mdev = priv->mdev;
519 struct mlx5_eswitch *esw =
520 mdev->priv.eswitch;
521
522 br_offloads = esw->br_offloads;
523 if (!br_offloads)
524 return;
525
526 cancel_delayed_work_sync(&br_offloads->update_work);
527 unregister_netdevice_notifier(&br_offloads->netdev_nb);
528 unregister_switchdev_blocking_notifier(&br_offloads->nb_blk);
529 unregister_switchdev_notifier(&br_offloads->nb);
530 destroy_workqueue(br_offloads->wq);
531 rtnl_lock();
532 mlx5_esw_bridge_cleanup(esw);
533 rtnl_unlock();
534}
535
