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

Commit 174ab544 authored by Jakub Kicinski's avatar Jakub Kicinski Committed by David S. Miller
Browse files

nfp: abm: add cls_u32 offload for simple band classification 



Use offload of very simple u32 filters to direct packets to GRED
bands based on the DSCP marking.  No u32 hashing is supported,
just plain simple filters matching on ToS or Priority with
appropriate mask device can support.

Signed-off-by: default avatarJakub Kicinski <jakub.kicinski@netronome.com>
Reviewed-by: default avatarJohn Hurley <john.hurley@netronome.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 6a802405

drivers/net/ethernet/netronome/nfp/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ endif 


ifeq ($(CONFIG_NFP_APP_ABM_NIC),y)

nfp-objs += \

	    abm/cls.o \

	    abm/ctrl.o \

	    abm/qdisc.o \

	    abm/main.o

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

0 → 100644
+283 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)

/* Copyright (C) 2018 Netronome Systems, Inc. */



#include <linux/bitfield.h>

#include <net/pkt_cls.h>



#include "../nfpcore/nfp_cpp.h"

#include "../nfp_app.h"

#include "../nfp_net_repr.h"

#include "main.h"



struct nfp_abm_u32_match {

	u32 handle;

	u32 band;

	u8 mask;

	u8 val;

	struct list_head list;

};



static bool

nfp_abm_u32_check_knode(struct nfp_abm *abm, struct tc_cls_u32_knode *knode,

			__be16 proto, struct netlink_ext_ack *extack)

{

	struct tc_u32_key *k;

	unsigned int tos_off;



	if (knode->exts && tcf_exts_has_actions(knode->exts)) {

		NL_SET_ERR_MSG_MOD(extack, "action offload not supported");

		return false;

	}

	if (knode->link_handle) {

		NL_SET_ERR_MSG_MOD(extack, "linking not supported");

		return false;

	}

	if (knode->sel->flags != TC_U32_TERMINAL) {

		NL_SET_ERR_MSG_MOD(extack,

				   "flags must be equal to TC_U32_TERMINAL");

		return false;

	}

	if (knode->sel->off || knode->sel->offshift || knode->sel->offmask ||

	    knode->sel->offoff || knode->fshift) {

		NL_SET_ERR_MSG_MOD(extack, "variable offseting not supported");

		return false;

	}

	if (knode->sel->hoff || knode->sel->hmask) {

		NL_SET_ERR_MSG_MOD(extack, "hashing not supported");

		return false;

	}

	if (knode->val || knode->mask) {

		NL_SET_ERR_MSG_MOD(extack, "matching on mark not supported");

		return false;

	}

	if (knode->res && knode->res->class) {

		NL_SET_ERR_MSG_MOD(extack, "setting non-0 class not supported");

		return false;

	}

	if (knode->res && knode->res->classid >= abm->num_bands) {

		NL_SET_ERR_MSG_MOD(extack,

				   "classid higher than number of bands");

		return false;

	}

	if (knode->sel->nkeys != 1) {

		NL_SET_ERR_MSG_MOD(extack, "exactly one key required");

		return false;

	}



	switch (proto) {

	case htons(ETH_P_IP):

		tos_off = 16;

		break;

	case htons(ETH_P_IPV6):

		tos_off = 20;

		break;

	default:

		NL_SET_ERR_MSG_MOD(extack, "only IP and IPv6 supported as filter protocol");

		return false;

	}



	k = &knode->sel->keys[0];

	if (k->offmask) {

		NL_SET_ERR_MSG_MOD(extack, "offset mask - variable offseting not supported");

		return false;

	}

	if (k->off) {

		NL_SET_ERR_MSG_MOD(extack, "only DSCP fields can be matched");

		return false;

	}

	if (k->val & ~k->mask) {

		NL_SET_ERR_MSG_MOD(extack, "mask does not cover the key");

		return false;

	}

	if (be32_to_cpu(k->mask) >> tos_off & ~abm->dscp_mask) {

		NL_SET_ERR_MSG_MOD(extack, "only high DSCP class selector bits can be used");

		nfp_err(abm->app->cpp,

			"u32 offload: requested mask %x FW can support only %x\n",

			be32_to_cpu(k->mask) >> tos_off, abm->dscp_mask);

		return false;

	}



	return true;

}



