nfp: abm: keep track of all RED thresholds (6666f545) · Commits · 戴 / test

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

+17 −15

Original line number	Diff line number	Diff line
		@@ -71,35 +71,37 @@ nfp_abm_ctrl_stat_all(struct nfp_abm_link alink, const struct nfp_rtsym sym,
		return 0;
		}

		int nfp_abm_ctrl_set_q_lvl(struct nfp_abm_link *alink, unsigned int i, u32 val)
		int __nfp_abm_ctrl_set_q_lvl(struct nfp_abm *abm, unsigned int id, u32 val)
		{
		struct nfp_cpp *cpp = alink->abm->app->cpp;
		struct nfp_cpp *cpp = abm->app->cpp;
		u64 sym_offset;
		int err;

		sym_offset = (alink->queue_base + i) * NFP_QLVL_STRIDE + NFP_QLVL_THRS;
		err = __nfp_rtsym_writel(cpp, alink->abm->q_lvls, 4, 0,
		sym_offset, val);
		__clear_bit(id, abm->threshold_undef);
		if (abm->thresholds[id] == val)
		return 0;

		sym_offset = id * NFP_QLVL_STRIDE + NFP_QLVL_THRS;
		err = __nfp_rtsym_writel(cpp, abm->q_lvls, 4, 0, sym_offset, val);
		if (err) {
		nfp_err(cpp, "RED offload setting level failed on vNIC %d queue %d\n",
		alink->id, i);
		nfp_err(cpp,
		"RED offload setting level failed on subqueue %d\n",
		id);
		return err;
		}

		abm->thresholds[id] = val;
		return 0;
		}

		int nfp_abm_ctrl_set_all_q_lvls(struct nfp_abm_link *alink, u32 val)
		int nfp_abm_ctrl_set_q_lvl(struct nfp_abm_link *alink, unsigned int queue,
		u32 val)
		{
		int i, err;
		unsigned int threshold;

		for (i = 0; i < alink->vnic->max_rx_rings; i++) {
		err = nfp_abm_ctrl_set_q_lvl(alink, i, val);
		if (err)
		return err;
		}
		threshold = alink->queue_base + queue;

		return 0;
		return __nfp_abm_ctrl_set_q_lvl(alink->abm, threshold, val);
		}

		u64 nfp_abm_ctrl_stat_non_sto(struct nfp_abm_link *alink, unsigned int i)

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

+23 −2

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@
		/* Copyright (C) 2018 Netronome Systems, Inc. */

		#include <linux/bitfield.h>
		#include <linux/bitmap.h>
		#include <linux/etherdevice.h>
		#include <linux/lockdep.h>
		#include <linux/netdevice.h>
		@@ -399,6 +400,7 @@ static int nfp_abm_init(struct nfp_app *app)
		struct nfp_pf *pf = app->pf;
		struct nfp_reprs *reprs;
		struct nfp_abm *abm;
		unsigned int i;
		int err;

		if (!pf->eth_tbl) {
		@@ -425,15 +427,28 @@ static int nfp_abm_init(struct nfp_app *app)
		if (err)
		goto err_free_abm;

		err = -ENOMEM;
		abm->num_thresholds = NFP_NET_MAX_RX_RINGS;
		abm->threshold_undef = bitmap_zalloc(abm->num_thresholds, GFP_KERNEL);
		if (!abm->threshold_undef)
		goto err_free_abm;

		abm->thresholds = kvcalloc(abm->num_thresholds,
		sizeof(*abm->thresholds), GFP_KERNEL);
		if (!abm->thresholds)
		goto err_free_thresh_umap;
		for (i = 0; i < NFP_NET_MAX_RX_RINGS; i++)
		__nfp_abm_ctrl_set_q_lvl(abm, i, NFP_ABM_LVL_INFINITY);

		/* We start in legacy mode, make sure advanced queuing is disabled */
		err = nfp_abm_ctrl_qm_disable(abm);
		if (err)
		goto err_free_abm;
		goto err_free_thresh;

		err = -ENOMEM;
		reprs = nfp_reprs_alloc(pf->max_data_vnics);
		if (!reprs)
		goto err_free_abm;
		goto err_free_thresh;
		RCU_INIT_POINTER(app->reprs[NFP_REPR_TYPE_PHYS_PORT], reprs);

		reprs = nfp_reprs_alloc(pf->max_data_vnics);
		@@ -445,6 +460,10 @@ static int nfp_abm_init(struct nfp_app *app)

		err_free_phys:
		nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
		err_free_thresh:
		kvfree(abm->thresholds);
		err_free_thresh_umap:
		bitmap_free(abm->threshold_undef);
		err_free_abm:
		kfree(abm);
		app->priv = NULL;
		@@ -458,6 +477,8 @@ static void nfp_abm_clean(struct nfp_app *app)
		nfp_abm_eswitch_clean_up(abm);
		nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
		nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
		bitmap_free(abm->threshold_undef);
		kvfree(abm->thresholds);
		kfree(abm);
		app->priv = NULL;
		}

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

