Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 43f84b72 authored by Pieter Jansen van Vuuren's avatar Pieter Jansen van Vuuren Committed by David S. Miller
Browse files

nfp: add metadata to each flow offload 



Adds metadata describing the mask id of each flow and keeps track of
flows installed in hardware. Previously a flow could not be removed
from hardware as there was no way of knowing if that a specific flow
was installed. This is solved by storing the offloaded flows in a
hash table.

Signed-off-by: default avatarPieter Jansen van Vuuren <pieter.jansenvanvuuren@netronome.com>
Signed-off-by: default avatarSimon Horman <simon.horman@netronome.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 1a1e586f

drivers/net/ethernet/netronome/nfp/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ nfp-objs += \ 
	    flower/cmsg.o \

	    flower/main.o \

	    flower/match.o \

	    flower/metadata.o \

	    flower/offload.o

endif

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

+11 −10
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 
#include <linux/etherdevice.h>

#include <linux/pci.h>

#include <linux/skbuff.h>

#include <linux/vmalloc.h>

#include <net/devlink.h>

#include <net/dst_metadata.h>
@@ -50,14 +51,6 @@ 


#define NFP_FLOWER_ALLOWED_VER 0x0001000000010000UL



/**

 * struct nfp_flower_priv - Flower APP per-vNIC priv data

 * @nn:		     Pointer to vNIC

 */

struct nfp_flower_priv {

	struct nfp_net *nn;

};



static const char *nfp_flower_extra_cap(struct nfp_app *app, struct nfp_net *nn)

{

	return "FLOWER";
@@ -347,16 +340,24 @@ static int nfp_flower_init(struct nfp_app *app) 
		return -EINVAL;

	}



	app->priv = kzalloc(sizeof(struct nfp_flower_priv), GFP_KERNEL);

	app->priv = vzalloc(sizeof(struct nfp_flower_priv));

	if (!app->priv)

		return -ENOMEM;



	err = nfp_flower_metadata_init(app);

	if (err)

		goto err_free_app_priv;



	return 0;



err_free_app_priv:

	vfree(app->priv);

	return err;

}



static void nfp_flower_clean(struct nfp_app *app)

{

	kfree(app->priv);

	vfree(app->priv);

	app->priv = NULL;

}

drivers/net/ethernet/netronome/nfp/flower/main.h

+54 −0
Original line number Diff line number Diff line
@@ -34,12 +34,50 @@ 
#ifndef __NFP_FLOWER_H__

#define __NFP_FLOWER_H__ 1



#include <linux/circ_buf.h>

#include <linux/hashtable.h>

#include <linux/time64.h>

#include <linux/types.h>



struct tc_to_netdev;

struct net_device;

struct nfp_app;



#define NFP_FLOWER_HASH_BITS		19

#define NFP_FLOWER_MASK_ENTRY_RS	256

#define NFP_FLOWER_MASK_ELEMENT_RS	1

#define NFP_FLOWER_MASK_HASH_BITS	10



#define NFP_FL_META_FLAG_NEW_MASK	128

#define NFP_FL_META_FLAG_LAST_MASK	1



#define NFP_FL_MASK_REUSE_TIME_NS	40000

#define NFP_FL_MASK_ID_LOCATION		1



struct nfp_fl_mask_id {

	struct circ_buf mask_id_free_list;

	struct timespec64 *last_used;

	u8 init_unallocated;

};



/**

 * struct nfp_flower_priv - Flower APP per-vNIC priv data

 * @nn:			Pointer to vNIC

 * @mask_id_seed:	Seed used for mask hash table

 * @flower_version:	HW version of flower

 * @mask_ids:		List of free mask ids

 * @mask_table:		Hash table used to store masks

 * @flow_table:		Hash table used to store flower rules

 */

struct nfp_flower_priv {

	struct nfp_net *nn;

	u32 mask_id_seed;

	u64 flower_version;

	struct nfp_fl_mask_id mask_ids;

	DECLARE_HASHTABLE(mask_table, NFP_FLOWER_MASK_HASH_BITS);

	DECLARE_HASHTABLE(flow_table, NFP_FLOWER_HASH_BITS);

};



struct nfp_fl_key_ls {

	u32 key_layer_two;

