drivers/net/ethernet/mellanox/mlx5/core/vxlan.c

   1 /*
   2  * Copyright (c) 2016, Mellanox Technologies, Ltd.  All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/kernel.h>
  34 #include <linux/module.h>
  35 #include <linux/mlx5/driver.h>
  36 #include "mlx5_core.h"
  37 #include "vxlan.h"
  38
  39 static void mlx5e_vxlan_add_port(struct mlx5e_priv *priv, u16 port);
  40
  41 void mlx5e_vxlan_init(struct mlx5e_priv *priv)
  42 {
  43         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
  44
  45         spin_lock_init(&vxlan_db->lock);
  46         INIT_RADIX_TREE(&vxlan_db->tree, GFP_ATOMIC);
  47
  48         if (mlx5e_vxlan_allowed(priv->mdev))
  49                 /* Hardware adds 4789 by default.
  50                  * Lockless since we are the only hash table consumers, wq and TX are disabled.
  51                  */
  52                 mlx5e_vxlan_add_port(priv, 4789);
  53 }
  54
  55 static inline u8 mlx5e_vxlan_max_udp_ports(struct mlx5_core_dev *mdev)
  56 {
  57         return MLX5_CAP_ETH(mdev, max_vxlan_udp_ports) ?: 4;
  58 }
  59
  60 static int mlx5e_vxlan_core_add_port_cmd(struct mlx5_core_dev *mdev, u16 port)
  61 {
  62         u32 in[MLX5_ST_SZ_DW(add_vxlan_udp_dport_in)]   = {0};
  63         u32 out[MLX5_ST_SZ_DW(add_vxlan_udp_dport_out)] = {0};
  64
  65         MLX5_SET(add_vxlan_udp_dport_in, in, opcode,
  66                  MLX5_CMD_OP_ADD_VXLAN_UDP_DPORT);
  67         MLX5_SET(add_vxlan_udp_dport_in, in, vxlan_udp_port, port);
  68         return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
  69 }
  70
  71 static int mlx5e_vxlan_core_del_port_cmd(struct mlx5_core_dev *mdev, u16 port)
  72 {
  73         u32 in[MLX5_ST_SZ_DW(delete_vxlan_udp_dport_in)]   = {0};
  74         u32 out[MLX5_ST_SZ_DW(delete_vxlan_udp_dport_out)] = {0};
  75
  76         MLX5_SET(delete_vxlan_udp_dport_in, in, opcode,
  77                  MLX5_CMD_OP_DELETE_VXLAN_UDP_DPORT);
  78         MLX5_SET(delete_vxlan_udp_dport_in, in, vxlan_udp_port, port);
  79         return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
  80 }
  81
  82 struct mlx5e_vxlan *mlx5e_vxlan_lookup_port(struct mlx5e_priv *priv, u16 port)
  83 {
  84         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
  85         struct mlx5e_vxlan *vxlan;
  86
  87         spin_lock_bh(&vxlan_db->lock);
  88         vxlan = radix_tree_lookup(&vxlan_db->tree, port);
  89         spin_unlock_bh(&vxlan_db->lock);
  90
  91         return vxlan;
  92 }
  93
  94 static void mlx5e_vxlan_add_port(struct mlx5e_priv *priv, u16 port)
  95 {
  96         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
  97         struct mlx5e_vxlan *vxlan;
  98         int err;
  99
 100         vxlan = mlx5e_vxlan_lookup_port(priv, port);
 101         if (vxlan) {
 102                 atomic_inc(&vxlan->refcount);
 103                 return;
 104         }
 105
 106         if (vxlan_db->num_ports >= mlx5e_vxlan_max_udp_ports(priv->mdev)) {
 107                 netdev_info(priv->netdev,
 108                             "UDP port (%d) not offloaded, max number of UDP ports (%d) are already offloaded\n",
 109                             port, mlx5e_vxlan_max_udp_ports(priv->mdev));
 110                 return;
 111         }
 112
 113         if (mlx5e_vxlan_core_add_port_cmd(priv->mdev, port))
 114                 return;
 115
 116         vxlan = kzalloc(sizeof(*vxlan), GFP_KERNEL);
 117         if (!vxlan)
 118                 goto err_delete_port;
 119
 120         vxlan->udp_port = port;
 121         atomic_set(&vxlan->refcount, 1);
 122
 123         spin_lock_bh(&vxlan_db->lock);
 124         err = radix_tree_insert(&vxlan_db->tree, vxlan->udp_port, vxlan);
 125         spin_unlock_bh(&vxlan_db->lock);
 126         if (err)
 127                 goto err_free;
 128
 129         vxlan_db->num_ports++;
 130         return;
 131
 132 err_free:
 133         kfree(vxlan);
 134 err_delete_port:
 135         mlx5e_vxlan_core_del_port_cmd(priv->mdev, port);
 136 }
 137
 138 static void mlx5e_vxlan_add_work(struct work_struct *work)
 139 {
 140         struct mlx5e_vxlan_work *vxlan_work =
 141                 container_of(work, struct mlx5e_vxlan_work, work);
 142         struct mlx5e_priv *priv = vxlan_work->priv;
 143         u16 port = vxlan_work->port;
 144
 145         mutex_lock(&priv->state_lock);
 146         mlx5e_vxlan_add_port(priv, port);
 147         mutex_unlock(&priv->state_lock);
 148
 149         kfree(vxlan_work);
 150 }
 151
 152 static void mlx5e_vxlan_del_work(struct work_struct *work)
 153 {
 154         struct mlx5e_vxlan_work *vxlan_work =
 155                 container_of(work, struct mlx5e_vxlan_work, work);
 156         struct mlx5e_priv *priv         = vxlan_work->priv;
 157         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
 158         u16 port = vxlan_work->port;
 159         struct mlx5e_vxlan *vxlan;
 160         bool remove = false;
 161
 162         mutex_lock(&priv->state_lock);
 163         spin_lock_bh(&vxlan_db->lock);
 164         vxlan = radix_tree_lookup(&vxlan_db->tree, port);
 165         if (!vxlan)
 166                 goto out_unlock;
 167
 168         if (atomic_dec_and_test(&vxlan->refcount)) {
 169                 radix_tree_delete(&vxlan_db->tree, port);
 170                 remove = true;
 171         }
 172
 173 out_unlock:
 174         spin_unlock_bh(&vxlan_db->lock);
 175
 176         if (remove) {
 177                 mlx5e_vxlan_core_del_port_cmd(priv->mdev, port);
 178                 kfree(vxlan);
 179                 vxlan_db->num_ports--;
 180         }
 181         mutex_unlock(&priv->state_lock);
 182         kfree(vxlan_work);
 183 }
 184
 185 void mlx5e_vxlan_queue_work(struct mlx5e_priv *priv, sa_family_t sa_family,
 186                             u16 port, int add)
 187 {
 188         struct mlx5e_vxlan_work *vxlan_work;
 189
 190         vxlan_work = kmalloc(sizeof(*vxlan_work), GFP_ATOMIC);
 191         if (!vxlan_work)
 192                 return;
 193
 194         if (add)
 195                 INIT_WORK(&vxlan_work->work, mlx5e_vxlan_add_work);
 196         else
 197                 INIT_WORK(&vxlan_work->work, mlx5e_vxlan_del_work);
 198
 199         vxlan_work->priv = priv;
 200         vxlan_work->port = port;
 201         vxlan_work->sa_family = sa_family;
 202         queue_work(priv->wq, &vxlan_work->work);
 203 }
 204
 205 void mlx5e_vxlan_cleanup(struct mlx5e_priv *priv)
 206 {
 207         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
 208         struct mlx5e_vxlan *vxlan;
 209         unsigned int port = 0;
 210
 211         /* Lockless since we are the only radix-tree consumers, wq is disabled */
 212         while (radix_tree_gang_lookup(&vxlan_db->tree, (void **)&vxlan, port, 1)) {
 213                 port = vxlan->udp_port;
 214                 radix_tree_delete(&vxlan_db->tree, port);
 215                 mlx5e_vxlan_core_del_port_cmd(priv->mdev, port);
 216                 kfree(vxlan);
 217         }
 218 }