net/mlx5e: Vxlan, reflect 4789 UDP port default addition to software database
[sfrench/cifs-2.6.git] / 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 int mlx5e_vxlan_core_add_port_cmd(struct mlx5_core_dev *mdev, u16 port)
56 {
57         u32 in[MLX5_ST_SZ_DW(add_vxlan_udp_dport_in)]   = {0};
58         u32 out[MLX5_ST_SZ_DW(add_vxlan_udp_dport_out)] = {0};
59
60         MLX5_SET(add_vxlan_udp_dport_in, in, opcode,
61                  MLX5_CMD_OP_ADD_VXLAN_UDP_DPORT);
62         MLX5_SET(add_vxlan_udp_dport_in, in, vxlan_udp_port, port);
63         return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
64 }
65
66 static int mlx5e_vxlan_core_del_port_cmd(struct mlx5_core_dev *mdev, u16 port)
67 {
68         u32 in[MLX5_ST_SZ_DW(delete_vxlan_udp_dport_in)]   = {0};
69         u32 out[MLX5_ST_SZ_DW(delete_vxlan_udp_dport_out)] = {0};
70
71         MLX5_SET(delete_vxlan_udp_dport_in, in, opcode,
72                  MLX5_CMD_OP_DELETE_VXLAN_UDP_DPORT);
73         MLX5_SET(delete_vxlan_udp_dport_in, in, vxlan_udp_port, port);
74         return mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
75 }
76
77 struct mlx5e_vxlan *mlx5e_vxlan_lookup_port(struct mlx5e_priv *priv, u16 port)
78 {
79         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
80         struct mlx5e_vxlan *vxlan;
81
82         spin_lock_bh(&vxlan_db->lock);
83         vxlan = radix_tree_lookup(&vxlan_db->tree, port);
84         spin_unlock_bh(&vxlan_db->lock);
85
86         return vxlan;
87 }
88
89 static void mlx5e_vxlan_add_port(struct mlx5e_priv *priv, u16 port)
90 {
91         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
92         struct mlx5e_vxlan *vxlan;
93         int err;
94
95         vxlan = mlx5e_vxlan_lookup_port(priv, port);
96         if (vxlan) {
97                 atomic_inc(&vxlan->refcount);
98                 return;
99         }
100
101         if (mlx5e_vxlan_core_add_port_cmd(priv->mdev, port))
102                 return;
103
104         vxlan = kzalloc(sizeof(*vxlan), GFP_KERNEL);
105         if (!vxlan)
106                 goto err_delete_port;
107
108         vxlan->udp_port = port;
109         atomic_set(&vxlan->refcount, 1);
110
111         spin_lock_bh(&vxlan_db->lock);
112         err = radix_tree_insert(&vxlan_db->tree, vxlan->udp_port, vxlan);
113         spin_unlock_bh(&vxlan_db->lock);
114         if (err)
115                 goto err_free;
116
117         return;
118
119 err_free:
120         kfree(vxlan);
121 err_delete_port:
122         mlx5e_vxlan_core_del_port_cmd(priv->mdev, port);
123 }
124
125 static void mlx5e_vxlan_add_work(struct work_struct *work)
126 {
127         struct mlx5e_vxlan_work *vxlan_work =
128                 container_of(work, struct mlx5e_vxlan_work, work);
129         struct mlx5e_priv *priv = vxlan_work->priv;
130         u16 port = vxlan_work->port;
131
132         mutex_lock(&priv->state_lock);
133         mlx5e_vxlan_add_port(priv, port);
134         mutex_unlock(&priv->state_lock);
135
136         kfree(vxlan_work);
137 }
138
139 static void mlx5e_vxlan_del_work(struct work_struct *work)
140 {
141         struct mlx5e_vxlan_work *vxlan_work =
142                 container_of(work, struct mlx5e_vxlan_work, work);
143         struct mlx5e_priv *priv         = vxlan_work->priv;
144         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
145         u16 port = vxlan_work->port;
146         struct mlx5e_vxlan *vxlan;
147         bool remove = false;
148
149         mutex_lock(&priv->state_lock);
150         spin_lock_bh(&vxlan_db->lock);
151         vxlan = radix_tree_lookup(&vxlan_db->tree, port);
152         if (!vxlan)
153                 goto out_unlock;
154
155         if (atomic_dec_and_test(&vxlan->refcount)) {
156                 radix_tree_delete(&vxlan_db->tree, port);
157                 remove = true;
158         }
159
160 out_unlock:
161         spin_unlock_bh(&vxlan_db->lock);
162
163         if (remove) {
164                 mlx5e_vxlan_core_del_port_cmd(priv->mdev, port);
165                 kfree(vxlan);
166         }
167         mutex_unlock(&priv->state_lock);
168         kfree(vxlan_work);
169 }
170
171 void mlx5e_vxlan_queue_work(struct mlx5e_priv *priv, sa_family_t sa_family,
172                             u16 port, int add)
173 {
174         struct mlx5e_vxlan_work *vxlan_work;
175
176         vxlan_work = kmalloc(sizeof(*vxlan_work), GFP_ATOMIC);
177         if (!vxlan_work)
178                 return;
179
180         if (add)
181                 INIT_WORK(&vxlan_work->work, mlx5e_vxlan_add_work);
182         else
183                 INIT_WORK(&vxlan_work->work, mlx5e_vxlan_del_work);
184
185         vxlan_work->priv = priv;
186         vxlan_work->port = port;
187         vxlan_work->sa_family = sa_family;
188         queue_work(priv->wq, &vxlan_work->work);
189 }
190
191 void mlx5e_vxlan_cleanup(struct mlx5e_priv *priv)
192 {
193         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
194         struct mlx5e_vxlan *vxlan;
195         unsigned int port = 0;
196
197         /* Lockless since we are the only radix-tree consumers, wq is disabled */
198         while (radix_tree_gang_lookup(&vxlan_db->tree, (void **)&vxlan, port, 1)) {
199                 port = vxlan->udp_port;
200                 radix_tree_delete(&vxlan_db->tree, port);
201                 mlx5e_vxlan_core_del_port_cmd(priv->mdev, port);
202                 kfree(vxlan);
203         }
204 }