+14 −2

Original line number	Diff line number	Diff line
		@@ -20,6 +20,11 @@ struct nfp_net;
		* struct nfp_abm - ABM NIC app structure
		* @app: back pointer to nfp_app
		* @pf_id: ID of our PF link
		*
		* @thresholds: current threshold configuration
		* @threshold_undef: bitmap of thresholds which have not been set
		* @num_thresholds: number of @thresholds and bits in @threshold_undef
		*
		* @eswitch_mode: devlink eswitch mode, advanced functions only visible
		* in switchdev mode
		* @q_lvls: queue level control area
		@@ -28,6 +33,11 @@ struct nfp_net;
		struct nfp_abm {
		struct nfp_app *app;
		unsigned int pf_id;

		u32 *thresholds;
		unsigned long *threshold_undef;
		size_t num_thresholds;

		enum devlink_eswitch_mode eswitch_mode;
		const struct nfp_rtsym *q_lvls;
		const struct nfp_rtsym *qm_stats;
		@@ -64,11 +74,13 @@ struct nfp_alink_xstats {
		/**
		* struct nfp_red_qdisc - representation of single RED Qdisc
		* @handle: handle of currently offloaded RED Qdisc
		* @threshold: marking threshold of this Qdisc
		* @stats: statistics from last refresh
		* @xstats: base of extended statistics
		*/
		struct nfp_red_qdisc {
		u32 handle;
		u32 threshold;
		struct nfp_alink_stats stats;
		struct nfp_alink_xstats xstats;
		};
		@@ -102,8 +114,8 @@ int nfp_abm_setup_tc_mq(struct net_device netdev, struct nfp_abm_link alink,

		void nfp_abm_ctrl_read_params(struct nfp_abm_link *alink);
		int nfp_abm_ctrl_find_addrs(struct nfp_abm *abm);
		int nfp_abm_ctrl_set_all_q_lvls(struct nfp_abm_link *alink, u32 val);
		int nfp_abm_ctrl_set_q_lvl(struct nfp_abm_link *alink, unsigned int i,
		int __nfp_abm_ctrl_set_q_lvl(struct nfp_abm *abm, unsigned int id, u32 val);
		int nfp_abm_ctrl_set_q_lvl(struct nfp_abm_link *alink, unsigned int queue,
		u32 val);
		int nfp_abm_ctrl_read_stats(struct nfp_abm_link *alink,
		struct nfp_alink_stats *stats);

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

+66 −22

Original line number	Diff line number	Diff line
		@@ -7,25 +7,73 @@

		#include "../nfpcore/nfp_cpp.h"
		#include "../nfp_app.h"
		#include "../nfp_main.h"
		#include "../nfp_net.h"
		#include "../nfp_port.h"
		#include "main.h"

		static int
		static void
		nfp_abm_offload_compile_red(struct nfp_abm_link *alink,
		struct nfp_red_qdisc *qdisc, unsigned int queue)
		{
		if (!qdisc->handle)
		return;

		nfp_abm_ctrl_set_q_lvl(alink, queue, qdisc->threshold);
		}

		static void nfp_abm_offload_compile_one(struct nfp_abm_link *alink)
		{
		unsigned int i;
		bool is_mq;

		is_mq = alink->num_qdiscs > 1;

		for (i = 0; i < alink->total_queues; i++) {
		struct nfp_red_qdisc *next;

		if (is_mq && !alink->red_qdiscs[i].handle)
		continue;

		next = is_mq ? &alink->red_qdiscs[i] : &alink->red_qdiscs[0];
		nfp_abm_offload_compile_red(alink, next, i);
		}
		}

		static void nfp_abm_offload_update(struct nfp_abm *abm)
		{
		struct nfp_abm_link *alink = NULL;
		struct nfp_pf *pf = abm->app->pf;
		struct nfp_net *nn;
		size_t i;

		/* Mark all thresholds as unconfigured */
		__bitmap_set(abm->threshold_undef, 0, abm->num_thresholds);

		/* Configure all offloads */
		list_for_each_entry(nn, &pf->vnics, vnic_list) {
		alink = nn->app_priv;
		nfp_abm_offload_compile_one(alink);
		}

		/* Reset the unconfigured thresholds */
		for (i = 0; i < abm->num_thresholds; i++)
		if (test_bit(i, abm->threshold_undef))
		__nfp_abm_ctrl_set_q_lvl(abm, i, NFP_ABM_LVL_INFINITY);
		}

		static void
		__nfp_abm_reset_root(struct net_device netdev, struct nfp_abm_link alink,
		u32 handle, unsigned int qs, u32 init_val)
		{
		struct nfp_port *port = nfp_port_from_netdev(netdev);
		int ret;

		ret = nfp_abm_ctrl_set_all_q_lvls(alink, init_val);
		memset(alink->red_qdiscs, 0,
		sizeof(alink->red_qdiscs) alink->num_qdiscs);

		alink->parent = handle;
		alink->num_qdiscs = qs;
		port->tc_offload_cnt = qs;

		return ret;
		}

		static void
		@@ -66,12 +114,12 @@ nfp_abm_red_destroy(struct net_device netdev, struct nfp_abm_link alink,
		if (i == alink->num_qdiscs)
		return;

		if (alink->parent == TC_H_ROOT) {
		if (alink->parent == TC_H_ROOT)
		nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 0);
		} else {
		nfp_abm_ctrl_set_q_lvl(alink, i, NFP_ABM_LVL_INFINITY);
		else
		memset(&alink->red_qdiscs[i], 0, sizeof(*alink->red_qdiscs));
		}

		nfp_abm_offload_update(alink->abm);
		}

		static bool
		@@ -121,29 +169,19 @@ nfp_abm_red_replace(struct net_device netdev, struct nfp_abm_link alink,
		}

		if (existing) {
		if (alink->parent == TC_H_ROOT)
		err = nfp_abm_ctrl_set_all_q_lvls(alink, opt->set.min);
		else
		err = nfp_abm_ctrl_set_q_lvl(alink, i, opt->set.min);
		if (err)
		goto err_destroy;
		nfp_abm_offload_update(alink->abm);
		return 0;
		}

		if (opt->parent == TC_H_ROOT) {
		i = 0;
		err = __nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 1,
		opt->set.min);
		__nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 1, opt->set.min);
		} else if (TC_H_MAJ(alink->parent) == TC_H_MAJ(opt->parent)) {
		i = TC_H_MIN(opt->parent) - 1;
		err = nfp_abm_ctrl_set_q_lvl(alink, i, opt->set.min);
		} else {
		return -EINVAL;
		}
		/* Set the handle to try full clean up, in case IO failed */
		alink->red_qdiscs[i].handle = opt->handle;
		if (err)
		goto err_destroy;

		if (opt->parent == TC_H_ROOT)
		err = nfp_abm_ctrl_read_stats(alink,
		@@ -163,9 +201,12 @@ nfp_abm_red_replace(struct net_device netdev, struct nfp_abm_link alink,
		if (err)
		goto err_destroy;

		alink->red_qdiscs[i].threshold = opt->set.min;
		alink->red_qdiscs[i].stats.backlog_pkts = 0;
		alink->red_qdiscs[i].stats.backlog_bytes = 0;

		nfp_abm_offload_update(alink->abm);

		return 0;
		err_destroy:
		/* If the qdisc keeps on living, but we can't offload undo changes */
		@@ -292,10 +333,13 @@ int nfp_abm_setup_tc_mq(struct net_device netdev, struct nfp_abm_link alink,
		case TC_MQ_CREATE:
		nfp_abm_reset_root(netdev, alink, opt->handle,
		alink->total_queues);
		nfp_abm_offload_update(alink->abm);
		return 0;
		case TC_MQ_DESTROY:
		if (opt->handle == alink->parent)
		if (opt->handle == alink->parent) {
		nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 0);
		nfp_abm_offload_update(alink->abm);
		}
		return 0;
		case TC_MQ_STATS:
		return nfp_abm_mq_stats(alink, opt);

Admin message