drivers/net/ethernet/netronome/nfp/flower/cmsg.c - hafnium/third_party/linux - Git at Google

 /*
  * Copyright (C) 2015-2017 Netronome Systems, Inc.
  *
  * This software is dual licensed under the GNU General License Version 2,
  * June 1991 as shown in the file COPYING in the top-level directory of this
  * source tree or the BSD 2-Clause License provided below.  You have the
  * option to license this software under the complete terms of either license.
  *
  * The BSD 2-Clause License:
  *
  *     Redistribution and use in source and binary forms, with or
  *     without modification, are permitted provided that the following
  *     conditions are met:
  *
  *      1. Redistributions of source code must retain the above
  *         copyright notice, this list of conditions and the following
  *         disclaimer.
  *
  *      2. Redistributions in binary form must reproduce the above
  *         copyright notice, this list of conditions and the following
  *         disclaimer in the documentation and/or other materials
  *         provided with the distribution.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */

 #include <linux/bitfield.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
 #include <linux/workqueue.h>
 #include <net/dst_metadata.h>

 #include "main.h"
 #include "../nfp_net.h"
 #include "../nfp_net_repr.h"
 #include "./cmsg.h"

 static struct nfp_flower_cmsg_hdr *
 nfp_flower_cmsg_get_hdr(struct sk_buff *skb)
 {
 	return (struct nfp_flower_cmsg_hdr *)skb->data;
 }

 struct sk_buff *
 nfp_flower_cmsg_alloc(struct nfp_app *app, unsigned int size,
 		      enum nfp_flower_cmsg_type_port type, gfp_t flag)
 {
 	struct nfp_flower_cmsg_hdr *ch;
 	struct sk_buff *skb;

 	size += NFP_FLOWER_CMSG_HLEN;

 	skb = nfp_app_ctrl_msg_alloc(app, size, flag);
 	if (!skb)
 		return NULL;

 	ch = nfp_flower_cmsg_get_hdr(skb);
 	ch->pad = 0;
 	ch->version = NFP_FLOWER_CMSG_VER1;
 	ch->type = type;
 	skb_put(skb, size);

 	return skb;
 }

 struct sk_buff *
 nfp_flower_cmsg_mac_repr_start(struct nfp_app *app, unsigned int num_ports)
 {
 	struct nfp_flower_cmsg_mac_repr *msg;
 	struct sk_buff *skb;
 	unsigned int size;

 	size = sizeof(*msg) + num_ports * sizeof(msg->ports[0]);
 	skb = nfp_flower_cmsg_alloc(app, size, NFP_FLOWER_CMSG_TYPE_MAC_REPR,
 				    GFP_KERNEL);
 	if (!skb)
 		return NULL;

 	msg = nfp_flower_cmsg_get_data(skb);
 	memset(msg->reserved, 0, sizeof(msg->reserved));
 	msg->num_ports = num_ports;

 	return skb;
 }

 void
 nfp_flower_cmsg_mac_repr_add(struct sk_buff *skb, unsigned int idx,
 			     unsigned int nbi, unsigned int nbi_port,
 			     unsigned int phys_port)
 {
 	struct nfp_flower_cmsg_mac_repr *msg;

 	msg = nfp_flower_cmsg_get_data(skb);
 	msg->ports[idx].idx = idx;
 	msg->ports[idx].info = nbi & NFP_FLOWER_CMSG_MAC_REPR_NBI;
 	msg->ports[idx].nbi_port = nbi_port;
 	msg->ports[idx].phys_port = phys_port;
 }

 int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok,
 			    unsigned int mtu, bool mtu_only)
 {
 	struct nfp_flower_cmsg_portmod *msg;
 	struct sk_buff *skb;

 	skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
 				    NFP_FLOWER_CMSG_TYPE_PORT_MOD, GFP_KERNEL);
 	if (!skb)
 		return -ENOMEM;

 	msg = nfp_flower_cmsg_get_data(skb);
 	msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
 	msg->reserved = 0;
 	msg->info = carrier_ok;

 	if (mtu_only)
 		msg->info |= NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY;

 	msg->mtu = cpu_to_be16(mtu);

 	nfp_ctrl_tx(repr->app->ctrl, skb);

 	return 0;
 }

 int nfp_flower_cmsg_portreify(struct nfp_repr *repr, bool exists)
 {
 	struct nfp_flower_cmsg_portreify *msg;
 	struct sk_buff *skb;

 	skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
 				    NFP_FLOWER_CMSG_TYPE_PORT_REIFY,
 				    GFP_KERNEL);
 	if (!skb)
 		return -ENOMEM;

 	msg = nfp_flower_cmsg_get_data(skb);
 	msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
 	msg->reserved = 0;
 	msg->info = cpu_to_be16(exists);

 	nfp_ctrl_tx(repr->app->ctrl, skb);

 	return 0;
 }

 static bool
 nfp_flower_process_mtu_ack(struct nfp_app *app, struct sk_buff *skb)
 {
 	struct nfp_flower_priv *app_priv = app->priv;
 	struct nfp_flower_cmsg_portmod *msg;

 	msg = nfp_flower_cmsg_get_data(skb);

 	if (!(msg->info & NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY))
 		return false;

 	spin_lock_bh(&app_priv->mtu_conf.lock);
 	if (!app_priv->mtu_conf.requested_val ||
 	    app_priv->mtu_conf.portnum != be32_to_cpu(msg->portnum) ||
 	    be16_to_cpu(msg->mtu) != app_priv->mtu_conf.requested_val) {
 		/* Not an ack for requested MTU change. */
 		spin_unlock_bh(&app_priv->mtu_conf.lock);
 		return false;
 	}

 	app_priv->mtu_conf.ack = true;
 	app_priv->mtu_conf.requested_val = 0;
 	wake_up(&app_priv->mtu_conf.wait_q);
 	spin_unlock_bh(&app_priv->mtu_conf.lock);

 	return true;
 }

 static void
 nfp_flower_cmsg_portmod_rx(struct nfp_app *app, struct sk_buff *skb)
 {
 	struct nfp_flower_cmsg_portmod *msg;
 	struct net_device *netdev;
 	bool link;

 	msg = nfp_flower_cmsg_get_data(skb);
 	link = msg->info & NFP_FLOWER_CMSG_PORTMOD_INFO_LINK;

 	rtnl_lock();
 	rcu_read_lock();
 	netdev = nfp_app_repr_get(app, be32_to_cpu(msg->portnum));
 	rcu_read_unlock();
 	if (!netdev) {
 		nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
 				     be32_to_cpu(msg->portnum));
 		rtnl_unlock();
 		return;
 	}

 	if (link) {
 		u16 mtu = be16_to_cpu(msg->mtu);

 		netif_carrier_on(netdev);

 		/* An MTU of 0 from the firmware should be ignored */
 		if (mtu)
 			dev_set_mtu(netdev, mtu);
 	} else {
 		netif_carrier_off(netdev);
 	}
 	rtnl_unlock();
 }

 static void
 nfp_flower_cmsg_portreify_rx(struct nfp_app *app, struct sk_buff *skb)
 {
 	struct nfp_flower_priv *priv = app->priv;
 	struct nfp_flower_cmsg_portreify *msg;
 	bool exists;

 	msg = nfp_flower_cmsg_get_data(skb);

 	rcu_read_lock();
 	exists = !!nfp_app_repr_get(app, be32_to_cpu(msg->portnum));
 	rcu_read_unlock();
 	if (!exists) {
 		nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
 				     be32_to_cpu(msg->portnum));
 		return;
 	}

 	atomic_inc(&priv->reify_replies);
 	wake_up_interruptible(&priv->reify_wait_queue);
 }

 static void
 nfp_flower_cmsg_process_one_rx(struct nfp_app *app, struct sk_buff *skb)
 {
 	struct nfp_flower_priv *app_priv = app->priv;
 	struct nfp_flower_cmsg_hdr *cmsg_hdr;
 	enum nfp_flower_cmsg_type_port type;
 	bool skb_stored = false;

 	cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);

 	type = cmsg_hdr->type;
 	switch (type) {
 	case NFP_FLOWER_CMSG_TYPE_PORT_REIFY:
 		nfp_flower_cmsg_portreify_rx(app, skb);
 		break;
 	case NFP_FLOWER_CMSG_TYPE_PORT_MOD:
 		nfp_flower_cmsg_portmod_rx(app, skb);
 		break;
 	case NFP_FLOWER_CMSG_TYPE_NO_NEIGH:
 		nfp_tunnel_request_route(app, skb);
 		break;
 	case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS:
 		nfp_tunnel_keep_alive(app, skb);
 		break;
 	case NFP_FLOWER_CMSG_TYPE_LAG_CONFIG:
 		if (app_priv->flower_ext_feats & NFP_FL_FEATS_LAG) {
 			skb_stored = nfp_flower_lag_unprocessed_msg(app, skb);
 			break;
 		}
 		/* fall through */
 	default:
 		nfp_flower_cmsg_warn(app, "Cannot handle invalid repr control type %u\n",
 				     type);
 		goto out;
 	}

 	if (!skb_stored)
 		dev_consume_skb_any(skb);
 	return;
 out:
 	dev_kfree_skb_any(skb);
 }

 void nfp_flower_cmsg_process_rx(struct work_struct *work)
 {
 	struct sk_buff_head cmsg_joined;
 	struct nfp_flower_priv *priv;
 	struct sk_buff *skb;

 	priv = container_of(work, struct nfp_flower_priv, cmsg_work);
 	skb_queue_head_init(&cmsg_joined);

 	spin_lock_bh(&priv->cmsg_skbs_high.lock);
 	skb_queue_splice_tail_init(&priv->cmsg_skbs_high, &cmsg_joined);
 	spin_unlock_bh(&priv->cmsg_skbs_high.lock);

 	spin_lock_bh(&priv->cmsg_skbs_low.lock);
 	skb_queue_splice_tail_init(&priv->cmsg_skbs_low, &cmsg_joined);
 	spin_unlock_bh(&priv->cmsg_skbs_low.lock);

 	while ((skb = __skb_dequeue(&cmsg_joined)))
 		nfp_flower_cmsg_process_one_rx(priv->app, skb);
 }

 static void
 nfp_flower_queue_ctl_msg(struct nfp_app *app, struct sk_buff *skb, int type)
 {
 	struct nfp_flower_priv *priv = app->priv;
 	struct sk_buff_head *skb_head;

 	if (type == NFP_FLOWER_CMSG_TYPE_PORT_REIFY ||
 	    type == NFP_FLOWER_CMSG_TYPE_PORT_MOD)
 		skb_head = &priv->cmsg_skbs_high;
 	else
 		skb_head = &priv->cmsg_skbs_low;

 	if (skb_queue_len(skb_head) >= NFP_FLOWER_WORKQ_MAX_SKBS) {
 		nfp_flower_cmsg_warn(app, "Dropping queued control messages\n");
 		dev_kfree_skb_any(skb);
 		return;
 	}

 	skb_queue_tail(skb_head, skb);
 	schedule_work(&priv->cmsg_work);
 }

 void nfp_flower_cmsg_rx(struct nfp_app *app, struct sk_buff *skb)
 {
 	struct nfp_flower_cmsg_hdr *cmsg_hdr;

 	cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);

 	if (unlikely(cmsg_hdr->version != NFP_FLOWER_CMSG_VER1)) {
 		nfp_flower_cmsg_warn(app, "Cannot handle repr control version %u\n",
 				     cmsg_hdr->version);
 		dev_kfree_skb_any(skb);
 		return;
 	}

 	if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_FLOW_STATS) {
 		/* We need to deal with stats updates from HW asap */
 		nfp_flower_rx_flow_stats(app, skb);
 		dev_consume_skb_any(skb);
 	} else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_MOD &&
 		   nfp_flower_process_mtu_ack(app, skb)) {
 		/* Handle MTU acks outside wq to prevent RTNL conflict. */
 		dev_consume_skb_any(skb);
 	} else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH) {
 		/* Acks from the NFP that the route is added - ignore. */
 		dev_consume_skb_any(skb);
 	} else {
 		nfp_flower_queue_ctl_msg(app, skb, cmsg_hdr->type);
 	}
 }
	/*
	* Copyright (C) 2015-2017 Netronome Systems, Inc.
	*
	* This software is dual licensed under the GNU General License Version 2,
	* June 1991 as shown in the file COPYING in the top-level directory of this
	* source tree or the BSD 2-Clause License provided below. You have the
	* option to license this software under the complete terms of either license.
	*
	* The BSD 2-Clause License:
	*
	* Redistribution and use in source and binary forms, with or
	* without modification, are permitted provided that the following
	* conditions are met:
	*
	* 1. Redistributions of source code must retain the above
	* copyright notice, this list of conditions and the following
	* disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials
	* provided with the distribution.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	* SOFTWARE.
	*/

	#include <linux/bitfield.h>
	#include <linux/netdevice.h>
	#include <linux/skbuff.h>
	#include <linux/workqueue.h>
	#include <net/dst_metadata.h>

	#include "main.h"
	#include "../nfp_net.h"
	#include "../nfp_net_repr.h"
	#include "./cmsg.h"

	static struct nfp_flower_cmsg_hdr *
	nfp_flower_cmsg_get_hdr(struct sk_buff *skb)
	{
	return (struct nfp_flower_cmsg_hdr *)skb->data;
	}

	struct sk_buff *
	nfp_flower_cmsg_alloc(struct nfp_app *app, unsigned int size,
	enum nfp_flower_cmsg_type_port type, gfp_t flag)
	{
	struct nfp_flower_cmsg_hdr *ch;
	struct sk_buff *skb;

	size += NFP_FLOWER_CMSG_HLEN;

	skb = nfp_app_ctrl_msg_alloc(app, size, flag);
	if (!skb)
	return NULL;

	ch = nfp_flower_cmsg_get_hdr(skb);
	ch->pad = 0;
	ch->version = NFP_FLOWER_CMSG_VER1;
	ch->type = type;
	skb_put(skb, size);

	return skb;
	}

	struct sk_buff *
	nfp_flower_cmsg_mac_repr_start(struct nfp_app *app, unsigned int num_ports)
	{
	struct nfp_flower_cmsg_mac_repr *msg;
	struct sk_buff *skb;
	unsigned int size;

	size = sizeof(msg) + num_ports sizeof(msg->ports[0]);
	skb = nfp_flower_cmsg_alloc(app, size, NFP_FLOWER_CMSG_TYPE_MAC_REPR,
	GFP_KERNEL);
	if (!skb)
	return NULL;

	msg = nfp_flower_cmsg_get_data(skb);
	memset(msg->reserved, 0, sizeof(msg->reserved));
	msg->num_ports = num_ports;

	return skb;
	}

	void
	nfp_flower_cmsg_mac_repr_add(struct sk_buff *skb, unsigned int idx,
	unsigned int nbi, unsigned int nbi_port,
	unsigned int phys_port)
	{
	struct nfp_flower_cmsg_mac_repr *msg;

	msg = nfp_flower_cmsg_get_data(skb);
	msg->ports[idx].idx = idx;
	msg->ports[idx].info = nbi & NFP_FLOWER_CMSG_MAC_REPR_NBI;
	msg->ports[idx].nbi_port = nbi_port;
	msg->ports[idx].phys_port = phys_port;
	}

	int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok,
	unsigned int mtu, bool mtu_only)
	{
	struct nfp_flower_cmsg_portmod *msg;
	struct sk_buff *skb;

	skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
	NFP_FLOWER_CMSG_TYPE_PORT_MOD, GFP_KERNEL);
	if (!skb)
	return -ENOMEM;

	msg = nfp_flower_cmsg_get_data(skb);
	msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
	msg->reserved = 0;
	msg->info = carrier_ok;

	if (mtu_only)
	msg->info \|= NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY;

	msg->mtu = cpu_to_be16(mtu);

	nfp_ctrl_tx(repr->app->ctrl, skb);

	return 0;
	}

	int nfp_flower_cmsg_portreify(struct nfp_repr *repr, bool exists)
	{
	struct nfp_flower_cmsg_portreify *msg;
	struct sk_buff *skb;

	skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
	NFP_FLOWER_CMSG_TYPE_PORT_REIFY,
	GFP_KERNEL);
	if (!skb)
	return -ENOMEM;

	msg = nfp_flower_cmsg_get_data(skb);
	msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
	msg->reserved = 0;
	msg->info = cpu_to_be16(exists);

	nfp_ctrl_tx(repr->app->ctrl, skb);

	return 0;
	}

	static bool
	nfp_flower_process_mtu_ack(struct nfp_app app, struct sk_buff skb)
	{
	struct nfp_flower_priv *app_priv = app->priv;
	struct nfp_flower_cmsg_portmod *msg;

	msg = nfp_flower_cmsg_get_data(skb);

	if (!(msg->info & NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY))
	return false;

	spin_lock_bh(&app_priv->mtu_conf.lock);
	if (!app_priv->mtu_conf.requested_val \|\|
	app_priv->mtu_conf.portnum != be32_to_cpu(msg->portnum) \|\|
	be16_to_cpu(msg->mtu) != app_priv->mtu_conf.requested_val) {
	/* Not an ack for requested MTU change. */
	spin_unlock_bh(&app_priv->mtu_conf.lock);
	return false;
	}

	app_priv->mtu_conf.ack = true;
	app_priv->mtu_conf.requested_val = 0;
	wake_up(&app_priv->mtu_conf.wait_q);
	spin_unlock_bh(&app_priv->mtu_conf.lock);

	return true;
	}

	static void
	nfp_flower_cmsg_portmod_rx(struct nfp_app app, struct sk_buff skb)
	{
	struct nfp_flower_cmsg_portmod *msg;
	struct net_device *netdev;
	bool link;

	msg = nfp_flower_cmsg_get_data(skb);
	link = msg->info & NFP_FLOWER_CMSG_PORTMOD_INFO_LINK;

	rtnl_lock();
	rcu_read_lock();
	netdev = nfp_app_repr_get(app, be32_to_cpu(msg->portnum));
	rcu_read_unlock();
	if (!netdev) {
	nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
	be32_to_cpu(msg->portnum));
	rtnl_unlock();
	return;
	}

	if (link) {
	u16 mtu = be16_to_cpu(msg->mtu);

	netif_carrier_on(netdev);

	/* An MTU of 0 from the firmware should be ignored */
	if (mtu)
	dev_set_mtu(netdev, mtu);
	} else {
	netif_carrier_off(netdev);
	}
	rtnl_unlock();
	}

	static void
	nfp_flower_cmsg_portreify_rx(struct nfp_app app, struct sk_buff skb)
	{
	struct nfp_flower_priv *priv = app->priv;
	struct nfp_flower_cmsg_portreify *msg;
	bool exists;

	msg = nfp_flower_cmsg_get_data(skb);

	rcu_read_lock();
	exists = !!nfp_app_repr_get(app, be32_to_cpu(msg->portnum));
	rcu_read_unlock();
	if (!exists) {
	nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
	be32_to_cpu(msg->portnum));
	return;
	}

	atomic_inc(&priv->reify_replies);
	wake_up_interruptible(&priv->reify_wait_queue);
	}

	static void
	nfp_flower_cmsg_process_one_rx(struct nfp_app app, struct sk_buff skb)
	{
	struct nfp_flower_priv *app_priv = app->priv;
	struct nfp_flower_cmsg_hdr *cmsg_hdr;
	enum nfp_flower_cmsg_type_port type;
	bool skb_stored = false;

	cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);

	type = cmsg_hdr->type;
	switch (type) {
	case NFP_FLOWER_CMSG_TYPE_PORT_REIFY:
	nfp_flower_cmsg_portreify_rx(app, skb);
	break;
	case NFP_FLOWER_CMSG_TYPE_PORT_MOD:
	nfp_flower_cmsg_portmod_rx(app, skb);
	break;
	case NFP_FLOWER_CMSG_TYPE_NO_NEIGH:
	nfp_tunnel_request_route(app, skb);
	break;
	case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS:
	nfp_tunnel_keep_alive(app, skb);
	break;
	case NFP_FLOWER_CMSG_TYPE_LAG_CONFIG:
	if (app_priv->flower_ext_feats & NFP_FL_FEATS_LAG) {
	skb_stored = nfp_flower_lag_unprocessed_msg(app, skb);
	break;
	}
	/* fall through */
	default:
	nfp_flower_cmsg_warn(app, "Cannot handle invalid repr control type %u\n",
	type);
	goto out;
	}

	if (!skb_stored)
	dev_consume_skb_any(skb);
	return;
	out:
	dev_kfree_skb_any(skb);
	}

	void nfp_flower_cmsg_process_rx(struct work_struct *work)
	{
	struct sk_buff_head cmsg_joined;
	struct nfp_flower_priv *priv;
	struct sk_buff *skb;

	priv = container_of(work, struct nfp_flower_priv, cmsg_work);
	skb_queue_head_init(&cmsg_joined);

	spin_lock_bh(&priv->cmsg_skbs_high.lock);
	skb_queue_splice_tail_init(&priv->cmsg_skbs_high, &cmsg_joined);
	spin_unlock_bh(&priv->cmsg_skbs_high.lock);

	spin_lock_bh(&priv->cmsg_skbs_low.lock);
	skb_queue_splice_tail_init(&priv->cmsg_skbs_low, &cmsg_joined);
	spin_unlock_bh(&priv->cmsg_skbs_low.lock);

	while ((skb = __skb_dequeue(&cmsg_joined)))
	nfp_flower_cmsg_process_one_rx(priv->app, skb);
	}

	static void
	nfp_flower_queue_ctl_msg(struct nfp_app app, struct sk_buff skb, int type)
	{
	struct nfp_flower_priv *priv = app->priv;
	struct sk_buff_head *skb_head;

	if (type == NFP_FLOWER_CMSG_TYPE_PORT_REIFY \|\|
	type == NFP_FLOWER_CMSG_TYPE_PORT_MOD)
	skb_head = &priv->cmsg_skbs_high;
	else
	skb_head = &priv->cmsg_skbs_low;

	if (skb_queue_len(skb_head) >= NFP_FLOWER_WORKQ_MAX_SKBS) {
	nfp_flower_cmsg_warn(app, "Dropping queued control messages\n");
	dev_kfree_skb_any(skb);
	return;
	}

	skb_queue_tail(skb_head, skb);
	schedule_work(&priv->cmsg_work);
	}

	void nfp_flower_cmsg_rx(struct nfp_app app, struct sk_buff skb)
	{
	struct nfp_flower_cmsg_hdr *cmsg_hdr;

	cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);

	if (unlikely(cmsg_hdr->version != NFP_FLOWER_CMSG_VER1)) {
	nfp_flower_cmsg_warn(app, "Cannot handle repr control version %u\n",
	cmsg_hdr->version);
	dev_kfree_skb_any(skb);
	return;
	}

	if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_FLOW_STATS) {
	/* We need to deal with stats updates from HW asap */
	nfp_flower_rx_flow_stats(app, skb);
	dev_consume_skb_any(skb);
	} else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_MOD &&
	nfp_flower_process_mtu_ack(app, skb)) {
	/* Handle MTU acks outside wq to prevent RTNL conflict. */
	dev_consume_skb_any(skb);
	} else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH) {
	/* Acks from the NFP that the route is added - ignore. */
	dev_consume_skb_any(skb);
	} else {
	nfp_flower_queue_ctl_msg(app, skb, cmsg_hdr->type);
	}
	}