1 /*
2  * Copyright (C) 2015-2017 Netronome Systems, Inc.
3  *
4  * This software is dual licensed under the GNU General License Version 2,
5  * June 1991 as shown in the file COPYING in the top-level directory of this
6  * source tree or the BSD 2-Clause License provided below.  You have the
7  * option to license this software under the complete terms of either license.
8  *
9  * The BSD 2-Clause License:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      1. Redistributions of source code must retain the above
16  *         copyright notice, this list of conditions and the following
17  *         disclaimer.
18  *
19  *      2. Redistributions in binary form must reproduce the above
20  *         copyright notice, this list of conditions and the following
21  *         disclaimer in the documentation and/or other materials
22  *         provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33 
34 #include <linux/bitfield.h>
35 #include <linux/netdevice.h>
36 #include <linux/skbuff.h>
37 #include <linux/workqueue.h>
38 #include <net/dst_metadata.h>
39 
40 #include "main.h"
41 #include "../nfp_net.h"
42 #include "../nfp_net_repr.h"
43 #include "./cmsg.h"
44 
45 static struct nfp_flower_cmsg_hdr *
46 nfp_flower_cmsg_get_hdr(struct sk_buff *skb)
47 {
48 	return (struct nfp_flower_cmsg_hdr *)skb->data;
49 }
50 
51 struct sk_buff *
52 nfp_flower_cmsg_alloc(struct nfp_app *app, unsigned int size,
53 		      enum nfp_flower_cmsg_type_port type, gfp_t flag)
54 {
55 	struct nfp_flower_cmsg_hdr *ch;
56 	struct sk_buff *skb;
57 
58 	size += NFP_FLOWER_CMSG_HLEN;
59 
60 	skb = nfp_app_ctrl_msg_alloc(app, size, flag);
61 	if (!skb)
62 		return NULL;
63 
64 	ch = nfp_flower_cmsg_get_hdr(skb);
65 	ch->pad = 0;
66 	ch->version = NFP_FLOWER_CMSG_VER1;
67 	ch->type = type;
68 	skb_put(skb, size);
69 
70 	return skb;
71 }
72 
73 struct sk_buff *
74 nfp_flower_cmsg_mac_repr_start(struct nfp_app *app, unsigned int num_ports)
75 {
76 	struct nfp_flower_cmsg_mac_repr *msg;
77 	struct sk_buff *skb;
78 	unsigned int size;
79 
80 	size = sizeof(*msg) + num_ports * sizeof(msg->ports[0]);
81 	skb = nfp_flower_cmsg_alloc(app, size, NFP_FLOWER_CMSG_TYPE_MAC_REPR,
82 				    GFP_KERNEL);
83 	if (!skb)
84 		return NULL;
85 
86 	msg = nfp_flower_cmsg_get_data(skb);
87 	memset(msg->reserved, 0, sizeof(msg->reserved));
88 	msg->num_ports = num_ports;
89 
90 	return skb;
91 }
92 
93 void
94 nfp_flower_cmsg_mac_repr_add(struct sk_buff *skb, unsigned int idx,
95 			     unsigned int nbi, unsigned int nbi_port,
96 			     unsigned int phys_port)
97 {
98 	struct nfp_flower_cmsg_mac_repr *msg;
99 
100 	msg = nfp_flower_cmsg_get_data(skb);
101 	msg->ports[idx].idx = idx;
102 	msg->ports[idx].info = nbi & NFP_FLOWER_CMSG_MAC_REPR_NBI;
103 	msg->ports[idx].nbi_port = nbi_port;
104 	msg->ports[idx].phys_port = phys_port;
105 }
106 
107 int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok,
108 			    unsigned int mtu, bool mtu_only)
109 {
110 	struct nfp_flower_cmsg_portmod *msg;
111 	struct sk_buff *skb;
112 
113 	skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
114 				    NFP_FLOWER_CMSG_TYPE_PORT_MOD, GFP_KERNEL);
115 	if (!skb)
116 		return -ENOMEM;
117 
118 	msg = nfp_flower_cmsg_get_data(skb);
119 	msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
120 	msg->reserved = 0;
121 	msg->info = carrier_ok;
122 
123 	if (mtu_only)
124 		msg->info |= NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY;
125 
126 	msg->mtu = cpu_to_be16(mtu);
127 
128 	nfp_ctrl_tx(repr->app->ctrl, skb);
129 
130 	return 0;
131 }
132 
133 int nfp_flower_cmsg_portreify(struct nfp_repr *repr, bool exists)
134 {
135 	struct nfp_flower_cmsg_portreify *msg;
136 	struct sk_buff *skb;
137 
138 	skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
139 				    NFP_FLOWER_CMSG_TYPE_PORT_REIFY,
140 				    GFP_KERNEL);
141 	if (!skb)
142 		return -ENOMEM;
143 
144 	msg = nfp_flower_cmsg_get_data(skb);
145 	msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
146 	msg->reserved = 0;
147 	msg->info = cpu_to_be16(exists);
148 
149 	nfp_ctrl_tx(repr->app->ctrl, skb);
150 
151 	return 0;
152 }
153 
154 static bool
155 nfp_flower_process_mtu_ack(struct nfp_app *app, struct sk_buff *skb)
156 {
157 	struct nfp_flower_priv *app_priv = app->priv;
158 	struct nfp_flower_cmsg_portmod *msg;
159 
160 	msg = nfp_flower_cmsg_get_data(skb);
161 
162 	if (!(msg->info & NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY))
163 		return false;
164 
165 	spin_lock_bh(&app_priv->mtu_conf.lock);
166 	if (!app_priv->mtu_conf.requested_val ||
167 	    app_priv->mtu_conf.portnum != be32_to_cpu(msg->portnum) ||
168 	    be16_to_cpu(msg->mtu) != app_priv->mtu_conf.requested_val) {
169 		/* Not an ack for requested MTU change. */
170 		spin_unlock_bh(&app_priv->mtu_conf.lock);
171 		return false;
172 	}
173 
174 	app_priv->mtu_conf.ack = true;
175 	app_priv->mtu_conf.requested_val = 0;
176 	wake_up(&app_priv->mtu_conf.wait_q);
177 	spin_unlock_bh(&app_priv->mtu_conf.lock);
178 
179 	return true;
180 }
181 
182 static void
183 nfp_flower_cmsg_portmod_rx(struct nfp_app *app, struct sk_buff *skb)
184 {
185 	struct nfp_flower_cmsg_portmod *msg;
186 	struct net_device *netdev;
187 	bool link;
188 
189 	msg = nfp_flower_cmsg_get_data(skb);
190 	link = msg->info & NFP_FLOWER_CMSG_PORTMOD_INFO_LINK;
191 
192 	rtnl_lock();
193 	rcu_read_lock();
194 	netdev = nfp_app_repr_get(app, be32_to_cpu(msg->portnum));
195 	rcu_read_unlock();
196 	if (!netdev) {
197 		nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
198 				     be32_to_cpu(msg->portnum));
199 		rtnl_unlock();
200 		return;
201 	}
202 
203 	if (link) {
204 		u16 mtu = be16_to_cpu(msg->mtu);
205 
206 		netif_carrier_on(netdev);
207 
208 		/* An MTU of 0 from the firmware should be ignored */
209 		if (mtu)
210 			dev_set_mtu(netdev, mtu);
211 	} else {
212 		netif_carrier_off(netdev);
213 	}
214 	rtnl_unlock();
215 }
216 
217 static void
218 nfp_flower_cmsg_portreify_rx(struct nfp_app *app, struct sk_buff *skb)
219 {
220 	struct nfp_flower_priv *priv = app->priv;
221 	struct nfp_flower_cmsg_portreify *msg;
222 	bool exists;
223 
224 	msg = nfp_flower_cmsg_get_data(skb);
225 
226 	rcu_read_lock();
227 	exists = !!nfp_app_repr_get(app, be32_to_cpu(msg->portnum));
228 	rcu_read_unlock();
229 	if (!exists) {
230 		nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
231 				     be32_to_cpu(msg->portnum));
232 		return;
233 	}
234 
235 	atomic_inc(&priv->reify_replies);
236 	wake_up_interruptible(&priv->reify_wait_queue);
237 }
238 
239 static void
240 nfp_flower_cmsg_process_one_rx(struct nfp_app *app, struct sk_buff *skb)
241 {
242 	struct nfp_flower_priv *app_priv = app->priv;
243 	struct nfp_flower_cmsg_hdr *cmsg_hdr;
244 	enum nfp_flower_cmsg_type_port type;
245 	bool skb_stored = false;
246 
247 	cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);
248 
249 	type = cmsg_hdr->type;
250 	switch (type) {
251 	case NFP_FLOWER_CMSG_TYPE_PORT_REIFY:
252 		nfp_flower_cmsg_portreify_rx(app, skb);
253 		break;
254 	case NFP_FLOWER_CMSG_TYPE_PORT_MOD:
255 		nfp_flower_cmsg_portmod_rx(app, skb);
256 		break;
257 	case NFP_FLOWER_CMSG_TYPE_NO_NEIGH:
258 		nfp_tunnel_request_route(app, skb);
259 		break;
260 	case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS:
261 		nfp_tunnel_keep_alive(app, skb);
262 		break;
263 	case NFP_FLOWER_CMSG_TYPE_LAG_CONFIG:
264 		if (app_priv->flower_ext_feats & NFP_FL_FEATS_LAG) {
265 			skb_stored = nfp_flower_lag_unprocessed_msg(app, skb);
266 			break;
267 		}
268 		/* fall through */
269 	default:
270 		nfp_flower_cmsg_warn(app, "Cannot handle invalid repr control type %u\n",
271 				     type);
272 		goto out;
273 	}
274 
275 	if (!skb_stored)
276 		dev_consume_skb_any(skb);
277 	return;
278 out:
279 	dev_kfree_skb_any(skb);
280 }
281 
282 void nfp_flower_cmsg_process_rx(struct work_struct *work)
283 {
284 	struct sk_buff_head cmsg_joined;
285 	struct nfp_flower_priv *priv;
286 	struct sk_buff *skb;
287 
288 	priv = container_of(work, struct nfp_flower_priv, cmsg_work);
289 	skb_queue_head_init(&cmsg_joined);
290 
291 	spin_lock_bh(&priv->cmsg_skbs_high.lock);
292 	skb_queue_splice_tail_init(&priv->cmsg_skbs_high, &cmsg_joined);
293 	spin_unlock_bh(&priv->cmsg_skbs_high.lock);
294 
295 	spin_lock_bh(&priv->cmsg_skbs_low.lock);
296 	skb_queue_splice_tail_init(&priv->cmsg_skbs_low, &cmsg_joined);
297 	spin_unlock_bh(&priv->cmsg_skbs_low.lock);
298 
299 	while ((skb = __skb_dequeue(&cmsg_joined)))
300 		nfp_flower_cmsg_process_one_rx(priv->app, skb);
301 }
302 
303 static void
304 nfp_flower_queue_ctl_msg(struct nfp_app *app, struct sk_buff *skb, int type)
305 {
306 	struct nfp_flower_priv *priv = app->priv;
307 	struct sk_buff_head *skb_head;
308 
309 	if (type == NFP_FLOWER_CMSG_TYPE_PORT_REIFY ||
310 	    type == NFP_FLOWER_CMSG_TYPE_PORT_MOD)
311 		skb_head = &priv->cmsg_skbs_high;
312 	else
313 		skb_head = &priv->cmsg_skbs_low;
314 
315 	if (skb_queue_len(skb_head) >= NFP_FLOWER_WORKQ_MAX_SKBS) {
316 		nfp_flower_cmsg_warn(app, "Dropping queued control messages\n");
317 		dev_kfree_skb_any(skb);
318 		return;
319 	}
320 
321 	skb_queue_tail(skb_head, skb);
322 	schedule_work(&priv->cmsg_work);
323 }
324 
325 void nfp_flower_cmsg_rx(struct nfp_app *app, struct sk_buff *skb)
326 {
327 	struct nfp_flower_cmsg_hdr *cmsg_hdr;
328 
329 	cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);
330 
331 	if (unlikely(cmsg_hdr->version != NFP_FLOWER_CMSG_VER1)) {
332 		nfp_flower_cmsg_warn(app, "Cannot handle repr control version %u\n",
333 				     cmsg_hdr->version);
334 		dev_kfree_skb_any(skb);
335 		return;
336 	}
337 
338 	if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_FLOW_STATS) {
339 		/* We need to deal with stats updates from HW asap */
340 		nfp_flower_rx_flow_stats(app, skb);
341 		dev_consume_skb_any(skb);
342 	} else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_MOD &&
343 		   nfp_flower_process_mtu_ack(app, skb)) {
344 		/* Handle MTU acks outside wq to prevent RTNL conflict. */
345 		dev_consume_skb_any(skb);
346 	} else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH) {
347 		/* Acks from the NFP that the route is added - ignore. */
348 		dev_consume_skb_any(skb);
349 	} else {
350 		nfp_flower_queue_ctl_msg(app, skb, cmsg_hdr->type);
351 	}
352 }
353