1 /*
2  * Copyright (C) 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/etherdevice.h>
35 #include <linux/inetdevice.h>
36 #include <net/netevent.h>
37 #include <linux/idr.h>
38 #include <net/dst_metadata.h>
39 #include <net/arp.h>
40 
41 #include "cmsg.h"
42 #include "main.h"
43 #include "../nfp_net_repr.h"
44 #include "../nfp_net.h"
45 
46 #define NFP_FL_MAX_ROUTES               32
47 
48 /**
49  * struct nfp_tun_active_tuns - periodic message of active tunnels
50  * @seq:		sequence number of the message
51  * @count:		number of tunnels report in message
52  * @flags:		options part of the request
53  * @tun_info.ipv4:		dest IPv4 address of active route
54  * @tun_info.egress_port:	port the encapsulated packet egressed
55  * @tun_info.extra:		reserved for future use
56  * @tun_info:		tunnels that have sent traffic in reported period
57  */
58 struct nfp_tun_active_tuns {
59 	__be32 seq;
60 	__be32 count;
61 	__be32 flags;
62 	struct route_ip_info {
63 		__be32 ipv4;
64 		__be32 egress_port;
65 		__be32 extra[2];
66 	} tun_info[];
67 };
68 
69 /**
70  * struct nfp_tun_neigh - neighbour/route entry on the NFP
71  * @dst_ipv4:	destination IPv4 address
72  * @src_ipv4:	source IPv4 address
73  * @dst_addr:	destination MAC address
74  * @src_addr:	source MAC address
75  * @port_id:	NFP port to output packet on - associated with source IPv4
76  */
77 struct nfp_tun_neigh {
78 	__be32 dst_ipv4;
79 	__be32 src_ipv4;
80 	u8 dst_addr[ETH_ALEN];
81 	u8 src_addr[ETH_ALEN];
82 	__be32 port_id;
83 };
84 
85 /**
86  * struct nfp_tun_req_route_ipv4 - NFP requests a route/neighbour lookup
87  * @ingress_port:	ingress port of packet that signalled request
88  * @ipv4_addr:		destination ipv4 address for route
89  * @reserved:		reserved for future use
90  */
91 struct nfp_tun_req_route_ipv4 {
92 	__be32 ingress_port;
93 	__be32 ipv4_addr;
94 	__be32 reserved[2];
95 };
96 
97 /**
98  * struct nfp_ipv4_route_entry - routes that are offloaded to the NFP
99  * @ipv4_addr:	destination of route
100  * @list:	list pointer
101  */
102 struct nfp_ipv4_route_entry {
103 	__be32 ipv4_addr;
104 	struct list_head list;
105 };
106 
107 #define NFP_FL_IPV4_ADDRS_MAX        32
108 
109 /**
110  * struct nfp_tun_ipv4_addr - set the IP address list on the NFP
111  * @count:	number of IPs populated in the array
112  * @ipv4_addr:	array of IPV4_ADDRS_MAX 32 bit IPv4 addresses
113  */
114 struct nfp_tun_ipv4_addr {
115 	__be32 count;
116 	__be32 ipv4_addr[NFP_FL_IPV4_ADDRS_MAX];
117 };
118 
119 /**
120  * struct nfp_ipv4_addr_entry - cached IPv4 addresses
121  * @ipv4_addr:	IP address
122  * @ref_count:	number of rules currently using this IP
123  * @list:	list pointer
124  */
125 struct nfp_ipv4_addr_entry {
126 	__be32 ipv4_addr;
127 	int ref_count;
128 	struct list_head list;
129 };
130 
131 /**
132  * struct nfp_tun_mac_addr - configure MAC address of tunnel EP on NFP
133  * @reserved:	reserved for future use
134  * @count:	number of MAC addresses in the message
135  * @addresses.index:	index of MAC address in the lookup table
136  * @addresses.addr:	interface MAC address
137  * @addresses:	series of MACs to offload
138  */
139 struct nfp_tun_mac_addr {
140 	__be16 reserved;
141 	__be16 count;
142 	struct index_mac_addr {
143 		__be16 index;
144 		u8 addr[ETH_ALEN];
145 	} addresses[];
146 };
147 
148 /**
149  * struct nfp_tun_mac_offload_entry - list of MACs to offload
150  * @index:	index of MAC address for offloading
151  * @addr:	interface MAC address
152  * @list:	list pointer
153  */
154 struct nfp_tun_mac_offload_entry {
155 	__be16 index;
156 	u8 addr[ETH_ALEN];
157 	struct list_head list;
158 };
159 
160 #define NFP_MAX_MAC_INDEX       0xff
161 
162 /**
163  * struct nfp_tun_mac_non_nfp_idx - converts non NFP netdev ifindex to 8-bit id
164  * @ifindex:	netdev ifindex of the device
165  * @index:	index of netdevs mac on NFP
166  * @list:	list pointer
167  */
168 struct nfp_tun_mac_non_nfp_idx {
169 	int ifindex;
170 	u8 index;
171 	struct list_head list;
172 };
173 
174 void nfp_tunnel_keep_alive(struct nfp_app *app, struct sk_buff *skb)
175 {
176 	struct nfp_tun_active_tuns *payload;
177 	struct net_device *netdev;
178 	int count, i, pay_len;
179 	struct neighbour *n;
180 	__be32 ipv4_addr;
181 	u32 port;
182 
183 	payload = nfp_flower_cmsg_get_data(skb);
184 	count = be32_to_cpu(payload->count);
185 	if (count > NFP_FL_MAX_ROUTES) {
186 		nfp_flower_cmsg_warn(app, "Tunnel keep-alive request exceeds max routes.\n");
187 		return;
188 	}
189 
190 	pay_len = nfp_flower_cmsg_get_data_len(skb);
191 	if (pay_len != sizeof(struct nfp_tun_active_tuns) +
192 	    sizeof(struct route_ip_info) * count) {
193 		nfp_flower_cmsg_warn(app, "Corruption in tunnel keep-alive message.\n");
194 		return;
195 	}
196 
197 	for (i = 0; i < count; i++) {
198 		ipv4_addr = payload->tun_info[i].ipv4;
199 		port = be32_to_cpu(payload->tun_info[i].egress_port);
200 		netdev = nfp_app_repr_get(app, port);
201 		if (!netdev)
202 			continue;
203 
204 		n = neigh_lookup(&arp_tbl, &ipv4_addr, netdev);
205 		if (!n)
206 			continue;
207 
208 		/* Update the used timestamp of neighbour */
209 		neigh_event_send(n, NULL);
210 		neigh_release(n);
211 	}
212 }
213 
214 static bool nfp_tun_is_netdev_to_offload(struct net_device *netdev)
215 {
216 	if (!netdev->rtnl_link_ops)
217 		return false;
218 	if (!strcmp(netdev->rtnl_link_ops->kind, "openvswitch"))
219 		return true;
220 	if (!strcmp(netdev->rtnl_link_ops->kind, "vxlan"))
221 		return true;
222 
223 	return false;
224 }
225 
226 static int
227 nfp_flower_xmit_tun_conf(struct nfp_app *app, u8 mtype, u16 plen, void *pdata,
228 			 gfp_t flag)
229 {
230 	struct sk_buff *skb;
231 	unsigned char *msg;
232 
233 	skb = nfp_flower_cmsg_alloc(app, plen, mtype, flag);
234 	if (!skb)
235 		return -ENOMEM;
236 
237 	msg = nfp_flower_cmsg_get_data(skb);
238 	memcpy(msg, pdata, nfp_flower_cmsg_get_data_len(skb));
239 
240 	nfp_ctrl_tx(app->ctrl, skb);
241 	return 0;
242 }
243 
244 static bool nfp_tun_has_route(struct nfp_app *app, __be32 ipv4_addr)
245 {
246 	struct nfp_flower_priv *priv = app->priv;
247 	struct nfp_ipv4_route_entry *entry;
248 	struct list_head *ptr, *storage;
249 
250 	spin_lock_bh(&priv->nfp_neigh_off_lock);
251 	list_for_each_safe(ptr, storage, &priv->nfp_neigh_off_list) {
252 		entry = list_entry(ptr, struct nfp_ipv4_route_entry, list);
253 		if (entry->ipv4_addr == ipv4_addr) {
254 			spin_unlock_bh(&priv->nfp_neigh_off_lock);
255 			return true;
256 		}
257 	}
258 	spin_unlock_bh(&priv->nfp_neigh_off_lock);
259 	return false;
260 }
261 
262 static void nfp_tun_add_route_to_cache(struct nfp_app *app, __be32 ipv4_addr)
263 {
264 	struct nfp_flower_priv *priv = app->priv;
265 	struct nfp_ipv4_route_entry *entry;
266 	struct list_head *ptr, *storage;
267 
268 	spin_lock_bh(&priv->nfp_neigh_off_lock);
269 	list_for_each_safe(ptr, storage, &priv->nfp_neigh_off_list) {
270 		entry = list_entry(ptr, struct nfp_ipv4_route_entry, list);
271 		if (entry->ipv4_addr == ipv4_addr) {
272 			spin_unlock_bh(&priv->nfp_neigh_off_lock);
273 			return;
274 		}
275 	}
276 	entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
277 	if (!entry) {
278 		spin_unlock_bh(&priv->nfp_neigh_off_lock);
279 		nfp_flower_cmsg_warn(app, "Mem error when storing new route.\n");
280 		return;
281 	}
282 
283 	entry->ipv4_addr = ipv4_addr;
284 	list_add_tail(&entry->list, &priv->nfp_neigh_off_list);
285 	spin_unlock_bh(&priv->nfp_neigh_off_lock);
286 }
287 
288 static void nfp_tun_del_route_from_cache(struct nfp_app *app, __be32 ipv4_addr)
289 {
290 	struct nfp_flower_priv *priv = app->priv;
291 	struct nfp_ipv4_route_entry *entry;
292 	struct list_head *ptr, *storage;
293 
294 	spin_lock_bh(&priv->nfp_neigh_off_lock);
295 	list_for_each_safe(ptr, storage, &priv->nfp_neigh_off_list) {
296 		entry = list_entry(ptr, struct nfp_ipv4_route_entry, list);
297 		if (entry->ipv4_addr == ipv4_addr) {
298 			list_del(&entry->list);
299 			kfree(entry);
300 			break;
301 		}
302 	}
303 	spin_unlock_bh(&priv->nfp_neigh_off_lock);
304 }
305 
306 static void
307 nfp_tun_write_neigh(struct net_device *netdev, struct nfp_app *app,
308 		    struct flowi4 *flow, struct neighbour *neigh, gfp_t flag)
309 {
310 	struct nfp_tun_neigh payload;
311 
312 	/* Only offload representor IPv4s for now. */
313 	if (!nfp_netdev_is_nfp_repr(netdev))
314 		return;
315 
316 	memset(&payload, 0, sizeof(struct nfp_tun_neigh));
317 	payload.dst_ipv4 = flow->daddr;
318 
319 	/* If entry has expired send dst IP with all other fields 0. */
320 	if (!(neigh->nud_state & NUD_VALID) || neigh->dead) {
321 		nfp_tun_del_route_from_cache(app, payload.dst_ipv4);
322 		/* Trigger ARP to verify invalid neighbour state. */
323 		neigh_event_send(neigh, NULL);
324 		goto send_msg;
325 	}
326 
327 	/* Have a valid neighbour so populate rest of entry. */
328 	payload.src_ipv4 = flow->saddr;
329 	ether_addr_copy(payload.src_addr, netdev->dev_addr);
330 	neigh_ha_snapshot(payload.dst_addr, neigh, netdev);
331 	payload.port_id = cpu_to_be32(nfp_repr_get_port_id(netdev));
332 	/* Add destination of new route to NFP cache. */
333 	nfp_tun_add_route_to_cache(app, payload.dst_ipv4);
334 
335 send_msg:
336 	nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_TUN_NEIGH,
337 				 sizeof(struct nfp_tun_neigh),
338 				 (unsigned char *)&payload, flag);
339 }
340 
341 static int
342 nfp_tun_neigh_event_handler(struct notifier_block *nb, unsigned long event,
343 			    void *ptr)
344 {
345 	struct nfp_flower_priv *app_priv;
346 	struct netevent_redirect *redir;
347 	struct flowi4 flow = {};
348 	struct neighbour *n;
349 	struct nfp_app *app;
350 	struct rtable *rt;
351 	int err;
352 
353 	switch (event) {
354 	case NETEVENT_REDIRECT:
355 		redir = (struct netevent_redirect *)ptr;
356 		n = redir->neigh;
357 		break;
358 	case NETEVENT_NEIGH_UPDATE:
359 		n = (struct neighbour *)ptr;
360 		break;
361 	default:
362 		return NOTIFY_DONE;
363 	}
364 
365 	flow.daddr = *(__be32 *)n->primary_key;
366 
367 	/* Only concerned with route changes for representors. */
368 	if (!nfp_netdev_is_nfp_repr(n->dev))
369 		return NOTIFY_DONE;
370 
371 	app_priv = container_of(nb, struct nfp_flower_priv, nfp_tun_neigh_nb);
372 	app = app_priv->app;
373 
374 	/* Only concerned with changes to routes already added to NFP. */
375 	if (!nfp_tun_has_route(app, flow.daddr))
376 		return NOTIFY_DONE;
377 
378 #if IS_ENABLED(CONFIG_INET)
379 	/* Do a route lookup to populate flow data. */
380 	rt = ip_route_output_key(dev_net(n->dev), &flow);
381 	err = PTR_ERR_OR_ZERO(rt);
382 	if (err)
383 		return NOTIFY_DONE;
384 
385 	ip_rt_put(rt);
386 #else
387 	return NOTIFY_DONE;
388 #endif
389 
390 	flow.flowi4_proto = IPPROTO_UDP;
391 	nfp_tun_write_neigh(n->dev, app, &flow, n, GFP_ATOMIC);
392 
393 	return NOTIFY_OK;
394 }
395 
396 void nfp_tunnel_request_route(struct nfp_app *app, struct sk_buff *skb)
397 {
398 	struct nfp_tun_req_route_ipv4 *payload;
399 	struct net_device *netdev;
400 	struct flowi4 flow = {};
401 	struct neighbour *n;
402 	struct rtable *rt;
403 	int err;
404 
405 	payload = nfp_flower_cmsg_get_data(skb);
406 
407 	netdev = nfp_app_repr_get(app, be32_to_cpu(payload->ingress_port));
408 	if (!netdev)
409 		goto route_fail_warning;
410 
411 	flow.daddr = payload->ipv4_addr;
412 	flow.flowi4_proto = IPPROTO_UDP;
413 
414 #if IS_ENABLED(CONFIG_INET)
415 	/* Do a route lookup on same namespace as ingress port. */
416 	rt = ip_route_output_key(dev_net(netdev), &flow);
417 	err = PTR_ERR_OR_ZERO(rt);
418 	if (err)
419 		goto route_fail_warning;
420 #else
421 	goto route_fail_warning;
422 #endif
423 
424 	/* Get the neighbour entry for the lookup */
425 	n = dst_neigh_lookup(&rt->dst, &flow.daddr);
426 	ip_rt_put(rt);
427 	if (!n)
428 		goto route_fail_warning;
429 	nfp_tun_write_neigh(n->dev, app, &flow, n, GFP_KERNEL);
430 	neigh_release(n);
431 	return;
432 
433 route_fail_warning:
434 	nfp_flower_cmsg_warn(app, "Requested route not found.\n");
435 }
436 
437 static void nfp_tun_write_ipv4_list(struct nfp_app *app)
438 {
439 	struct nfp_flower_priv *priv = app->priv;
440 	struct nfp_ipv4_addr_entry *entry;
441 	struct nfp_tun_ipv4_addr payload;
442 	struct list_head *ptr, *storage;
443 	int count;
444 
445 	memset(&payload, 0, sizeof(struct nfp_tun_ipv4_addr));
446 	mutex_lock(&priv->nfp_ipv4_off_lock);
447 	count = 0;
448 	list_for_each_safe(ptr, storage, &priv->nfp_ipv4_off_list) {
449 		if (count >= NFP_FL_IPV4_ADDRS_MAX) {
450 			mutex_unlock(&priv->nfp_ipv4_off_lock);
451 			nfp_flower_cmsg_warn(app, "IPv4 offload exceeds limit.\n");
452 			return;
453 		}
454 		entry = list_entry(ptr, struct nfp_ipv4_addr_entry, list);
455 		payload.ipv4_addr[count++] = entry->ipv4_addr;
456 	}
457 	payload.count = cpu_to_be32(count);
458 	mutex_unlock(&priv->nfp_ipv4_off_lock);
459 
460 	nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_TUN_IPS,
461 				 sizeof(struct nfp_tun_ipv4_addr),
462 				 &payload, GFP_KERNEL);
463 }
464 
465 void nfp_tunnel_add_ipv4_off(struct nfp_app *app, __be32 ipv4)
466 {
467 	struct nfp_flower_priv *priv = app->priv;
468 	struct nfp_ipv4_addr_entry *entry;
469 	struct list_head *ptr, *storage;
470 
471 	mutex_lock(&priv->nfp_ipv4_off_lock);
472 	list_for_each_safe(ptr, storage, &priv->nfp_ipv4_off_list) {
473 		entry = list_entry(ptr, struct nfp_ipv4_addr_entry, list);
474 		if (entry->ipv4_addr == ipv4) {
475 			entry->ref_count++;
476 			mutex_unlock(&priv->nfp_ipv4_off_lock);
477 			return;
478 		}
479 	}
480 
481 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
482 	if (!entry) {
483 		mutex_unlock(&priv->nfp_ipv4_off_lock);
484 		nfp_flower_cmsg_warn(app, "Mem error when offloading IP address.\n");
485 		return;
486 	}
487 	entry->ipv4_addr = ipv4;
488 	entry->ref_count = 1;
489 	list_add_tail(&entry->list, &priv->nfp_ipv4_off_list);
490 	mutex_unlock(&priv->nfp_ipv4_off_lock);
491 
492 	nfp_tun_write_ipv4_list(app);
493 }
494 
495 void nfp_tunnel_del_ipv4_off(struct nfp_app *app, __be32 ipv4)
496 {
497 	struct nfp_flower_priv *priv = app->priv;
498 	struct nfp_ipv4_addr_entry *entry;
499 	struct list_head *ptr, *storage;
500 
501 	mutex_lock(&priv->nfp_ipv4_off_lock);
502 	list_for_each_safe(ptr, storage, &priv->nfp_ipv4_off_list) {
503 		entry = list_entry(ptr, struct nfp_ipv4_addr_entry, list);
504 		if (entry->ipv4_addr == ipv4) {
505 			entry->ref_count--;
506 			if (!entry->ref_count) {
507 				list_del(&entry->list);
508 				kfree(entry);
509 			}
510 			break;
511 		}
512 	}
513 	mutex_unlock(&priv->nfp_ipv4_off_lock);
514 
515 	nfp_tun_write_ipv4_list(app);
516 }
517 
518 void nfp_tunnel_write_macs(struct nfp_app *app)
519 {
520 	struct nfp_flower_priv *priv = app->priv;
521 	struct nfp_tun_mac_offload_entry *entry;
522 	struct nfp_tun_mac_addr *payload;
523 	struct list_head *ptr, *storage;
524 	int mac_count, err, pay_size;
525 
526 	mutex_lock(&priv->nfp_mac_off_lock);
527 	if (!priv->nfp_mac_off_count) {
528 		mutex_unlock(&priv->nfp_mac_off_lock);
529 		return;
530 	}
531 
532 	pay_size = sizeof(struct nfp_tun_mac_addr) +
533 		   sizeof(struct index_mac_addr) * priv->nfp_mac_off_count;
534 
535 	payload = kzalloc(pay_size, GFP_KERNEL);
536 	if (!payload) {
537 		mutex_unlock(&priv->nfp_mac_off_lock);
538 		return;
539 	}
540 
541 	payload->count = cpu_to_be16(priv->nfp_mac_off_count);
542 
543 	mac_count = 0;
544 	list_for_each_safe(ptr, storage, &priv->nfp_mac_off_list) {
545 		entry = list_entry(ptr, struct nfp_tun_mac_offload_entry,
546 				   list);
547 		payload->addresses[mac_count].index = entry->index;
548 		ether_addr_copy(payload->addresses[mac_count].addr,
549 				entry->addr);
550 		mac_count++;
551 	}
552 
553 	err = nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_TUN_MAC,
554 				       pay_size, payload, GFP_KERNEL);
555 
556 	kfree(payload);
557 
558 	if (err) {
559 		mutex_unlock(&priv->nfp_mac_off_lock);
560 		/* Write failed so retain list for future retry. */
561 		return;
562 	}
563 
564 	/* If list was successfully offloaded, flush it. */
565 	list_for_each_safe(ptr, storage, &priv->nfp_mac_off_list) {
566 		entry = list_entry(ptr, struct nfp_tun_mac_offload_entry,
567 				   list);
568 		list_del(&entry->list);
569 		kfree(entry);
570 	}
571 
572 	priv->nfp_mac_off_count = 0;
573 	mutex_unlock(&priv->nfp_mac_off_lock);
574 }
575 
576 static int nfp_tun_get_mac_idx(struct nfp_app *app, int ifindex)
577 {
578 	struct nfp_flower_priv *priv = app->priv;
579 	struct nfp_tun_mac_non_nfp_idx *entry;
580 	struct list_head *ptr, *storage;
581 	int idx;
582 
583 	mutex_lock(&priv->nfp_mac_index_lock);
584 	list_for_each_safe(ptr, storage, &priv->nfp_mac_index_list) {
585 		entry = list_entry(ptr, struct nfp_tun_mac_non_nfp_idx, list);
586 		if (entry->ifindex == ifindex) {
587 			idx = entry->index;
588 			mutex_unlock(&priv->nfp_mac_index_lock);
589 			return idx;
590 		}
591 	}
592 
593 	idx = ida_simple_get(&priv->nfp_mac_off_ids, 0,
594 			     NFP_MAX_MAC_INDEX, GFP_KERNEL);
595 	if (idx < 0) {
596 		mutex_unlock(&priv->nfp_mac_index_lock);
597 		return idx;
598 	}
599 
600 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
601 	if (!entry) {
602 		mutex_unlock(&priv->nfp_mac_index_lock);
603 		return -ENOMEM;
604 	}
605 	entry->ifindex = ifindex;
606 	entry->index = idx;
607 	list_add_tail(&entry->list, &priv->nfp_mac_index_list);
608 	mutex_unlock(&priv->nfp_mac_index_lock);
609 
610 	return idx;
611 }
612 
613 static void nfp_tun_del_mac_idx(struct nfp_app *app, int ifindex)
614 {
615 	struct nfp_flower_priv *priv = app->priv;
616 	struct nfp_tun_mac_non_nfp_idx *entry;
617 	struct list_head *ptr, *storage;
618 
619 	mutex_lock(&priv->nfp_mac_index_lock);
620 	list_for_each_safe(ptr, storage, &priv->nfp_mac_index_list) {
621 		entry = list_entry(ptr, struct nfp_tun_mac_non_nfp_idx, list);
622 		if (entry->ifindex == ifindex) {
623 			ida_simple_remove(&priv->nfp_mac_off_ids,
624 					  entry->index);
625 			list_del(&entry->list);
626 			kfree(entry);
627 			break;
628 		}
629 	}
630 	mutex_unlock(&priv->nfp_mac_index_lock);
631 }
632 
633 static void nfp_tun_add_to_mac_offload_list(struct net_device *netdev,
634 					    struct nfp_app *app)
635 {
636 	struct nfp_flower_priv *priv = app->priv;
637 	struct nfp_tun_mac_offload_entry *entry;
638 	u16 nfp_mac_idx;
639 	int port = 0;
640 
641 	/* Check if MAC should be offloaded. */
642 	if (!is_valid_ether_addr(netdev->dev_addr))
643 		return;
644 
645 	if (nfp_netdev_is_nfp_repr(netdev))
646 		port = nfp_repr_get_port_id(netdev);
647 	else if (!nfp_tun_is_netdev_to_offload(netdev))
648 		return;
649 
650 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
651 	if (!entry) {
652 		nfp_flower_cmsg_warn(app, "Mem fail when offloading MAC.\n");
653 		return;
654 	}
655 
656 	if (FIELD_GET(NFP_FLOWER_CMSG_PORT_TYPE, port) ==
657 	    NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT) {
658 		nfp_mac_idx = port << 8 | NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT;
659 	} else if (FIELD_GET(NFP_FLOWER_CMSG_PORT_TYPE, port) ==
660 		   NFP_FLOWER_CMSG_PORT_TYPE_PCIE_PORT) {
661 		port = FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC, port);
662 		nfp_mac_idx = port << 8 | NFP_FLOWER_CMSG_PORT_TYPE_PCIE_PORT;
663 	} else {
664 		/* Must assign our own unique 8-bit index. */
665 		int idx = nfp_tun_get_mac_idx(app, netdev->ifindex);
666 
667 		if (idx < 0) {
668 			nfp_flower_cmsg_warn(app, "Can't assign non-repr MAC index.\n");
669 			kfree(entry);
670 			return;
671 		}
672 		nfp_mac_idx = idx << 8 | NFP_FLOWER_CMSG_PORT_TYPE_OTHER_PORT;
673 	}
674 
675 	entry->index = cpu_to_be16(nfp_mac_idx);
676 	ether_addr_copy(entry->addr, netdev->dev_addr);
677 
678 	mutex_lock(&priv->nfp_mac_off_lock);
679 	priv->nfp_mac_off_count++;
680 	list_add_tail(&entry->list, &priv->nfp_mac_off_list);
681 	mutex_unlock(&priv->nfp_mac_off_lock);
682 }
683 
684 static int nfp_tun_mac_event_handler(struct notifier_block *nb,
685 				     unsigned long event, void *ptr)
686 {
687 	struct nfp_flower_priv *app_priv;
688 	struct net_device *netdev;
689 	struct nfp_app *app;
690 
691 	if (event == NETDEV_DOWN || event == NETDEV_UNREGISTER) {
692 		app_priv = container_of(nb, struct nfp_flower_priv,
693 					nfp_tun_mac_nb);
694 		app = app_priv->app;
695 		netdev = netdev_notifier_info_to_dev(ptr);
696 
697 		/* If non-nfp netdev then free its offload index. */
698 		if (nfp_tun_is_netdev_to_offload(netdev))
699 			nfp_tun_del_mac_idx(app, netdev->ifindex);
700 	} else if (event == NETDEV_UP || event == NETDEV_CHANGEADDR ||
701 		   event == NETDEV_REGISTER) {
702 		app_priv = container_of(nb, struct nfp_flower_priv,
703 					nfp_tun_mac_nb);
704 		app = app_priv->app;
705 		netdev = netdev_notifier_info_to_dev(ptr);
706 
707 		nfp_tun_add_to_mac_offload_list(netdev, app);
708 
709 		/* Force a list write to keep NFP up to date. */
710 		nfp_tunnel_write_macs(app);
711 	}
712 	return NOTIFY_OK;
713 }
714 
715 int nfp_tunnel_config_start(struct nfp_app *app)
716 {
717 	struct nfp_flower_priv *priv = app->priv;
718 	struct net_device *netdev;
719 	int err;
720 
721 	/* Initialise priv data for MAC offloading. */
722 	priv->nfp_mac_off_count = 0;
723 	mutex_init(&priv->nfp_mac_off_lock);
724 	INIT_LIST_HEAD(&priv->nfp_mac_off_list);
725 	priv->nfp_tun_mac_nb.notifier_call = nfp_tun_mac_event_handler;
726 	mutex_init(&priv->nfp_mac_index_lock);
727 	INIT_LIST_HEAD(&priv->nfp_mac_index_list);
728 	ida_init(&priv->nfp_mac_off_ids);
729 
730 	/* Initialise priv data for IPv4 offloading. */
731 	mutex_init(&priv->nfp_ipv4_off_lock);
732 	INIT_LIST_HEAD(&priv->nfp_ipv4_off_list);
733 
734 	/* Initialise priv data for neighbour offloading. */
735 	spin_lock_init(&priv->nfp_neigh_off_lock);
736 	INIT_LIST_HEAD(&priv->nfp_neigh_off_list);
737 	priv->nfp_tun_neigh_nb.notifier_call = nfp_tun_neigh_event_handler;
738 
739 	err = register_netdevice_notifier(&priv->nfp_tun_mac_nb);
740 	if (err)
741 		goto err_free_mac_ida;
742 
743 	err = register_netevent_notifier(&priv->nfp_tun_neigh_nb);
744 	if (err)
745 		goto err_unreg_mac_nb;
746 
747 	/* Parse netdevs already registered for MACs that need offloaded. */
748 	rtnl_lock();
749 	for_each_netdev(&init_net, netdev)
750 		nfp_tun_add_to_mac_offload_list(netdev, app);
751 	rtnl_unlock();
752 
753 	return 0;
754 
755 err_unreg_mac_nb:
756 	unregister_netdevice_notifier(&priv->nfp_tun_mac_nb);
757 err_free_mac_ida:
758 	ida_destroy(&priv->nfp_mac_off_ids);
759 	return err;
760 }
761 
762 void nfp_tunnel_config_stop(struct nfp_app *app)
763 {
764 	struct nfp_tun_mac_offload_entry *mac_entry;
765 	struct nfp_flower_priv *priv = app->priv;
766 	struct nfp_ipv4_route_entry *route_entry;
767 	struct nfp_tun_mac_non_nfp_idx *mac_idx;
768 	struct nfp_ipv4_addr_entry *ip_entry;
769 	struct list_head *ptr, *storage;
770 
771 	unregister_netdevice_notifier(&priv->nfp_tun_mac_nb);
772 	unregister_netevent_notifier(&priv->nfp_tun_neigh_nb);
773 
774 	/* Free any memory that may be occupied by MAC list. */
775 	list_for_each_safe(ptr, storage, &priv->nfp_mac_off_list) {
776 		mac_entry = list_entry(ptr, struct nfp_tun_mac_offload_entry,
777 				       list);
778 		list_del(&mac_entry->list);
779 		kfree(mac_entry);
780 	}
781 
782 	/* Free any memory that may be occupied by MAC index list. */
783 	list_for_each_safe(ptr, storage, &priv->nfp_mac_index_list) {
784 		mac_idx = list_entry(ptr, struct nfp_tun_mac_non_nfp_idx,
785 				     list);
786 		list_del(&mac_idx->list);
787 		kfree(mac_idx);
788 	}
789 
790 	ida_destroy(&priv->nfp_mac_off_ids);
791 
792 	/* Free any memory that may be occupied by ipv4 list. */
793 	list_for_each_safe(ptr, storage, &priv->nfp_ipv4_off_list) {
794 		ip_entry = list_entry(ptr, struct nfp_ipv4_addr_entry, list);
795 		list_del(&ip_entry->list);
796 		kfree(ip_entry);
797 	}
798 
799 	/* Free any memory that may be occupied by the route list. */
800 	list_for_each_safe(ptr, storage, &priv->nfp_neigh_off_list) {
801 		route_entry = list_entry(ptr, struct nfp_ipv4_route_entry,
802 					 list);
803 		list_del(&route_entry->list);
804 		kfree(route_entry);
805 	}
806 }
807