/* This filter list -> map conversion is O(n * m), we expect single digit or

 * low double digit number of prios and likewise for the filters.  Also u32

 * doesn't report stats, so it's really only setup time cost.

 */

static unsigned int

nfp_abm_find_band_for_prio(struct nfp_abm_link *alink, unsigned int prio)

{

	struct nfp_abm_u32_match *iter;



	list_for_each_entry(iter, &alink->dscp_map, list)

		if ((prio & iter->mask) == iter->val)

			return iter->band;



	return alink->def_band;

}



static int nfp_abm_update_band_map(struct nfp_abm_link *alink)

{

	unsigned int i, bits_per_prio, prios_per_word, base_shift;

	struct nfp_abm *abm = alink->abm;

	u32 field_mask;



	alink->has_prio = !list_empty(&alink->dscp_map);



	bits_per_prio = roundup_pow_of_two(order_base_2(abm->num_bands));

	field_mask = (1 << bits_per_prio) - 1;

	prios_per_word = sizeof(u32) * BITS_PER_BYTE / bits_per_prio;



	/* FW mask applies from top bits */

	base_shift = 8 - order_base_2(abm->num_prios);



	for (i = 0; i < abm->num_prios; i++) {

		unsigned int offset;

		u32 *word;

		u8 band;



		word = &alink->prio_map[i / prios_per_word];

		offset = (i % prios_per_word) * bits_per_prio;



		band = nfp_abm_find_band_for_prio(alink, i << base_shift);



		*word &= ~(field_mask << offset);

		*word |= band << offset;

	}



	/* Qdisc offload status may change if has_prio changed */

	nfp_abm_qdisc_offload_update(alink);



	return nfp_abm_ctrl_prio_map_update(alink, alink->prio_map);

}



static void

nfp_abm_u32_knode_delete(struct nfp_abm_link *alink,

			 struct tc_cls_u32_knode *knode)

{

	struct nfp_abm_u32_match *iter;



	list_for_each_entry(iter, &alink->dscp_map, list)

		if (iter->handle == knode->handle) {

			list_del(&iter->list);

			kfree(iter);

			nfp_abm_update_band_map(alink);

			return;

		}

}



static int

nfp_abm_u32_knode_replace(struct nfp_abm_link *alink,

			  struct tc_cls_u32_knode *knode,

			  __be16 proto, struct netlink_ext_ack *extack)

{

	struct nfp_abm_u32_match *match = NULL, *iter;

	unsigned int tos_off;

	u8 mask, val;

	int err;



	if (!nfp_abm_u32_check_knode(alink->abm, knode, proto, extack))

		goto err_delete;



	tos_off = proto == htons(ETH_P_IP) ? 16 : 20;



	/* Extract the DSCP Class Selector bits */

	val = be32_to_cpu(knode->sel->keys[0].val) >> tos_off & 0xff;

	mask = be32_to_cpu(knode->sel->keys[0].mask) >> tos_off & 0xff;



	/* Check if there is no conflicting mapping and find match by handle */

	list_for_each_entry(iter, &alink->dscp_map, list) {

		u32 cmask;



		if (iter->handle == knode->handle) {

			match = iter;

			continue;

		}



		cmask = iter->mask & mask;

		if ((iter->val & cmask) == (val & cmask) &&

		    iter->band != knode->res->classid) {

			NL_SET_ERR_MSG_MOD(extack, "conflict with already offloaded filter");

			goto err_delete;

		}

	}



	if (!match) {

		match = kzalloc(sizeof(*match), GFP_KERNEL);

		if (!match)

			return -ENOMEM;

		list_add(&match->list, &alink->dscp_map);

	}

	match->handle = knode->handle;

	match->band = knode->res->classid;

	match->mask = mask;

	match->val = val;



	err = nfp_abm_update_band_map(alink);

	if (err)

		goto err_delete;



	return 0;



err_delete:

	nfp_abm_u32_knode_delete(alink, knode);

	return -EOPNOTSUPP;

}



static int nfp_abm_setup_tc_block_cb(enum tc_setup_type type,

				     void *type_data, void *cb_priv)