	u8 key_layer;
@@ -59,11 +97,17 @@ struct nfp_fl_rule_metadata { 


struct nfp_fl_payload {

	struct nfp_fl_rule_metadata meta;

	unsigned long tc_flower_cookie;

	struct hlist_node link;

	struct rcu_head rcu;

	char *unmasked_data;

	char *mask_data;

	char *action_data;

};



int nfp_flower_metadata_init(struct nfp_app *app);

void nfp_flower_metadata_cleanup(struct nfp_app *app);



int nfp_flower_setup_tc(struct nfp_app *app, struct net_device *netdev,

			u32 handle, __be16 proto, struct tc_to_netdev *tc);

int nfp_flower_compile_flow_match(struct tc_cls_flower_offload *flow,
@@ -73,5 +117,15 @@ int nfp_flower_compile_flow_match(struct tc_cls_flower_offload *flow, 
int nfp_flower_compile_action(struct tc_cls_flower_offload *flow,

			      struct net_device *netdev,

			      struct nfp_fl_payload *nfp_flow);

int nfp_compile_flow_metadata(struct nfp_app *app,

			      struct tc_cls_flower_offload *flow,

			      struct nfp_fl_payload *nfp_flow);

int nfp_modify_flow_metadata(struct nfp_app *app,

			     struct nfp_fl_payload *nfp_flow);



struct nfp_fl_payload *

nfp_flower_search_fl_table(struct nfp_app *app, unsigned long tc_flower_cookie);

struct nfp_fl_payload *

nfp_flower_remove_fl_table(struct nfp_app *app, unsigned long tc_flower_cookie);



#endif

drivers/net/ethernet/netronome/nfp/flower/metadata.c

0 → 100644
+318 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 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/hash.h>

#include <linux/hashtable.h>

#include <linux/jhash.h>

#include <linux/vmalloc.h>

#include <net/pkt_cls.h>



#include "cmsg.h"

#include "main.h"

#include "../nfp_app.h"



struct nfp_mask_id_table {

	struct hlist_node link;

	u32 hash_key;

	u32 ref_cnt;

	u8 mask_id;

};



/* Must be called with either RTNL or rcu_read_lock */

struct nfp_fl_payload *

nfp_flower_search_fl_table(struct nfp_app *app, unsigned long tc_flower_cookie)

{

	struct nfp_flower_priv *priv = app->priv;

	struct nfp_fl_payload *flower_entry;



	hash_for_each_possible_rcu(priv->flow_table, flower_entry, link,

				   tc_flower_cookie)

		if (flower_entry->tc_flower_cookie == tc_flower_cookie)

			return flower_entry;



	return NULL;

}



static int nfp_release_mask_id(struct nfp_app *app, u8 mask_id)

{

	struct nfp_flower_priv *priv = app->priv;

	struct circ_buf *ring;

	struct timespec64 now;



	ring = &priv->mask_ids.mask_id_free_list;

	/* Checking if buffer is full. */

	if (CIRC_SPACE(ring->head, ring->tail, NFP_FLOWER_MASK_ENTRY_RS) == 0)

		return -ENOBUFS;



	memcpy(&ring->buf[ring->head], &mask_id, NFP_FLOWER_MASK_ELEMENT_RS);

	ring->head = (ring->head + NFP_FLOWER_MASK_ELEMENT_RS) %

		     (NFP_FLOWER_MASK_ENTRY_RS * NFP_FLOWER_MASK_ELEMENT_RS);



	getnstimeofday64(&now);

	priv->mask_ids.last_used[mask_id] = now;



	return 0;

}



static int nfp_mask_alloc(struct nfp_app *app, u8 *mask_id)

{

	struct nfp_flower_priv *priv = app->priv;

	struct timespec64 delta, now;

	struct circ_buf *ring;

	u8 temp_id, freed_id;



	ring = &priv->mask_ids.mask_id_free_list;

	freed_id = NFP_FLOWER_MASK_ENTRY_RS - 1;

	/* Checking for unallocated entries first. */

	if (priv->mask_ids.init_unallocated > 0) {

		*mask_id = priv->mask_ids.init_unallocated;

		priv->mask_ids.init_unallocated--;

		return 0;

	}



	/* Checking if buffer is empty. */

	if (ring->head == ring->tail)

		goto err_not_found;



	memcpy(&temp_id, &ring->buf[ring->tail], NFP_FLOWER_MASK_ELEMENT_RS);

	*mask_id = temp_id;



	getnstimeofday64(&now);

	delta = timespec64_sub(now, priv->mask_ids.last_used[*mask_id]);



	if (timespec64_to_ns(&delta) < NFP_FL_MASK_REUSE_TIME_NS)

		goto err_not_found;



	memcpy(&ring->buf[ring->tail], &freed_id, NFP_FLOWER_MASK_ELEMENT_RS);

	ring->tail = (ring->tail + NFP_FLOWER_MASK_ELEMENT_RS) %

		     (NFP_FLOWER_MASK_ENTRY_RS * NFP_FLOWER_MASK_ELEMENT_RS);



	return 0;



err_not_found:

	*mask_id = freed_id;

	return -ENOENT;

}



static int

nfp_add_mask_table(struct nfp_app *app, char *mask_data, u32 mask_len)

{

	struct nfp_flower_priv *priv = app->priv;

	struct nfp_mask_id_table *mask_entry;

	unsigned long hash_key;

	u8 mask_id;



	if (nfp_mask_alloc(app, &mask_id))

		return -ENOENT;



	mask_entry = kmalloc(sizeof(*mask_entry), GFP_KERNEL);

	if (!mask_entry) {

		nfp_release_mask_id(app, mask_id);

		return -ENOMEM;

	}



	INIT_HLIST_NODE(&mask_entry->link);

	mask_entry->mask_id = mask_id;

	hash_key = jhash(mask_data, mask_len, priv->mask_id_seed);

	mask_entry->hash_key = hash_key;

	mask_entry->ref_cnt = 1;

	hash_add(priv->mask_table, &mask_entry->link, hash_key);



	return mask_id;

}



static struct nfp_mask_id_table *

nfp_search_mask_table(struct nfp_app *app, char *mask_data, u32 mask_len)

{

	struct nfp_flower_priv *priv = app->priv;

	struct nfp_mask_id_table *mask_entry;

	unsigned long hash_key;



	hash_key = jhash(mask_data, mask_len, priv->mask_id_seed);



	hash_for_each_possible(priv->mask_table, mask_entry, link, hash_key)

		if (mask_entry->hash_key == hash_key)

			return mask_entry;



	return NULL;

}



static int

nfp_find_in_mask_table(struct nfp_app *app, char *mask_data, u32 mask_len)

{

	struct nfp_mask_id_table *mask_entry;



	mask_entry = nfp_search_mask_table(app, mask_data, mask_len);

	if (!mask_entry)

		return -ENOENT;



	mask_entry->ref_cnt++;



	/* Casting u8 to int for later use. */

	return mask_entry->mask_id;

}



static bool

nfp_check_mask_add(struct nfp_app *app, char *mask_data, u32 mask_len,

		   u8 *meta_flags, u8 *mask_id)

{

	int id;



	id = nfp_find_in_mask_table(app, mask_data, mask_len);

	if (id < 0) {

		id = nfp_add_mask_table(app, mask_data, mask_len);

		if (id < 0)

			return false;

		*meta_flags |= NFP_FL_META_FLAG_NEW_MASK;

	}

	*mask_id = id;



	return true;

}



static bool

nfp_check_mask_remove(struct nfp_app *app, char *mask_data, u32 mask_len,

		      u8 *meta_flags, u8 *mask_id)

{

	struct nfp_mask_id_table *mask_entry;



	mask_entry = nfp_search_mask_table(app, mask_data, mask_len);

	if (!mask_entry)

		return false;



	*mask_id = mask_entry->mask_id;

	mask_entry->ref_cnt--;

	if (!mask_entry->ref_cnt) {

		hash_del(&mask_entry->link);

		nfp_release_mask_id(app, *mask_id);

		kfree(mask_entry);

		if (meta_flags)

			*meta_flags |= NFP_FL_META_FLAG_LAST_MASK;

	}



	return true;

}



int nfp_compile_flow_metadata(struct nfp_app *app,

			      struct tc_cls_flower_offload *flow,

			      struct nfp_fl_payload *nfp_flow)

{

	struct nfp_flower_priv *priv = app->priv;

	struct nfp_fl_payload *check_entry;

	u8 new_mask_id;



	new_mask_id = 0;

	if (!nfp_check_mask_add(app, nfp_flow->mask_data,

				nfp_flow->meta.mask_len,

				&nfp_flow->meta.flags, &new_mask_id))

		return -ENOENT;



	nfp_flow->meta.flow_version = cpu_to_be64(priv->flower_version);

	priv->flower_version++;



	/* Update flow payload with mask ids. */

	nfp_flow->unmasked_data[NFP_FL_MASK_ID_LOCATION] = new_mask_id;



	check_entry = nfp_flower_search_fl_table(app, flow->cookie);

	if (check_entry) {

		if (!nfp_check_mask_remove(app, nfp_flow->mask_data,

					   nfp_flow->meta.mask_len,

					   NULL, &new_mask_id))

			return -EINVAL;



		return -EEXIST;

	}



	return 0;

}



int nfp_modify_flow_metadata(struct nfp_app *app,

			     struct nfp_fl_payload *nfp_flow)

{

	struct nfp_flower_priv *priv = app->priv;

	u8 new_mask_id = 0;



	nfp_check_mask_remove(app, nfp_flow->mask_data,

			      nfp_flow->meta.mask_len, &nfp_flow->meta.flags,

			      &new_mask_id);



	nfp_flow->meta.flow_version = cpu_to_be64(priv->flower_version);

	priv->flower_version++;



	/* Update flow payload with mask ids. */

	nfp_flow->unmasked_data[NFP_FL_MASK_ID_LOCATION] = new_mask_id;



	return 0;

}



int nfp_flower_metadata_init(struct nfp_app *app)

{

	struct nfp_flower_priv *priv = app->priv;



	hash_init(priv->mask_table);

	hash_init(priv->flow_table);

	get_random_bytes(&priv->mask_id_seed, sizeof(priv->mask_id_seed));



	/* Init ring buffer and unallocated mask_ids. */

	priv->mask_ids.mask_id_free_list.buf =

		kmalloc_array(NFP_FLOWER_MASK_ENTRY_RS,

			      NFP_FLOWER_MASK_ELEMENT_RS, GFP_KERNEL);

	if (!priv->mask_ids.mask_id_free_list.buf)

		return -ENOMEM;



	priv->mask_ids.init_unallocated = NFP_FLOWER_MASK_ENTRY_RS - 1;



	/* Init timestamps for mask id*/

	priv->mask_ids.last_used =

		kmalloc_array(NFP_FLOWER_MASK_ENTRY_RS,

			      sizeof(*priv->mask_ids.last_used), GFP_KERNEL);

	if (!priv->mask_ids.last_used)

		goto err_free_mask_id;



	return 0;



err_free_mask_id:

	kfree(priv->mask_ids.mask_id_free_list.buf);

	return -ENOMEM;

}



void nfp_flower_metadata_cleanup(struct nfp_app *app)

{

	struct nfp_flower_priv *priv = app->priv;



	if (!priv)

		return;



	kfree(priv->mask_ids.mask_id_free_list.buf);

	kfree(priv->mask_ids.last_used);

}

drivers/net/ethernet/netronome/nfp/flower/offload.c

+28 −3
Original line number Diff line number Diff line
@@ -196,6 +196,7 @@ static int 
nfp_flower_add_offload(struct nfp_app *app, struct net_device *netdev,

		       struct tc_cls_flower_offload *flow)

{

	struct nfp_flower_priv *priv = app->priv;

	struct nfp_fl_payload *flow_pay;

	struct nfp_fl_key_ls *key_layer;

	int err;
@@ -222,8 +223,18 @@ nfp_flower_add_offload(struct nfp_app *app, struct net_device *netdev, 
	if (err)

		goto err_destroy_flow;



	/* TODO: Complete flower_add_offload. */

	err = -EOPNOTSUPP;

	err = nfp_compile_flow_metadata(app, flow, flow_pay);

	if (err)

		goto err_destroy_flow;



	INIT_HLIST_NODE(&flow_pay->link);

	flow_pay->tc_flower_cookie = flow->cookie;

	hash_add_rcu(priv->flow_table, &flow_pay->link, flow->cookie);



	/* Deallocate flow payload when flower rule has been destroyed. */

	kfree(key_layer);



	return 0;



err_destroy_flow:

	kfree(flow_pay->action_data);
@@ -250,7 +261,21 @@ static int 
nfp_flower_del_offload(struct nfp_app *app, struct net_device *netdev,

		       struct tc_cls_flower_offload *flow)

{

	return -EOPNOTSUPP;

	struct nfp_fl_payload *nfp_flow;

	int err;



	nfp_flow = nfp_flower_search_fl_table(app, flow->cookie);

	if (!nfp_flow)

		return -ENOENT;



	err = nfp_modify_flow_metadata(app, nfp_flow);



	hash_del_rcu(&nfp_flow->link);

	kfree(nfp_flow->action_data);

	kfree(nfp_flow->mask_data);

	kfree(nfp_flow->unmasked_data);

	kfree_rcu(nfp_flow, rcu);

	return err;

}



/**