drivers/net/ethernet/mellanox/mlx5/core/en/rep/bridge.c

   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
  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
  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 *
  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 *
  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         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
  86 static struct net_device *
  87 mlx5_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
 112 static 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
 128 static 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
 167 static 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
 184 static int
 185 mlx5_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
 213 static int
 214 mlx5_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
 239 static int
 240 mlx5_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
 279 static 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
 305 static void
 306 mlx5_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
 313 static 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
 337 out:
 338         rtnl_unlock();
 339         mlx5_esw_bridge_cleanup_switchdev_fdb_work(fdb_work);
 340 }
 341
 342 static struct mlx5_bridge_switchdev_fdb_work *
 343 mlx5_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
 372 static 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                 /* only handle the event on native eswtich of representor */
 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                 /* only handle the event on peers */
 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
 443 static 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
 457 void 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
 505 err_register_netdev:
 506         unregister_switchdev_blocking_notifier(&br_offloads->nb_blk);
 507 err_register_swdev_blk:
 508         unregister_switchdev_notifier(&br_offloads->nb);
 509 err_register_swdev:
 510         destroy_workqueue(br_offloads->wq);
 511 err_alloc_wq:
 512         mlx5_esw_bridge_cleanup(esw);
 513 }
 514
 515 void 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 }