{

	struct tc_cls_u32_offload *cls_u32 = type_data;

	struct nfp_repr *repr = cb_priv;

	struct nfp_abm_link *alink;



	alink = repr->app_priv;



	if (type != TC_SETUP_CLSU32) {

		NL_SET_ERR_MSG_MOD(cls_u32->common.extack,

				   "only offload of u32 classifier supported");

		return -EOPNOTSUPP;

	}

	if (!tc_cls_can_offload_and_chain0(repr->netdev, &cls_u32->common))

		return -EOPNOTSUPP;



	if (cls_u32->common.protocol != htons(ETH_P_IP) &&

	    cls_u32->common.protocol != htons(ETH_P_IPV6)) {

		NL_SET_ERR_MSG_MOD(cls_u32->common.extack,

				   "only IP and IPv6 supported as filter protocol");

		return -EOPNOTSUPP;

	}



	switch (cls_u32->command) {

	case TC_CLSU32_NEW_KNODE:

	case TC_CLSU32_REPLACE_KNODE:

		return nfp_abm_u32_knode_replace(alink, &cls_u32->knode,

						 cls_u32->common.protocol,

						 cls_u32->common.extack);

	case TC_CLSU32_DELETE_KNODE:

		nfp_abm_u32_knode_delete(alink, &cls_u32->knode);

		return 0;

	default:

		return -EOPNOTSUPP;

	}

}



int nfp_abm_setup_cls_block(struct net_device *netdev, struct nfp_repr *repr,

			    struct tc_block_offload *f)

{

	if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS)

		return -EOPNOTSUPP;



	switch (f->command) {

	case TC_BLOCK_BIND:

		return tcf_block_cb_register(f->block,

					     nfp_abm_setup_tc_block_cb,

					     repr, repr, f->extack);

	case TC_BLOCK_UNBIND:

		tcf_block_cb_unregister(f->block, nfp_abm_setup_tc_block_cb,

					repr);

		return 0;

	default:

		return -EOPNOTSUPP;

	}

}

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

+1 −0
Original line number Diff line number Diff line
@@ -335,6 +335,7 @@ int nfp_abm_ctrl_find_addrs(struct nfp_abm *abm) 
	abm->num_prios = res;



	abm->prio_map_len = nfp_abm_ctrl_prio_map_size(abm);

	abm->dscp_mask = GENMASK(7, 8 - order_base_2(abm->num_prios));



	/* Check values are sane, U16_MAX is arbitrarily chosen as max */

	if (!is_power_of_2(abm->num_bands) || !is_power_of_2(abm->num_prios) ||

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

+22 −1
Original line number Diff line number Diff line
@@ -46,6 +46,8 @@ nfp_abm_setup_tc(struct nfp_app *app, struct net_device *netdev, 
		return nfp_abm_setup_tc_red(netdev, repr->app_priv, type_data);

	case TC_SETUP_QDISC_GRED:

		return nfp_abm_setup_tc_gred(netdev, repr->app_priv, type_data);

	case TC_SETUP_BLOCK:

		return nfp_abm_setup_cls_block(netdev, repr, type_data);

	default:

		return -EOPNOTSUPP;

	}
@@ -315,16 +317,22 @@ nfp_abm_vnic_alloc(struct nfp_app *app, struct nfp_net *nn, unsigned int id) 
	alink->id = id;

	alink->total_queues = alink->vnic->max_rx_rings;



	INIT_LIST_HEAD(&alink->dscp_map);



	err = nfp_abm_ctrl_read_params(alink);

	if (err)

		goto err_free_alink;



	alink->prio_map = kzalloc(abm->prio_map_len, GFP_KERNEL);

	if (!alink->prio_map)

		goto err_free_alink;



	/* This is a multi-host app, make sure MAC/PHY is up, but don't

	 * make the MAC/PHY state follow the state of any of the ports.

	 */

	err = nfp_eth_set_configured(app->cpp, eth_port->index, true);

	if (err < 0)

		goto err_free_alink;

		goto err_free_priomap;



	netif_keep_dst(nn->dp.netdev);
@@ -333,6 +341,8 @@ nfp_abm_vnic_alloc(struct nfp_app *app, struct nfp_net *nn, unsigned int id) 


	return 0;



err_free_priomap:

	kfree(alink->prio_map);

err_free_alink:

	kfree(alink);

	return err;
@@ -344,9 +354,19 @@ static void nfp_abm_vnic_free(struct nfp_app *app, struct nfp_net *nn) 


	nfp_abm_kill_reprs(alink->abm, alink);

	WARN(!radix_tree_empty(&alink->qdiscs), "left over qdiscs\n");

	kfree(alink->prio_map);

	kfree(alink);

}



