Commit 9d60f0ea authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'nfp-update-to-control-structures' 



Jakub Kicinski says:

====================
nfp: update to control structures

This series prepares NFP control structures for crypto offloads.
So far we mostly dealt with configuration requests under rtnl lock.
This will no longer be the case with crypto.  Additionally we will
try to reuse the BPF control message format, so we move common code
out of BPF.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 1deeb640 bcf0cafa

drivers/net/ethernet/netronome/nfp/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ nfp-objs := \ 
	    nfpcore/nfp_resource.o \

	    nfpcore/nfp_rtsym.o \

	    nfpcore/nfp_target.o \

	    ccm.o \

	    nfp_asm.o \

	    nfp_app.o \

	    nfp_app_nic.o \

drivers/net/ethernet/netronome/nfp/abm/ctrl.c

+6 −2
Original line number Diff line number Diff line
@@ -261,10 +261,15 @@ int nfp_abm_ctrl_qm_disable(struct nfp_abm *abm) 


int nfp_abm_ctrl_prio_map_update(struct nfp_abm_link *alink, u32 *packed)

{

	const u32 cmd = NFP_NET_CFG_MBOX_CMD_PCI_DSCP_PRIOMAP_SET;

	struct nfp_net *nn = alink->vnic;

	unsigned int i;

	int err;



	err = nfp_net_mbox_lock(nn, alink->abm->prio_map_len);

	if (err)

		return err;



	/* Write data_len and wipe reserved */

	nn_writeq(nn, nn->tlv_caps.mbox_off + NFP_NET_ABM_MBOX_DATALEN,

		  alink->abm->prio_map_len);
@@ -273,8 +278,7 @@ int nfp_abm_ctrl_prio_map_update(struct nfp_abm_link *alink, u32 *packed) 
		nn_writel(nn, nn->tlv_caps.mbox_off + NFP_NET_ABM_MBOX_DATA + i,

			  packed[i / sizeof(u32)]);



	err = nfp_net_reconfig_mbox(nn,

				    NFP_NET_CFG_MBOX_CMD_PCI_DSCP_PRIOMAP_SET);

	err = nfp_net_mbox_reconfig_and_unlock(nn, cmd);

	if (err)

		nfp_err(alink->abm->app->cpp,

			"setting DSCP -> VQ map failed with error %d\n", err);

drivers/net/ethernet/netronome/nfp/bpf/cmsg.c

+19 −217
Original line number Diff line number Diff line
@@ -6,48 +6,13 @@ 
#include <linux/bug.h>

#include <linux/jiffies.h>

#include <linux/skbuff.h>

#include <linux/wait.h>



#include "../ccm.h"

#include "../nfp_app.h"

#include "../nfp_net.h"

#include "fw.h"

#include "main.h"



#define NFP_BPF_TAG_ALLOC_SPAN	(U16_MAX / 4)



static bool nfp_bpf_all_tags_busy(struct nfp_app_bpf *bpf)

{

	u16 used_tags;



	used_tags = bpf->tag_alloc_next - bpf->tag_alloc_last;



	return used_tags > NFP_BPF_TAG_ALLOC_SPAN;

}



static int nfp_bpf_alloc_tag(struct nfp_app_bpf *bpf)

{

	/* All FW communication for BPF is request-reply.  To make sure we

	 * don't reuse the message ID too early after timeout - limit the

	 * number of requests in flight.

	 */

	if (nfp_bpf_all_tags_busy(bpf)) {

		cmsg_warn(bpf, "all FW request contexts busy!\n");

		return -EAGAIN;

	}



	WARN_ON(__test_and_set_bit(bpf->tag_alloc_next, bpf->tag_allocator));

	return bpf->tag_alloc_next++;

}



static void nfp_bpf_free_tag(struct nfp_app_bpf *bpf, u16 tag)

{

	WARN_ON(!__test_and_clear_bit(tag, bpf->tag_allocator));



	while (!test_bit(bpf->tag_alloc_last, bpf->tag_allocator) &&

	       bpf->tag_alloc_last != bpf->tag_alloc_next)

		bpf->tag_alloc_last++;

}



static struct sk_buff *

nfp_bpf_cmsg_alloc(struct nfp_app_bpf *bpf, unsigned int size)

{
@@ -87,149 +52,6 @@ nfp_bpf_cmsg_map_reply_size(struct nfp_app_bpf *bpf, unsigned int n) 
	return size;

}



static u8 nfp_bpf_cmsg_get_type(struct sk_buff *skb)

{

	struct cmsg_hdr *hdr;



	hdr = (struct cmsg_hdr *)skb->data;



	return hdr->type;

}



static unsigned int nfp_bpf_cmsg_get_tag(struct sk_buff *skb)

{

	struct cmsg_hdr *hdr;



	hdr = (struct cmsg_hdr *)skb->data;



	return be16_to_cpu(hdr->tag);

}



static struct sk_buff *__nfp_bpf_reply(struct nfp_app_bpf *bpf, u16 tag)

{

	unsigned int msg_tag;

	struct sk_buff *skb;



	skb_queue_walk(&bpf->cmsg_replies, skb) {

		msg_tag = nfp_bpf_cmsg_get_tag(skb);

		if (msg_tag == tag) {

			nfp_bpf_free_tag(bpf, tag);

			__skb_unlink(skb, &bpf->cmsg_replies);

			return skb;

		}

	}



	return NULL;

}



static struct sk_buff *nfp_bpf_reply(struct nfp_app_bpf *bpf, u16 tag)

{

	struct sk_buff *skb;



	nfp_ctrl_lock(bpf->app->ctrl);

	skb = __nfp_bpf_reply(bpf, tag);

	nfp_ctrl_unlock(bpf->app->ctrl);



	return skb;

}



static struct sk_buff *nfp_bpf_reply_drop_tag(struct nfp_app_bpf *bpf, u16 tag)

{

	struct sk_buff *skb;



	nfp_ctrl_lock(bpf->app->ctrl);

	skb = __nfp_bpf_reply(bpf, tag);

	if (!skb)

		nfp_bpf_free_tag(bpf, tag);

	nfp_ctrl_unlock(bpf->app->ctrl);



	return skb;

}



static struct sk_buff *

nfp_bpf_cmsg_wait_reply(struct nfp_app_bpf *bpf, enum nfp_bpf_cmsg_type type,

			int tag)

{

	struct sk_buff *skb;

	int i, err;



	for (i = 0; i < 50; i++) {

		udelay(4);

		skb = nfp_bpf_reply(bpf, tag);

		if (skb)

			return skb;

	}



	err = wait_event_interruptible_timeout(bpf->cmsg_wq,

					       skb = nfp_bpf_reply(bpf, tag),

					       msecs_to_jiffies(5000));

	/* We didn't get a response - try last time and atomically drop

	 * the tag even if no response is matched.

	 */

	if (!skb)

		skb = nfp_bpf_reply_drop_tag(bpf, tag);

	if (err < 0) {

		cmsg_warn(bpf, "%s waiting for response to 0x%02x: %d\n",

			  err == ERESTARTSYS ? "interrupted" : "error",

			  type, err);

		return ERR_PTR(err);

	}

	if (!skb) {

		cmsg_warn(bpf, "timeout waiting for response to 0x%02x\n",

			  type);

		return ERR_PTR(-ETIMEDOUT);

	}



	return skb;

}



static struct sk_buff *

nfp_bpf_cmsg_communicate(struct nfp_app_bpf *bpf, struct sk_buff *skb,

			 enum nfp_bpf_cmsg_type type, unsigned int reply_size)

{

	struct cmsg_hdr *hdr;

	int tag;



	nfp_ctrl_lock(bpf->app->ctrl);

	tag = nfp_bpf_alloc_tag(bpf);

	if (tag < 0) {

		nfp_ctrl_unlock(bpf->app->ctrl);

		dev_kfree_skb_any(skb);

		return ERR_PTR(tag);

	}



	hdr = (void *)skb->data;

	hdr->ver = CMSG_MAP_ABI_VERSION;

	hdr->type = type;

	hdr->tag = cpu_to_be16(tag);



	__nfp_app_ctrl_tx(bpf->app, skb);



	nfp_ctrl_unlock(bpf->app->ctrl);



	skb = nfp_bpf_cmsg_wait_reply(bpf, type, tag);

	if (IS_ERR(skb))

		return skb;



	hdr = (struct cmsg_hdr *)skb->data;

	if (hdr->type != __CMSG_REPLY(type)) {

		cmsg_warn(bpf, "cmsg drop - wrong type 0x%02x != 0x%02lx!\n",

			  hdr->type, __CMSG_REPLY(type));

		goto err_free;

	}

	/* 0 reply_size means caller will do the validation */

	if (reply_size && skb->len != reply_size) {

		cmsg_warn(bpf, "cmsg drop - type 0x%02x wrong size %d != %d!\n",

			  type, skb->len, reply_size);

		goto err_free;

	}



	return skb;

err_free:

	dev_kfree_skb_any(skb);

	return ERR_PTR(-EIO);

}



static int

nfp_bpf_ctrl_rc_to_errno(struct nfp_app_bpf *bpf,

			 struct cmsg_reply_map_simple *reply)
@@ -275,7 +97,7 @@ nfp_bpf_ctrl_alloc_map(struct nfp_app_bpf *bpf, struct bpf_map *map) 
	req->map_type = cpu_to_be32(map->map_type);

	req->map_flags = 0;



	skb = nfp_bpf_cmsg_communicate(bpf, skb, CMSG_TYPE_MAP_ALLOC,

	skb = nfp_ccm_communicate(&bpf->ccm, skb, NFP_CCM_TYPE_BPF_MAP_ALLOC,

				  sizeof(*reply));

	if (IS_ERR(skb))

		return PTR_ERR(skb);
@@ -310,7 +132,7 @@ void nfp_bpf_ctrl_free_map(struct nfp_app_bpf *bpf, struct nfp_bpf_map *nfp_map) 
	req = (void *)skb->data;

	req->tid = cpu_to_be32(nfp_map->tid);



	skb = nfp_bpf_cmsg_communicate(bpf, skb, CMSG_TYPE_MAP_FREE,

	skb = nfp_ccm_communicate(&bpf->ccm, skb, NFP_CCM_TYPE_BPF_MAP_FREE,

				  sizeof(*reply));

	if (IS_ERR(skb)) {

		cmsg_warn(bpf, "leaking map - I/O error\n");
@@ -354,8 +176,7 @@ nfp_bpf_ctrl_reply_val(struct nfp_app_bpf *bpf, struct cmsg_reply_map_op *reply, 
}



static int

nfp_bpf_ctrl_entry_op(struct bpf_offloaded_map *offmap,

		      enum nfp_bpf_cmsg_type op,

nfp_bpf_ctrl_entry_op(struct bpf_offloaded_map *offmap, enum nfp_ccm_type op,

		      u8 *key, u8 *value, u64 flags, u8 *out_key, u8 *out_value)

{

	struct nfp_bpf_map *nfp_map = offmap->dev_priv;
@@ -386,7 +207,7 @@ nfp_bpf_ctrl_entry_op(struct bpf_offloaded_map *offmap, 
		memcpy(nfp_bpf_ctrl_req_val(bpf, req, 0), value,

		       map->value_size);



	skb = nfp_bpf_cmsg_communicate(bpf, skb, op,

	skb = nfp_ccm_communicate(&bpf->ccm, skb, op,

				  nfp_bpf_cmsg_map_reply_size(bpf, 1));

	if (IS_ERR(skb))

		return PTR_ERR(skb);
@@ -415,34 +236,34 @@ err_free: 
int nfp_bpf_ctrl_update_entry(struct bpf_offloaded_map *offmap,

			      void *key, void *value, u64 flags)

{

	return nfp_bpf_ctrl_entry_op(offmap, CMSG_TYPE_MAP_UPDATE,

	return nfp_bpf_ctrl_entry_op(offmap, NFP_CCM_TYPE_BPF_MAP_UPDATE,

				     key, value, flags, NULL, NULL);

}



int nfp_bpf_ctrl_del_entry(struct bpf_offloaded_map *offmap, void *key)

{

	return nfp_bpf_ctrl_entry_op(offmap, CMSG_TYPE_MAP_DELETE,

	return nfp_bpf_ctrl_entry_op(offmap, NFP_CCM_TYPE_BPF_MAP_DELETE,

				     key, NULL, 0, NULL, NULL);

}



int nfp_bpf_ctrl_lookup_entry(struct bpf_offloaded_map *offmap,

			      void *key, void *value)

{

	return nfp_bpf_ctrl_entry_op(offmap, CMSG_TYPE_MAP_LOOKUP,

	return nfp_bpf_ctrl_entry_op(offmap, NFP_CCM_TYPE_BPF_MAP_LOOKUP,

				     key, NULL, 0, NULL, value);

}



int nfp_bpf_ctrl_getfirst_entry(struct bpf_offloaded_map *offmap,

				void *next_key)

{

	return nfp_bpf_ctrl_entry_op(offmap, CMSG_TYPE_MAP_GETFIRST,

	return nfp_bpf_ctrl_entry_op(offmap, NFP_CCM_TYPE_BPF_MAP_GETFIRST,

				     NULL, NULL, 0, next_key, NULL);

}



int nfp_bpf_ctrl_getnext_entry(struct bpf_offloaded_map *offmap,

			       void *key, void *next_key)

{

	return nfp_bpf_ctrl_entry_op(offmap, CMSG_TYPE_MAP_GETNEXT,

	return nfp_bpf_ctrl_entry_op(offmap, NFP_CCM_TYPE_BPF_MAP_GETNEXT,

				     key, NULL, 0, next_key, NULL);

}
@@ -456,54 +277,35 @@ unsigned int nfp_bpf_ctrl_cmsg_mtu(struct nfp_app_bpf *bpf) 
void nfp_bpf_ctrl_msg_rx(struct nfp_app *app, struct sk_buff *skb)

{

	struct nfp_app_bpf *bpf = app->priv;

	unsigned int tag;



	if (unlikely(skb->len < sizeof(struct cmsg_reply_map_simple))) {

		cmsg_warn(bpf, "cmsg drop - too short %d!\n", skb->len);

		goto err_free;

		dev_kfree_skb_any(skb);

		return;

	}



	if (nfp_bpf_cmsg_get_type(skb) == CMSG_TYPE_BPF_EVENT) {

	if (nfp_ccm_get_type(skb) == NFP_CCM_TYPE_BPF_BPF_EVENT) {

		if (!nfp_bpf_event_output(bpf, skb->data, skb->len))

			dev_consume_skb_any(skb);

		else

			dev_kfree_skb_any(skb);

		return;

	}



	nfp_ctrl_lock(bpf->app->ctrl);



	tag = nfp_bpf_cmsg_get_tag(skb);

	if (unlikely(!test_bit(tag, bpf->tag_allocator))) {

		cmsg_warn(bpf, "cmsg drop - no one is waiting for tag %u!\n",

			  tag);

		goto err_unlock;

	}



	__skb_queue_tail(&bpf->cmsg_replies, skb);

	wake_up_interruptible_all(&bpf->cmsg_wq);



	nfp_ctrl_unlock(bpf->app->ctrl);



	return;

err_unlock:

	nfp_ctrl_unlock(bpf->app->ctrl);

err_free:

	dev_kfree_skb_any(skb);

	nfp_ccm_rx(&bpf->ccm, skb);

}



void

nfp_bpf_ctrl_msg_rx_raw(struct nfp_app *app, const void *data, unsigned int len)

{

	const struct nfp_ccm_hdr *hdr = data;

	struct nfp_app_bpf *bpf = app->priv;

	const struct cmsg_hdr *hdr = data;



	if (unlikely(len < sizeof(struct cmsg_reply_map_simple))) {

		cmsg_warn(bpf, "cmsg drop - too short %d!\n", len);

		return;

	}



	if (hdr->type == CMSG_TYPE_BPF_EVENT)

	if (hdr->type == NFP_CCM_TYPE_BPF_BPF_EVENT)

		nfp_bpf_event_output(bpf, data, len);

	else

		cmsg_warn(bpf, "cmsg drop - msg type %d with raw buffer!\n",

drivers/net/ethernet/netronome/nfp/bpf/fw.h

+6 −27
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 


#include <linux/bitops.h>

#include <linux/types.h>

#include "../ccm.h"



/* Kernel's enum bpf_reg_type is not uABI so people may change it breaking

 * our FW ABI.  In that case we will do translation in the driver.
@@ -52,22 +53,6 @@ struct nfp_bpf_cap_tlv_maps { 
/*

 * Types defined for map related control messages

 */

#define CMSG_MAP_ABI_VERSION		1



enum nfp_bpf_cmsg_type {

	CMSG_TYPE_MAP_ALLOC	= 1,

	CMSG_TYPE_MAP_FREE	= 2,

	CMSG_TYPE_MAP_LOOKUP	= 3,

	CMSG_TYPE_MAP_UPDATE	= 4,

	CMSG_TYPE_MAP_DELETE	= 5,

	CMSG_TYPE_MAP_GETNEXT	= 6,

	CMSG_TYPE_MAP_GETFIRST	= 7,

	CMSG_TYPE_BPF_EVENT	= 8,

	__CMSG_TYPE_MAP_MAX,

};



#define CMSG_TYPE_MAP_REPLY_BIT		7

#define __CMSG_REPLY(req)		(BIT(CMSG_TYPE_MAP_REPLY_BIT) | (req))



/* BPF ABIv2 fixed-length control message fields */

#define CMSG_MAP_KEY_LW			16
@@ -84,19 +69,13 @@ enum nfp_bpf_cmsg_status { 
	CMSG_RC_ERR_MAP_E2BIG		= 7,

};



struct cmsg_hdr {

	u8 type;

	u8 ver;

	__be16 tag;

};



struct cmsg_reply_map_simple {

	struct cmsg_hdr hdr;

	struct nfp_ccm_hdr hdr;

	__be32 rc;

};



struct cmsg_req_map_alloc_tbl {

	struct cmsg_hdr hdr;

	struct nfp_ccm_hdr hdr;

	__be32 key_size;		/* in bytes */

	__be32 value_size;		/* in bytes */

	__be32 max_entries;
@@ -110,7 +89,7 @@ struct cmsg_reply_map_alloc_tbl { 
};



struct cmsg_req_map_free_tbl {

	struct cmsg_hdr hdr;

	struct nfp_ccm_hdr hdr;

	__be32 tid;

};
@@ -120,7 +99,7 @@ struct cmsg_reply_map_free_tbl { 
};



struct cmsg_req_map_op {

	struct cmsg_hdr hdr;

	struct nfp_ccm_hdr hdr;

	__be32 tid;

	__be32 count;

	__be32 flags;
@@ -135,7 +114,7 @@ struct cmsg_reply_map_op { 
};



struct cmsg_bpf_event {

	struct cmsg_hdr hdr;

	struct nfp_ccm_hdr hdr;

	__be32 cpu_id;

	__be64 map_ptr;

	__be32 data_size;

drivers/net/ethernet/netronome/nfp/bpf/main.c

+8 −4
Original line number Diff line number Diff line
@@ -442,14 +442,16 @@ static int nfp_bpf_init(struct nfp_app *app) 
	bpf->app = app;

	app->priv = bpf;



	skb_queue_head_init(&bpf->cmsg_replies);

	init_waitqueue_head(&bpf->cmsg_wq);

	INIT_LIST_HEAD(&bpf->map_list);



	err = rhashtable_init(&bpf->maps_neutral, &nfp_bpf_maps_neutral_params);

	err = nfp_ccm_init(&bpf->ccm, app);

	if (err)

		goto err_free_bpf;



	err = rhashtable_init(&bpf->maps_neutral, &nfp_bpf_maps_neutral_params);

	if (err)

		goto err_clean_ccm;



	nfp_bpf_init_capabilities(bpf);



	err = nfp_bpf_parse_capabilities(app);
@@ -474,6 +476,8 @@ static int nfp_bpf_init(struct nfp_app *app) 


err_free_neutral_maps:

	rhashtable_destroy(&bpf->maps_neutral);

err_clean_ccm:

	nfp_ccm_clean(&bpf->ccm);

err_free_bpf:

	kfree(bpf);

	return err;
@@ -484,7 +488,7 @@ static void nfp_bpf_clean(struct nfp_app *app) 
	struct nfp_app_bpf *bpf = app->priv;



	bpf_offload_dev_destroy(bpf->bpf_dev);

	WARN_ON(!skb_queue_empty(&bpf->cmsg_replies));

	nfp_ccm_clean(&bpf->ccm);

	WARN_ON(!list_empty(&bpf->map_list));

	WARN_ON(bpf->maps_in_use || bpf->map_elems_in_use);

	rhashtable_free_and_destroy(&bpf->maps_neutral,

CRA Git | Maintained and supported by SUSTech CRA and CCSE