nfp: abm: add cls_u32 offload for simple band classification (174ab544) · Commits · 戴 / test

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

Admin message