static int nfp_abm_vnic_init(struct nfp_app *app, struct nfp_net *nn)

{

	struct nfp_abm_link *alink = nn->app_priv;



	if (nfp_abm_has_prio(alink->abm))

		return nfp_abm_ctrl_prio_map_update(alink, alink->prio_map);

	return 0;

}



static u64 *

nfp_abm_port_get_stats(struct nfp_app *app, struct nfp_port *port, u64 *data)

{
@@ -491,6 +511,7 @@ const struct nfp_app_type app_abm = { 


	.vnic_alloc	= nfp_abm_vnic_alloc,

	.vnic_free	= nfp_abm_vnic_free,

	.vnic_init	= nfp_abm_vnic_init,



	.port_get_stats		= nfp_abm_port_get_stats,

	.port_get_stats_count	= nfp_abm_port_get_stats_count,

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

+16 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
#define __NFP_ABM_H__ 1



#include <linux/bits.h>

#include <linux/list.h>

#include <linux/radix-tree.h>

#include <net/devlink.h>

#include <net/pkt_cls.h>
@@ -34,7 +35,9 @@ struct nfp_net; 
 * @thresholds:		current threshold configuration

 * @threshold_undef:	bitmap of thresholds which have not been set

 * @num_thresholds:	number of @thresholds and bits in @threshold_undef

 *

 * @prio_map_len:	computed length of FW priority map (in bytes)

 * @dscp_mask:		mask FW will apply on DSCP field

 *

 * @eswitch_mode:	devlink eswitch mode, advanced functions only visible

 *			in switchdev mode
@@ -53,7 +56,9 @@ struct nfp_abm { 
	u32 *thresholds;

	unsigned long *threshold_undef;

	size_t num_thresholds;



	unsigned int prio_map_len;

	u8 dscp_mask;



	enum devlink_eswitch_mode eswitch_mode;
@@ -170,7 +175,11 @@ struct nfp_qdisc { 
 *

 * @last_stats_update:	ktime of last stats update

 *

 * @prio_map:		current map of priorities

 * @has_prio:		@prio_map is valid

 *

 * @def_band:		default band to use

 * @dscp_map:		list of DSCP to band mappings

 *

 * @root_qdisc:	pointer to the current root of the Qdisc hierarchy

 * @qdiscs:	all qdiscs recorded by major part of the handle
@@ -184,7 +193,11 @@ struct nfp_abm_link { 


	u64 last_stats_update;



	u32 *prio_map;

	bool has_prio;



	u8 def_band;

	struct list_head dscp_map;



	struct nfp_qdisc *root_qdisc;

	struct radix_tree_root qdiscs;
@@ -204,6 +217,8 @@ int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, 
			struct tc_mq_qopt_offload *opt);

int nfp_abm_setup_tc_gred(struct net_device *netdev, struct nfp_abm_link *alink,

			  struct tc_gred_qopt_offload *opt);

int nfp_abm_setup_cls_block(struct net_device *netdev, struct nfp_repr *repr,

			    struct tc_block_offload *opt);



int nfp_abm_ctrl_read_params(struct nfp_abm_link *alink);

int nfp_abm_ctrl_find_addrs(struct nfp_abm *abm);
@@ -220,5 +235,6 @@ u64 nfp_abm_ctrl_stat_non_sto(struct nfp_abm_link *alink, unsigned int i); 
u64 nfp_abm_ctrl_stat_sto(struct nfp_abm_link *alink, unsigned int i);

int nfp_abm_ctrl_qm_enable(struct nfp_abm *abm);

int nfp_abm_ctrl_qm_disable(struct nfp_abm *abm);

void nfp_abm_prio_map_update(struct nfp_abm *abm);

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

#endif