From 47330f9bdf240f5a582f756cf93354281b36453a Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Thu, 8 Nov 2018 19:50:33 -0800 Subject: nfp: abm: split qdisc offload code into a separate file The Qdisc offload code is logically separate, and we will soon do significant surgery on it to support more Qdiscs, so move it to a separate file. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Reviewed-by: Quentin Monnet Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 272 +++++++++++++++++++++++++ 1 file changed, 272 insertions(+) create mode 100644 drivers/net/ethernet/netronome/nfp/abm/qdisc.c (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c new file mode 100644 index 000000000000..f36da95827ee --- /dev/null +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -0,0 +1,272 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +/* Copyright (C) 2018 Netronome Systems, Inc. */ + +#include +#include +#include + +#include "../nfpcore/nfp_cpp.h" +#include "../nfp_app.h" +#include "../nfp_port.h" +#include "main.h" + +static int +__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->qdiscs, 0, sizeof(*alink->qdiscs) * alink->num_qdiscs); + + alink->parent = handle; + alink->num_qdiscs = qs; + port->tc_offload_cnt = qs; + + return ret; +} + +static void +nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink, + u32 handle, unsigned int qs) +{ + __nfp_abm_reset_root(netdev, alink, handle, qs, ~0); +} + +static int +nfp_abm_red_find(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) +{ + unsigned int i = TC_H_MIN(opt->parent) - 1; + + if (opt->parent == TC_H_ROOT) + i = 0; + else if (TC_H_MAJ(alink->parent) == TC_H_MAJ(opt->parent)) + i = TC_H_MIN(opt->parent) - 1; + else + return -EOPNOTSUPP; + + if (i >= alink->num_qdiscs || opt->handle != alink->qdiscs[i].handle) + return -EOPNOTSUPP; + + return i; +} + +static void +nfp_abm_red_destroy(struct net_device *netdev, struct nfp_abm_link *alink, + u32 handle) +{ + unsigned int i; + + for (i = 0; i < alink->num_qdiscs; i++) + if (handle == alink->qdiscs[i].handle) + break; + if (i == alink->num_qdiscs) + return; + + 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, ~0); + memset(&alink->qdiscs[i], 0, sizeof(*alink->qdiscs)); + } +} + +static int +nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, + struct tc_red_qopt_offload *opt) +{ + bool existing; + int i, err; + + i = nfp_abm_red_find(alink, opt); + existing = i >= 0; + + if (opt->set.min != opt->set.max || !opt->set.is_ecn) { + nfp_warn(alink->abm->app->cpp, + "RED offload failed - unsupported parameters\n"); + err = -EINVAL; + goto err_destroy; + } + + 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; + return 0; + } + + if (opt->parent == TC_H_ROOT) { + i = 0; + err = __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->qdiscs[i].handle = opt->handle; + if (err) + goto err_destroy; + + if (opt->parent == TC_H_ROOT) + err = nfp_abm_ctrl_read_stats(alink, &alink->qdiscs[i].stats); + else + err = nfp_abm_ctrl_read_q_stats(alink, i, + &alink->qdiscs[i].stats); + if (err) + goto err_destroy; + + if (opt->parent == TC_H_ROOT) + err = nfp_abm_ctrl_read_xstats(alink, + &alink->qdiscs[i].xstats); + else + err = nfp_abm_ctrl_read_q_xstats(alink, i, + &alink->qdiscs[i].xstats); + if (err) + goto err_destroy; + + alink->qdiscs[i].stats.backlog_pkts = 0; + alink->qdiscs[i].stats.backlog_bytes = 0; + + return 0; +err_destroy: + /* If the qdisc keeps on living, but we can't offload undo changes */ + if (existing) { + opt->set.qstats->qlen -= alink->qdiscs[i].stats.backlog_pkts; + opt->set.qstats->backlog -= + alink->qdiscs[i].stats.backlog_bytes; + } + nfp_abm_red_destroy(netdev, alink, opt->handle); + + return err; +} + +static void +nfp_abm_update_stats(struct nfp_alink_stats *new, struct nfp_alink_stats *old, + struct tc_qopt_offload_stats *stats) +{ + _bstats_update(stats->bstats, new->tx_bytes - old->tx_bytes, + new->tx_pkts - old->tx_pkts); + stats->qstats->qlen += new->backlog_pkts - old->backlog_pkts; + stats->qstats->backlog += new->backlog_bytes - old->backlog_bytes; + stats->qstats->overlimits += new->overlimits - old->overlimits; + stats->qstats->drops += new->drops - old->drops; +} + +static int +nfp_abm_red_stats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) +{ + struct nfp_alink_stats *prev_stats; + struct nfp_alink_stats stats; + int i, err; + + i = nfp_abm_red_find(alink, opt); + if (i < 0) + return i; + prev_stats = &alink->qdiscs[i].stats; + + if (alink->parent == TC_H_ROOT) + err = nfp_abm_ctrl_read_stats(alink, &stats); + else + err = nfp_abm_ctrl_read_q_stats(alink, i, &stats); + if (err) + return err; + + nfp_abm_update_stats(&stats, prev_stats, &opt->stats); + + *prev_stats = stats; + + return 0; +} + +static int +nfp_abm_red_xstats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) +{ + struct nfp_alink_xstats *prev_xstats; + struct nfp_alink_xstats xstats; + int i, err; + + i = nfp_abm_red_find(alink, opt); + if (i < 0) + return i; + prev_xstats = &alink->qdiscs[i].xstats; + + if (alink->parent == TC_H_ROOT) + err = nfp_abm_ctrl_read_xstats(alink, &xstats); + else + err = nfp_abm_ctrl_read_q_xstats(alink, i, &xstats); + if (err) + return err; + + opt->xstats->forced_mark += xstats.ecn_marked - prev_xstats->ecn_marked; + opt->xstats->pdrop += xstats.pdrop - prev_xstats->pdrop; + + *prev_xstats = xstats; + + return 0; +} + +int nfp_abm_setup_tc_red(struct net_device *netdev, struct nfp_abm_link *alink, + struct tc_red_qopt_offload *opt) +{ + switch (opt->command) { + case TC_RED_REPLACE: + return nfp_abm_red_replace(netdev, alink, opt); + case TC_RED_DESTROY: + nfp_abm_red_destroy(netdev, alink, opt->handle); + return 0; + case TC_RED_STATS: + return nfp_abm_red_stats(alink, opt); + case TC_RED_XSTATS: + return nfp_abm_red_xstats(alink, opt); + default: + return -EOPNOTSUPP; + } +} + +static int +nfp_abm_mq_stats(struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt) +{ + struct nfp_alink_stats stats; + unsigned int i; + int err; + + for (i = 0; i < alink->num_qdiscs; i++) { + if (alink->qdiscs[i].handle == TC_H_UNSPEC) + continue; + + err = nfp_abm_ctrl_read_q_stats(alink, i, &stats); + if (err) + return err; + + nfp_abm_update_stats(&stats, &alink->qdiscs[i].stats, + &opt->stats); + } + + return 0; +} + +int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, + struct tc_mq_qopt_offload *opt) +{ + switch (opt->command) { + case TC_MQ_CREATE: + nfp_abm_reset_root(netdev, alink, opt->handle, + alink->total_queues); + return 0; + case TC_MQ_DESTROY: + if (opt->handle == alink->parent) + nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 0); + return 0; + case TC_MQ_STATS: + return nfp_abm_mq_stats(alink, opt); + default: + return -EOPNOTSUPP; + } +} -- cgit From 032748acf616c250aa195c92715ba89e136c61fe Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Thu, 8 Nov 2018 19:50:36 -0800 Subject: nfp: abm: provide more precise info about offload parameter validation Improve log messages printed when RED can't be offloaded because of Qdisc parameters. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Reviewed-by: Quentin Monnet Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index f36da95827ee..04b91cc12434 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -72,6 +72,26 @@ nfp_abm_red_destroy(struct net_device *netdev, struct nfp_abm_link *alink, } } +static bool +nfp_abm_red_check_params(struct nfp_abm_link *alink, + struct tc_red_qopt_offload *opt) +{ + struct nfp_cpp *cpp = alink->abm->app->cpp; + + if (!opt->set.is_ecn) { + nfp_warn(cpp, "RED offload failed - drop is not supported (ECN option required) (p:%08x h:%08x)\n", + opt->parent, opt->handle); + return false; + } + if (opt->set.min != opt->set.max) { + nfp_warn(cpp, "RED offload failed - unsupported min/max parameters (p:%08x h:%08x)\n", + opt->parent, opt->handle); + return false; + } + + return true; +} + static int nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) @@ -82,9 +102,7 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, i = nfp_abm_red_find(alink, opt); existing = i >= 0; - if (opt->set.min != opt->set.max || !opt->set.is_ecn) { - nfp_warn(alink->abm->app->cpp, - "RED offload failed - unsupported parameters\n"); + if (!nfp_abm_red_check_params(alink, opt)) { err = -EINVAL; goto err_destroy; } -- cgit From cae5f48e3234dda5bab6f7f361b5eff6d4cc77b2 Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Thu, 8 Nov 2018 19:50:37 -0800 Subject: nfp: abm: don't set negative threshold Turns out the threshold value is used in signed compares in the FW, so we should avoid setting the top bit. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Reviewed-by: Quentin Monnet Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index 04b91cc12434..979afb3ea855 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -31,7 +31,7 @@ static void nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink, u32 handle, unsigned int qs) { - __nfp_abm_reset_root(netdev, alink, handle, qs, ~0); + __nfp_abm_reset_root(netdev, alink, handle, qs, NFP_ABM_LVL_INFINITY); } static int @@ -67,7 +67,7 @@ nfp_abm_red_destroy(struct net_device *netdev, struct nfp_abm_link *alink, 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, ~0); + nfp_abm_ctrl_set_q_lvl(alink, i, NFP_ABM_LVL_INFINITY); memset(&alink->qdiscs[i], 0, sizeof(*alink->qdiscs)); } } @@ -88,6 +88,12 @@ nfp_abm_red_check_params(struct nfp_abm_link *alink, opt->parent, opt->handle); return false; } + if (opt->set.min > NFP_ABM_LVL_INFINITY) { + nfp_warn(cpp, "RED offload failed - threshold too large %d > %d (p:%08x h:%08x)\n", + opt->set.min, NFP_ABM_LVL_INFINITY, opt->parent, + opt->handle); + return false; + } return true; } -- cgit From 6e5a716f424b1020fc8cf52b0ab4a1551e952733 Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Thu, 8 Nov 2018 19:50:39 -0800 Subject: nfp: abm: refuse RED offload with harddrop set RED Qdisc will now inform the drivers about the state of the harddrop flag. Refuse to offload in case harddrop is set. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Reviewed-by: Quentin Monnet Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index 979afb3ea855..bb05f9ee0401 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -83,6 +83,11 @@ nfp_abm_red_check_params(struct nfp_abm_link *alink, opt->parent, opt->handle); return false; } + if (opt->set.is_harddrop) { + nfp_warn(cpp, "RED offload failed - harddrop is not supported (p:%08x h:%08x)\n", + opt->parent, opt->handle); + return false; + } if (opt->set.min != opt->set.max) { nfp_warn(cpp, "RED offload failed - unsupported min/max parameters (p:%08x h:%08x)\n", opt->parent, opt->handle); -- cgit From 08990494e59d1ee43f02a687042b7b30ca260bad Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:07 -0800 Subject: nfp: abm: rename qdiscs -> red_qdiscs Rename qdiscs member to red_qdiscs. One of following patches will use the name qdiscs for tracking all qdisc types. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 38 ++++++++++++++------------ 1 file changed, 21 insertions(+), 17 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index bb05f9ee0401..abda392880e0 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -18,7 +18,8 @@ __nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink, int ret; ret = nfp_abm_ctrl_set_all_q_lvls(alink, init_val); - memset(alink->qdiscs, 0, sizeof(*alink->qdiscs) * alink->num_qdiscs); + memset(alink->red_qdiscs, 0, + sizeof(*alink->red_qdiscs) * alink->num_qdiscs); alink->parent = handle; alink->num_qdiscs = qs; @@ -46,7 +47,8 @@ nfp_abm_red_find(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) else return -EOPNOTSUPP; - if (i >= alink->num_qdiscs || opt->handle != alink->qdiscs[i].handle) + if (i >= alink->num_qdiscs || + opt->handle != alink->red_qdiscs[i].handle) return -EOPNOTSUPP; return i; @@ -59,7 +61,7 @@ nfp_abm_red_destroy(struct net_device *netdev, struct nfp_abm_link *alink, unsigned int i; for (i = 0; i < alink->num_qdiscs; i++) - if (handle == alink->qdiscs[i].handle) + if (handle == alink->red_qdiscs[i].handle) break; if (i == alink->num_qdiscs) return; @@ -68,7 +70,7 @@ nfp_abm_red_destroy(struct net_device *netdev, struct nfp_abm_link *alink, nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 0); } else { nfp_abm_ctrl_set_q_lvl(alink, i, NFP_ABM_LVL_INFINITY); - memset(&alink->qdiscs[i], 0, sizeof(*alink->qdiscs)); + memset(&alink->red_qdiscs[i], 0, sizeof(*alink->red_qdiscs)); } } @@ -139,37 +141,39 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, return -EINVAL; } /* Set the handle to try full clean up, in case IO failed */ - alink->qdiscs[i].handle = opt->handle; + 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, &alink->qdiscs[i].stats); + err = nfp_abm_ctrl_read_stats(alink, + &alink->red_qdiscs[i].stats); else err = nfp_abm_ctrl_read_q_stats(alink, i, - &alink->qdiscs[i].stats); + &alink->red_qdiscs[i].stats); if (err) goto err_destroy; if (opt->parent == TC_H_ROOT) err = nfp_abm_ctrl_read_xstats(alink, - &alink->qdiscs[i].xstats); + &alink->red_qdiscs[i].xstats); else err = nfp_abm_ctrl_read_q_xstats(alink, i, - &alink->qdiscs[i].xstats); + &alink->red_qdiscs[i].xstats); if (err) goto err_destroy; - alink->qdiscs[i].stats.backlog_pkts = 0; - alink->qdiscs[i].stats.backlog_bytes = 0; + alink->red_qdiscs[i].stats.backlog_pkts = 0; + alink->red_qdiscs[i].stats.backlog_bytes = 0; return 0; err_destroy: /* If the qdisc keeps on living, but we can't offload undo changes */ if (existing) { - opt->set.qstats->qlen -= alink->qdiscs[i].stats.backlog_pkts; + opt->set.qstats->qlen -= + alink->red_qdiscs[i].stats.backlog_pkts; opt->set.qstats->backlog -= - alink->qdiscs[i].stats.backlog_bytes; + alink->red_qdiscs[i].stats.backlog_bytes; } nfp_abm_red_destroy(netdev, alink, opt->handle); @@ -198,7 +202,7 @@ nfp_abm_red_stats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) i = nfp_abm_red_find(alink, opt); if (i < 0) return i; - prev_stats = &alink->qdiscs[i].stats; + prev_stats = &alink->red_qdiscs[i].stats; if (alink->parent == TC_H_ROOT) err = nfp_abm_ctrl_read_stats(alink, &stats); @@ -224,7 +228,7 @@ nfp_abm_red_xstats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) i = nfp_abm_red_find(alink, opt); if (i < 0) return i; - prev_xstats = &alink->qdiscs[i].xstats; + prev_xstats = &alink->red_qdiscs[i].xstats; if (alink->parent == TC_H_ROOT) err = nfp_abm_ctrl_read_xstats(alink, &xstats); @@ -267,14 +271,14 @@ nfp_abm_mq_stats(struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt) int err; for (i = 0; i < alink->num_qdiscs; i++) { - if (alink->qdiscs[i].handle == TC_H_UNSPEC) + if (alink->red_qdiscs[i].handle == TC_H_UNSPEC) continue; err = nfp_abm_ctrl_read_q_stats(alink, i, &stats); if (err) return err; - nfp_abm_update_stats(&stats, &alink->qdiscs[i].stats, + nfp_abm_update_stats(&stats, &alink->red_qdiscs[i].stats, &opt->stats); } -- cgit From 6666f545e9e19bb6b4836b6c5215ceba47d58d3e Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:08 -0800 Subject: nfp: abm: keep track of all RED thresholds Instead of writing the threshold out when Qdisc is configured and not remembering it move to a scheme where we remember all thresholds. When configuration changes parse the offloaded Qdiscs and set thresholds appropriately. This will help future extensions. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 88 +++++++++++++++++++------- 1 file changed, 66 insertions(+), 22 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index abda392880e0..abb0a24c7fac 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -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); -- cgit From 4f5681d088ba01f12f63160fa843c915e1ce1358 Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:09 -0800 Subject: nfp: abm: track all offload-enabled qdiscs Allocate an object corresponding to any offloaded qdisc we are informed about by the kernel. Not only the qdiscs we have a chance of offloading. The count of created objects will be used to decide whether the ethtool TC offload can be disabled, since otherwise we may miss destroy commands. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 111 ++++++++++++++++++++++++- 1 file changed, 107 insertions(+), 4 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index abb0a24c7fac..a6f95924656d 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -63,17 +63,97 @@ static void nfp_abm_offload_update(struct nfp_abm *abm) } static void -__nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink, - u32 handle, unsigned int qs, u32 init_val) +nfp_abm_qdisc_free(struct net_device *netdev, struct nfp_abm_link *alink, + struct nfp_qdisc *qdisc) { struct nfp_port *port = nfp_port_from_netdev(netdev); + if (!qdisc) + return; + WARN_ON(radix_tree_delete(&alink->qdiscs, + TC_H_MAJ(qdisc->handle)) != qdisc); + kfree(qdisc); + + port->tc_offload_cnt--; +} + +static struct nfp_qdisc * +nfp_abm_qdisc_alloc(struct net_device *netdev, struct nfp_abm_link *alink, + enum nfp_qdisc_type type, u32 parent_handle, u32 handle) +{ + struct nfp_port *port = nfp_port_from_netdev(netdev); + struct nfp_qdisc *qdisc; + int err; + + qdisc = kzalloc(sizeof(*qdisc), GFP_KERNEL); + if (!qdisc) + return NULL; + + qdisc->netdev = netdev; + qdisc->type = type; + qdisc->parent_handle = parent_handle; + qdisc->handle = handle; + + err = radix_tree_insert(&alink->qdiscs, TC_H_MAJ(qdisc->handle), qdisc); + if (err) { + nfp_err(alink->abm->app->cpp, + "Qdisc insertion into radix tree failed: %d\n", err); + goto err_free_qdisc; + } + + port->tc_offload_cnt++; + return qdisc; + +err_free_qdisc: + kfree(qdisc); + return NULL; +} + +static struct nfp_qdisc * +nfp_abm_qdisc_find(struct nfp_abm_link *alink, u32 handle) +{ + return radix_tree_lookup(&alink->qdiscs, TC_H_MAJ(handle)); +} + +static int +nfp_abm_qdisc_replace(struct net_device *netdev, struct nfp_abm_link *alink, + enum nfp_qdisc_type type, u32 parent_handle, u32 handle, + struct nfp_qdisc **qdisc) +{ + *qdisc = nfp_abm_qdisc_find(alink, handle); + if (*qdisc) { + if (WARN_ON((*qdisc)->type != type)) + return -EINVAL; + return 0; + } + + *qdisc = nfp_abm_qdisc_alloc(netdev, alink, type, parent_handle, + handle); + return *qdisc ? 0 : -ENOMEM; +} + +static void +nfp_abm_qdisc_destroy(struct net_device *netdev, struct nfp_abm_link *alink, + u32 handle) +{ + struct nfp_qdisc *qdisc; + + qdisc = nfp_abm_qdisc_find(alink, handle); + if (!qdisc) + return; + + nfp_abm_qdisc_free(netdev, alink, qdisc); +} + +static void +__nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink, + u32 handle, unsigned int qs, u32 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; } static void @@ -108,6 +188,8 @@ nfp_abm_red_destroy(struct net_device *netdev, struct nfp_abm_link *alink, { unsigned int i; + nfp_abm_qdisc_destroy(netdev, alink, handle); + for (i = 0; i < alink->num_qdiscs; i++) if (handle == alink->red_qdiscs[i].handle) break; @@ -157,12 +239,22 @@ static int nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) { + struct nfp_qdisc *qdisc; bool existing; int i, err; + int ret; + + ret = nfp_abm_qdisc_replace(netdev, alink, NFP_QDISC_RED, opt->parent, + opt->handle, &qdisc); i = nfp_abm_red_find(alink, opt); existing = i >= 0; + if (ret) { + err = ret; + goto err_destroy; + } + if (!nfp_abm_red_check_params(alink, opt)) { err = -EINVAL; goto err_destroy; @@ -326,6 +418,16 @@ nfp_abm_mq_stats(struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt) return 0; } +static int +nfp_abm_mq_create(struct net_device *netdev, struct nfp_abm_link *alink, + struct tc_mq_qopt_offload *opt) +{ + struct nfp_qdisc *qdisc; + + return nfp_abm_qdisc_replace(netdev, alink, NFP_QDISC_MQ, + TC_H_ROOT, opt->handle, &qdisc); +} + int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt) { @@ -334,8 +436,9 @@ int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, nfp_abm_reset_root(netdev, alink, opt->handle, alink->total_queues); nfp_abm_offload_update(alink->abm); - return 0; + return nfp_abm_mq_create(netdev, alink, opt); case TC_MQ_DESTROY: + nfp_abm_qdisc_destroy(netdev, alink, opt->handle); if (opt->handle == alink->parent) { nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 0); nfp_abm_offload_update(alink->abm); -- cgit From 1853125889a397725420e8ef003502141269d08f Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:11 -0800 Subject: nfp: abm: remember which Qdisc is root Keep track of which Qdisc is currently root. We need to implement TC_SETUP_ROOT_QDISC handling, and for completeness also clear the root Qdisc pointer when it's freed. TC_SETUP_ROOT_QDISC isn't always sent when device is dismantled. Remembering the root Qdisc will allow us to build the entire hierarchy in following patches. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index a6f95924656d..ba6ce2d1eda2 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -143,6 +143,9 @@ nfp_abm_qdisc_destroy(struct net_device *netdev, struct nfp_abm_link *alink, return; nfp_abm_qdisc_free(netdev, alink, qdisc); + + if (alink->root_qdisc == qdisc) + alink->root_qdisc = NULL; } static void @@ -450,3 +453,13 @@ int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, return -EOPNOTSUPP; } } + +int nfp_abm_setup_root(struct net_device *netdev, struct nfp_abm_link *alink, + struct tc_root_qopt_offload *opt) +{ + if (opt->ingress) + return -EOPNOTSUPP; + alink->root_qdisc = nfp_abm_qdisc_find(alink, opt->handle); + + return 0; +} -- cgit From aee7539c5876cc65f5ffa88615a88eb724358cc1 Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:12 -0800 Subject: nfp: abm: allocate Qdisc child table To keep track of Qdisc hierarchy allocate a table for children for each Qdisc. RED Qdisc can only have one child. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index ba6ce2d1eda2..3ecb63060429 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -72,6 +72,8 @@ nfp_abm_qdisc_free(struct net_device *netdev, struct nfp_abm_link *alink, return; WARN_ON(radix_tree_delete(&alink->qdiscs, TC_H_MAJ(qdisc->handle)) != qdisc); + + kfree(qdisc->children); kfree(qdisc); port->tc_offload_cnt--; @@ -79,7 +81,8 @@ nfp_abm_qdisc_free(struct net_device *netdev, struct nfp_abm_link *alink, static struct nfp_qdisc * nfp_abm_qdisc_alloc(struct net_device *netdev, struct nfp_abm_link *alink, - enum nfp_qdisc_type type, u32 parent_handle, u32 handle) + enum nfp_qdisc_type type, u32 parent_handle, u32 handle, + unsigned int children) { struct nfp_port *port = nfp_port_from_netdev(netdev); struct nfp_qdisc *qdisc; @@ -89,21 +92,28 @@ nfp_abm_qdisc_alloc(struct net_device *netdev, struct nfp_abm_link *alink, if (!qdisc) return NULL; + qdisc->children = kcalloc(children, sizeof(void *), GFP_KERNEL); + if (!qdisc->children) + goto err_free_qdisc; + qdisc->netdev = netdev; qdisc->type = type; qdisc->parent_handle = parent_handle; qdisc->handle = handle; + qdisc->num_children = children; err = radix_tree_insert(&alink->qdiscs, TC_H_MAJ(qdisc->handle), qdisc); if (err) { nfp_err(alink->abm->app->cpp, "Qdisc insertion into radix tree failed: %d\n", err); - goto err_free_qdisc; + goto err_free_child_tbl; } port->tc_offload_cnt++; return qdisc; +err_free_child_tbl: + kfree(qdisc->children); err_free_qdisc: kfree(qdisc); return NULL; @@ -118,7 +128,7 @@ nfp_abm_qdisc_find(struct nfp_abm_link *alink, u32 handle) static int nfp_abm_qdisc_replace(struct net_device *netdev, struct nfp_abm_link *alink, enum nfp_qdisc_type type, u32 parent_handle, u32 handle, - struct nfp_qdisc **qdisc) + unsigned int children, struct nfp_qdisc **qdisc) { *qdisc = nfp_abm_qdisc_find(alink, handle); if (*qdisc) { @@ -127,8 +137,8 @@ nfp_abm_qdisc_replace(struct net_device *netdev, struct nfp_abm_link *alink, return 0; } - *qdisc = nfp_abm_qdisc_alloc(netdev, alink, type, parent_handle, - handle); + *qdisc = nfp_abm_qdisc_alloc(netdev, alink, type, parent_handle, handle, + children); return *qdisc ? 0 : -ENOMEM; } @@ -248,7 +258,7 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, int ret; ret = nfp_abm_qdisc_replace(netdev, alink, NFP_QDISC_RED, opt->parent, - opt->handle, &qdisc); + opt->handle, 1, &qdisc); i = nfp_abm_red_find(alink, opt); existing = i >= 0; @@ -428,7 +438,8 @@ nfp_abm_mq_create(struct net_device *netdev, struct nfp_abm_link *alink, struct nfp_qdisc *qdisc; return nfp_abm_qdisc_replace(netdev, alink, NFP_QDISC_MQ, - TC_H_ROOT, opt->handle, &qdisc); + TC_H_ROOT, opt->handle, + alink->total_queues, &qdisc); } int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, -- cgit From 6b8417b7e6f5e4da2bfb4dd087d5f7f082d077de Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:15 -0800 Subject: nfp: abm: build full Qdisc hierarchy based on graft notifications Using graft notifications recreate in the driver the full Qdisc hierarchy. Keep track of how many times each Qdisc is attached to the hierarchy to make sure we don't offload Qdiscs which are attached multiple times (device queues can't be shared). For graft events of Qdiscs we don't know exist make the child as invalid/untracked. Note that MQ Qdisc doesn't send destruction events reliably when device is dismantled, so we need to manually clean out the children otherwise we'd think Qdiscs which are still in use are getting freed. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 105 +++++++++++++++++++++++++ 1 file changed, 105 insertions(+) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index 3ecb63060429..151d2dafbc76 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -1,6 +1,7 @@ // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) /* Copyright (C) 2018 Netronome Systems, Inc. */ +#include #include #include #include @@ -12,6 +13,66 @@ #include "../nfp_port.h" #include "main.h" +static bool nfp_abm_qdisc_child_valid(struct nfp_qdisc *qdisc, unsigned int id) +{ + return qdisc->children[id] && + qdisc->children[id] != NFP_QDISC_UNTRACKED; +} + +static void *nfp_abm_qdisc_tree_deref_slot(void __rcu **slot) +{ + return rtnl_dereference(*slot); +} + +static void +nfp_abm_qdisc_unlink_children(struct nfp_qdisc *qdisc, + unsigned int start, unsigned int end) +{ + unsigned int i; + + for (i = start; i < end; i++) + if (nfp_abm_qdisc_child_valid(qdisc, i)) { + qdisc->children[i]->use_cnt--; + qdisc->children[i] = NULL; + } +} + +static void +nfp_abm_qdisc_clear_mq(struct net_device *netdev, struct nfp_abm_link *alink, + struct nfp_qdisc *qdisc) +{ + struct radix_tree_iter iter; + unsigned int mq_refs = 0; + void __rcu **slot; + + if (!qdisc->use_cnt) + return; + /* MQ doesn't notify well on destruction, we need special handling of + * MQ's children. + */ + if (qdisc->type == NFP_QDISC_MQ && + qdisc == alink->root_qdisc && + netdev->reg_state == NETREG_UNREGISTERING) + return; + + /* Count refs held by MQ instances and clear pointers */ + radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) { + struct nfp_qdisc *mq = nfp_abm_qdisc_tree_deref_slot(slot); + unsigned int i; + + if (mq->type != NFP_QDISC_MQ || mq->netdev != netdev) + continue; + for (i = 0; i < mq->num_children; i++) + if (mq->children[i] == qdisc) { + mq->children[i] = NULL; + mq_refs++; + } + } + + WARN(qdisc->use_cnt != mq_refs, "non-zero qdisc use count: %d (- %d)\n", + qdisc->use_cnt, mq_refs); +} + static void nfp_abm_offload_compile_red(struct nfp_abm_link *alink, struct nfp_red_qdisc *qdisc, unsigned int queue) @@ -70,6 +131,7 @@ nfp_abm_qdisc_free(struct net_device *netdev, struct nfp_abm_link *alink, if (!qdisc) return; + nfp_abm_qdisc_clear_mq(netdev, alink, qdisc); WARN_ON(radix_tree_delete(&alink->qdiscs, TC_H_MAJ(qdisc->handle)) != qdisc); @@ -152,12 +214,44 @@ nfp_abm_qdisc_destroy(struct net_device *netdev, struct nfp_abm_link *alink, if (!qdisc) return; + /* We don't get TC_SETUP_ROOT_QDISC w/ MQ when netdev is unregistered */ + if (alink->root_qdisc == qdisc) + qdisc->use_cnt--; + + nfp_abm_qdisc_unlink_children(qdisc, 0, qdisc->num_children); nfp_abm_qdisc_free(netdev, alink, qdisc); if (alink->root_qdisc == qdisc) alink->root_qdisc = NULL; } +static int +nfp_abm_qdisc_graft(struct nfp_abm_link *alink, u32 handle, u32 child_handle, + unsigned int id) +{ + struct nfp_qdisc *parent, *child; + + parent = nfp_abm_qdisc_find(alink, handle); + if (!parent) + return 0; + + if (WARN(id >= parent->num_children, + "graft child out of bound %d >= %d\n", + id, parent->num_children)) + return -EINVAL; + + nfp_abm_qdisc_unlink_children(parent, id, id + 1); + + child = nfp_abm_qdisc_find(alink, child_handle); + if (child) + child->use_cnt++; + else + child = NFP_QDISC_UNTRACKED; + parent->children[id] = child; + + return 0; +} + static void __nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink, u32 handle, unsigned int qs, u32 init_val) @@ -404,6 +498,9 @@ int nfp_abm_setup_tc_red(struct net_device *netdev, struct nfp_abm_link *alink, return nfp_abm_red_stats(alink, opt); case TC_RED_XSTATS: return nfp_abm_red_xstats(alink, opt); + case TC_RED_GRAFT: + return nfp_abm_qdisc_graft(alink, opt->handle, + opt->child_handle, 0); default: return -EOPNOTSUPP; } @@ -460,6 +557,10 @@ int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, return 0; case TC_MQ_STATS: return nfp_abm_mq_stats(alink, opt); + case TC_MQ_GRAFT: + return nfp_abm_qdisc_graft(alink, opt->handle, + opt->graft_params.child_handle, + opt->graft_params.queue); default: return -EOPNOTSUPP; } @@ -470,7 +571,11 @@ int nfp_abm_setup_root(struct net_device *netdev, struct nfp_abm_link *alink, { if (opt->ingress) return -EOPNOTSUPP; + if (alink->root_qdisc) + alink->root_qdisc->use_cnt--; alink->root_qdisc = nfp_abm_qdisc_find(alink, opt->handle); + if (alink->root_qdisc) + alink->root_qdisc->use_cnt++; return 0; } -- cgit From 6c5dbda0d4df000cff88d8bbb382de3d2e034d8f Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:17 -0800 Subject: nfp: abm: reset RED's child based on limit RED qdisc will replace its child Qdisc with a new FIFO queue if it is reconfigured and the limit parameter is not 0. This means that when it's created with limit of 0 it will have no FIFO, and all packets will be dropped. If it's changed and limit is specified it will loose its existing child (implicit graft). Make sure we mark RED Qdisc child as NFP_QDISC_UNTRACKED if its not the expected FIFO. nfp_abm_qdisc_replace() will return 1 if Qdisc already existed. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 27 +++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index 151d2dafbc76..1b3c0b5b52bf 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -196,7 +196,7 @@ nfp_abm_qdisc_replace(struct net_device *netdev, struct nfp_abm_link *alink, if (*qdisc) { if (WARN_ON((*qdisc)->type != type)) return -EINVAL; - return 0; + return 1; } *qdisc = nfp_abm_qdisc_alloc(netdev, alink, type, parent_handle, handle, @@ -357,11 +357,24 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, i = nfp_abm_red_find(alink, opt); existing = i >= 0; - if (ret) { + if (ret < 0) { err = ret; goto err_destroy; } + /* If limit != 0 child gets reset */ + if (opt->set.limit) { + if (nfp_abm_qdisc_child_valid(qdisc, 0)) + qdisc->children[0]->use_cnt--; + qdisc->children[0] = NULL; + } else { + /* Qdisc was just allocated without a limit will use noop_qdisc, + * i.e. a block hole. + */ + if (!ret) + qdisc->children[0] = NFP_QDISC_UNTRACKED; + } + if (!nfp_abm_red_check_params(alink, opt)) { err = -EINVAL; goto err_destroy; @@ -533,10 +546,14 @@ nfp_abm_mq_create(struct net_device *netdev, struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt) { struct nfp_qdisc *qdisc; + int ret; - return nfp_abm_qdisc_replace(netdev, alink, NFP_QDISC_MQ, - TC_H_ROOT, opt->handle, - alink->total_queues, &qdisc); + ret = nfp_abm_qdisc_replace(netdev, alink, NFP_QDISC_MQ, + TC_H_ROOT, opt->handle, alink->total_queues, + &qdisc); + if (ret < 0) + return ret; + return 0; } int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, -- cgit From 52db4eaca59fd2af8f3579ae9361214def014dbe Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:18 -0800 Subject: nfp: abm: save RED's parameters Use the new driver Qdisc structure to keep track of parameters of RED Qdiscs. This way as the Qdisc moves around in the hierarchy we will be able to configure the HW appropriately. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index 1b3c0b5b52bf..fb68038ec1da 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -375,7 +375,10 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, qdisc->children[0] = NFP_QDISC_UNTRACKED; } - if (!nfp_abm_red_check_params(alink, opt)) { + qdisc->params_ok = nfp_abm_red_check_params(alink, opt); + if (qdisc->params_ok) { + qdisc->red.threshold = opt->set.min; + } else { err = -EINVAL; goto err_destroy; } -- cgit From bd3b5d462add1c703dd02a7a6f498a0f1bea9f4a Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 12 Nov 2018 14:58:19 -0800 Subject: nfp: abm: restructure Qdisc handling In preparation of handling more Qdisc types switch to a different offload strategy. We have now recreated the Qdisc hierarchy in the driver. Every time the hierarchy changes parse it, and update the configuration of the HW accordingly. While at it drop the support of pretending that we can instantiate a single queue on a multi-queue device in HW/FW. MQ is now required, and each queue will have its own instance of RED. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 548 ++++++++++++++----------- 1 file changed, 305 insertions(+), 243 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index fb68038ec1da..16c4afe3a37f 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -13,6 +13,11 @@ #include "../nfp_port.h" #include "main.h" +static bool nfp_abm_qdisc_is_red(struct nfp_qdisc *qdisc) +{ + return qdisc->type == NFP_QDISC_RED; +} + static bool nfp_abm_qdisc_child_valid(struct nfp_qdisc *qdisc, unsigned int id) { return qdisc->children[id] && @@ -24,6 +29,74 @@ static void *nfp_abm_qdisc_tree_deref_slot(void __rcu **slot) return rtnl_dereference(*slot); } +static void +nfp_abm_stats_propagate(struct nfp_alink_stats *parent, + struct nfp_alink_stats *child) +{ + parent->tx_pkts += child->tx_pkts; + parent->tx_bytes += child->tx_bytes; + parent->backlog_pkts += child->backlog_pkts; + parent->backlog_bytes += child->backlog_bytes; + parent->overlimits += child->overlimits; + parent->drops += child->drops; +} + +static void +nfp_abm_stats_update_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, + unsigned int queue) +{ + struct nfp_cpp *cpp = alink->abm->app->cpp; + int err; + + if (!qdisc->offloaded) + return; + + err = nfp_abm_ctrl_read_q_stats(alink, queue, &qdisc->red.stats); + if (err) + nfp_err(cpp, "RED stats (%d) read failed with error %d\n", + queue, err); + + err = nfp_abm_ctrl_read_q_xstats(alink, queue, &qdisc->red.xstats); + if (err) + nfp_err(cpp, "RED xstats (%d) read failed with error %d\n", + queue, err); +} + +static void +nfp_abm_stats_update_mq(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc) +{ + unsigned int i; + + if (qdisc->type != NFP_QDISC_MQ) + return; + + for (i = 0; i < alink->total_queues; i++) + if (nfp_abm_qdisc_child_valid(qdisc, i)) + nfp_abm_stats_update_red(alink, qdisc->children[i], i); +} + +static void __nfp_abm_stats_update(struct nfp_abm_link *alink, u64 time_now) +{ + alink->last_stats_update = time_now; + if (alink->root_qdisc) + nfp_abm_stats_update_mq(alink, alink->root_qdisc); +} + +static void nfp_abm_stats_update(struct nfp_abm_link *alink) +{ + u64 now; + + /* Limit the frequency of updates - stats of non-leaf qdiscs are a sum + * of all their leafs, so we would read the same stat multiple times + * for every dump. + */ + now = ktime_get(); + if (now - alink->last_stats_update < NFP_ABM_STATS_REFRESH_IVAL) + return; + + __nfp_abm_stats_update(alink, now); +} + static void nfp_abm_qdisc_unlink_children(struct nfp_qdisc *qdisc, unsigned int start, unsigned int end) @@ -38,89 +111,174 @@ nfp_abm_qdisc_unlink_children(struct nfp_qdisc *qdisc, } static void -nfp_abm_qdisc_clear_mq(struct net_device *netdev, struct nfp_abm_link *alink, - struct nfp_qdisc *qdisc) +nfp_abm_qdisc_offload_stop(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc) { - struct radix_tree_iter iter; - unsigned int mq_refs = 0; - void __rcu **slot; + /* Don't complain when qdisc is getting unlinked */ + if (qdisc->use_cnt) + nfp_warn(alink->abm->app->cpp, "Offload of '%08x' stopped\n", + qdisc->handle); - if (!qdisc->use_cnt) + if (!nfp_abm_qdisc_is_red(qdisc)) return; - /* MQ doesn't notify well on destruction, we need special handling of - * MQ's children. + + qdisc->red.stats.backlog_pkts = 0; + qdisc->red.stats.backlog_bytes = 0; +} + +static int +__nfp_abm_stats_init(struct nfp_abm_link *alink, + unsigned int queue, struct nfp_alink_stats *prev_stats, + struct nfp_alink_xstats *prev_xstats) +{ + u64 backlog_pkts, backlog_bytes; + int err; + + /* Don't touch the backlog, backlog can only be reset after it has + * been reported back to the tc qdisc stats. */ - if (qdisc->type == NFP_QDISC_MQ && - qdisc == alink->root_qdisc && - netdev->reg_state == NETREG_UNREGISTERING) - return; + backlog_pkts = prev_stats->backlog_pkts; + backlog_bytes = prev_stats->backlog_bytes; - /* Count refs held by MQ instances and clear pointers */ - radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) { - struct nfp_qdisc *mq = nfp_abm_qdisc_tree_deref_slot(slot); - unsigned int i; + err = nfp_abm_ctrl_read_q_stats(alink, queue, prev_stats); + if (err) { + nfp_err(alink->abm->app->cpp, + "RED stats init (%d) failed with error %d\n", + queue, err); + return err; + } - if (mq->type != NFP_QDISC_MQ || mq->netdev != netdev) - continue; - for (i = 0; i < mq->num_children; i++) - if (mq->children[i] == qdisc) { - mq->children[i] = NULL; - mq_refs++; - } + err = nfp_abm_ctrl_read_q_xstats(alink, queue, prev_xstats); + if (err) { + nfp_err(alink->abm->app->cpp, + "RED xstats init (%d) failed with error %d\n", + queue, err); + return err; } - WARN(qdisc->use_cnt != mq_refs, "non-zero qdisc use count: %d (- %d)\n", - qdisc->use_cnt, mq_refs); + prev_stats->backlog_pkts = backlog_pkts; + prev_stats->backlog_bytes = backlog_bytes; + return 0; +} + +static int +nfp_abm_stats_init(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, + unsigned int queue) +{ + return __nfp_abm_stats_init(alink, queue, + &qdisc->red.prev_stats, + &qdisc->red.prev_xstats); } static void -nfp_abm_offload_compile_red(struct nfp_abm_link *alink, - struct nfp_red_qdisc *qdisc, unsigned int queue) +nfp_abm_offload_compile_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, + unsigned int queue) { - if (!qdisc->handle) + qdisc->offload_mark = qdisc->type == NFP_QDISC_RED && + qdisc->params_ok && + qdisc->use_cnt == 1 && + !qdisc->children[0]; + + /* If we are starting offload init prev_stats */ + if (qdisc->offload_mark && !qdisc->offloaded) + if (nfp_abm_stats_init(alink, qdisc, queue)) + qdisc->offload_mark = false; + + if (!qdisc->offload_mark) return; - nfp_abm_ctrl_set_q_lvl(alink, queue, qdisc->threshold); + nfp_abm_ctrl_set_q_lvl(alink, queue, qdisc->red.threshold); } -static void nfp_abm_offload_compile_one(struct nfp_abm_link *alink) +static void +nfp_abm_offload_compile_mq(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc) { unsigned int i; - bool is_mq; - is_mq = alink->num_qdiscs > 1; + qdisc->offload_mark = qdisc->type == NFP_QDISC_MQ; + if (!qdisc->offload_mark) + return; for (i = 0; i < alink->total_queues; i++) { - struct nfp_red_qdisc *next; + struct nfp_qdisc *child = qdisc->children[i]; - if (is_mq && !alink->red_qdiscs[i].handle) + if (!nfp_abm_qdisc_child_valid(qdisc, i)) continue; - next = is_mq ? &alink->red_qdiscs[i] : &alink->red_qdiscs[0]; - nfp_abm_offload_compile_red(alink, next, i); + nfp_abm_offload_compile_red(alink, child, i); } } -static void nfp_abm_offload_update(struct nfp_abm *abm) +void nfp_abm_qdisc_offload_update(struct nfp_abm_link *alink) { - struct nfp_abm_link *alink = NULL; - struct nfp_pf *pf = abm->app->pf; - struct nfp_net *nn; + struct nfp_abm *abm = alink->abm; + struct radix_tree_iter iter; + struct nfp_qdisc *qdisc; + void __rcu **slot; size_t i; /* Mark all thresholds as unconfigured */ - __bitmap_set(abm->threshold_undef, 0, abm->num_thresholds); + __bitmap_set(abm->threshold_undef, + alink->queue_base, alink->total_queues); - /* Configure all offloads */ - list_for_each_entry(nn, &pf->vnics, vnic_list) { - alink = nn->app_priv; - nfp_abm_offload_compile_one(alink); + /* Clear offload marks */ + radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) { + qdisc = nfp_abm_qdisc_tree_deref_slot(slot); + qdisc->offload_mark = false; + } + + if (alink->root_qdisc) + nfp_abm_offload_compile_mq(alink, alink->root_qdisc); + + /* Refresh offload status */ + radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) { + qdisc = nfp_abm_qdisc_tree_deref_slot(slot); + if (!qdisc->offload_mark && qdisc->offloaded) + nfp_abm_qdisc_offload_stop(alink, qdisc); + qdisc->offloaded = qdisc->offload_mark; } /* 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); + + __nfp_abm_stats_update(alink, ktime_get()); +} + +static void +nfp_abm_qdisc_clear_mq(struct net_device *netdev, struct nfp_abm_link *alink, + struct nfp_qdisc *qdisc) +{ + struct radix_tree_iter iter; + unsigned int mq_refs = 0; + void __rcu **slot; + + if (!qdisc->use_cnt) + return; + /* MQ doesn't notify well on destruction, we need special handling of + * MQ's children. + */ + if (qdisc->type == NFP_QDISC_MQ && + qdisc == alink->root_qdisc && + netdev->reg_state == NETREG_UNREGISTERING) + return; + + /* Count refs held by MQ instances and clear pointers */ + radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) { + struct nfp_qdisc *mq = nfp_abm_qdisc_tree_deref_slot(slot); + unsigned int i; + + if (mq->type != NFP_QDISC_MQ || mq->netdev != netdev) + continue; + for (i = 0; i < mq->num_children; i++) + if (mq->children[i] == qdisc) { + mq->children[i] = NULL; + mq_refs++; + } + } + + WARN(qdisc->use_cnt != mq_refs, "non-zero qdisc use count: %d (- %d)\n", + qdisc->use_cnt, mq_refs); } static void @@ -221,8 +379,13 @@ nfp_abm_qdisc_destroy(struct net_device *netdev, struct nfp_abm_link *alink, nfp_abm_qdisc_unlink_children(qdisc, 0, qdisc->num_children); nfp_abm_qdisc_free(netdev, alink, qdisc); - if (alink->root_qdisc == qdisc) + if (alink->root_qdisc == qdisc) { alink->root_qdisc = NULL; + /* Only root change matters, other changes are acted upon on + * the graft notification. + */ + nfp_abm_qdisc_offload_update(alink); + } } static int @@ -249,66 +412,73 @@ nfp_abm_qdisc_graft(struct nfp_abm_link *alink, u32 handle, u32 child_handle, child = NFP_QDISC_UNTRACKED; parent->children[id] = child; + nfp_abm_qdisc_offload_update(alink); + return 0; } static void -__nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink, - u32 handle, unsigned int qs, u32 init_val) +nfp_abm_stats_calculate(struct nfp_alink_stats *new, + struct nfp_alink_stats *old, + struct gnet_stats_basic_packed *bstats, + struct gnet_stats_queue *qstats) { - memset(alink->red_qdiscs, 0, - sizeof(*alink->red_qdiscs) * alink->num_qdiscs); - - alink->parent = handle; - alink->num_qdiscs = qs; + _bstats_update(bstats, new->tx_bytes - old->tx_bytes, + new->tx_pkts - old->tx_pkts); + qstats->qlen += new->backlog_pkts - old->backlog_pkts; + qstats->backlog += new->backlog_bytes - old->backlog_bytes; + qstats->overlimits += new->overlimits - old->overlimits; + qstats->drops += new->drops - old->drops; } static void -nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink, - u32 handle, unsigned int qs) +nfp_abm_stats_red_calculate(struct nfp_alink_xstats *new, + struct nfp_alink_xstats *old, + struct red_stats *stats) { - __nfp_abm_reset_root(netdev, alink, handle, qs, NFP_ABM_LVL_INFINITY); + stats->forced_mark += new->ecn_marked - old->ecn_marked; + stats->pdrop += new->pdrop - old->pdrop; } static int -nfp_abm_red_find(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) +nfp_abm_red_xstats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) { - unsigned int i = TC_H_MIN(opt->parent) - 1; + struct nfp_qdisc *qdisc; - if (opt->parent == TC_H_ROOT) - i = 0; - else if (TC_H_MAJ(alink->parent) == TC_H_MAJ(opt->parent)) - i = TC_H_MIN(opt->parent) - 1; - else - return -EOPNOTSUPP; + nfp_abm_stats_update(alink); - if (i >= alink->num_qdiscs || - opt->handle != alink->red_qdiscs[i].handle) + qdisc = nfp_abm_qdisc_find(alink, opt->handle); + if (!qdisc || !qdisc->offloaded) return -EOPNOTSUPP; - return i; + nfp_abm_stats_red_calculate(&qdisc->red.xstats, + &qdisc->red.prev_xstats, + opt->xstats); + qdisc->red.prev_xstats = qdisc->red.xstats; + return 0; } -static void -nfp_abm_red_destroy(struct net_device *netdev, struct nfp_abm_link *alink, - u32 handle) +static int +nfp_abm_red_stats(struct nfp_abm_link *alink, u32 handle, + struct tc_qopt_offload_stats *stats) { - unsigned int i; + struct nfp_qdisc *qdisc; - nfp_abm_qdisc_destroy(netdev, alink, handle); + nfp_abm_stats_update(alink); - for (i = 0; i < alink->num_qdiscs; i++) - if (handle == alink->red_qdiscs[i].handle) - break; - if (i == alink->num_qdiscs) - return; + qdisc = nfp_abm_qdisc_find(alink, handle); + if (!qdisc) + return -EOPNOTSUPP; + /* If the qdisc offload has stopped we may need to adjust the backlog + * counters back so carry on even if qdisc is not currently offloaded. + */ - if (alink->parent == TC_H_ROOT) - nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 0); - else - memset(&alink->red_qdiscs[i], 0, sizeof(*alink->red_qdiscs)); + nfp_abm_stats_calculate(&qdisc->red.stats, + &qdisc->red.prev_stats, + stats->bstats, stats->qstats); + qdisc->red.prev_stats = qdisc->red.stats; - nfp_abm_offload_update(alink->abm); + return qdisc->offloaded ? 0 : -EOPNOTSUPP; } static bool @@ -347,20 +517,12 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) { struct nfp_qdisc *qdisc; - bool existing; - int i, err; int ret; ret = nfp_abm_qdisc_replace(netdev, alink, NFP_QDISC_RED, opt->parent, opt->handle, 1, &qdisc); - - i = nfp_abm_red_find(alink, opt); - existing = i >= 0; - - if (ret < 0) { - err = ret; - goto err_destroy; - } + if (ret < 0) + return ret; /* If limit != 0 child gets reset */ if (opt->set.limit) { @@ -376,127 +538,11 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, } qdisc->params_ok = nfp_abm_red_check_params(alink, opt); - if (qdisc->params_ok) { + if (qdisc->params_ok) qdisc->red.threshold = opt->set.min; - } else { - err = -EINVAL; - goto err_destroy; - } - - if (existing) { - nfp_abm_offload_update(alink->abm); - return 0; - } - - if (opt->parent == TC_H_ROOT) { - i = 0; - __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; - } else { - return -EINVAL; - } - alink->red_qdiscs[i].handle = opt->handle; - - if (opt->parent == TC_H_ROOT) - err = nfp_abm_ctrl_read_stats(alink, - &alink->red_qdiscs[i].stats); - else - err = nfp_abm_ctrl_read_q_stats(alink, i, - &alink->red_qdiscs[i].stats); - if (err) - goto err_destroy; - - if (opt->parent == TC_H_ROOT) - err = nfp_abm_ctrl_read_xstats(alink, - &alink->red_qdiscs[i].xstats); - else - err = nfp_abm_ctrl_read_q_xstats(alink, i, - &alink->red_qdiscs[i].xstats); - 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 */ - if (existing) { - opt->set.qstats->qlen -= - alink->red_qdiscs[i].stats.backlog_pkts; - opt->set.qstats->backlog -= - alink->red_qdiscs[i].stats.backlog_bytes; - } - nfp_abm_red_destroy(netdev, alink, opt->handle); - - return err; -} - -static void -nfp_abm_update_stats(struct nfp_alink_stats *new, struct nfp_alink_stats *old, - struct tc_qopt_offload_stats *stats) -{ - _bstats_update(stats->bstats, new->tx_bytes - old->tx_bytes, - new->tx_pkts - old->tx_pkts); - stats->qstats->qlen += new->backlog_pkts - old->backlog_pkts; - stats->qstats->backlog += new->backlog_bytes - old->backlog_bytes; - stats->qstats->overlimits += new->overlimits - old->overlimits; - stats->qstats->drops += new->drops - old->drops; -} - -static int -nfp_abm_red_stats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) -{ - struct nfp_alink_stats *prev_stats; - struct nfp_alink_stats stats; - int i, err; - - i = nfp_abm_red_find(alink, opt); - if (i < 0) - return i; - prev_stats = &alink->red_qdiscs[i].stats; - - if (alink->parent == TC_H_ROOT) - err = nfp_abm_ctrl_read_stats(alink, &stats); - else - err = nfp_abm_ctrl_read_q_stats(alink, i, &stats); - if (err) - return err; - - nfp_abm_update_stats(&stats, prev_stats, &opt->stats); - *prev_stats = stats; - - return 0; -} - -static int -nfp_abm_red_xstats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) -{ - struct nfp_alink_xstats *prev_xstats; - struct nfp_alink_xstats xstats; - int i, err; - - i = nfp_abm_red_find(alink, opt); - if (i < 0) - return i; - prev_xstats = &alink->red_qdiscs[i].xstats; - - if (alink->parent == TC_H_ROOT) - err = nfp_abm_ctrl_read_xstats(alink, &xstats); - else - err = nfp_abm_ctrl_read_q_xstats(alink, i, &xstats); - if (err) - return err; - - opt->xstats->forced_mark += xstats.ecn_marked - prev_xstats->ecn_marked; - opt->xstats->pdrop += xstats.pdrop - prev_xstats->pdrop; - - *prev_xstats = xstats; + if (qdisc->use_cnt == 1) + nfp_abm_qdisc_offload_update(alink); return 0; } @@ -508,10 +554,10 @@ int nfp_abm_setup_tc_red(struct net_device *netdev, struct nfp_abm_link *alink, case TC_RED_REPLACE: return nfp_abm_red_replace(netdev, alink, opt); case TC_RED_DESTROY: - nfp_abm_red_destroy(netdev, alink, opt->handle); + nfp_abm_qdisc_destroy(netdev, alink, opt->handle); return 0; case TC_RED_STATS: - return nfp_abm_red_stats(alink, opt); + return nfp_abm_red_stats(alink, opt->handle, &opt->stats); case TC_RED_XSTATS: return nfp_abm_red_xstats(alink, opt); case TC_RED_GRAFT: @@ -522,28 +568,6 @@ int nfp_abm_setup_tc_red(struct net_device *netdev, struct nfp_abm_link *alink, } } -static int -nfp_abm_mq_stats(struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt) -{ - struct nfp_alink_stats stats; - unsigned int i; - int err; - - for (i = 0; i < alink->num_qdiscs; i++) { - if (alink->red_qdiscs[i].handle == TC_H_UNSPEC) - continue; - - err = nfp_abm_ctrl_read_q_stats(alink, i, &stats); - if (err) - return err; - - nfp_abm_update_stats(&stats, &alink->red_qdiscs[i].stats, - &opt->stats); - } - - return 0; -} - static int nfp_abm_mq_create(struct net_device *netdev, struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt) @@ -556,27 +580,63 @@ nfp_abm_mq_create(struct net_device *netdev, struct nfp_abm_link *alink, &qdisc); if (ret < 0) return ret; + + qdisc->params_ok = true; + qdisc->offloaded = true; + nfp_abm_qdisc_offload_update(alink); return 0; } +static int +nfp_abm_mq_stats(struct nfp_abm_link *alink, u32 handle, + struct tc_qopt_offload_stats *stats) +{ + struct nfp_qdisc *qdisc, *red; + unsigned int i; + + qdisc = nfp_abm_qdisc_find(alink, handle); + if (!qdisc) + return -EOPNOTSUPP; + + nfp_abm_stats_update(alink); + + /* MQ stats are summed over the children in the core, so we need + * to add up the unreported child values. + */ + memset(&qdisc->mq.stats, 0, sizeof(qdisc->mq.stats)); + memset(&qdisc->mq.prev_stats, 0, sizeof(qdisc->mq.prev_stats)); + + for (i = 0; i < qdisc->num_children; i++) { + if (!nfp_abm_qdisc_child_valid(qdisc, i)) + continue; + + if (!nfp_abm_qdisc_is_red(qdisc->children[i])) + continue; + red = qdisc->children[i]; + + nfp_abm_stats_propagate(&qdisc->mq.stats, + &red->red.stats); + nfp_abm_stats_propagate(&qdisc->mq.prev_stats, + &red->red.prev_stats); + } + + nfp_abm_stats_calculate(&qdisc->mq.stats, &qdisc->mq.prev_stats, + stats->bstats, stats->qstats); + + return qdisc->offloaded ? 0 : -EOPNOTSUPP; +} + int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt) { switch (opt->command) { case TC_MQ_CREATE: - nfp_abm_reset_root(netdev, alink, opt->handle, - alink->total_queues); - nfp_abm_offload_update(alink->abm); return nfp_abm_mq_create(netdev, alink, opt); case TC_MQ_DESTROY: nfp_abm_qdisc_destroy(netdev, alink, opt->handle); - 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); + return nfp_abm_mq_stats(alink, opt->handle, &opt->stats); case TC_MQ_GRAFT: return nfp_abm_qdisc_graft(alink, opt->handle, opt->graft_params.child_handle, @@ -597,5 +657,7 @@ int nfp_abm_setup_root(struct net_device *netdev, struct nfp_abm_link *alink, if (alink->root_qdisc) alink->root_qdisc->use_cnt++; + nfp_abm_qdisc_offload_update(alink); + return 0; } -- cgit From 5720769609fbc244c67ccbcf817db44e3fa5f50c Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 19 Nov 2018 15:21:38 -0800 Subject: nfp: abm: pass band parameter to functions In preparation for per-band RED offload pass band parameter to functions. For now it will always be 0. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 30 +++++++++++++------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index 16c4afe3a37f..251ce3070564 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -51,15 +51,15 @@ nfp_abm_stats_update_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, if (!qdisc->offloaded) return; - err = nfp_abm_ctrl_read_q_stats(alink, queue, &qdisc->red.stats); + err = nfp_abm_ctrl_read_q_stats(alink, 0, queue, &qdisc->red.stats); if (err) - nfp_err(cpp, "RED stats (%d) read failed with error %d\n", - queue, err); + nfp_err(cpp, "RED stats (%d, %d) read failed with error %d\n", + 0, queue, err); - err = nfp_abm_ctrl_read_q_xstats(alink, queue, &qdisc->red.xstats); + err = nfp_abm_ctrl_read_q_xstats(alink, 0, queue, &qdisc->red.xstats); if (err) - nfp_err(cpp, "RED xstats (%d) read failed with error %d\n", - queue, err); + nfp_err(cpp, "RED xstats (%d, %d) read failed with error %d\n", + 0, queue, err); } static void @@ -126,7 +126,7 @@ nfp_abm_qdisc_offload_stop(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc) } static int -__nfp_abm_stats_init(struct nfp_abm_link *alink, +__nfp_abm_stats_init(struct nfp_abm_link *alink, unsigned int band, unsigned int queue, struct nfp_alink_stats *prev_stats, struct nfp_alink_xstats *prev_xstats) { @@ -139,19 +139,19 @@ __nfp_abm_stats_init(struct nfp_abm_link *alink, backlog_pkts = prev_stats->backlog_pkts; backlog_bytes = prev_stats->backlog_bytes; - err = nfp_abm_ctrl_read_q_stats(alink, queue, prev_stats); + err = nfp_abm_ctrl_read_q_stats(alink, band, queue, prev_stats); if (err) { nfp_err(alink->abm->app->cpp, - "RED stats init (%d) failed with error %d\n", - queue, err); + "RED stats init (%d, %d) failed with error %d\n", + band, queue, err); return err; } - err = nfp_abm_ctrl_read_q_xstats(alink, queue, prev_xstats); + err = nfp_abm_ctrl_read_q_xstats(alink, band, queue, prev_xstats); if (err) { nfp_err(alink->abm->app->cpp, - "RED xstats init (%d) failed with error %d\n", - queue, err); + "RED xstats init (%d, %d) failed with error %d\n", + band, queue, err); return err; } @@ -164,7 +164,7 @@ static int nfp_abm_stats_init(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, unsigned int queue) { - return __nfp_abm_stats_init(alink, queue, + return __nfp_abm_stats_init(alink, 0, queue, &qdisc->red.prev_stats, &qdisc->red.prev_xstats); } @@ -186,7 +186,7 @@ nfp_abm_offload_compile_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, if (!qdisc->offload_mark) return; - nfp_abm_ctrl_set_q_lvl(alink, queue, qdisc->red.threshold); + nfp_abm_ctrl_set_q_lvl(alink, 0, queue, qdisc->red.threshold); } static void -- cgit From 990b50a53ad80fe4e0357c7cc41a393eea2b0d76 Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 19 Nov 2018 15:21:44 -0800 Subject: nfp: abm: wrap RED parameters in bands Wrap RED parameters and stats into a structure, and a 1-element array. Upcoming GRED offload will add the support for more bands. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 88 +++++++++++++++++--------- 1 file changed, 58 insertions(+), 30 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index 251ce3070564..b65b3177c94a 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -46,20 +46,25 @@ nfp_abm_stats_update_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, unsigned int queue) { struct nfp_cpp *cpp = alink->abm->app->cpp; + unsigned int i; int err; if (!qdisc->offloaded) return; - err = nfp_abm_ctrl_read_q_stats(alink, 0, queue, &qdisc->red.stats); - if (err) - nfp_err(cpp, "RED stats (%d, %d) read failed with error %d\n", - 0, queue, err); - - err = nfp_abm_ctrl_read_q_xstats(alink, 0, queue, &qdisc->red.xstats); - if (err) - nfp_err(cpp, "RED xstats (%d, %d) read failed with error %d\n", - 0, queue, err); + for (i = 0; i < qdisc->red.num_bands; i++) { + err = nfp_abm_ctrl_read_q_stats(alink, i, queue, + &qdisc->red.band[i].stats); + if (err) + nfp_err(cpp, "RED stats (%d, %d) read failed with error %d\n", + i, queue, err); + + err = nfp_abm_ctrl_read_q_xstats(alink, i, queue, + &qdisc->red.band[i].xstats); + if (err) + nfp_err(cpp, "RED xstats (%d, %d) read failed with error %d\n", + i, queue, err); + } } static void @@ -113,6 +118,8 @@ nfp_abm_qdisc_unlink_children(struct nfp_qdisc *qdisc, static void nfp_abm_qdisc_offload_stop(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc) { + unsigned int i; + /* Don't complain when qdisc is getting unlinked */ if (qdisc->use_cnt) nfp_warn(alink->abm->app->cpp, "Offload of '%08x' stopped\n", @@ -121,8 +128,10 @@ nfp_abm_qdisc_offload_stop(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc) if (!nfp_abm_qdisc_is_red(qdisc)) return; - qdisc->red.stats.backlog_pkts = 0; - qdisc->red.stats.backlog_bytes = 0; + for (i = 0; i < qdisc->red.num_bands; i++) { + qdisc->red.band[i].stats.backlog_pkts = 0; + qdisc->red.band[i].stats.backlog_bytes = 0; + } } static int @@ -164,15 +173,26 @@ static int nfp_abm_stats_init(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, unsigned int queue) { - return __nfp_abm_stats_init(alink, 0, queue, - &qdisc->red.prev_stats, - &qdisc->red.prev_xstats); + unsigned int i; + int err; + + for (i = 0; i < qdisc->red.num_bands; i++) { + err = __nfp_abm_stats_init(alink, i, queue, + &qdisc->red.band[i].prev_stats, + &qdisc->red.band[i].prev_xstats); + if (err) + return err; + } + + return 0; } static void nfp_abm_offload_compile_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, unsigned int queue) { + unsigned int i; + qdisc->offload_mark = qdisc->type == NFP_QDISC_RED && qdisc->params_ok && qdisc->use_cnt == 1 && @@ -186,7 +206,9 @@ nfp_abm_offload_compile_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, if (!qdisc->offload_mark) return; - nfp_abm_ctrl_set_q_lvl(alink, 0, queue, qdisc->red.threshold); + for (i = 0; i < alink->abm->num_bands; i++) + nfp_abm_ctrl_set_q_lvl(alink, i, queue, + qdisc->red.band[i].threshold); } static void @@ -217,8 +239,10 @@ void nfp_abm_qdisc_offload_update(struct nfp_abm_link *alink) size_t i; /* Mark all thresholds as unconfigured */ - __bitmap_set(abm->threshold_undef, - alink->queue_base, alink->total_queues); + for (i = 0; i < abm->num_bands; i++) + __bitmap_set(abm->threshold_undef, + i * NFP_NET_MAX_RX_RINGS + alink->queue_base, + alink->total_queues); /* Clear offload marks */ radix_tree_for_each_slot(slot, &alink->qdiscs, &iter, 0) { @@ -451,10 +475,10 @@ nfp_abm_red_xstats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) if (!qdisc || !qdisc->offloaded) return -EOPNOTSUPP; - nfp_abm_stats_red_calculate(&qdisc->red.xstats, - &qdisc->red.prev_xstats, + nfp_abm_stats_red_calculate(&qdisc->red.band[0].xstats, + &qdisc->red.band[0].prev_xstats, opt->xstats); - qdisc->red.prev_xstats = qdisc->red.xstats; + qdisc->red.band[0].prev_xstats = qdisc->red.band[0].xstats; return 0; } @@ -473,10 +497,10 @@ nfp_abm_red_stats(struct nfp_abm_link *alink, u32 handle, * counters back so carry on even if qdisc is not currently offloaded. */ - nfp_abm_stats_calculate(&qdisc->red.stats, - &qdisc->red.prev_stats, + nfp_abm_stats_calculate(&qdisc->red.band[0].stats, + &qdisc->red.band[0].prev_stats, stats->bstats, stats->qstats); - qdisc->red.prev_stats = qdisc->red.stats; + qdisc->red.band[0].prev_stats = qdisc->red.band[0].stats; return qdisc->offloaded ? 0 : -EOPNOTSUPP; } @@ -538,8 +562,10 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, } qdisc->params_ok = nfp_abm_red_check_params(alink, opt); - if (qdisc->params_ok) - qdisc->red.threshold = opt->set.min; + if (qdisc->params_ok) { + qdisc->red.num_bands = 1; + qdisc->red.band[0].threshold = opt->set.min; + } if (qdisc->use_cnt == 1) nfp_abm_qdisc_offload_update(alink); @@ -592,7 +618,7 @@ nfp_abm_mq_stats(struct nfp_abm_link *alink, u32 handle, struct tc_qopt_offload_stats *stats) { struct nfp_qdisc *qdisc, *red; - unsigned int i; + unsigned int i, j; qdisc = nfp_abm_qdisc_find(alink, handle); if (!qdisc) @@ -614,10 +640,12 @@ nfp_abm_mq_stats(struct nfp_abm_link *alink, u32 handle, continue; red = qdisc->children[i]; - nfp_abm_stats_propagate(&qdisc->mq.stats, - &red->red.stats); - nfp_abm_stats_propagate(&qdisc->mq.prev_stats, - &red->red.prev_stats); + for (j = 0; j < red->red.num_bands; j++) { + nfp_abm_stats_propagate(&qdisc->mq.stats, + &red->red.band[j].stats); + nfp_abm_stats_propagate(&qdisc->mq.prev_stats, + &red->red.band[j].prev_stats); + } } nfp_abm_stats_calculate(&qdisc->mq.stats, &qdisc->mq.prev_stats, -- cgit From f3d63720649413ac60f4723f117280391acd5015 Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 19 Nov 2018 15:21:45 -0800 Subject: nfp: abm: add GRED offload Add support for GRED offload. It behaves much like RED, but can apply different parameters to different bands. GRED operates pretty much exactly like our HW/FW with a single FIFO and different RED state instances. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 154 +++++++++++++++++++++++-- 1 file changed, 146 insertions(+), 8 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index b65b3177c94a..e80a3d40a48b 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -15,7 +15,7 @@ static bool nfp_abm_qdisc_is_red(struct nfp_qdisc *qdisc) { - return qdisc->type == NFP_QDISC_RED; + return qdisc->type == NFP_QDISC_RED || qdisc->type == NFP_QDISC_GRED; } static bool nfp_abm_qdisc_child_valid(struct nfp_qdisc *qdisc, unsigned int id) @@ -191,12 +191,17 @@ static void nfp_abm_offload_compile_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, unsigned int queue) { + bool good_red, good_gred; unsigned int i; - qdisc->offload_mark = qdisc->type == NFP_QDISC_RED && - qdisc->params_ok && - qdisc->use_cnt == 1 && - !qdisc->children[0]; + good_red = qdisc->type == NFP_QDISC_RED && + qdisc->params_ok && + qdisc->use_cnt == 1 && + !qdisc->children[0]; + good_gred = qdisc->type == NFP_QDISC_GRED && + qdisc->params_ok && + qdisc->use_cnt == 1; + qdisc->offload_mark = good_red || good_gred; /* If we are starting offload init prev_stats */ if (qdisc->offload_mark && !qdisc->offloaded) @@ -336,9 +341,11 @@ nfp_abm_qdisc_alloc(struct net_device *netdev, struct nfp_abm_link *alink, if (!qdisc) return NULL; - qdisc->children = kcalloc(children, sizeof(void *), GFP_KERNEL); - if (!qdisc->children) - goto err_free_qdisc; + if (children) { + qdisc->children = kcalloc(children, sizeof(void *), GFP_KERNEL); + if (!qdisc->children) + goto err_free_qdisc; + } qdisc->netdev = netdev; qdisc->type = type; @@ -464,6 +471,137 @@ nfp_abm_stats_red_calculate(struct nfp_alink_xstats *new, stats->pdrop += new->pdrop - old->pdrop; } +static int +nfp_abm_gred_stats(struct nfp_abm_link *alink, u32 handle, + struct tc_gred_qopt_offload_stats *stats) +{ + struct nfp_qdisc *qdisc; + unsigned int i; + + nfp_abm_stats_update(alink); + + qdisc = nfp_abm_qdisc_find(alink, handle); + if (!qdisc) + return -EOPNOTSUPP; + /* If the qdisc offload has stopped we may need to adjust the backlog + * counters back so carry on even if qdisc is not currently offloaded. + */ + + for (i = 0; i < qdisc->red.num_bands; i++) { + if (!stats->xstats[i]) + continue; + + nfp_abm_stats_calculate(&qdisc->red.band[i].stats, + &qdisc->red.band[i].prev_stats, + &stats->bstats[i], &stats->qstats[i]); + qdisc->red.band[i].prev_stats = qdisc->red.band[i].stats; + + nfp_abm_stats_red_calculate(&qdisc->red.band[i].xstats, + &qdisc->red.band[i].prev_xstats, + stats->xstats[i]); + qdisc->red.band[i].prev_xstats = qdisc->red.band[i].xstats; + } + + return qdisc->offloaded ? 0 : -EOPNOTSUPP; +} + +static bool +nfp_abm_gred_check_params(struct nfp_abm_link *alink, + struct tc_gred_qopt_offload *opt) +{ + struct nfp_cpp *cpp = alink->abm->app->cpp; + struct nfp_abm *abm = alink->abm; + unsigned int i; + + if (opt->set.grio_on || opt->set.wred_on) { + nfp_warn(cpp, "GRED offload failed - GRIO and WRED not supported (p:%08x h:%08x)\n", + opt->parent, opt->handle); + return false; + } + if (opt->set.dp_def != alink->def_band) { + nfp_warn(cpp, "GRED offload failed - default band must be %d (p:%08x h:%08x)\n", + alink->def_band, opt->parent, opt->handle); + return false; + } + if (opt->set.dp_cnt != abm->num_bands) { + nfp_warn(cpp, "GRED offload failed - band count must be %d (p:%08x h:%08x)\n", + abm->num_bands, opt->parent, opt->handle); + return false; + } + + for (i = 0; i < abm->num_bands; i++) { + struct tc_gred_vq_qopt_offload_params *band = &opt->set.tab[i]; + + if (!band->present) + return false; + if (!band->is_ecn) { + nfp_warn(cpp, "GRED offload failed - drop is not supported (ECN option required) (p:%08x h:%08x vq:%d)\n", + opt->parent, opt->handle, i); + return false; + } + if (band->is_harddrop) { + nfp_warn(cpp, "GRED offload failed - harddrop is not supported (p:%08x h:%08x vq:%d)\n", + opt->parent, opt->handle, i); + return false; + } + if (band->min != band->max) { + nfp_warn(cpp, "GRED offload failed - threshold mismatch (p:%08x h:%08x vq:%d)\n", + opt->parent, opt->handle, i); + return false; + } + if (band->min > S32_MAX) { + nfp_warn(cpp, "GRED offload failed - threshold too large %d > %d (p:%08x h:%08x vq:%d)\n", + band->min, S32_MAX, opt->parent, opt->handle, + i); + return false; + } + } + + return true; +} + +static int +nfp_abm_gred_replace(struct net_device *netdev, struct nfp_abm_link *alink, + struct tc_gred_qopt_offload *opt) +{ + struct nfp_qdisc *qdisc; + unsigned int i; + int ret; + + ret = nfp_abm_qdisc_replace(netdev, alink, NFP_QDISC_GRED, opt->parent, + opt->handle, 0, &qdisc); + if (ret < 0) + return ret; + + qdisc->params_ok = nfp_abm_gred_check_params(alink, opt); + if (qdisc->params_ok) { + qdisc->red.num_bands = opt->set.dp_cnt; + for (i = 0; i < qdisc->red.num_bands; i++) + qdisc->red.band[i].threshold = opt->set.tab[i].min; + } + + if (qdisc->use_cnt) + nfp_abm_qdisc_offload_update(alink); + + return 0; +} + +int nfp_abm_setup_tc_gred(struct net_device *netdev, struct nfp_abm_link *alink, + struct tc_gred_qopt_offload *opt) +{ + switch (opt->command) { + case TC_GRED_REPLACE: + return nfp_abm_gred_replace(netdev, alink, opt); + case TC_GRED_DESTROY: + nfp_abm_qdisc_destroy(netdev, alink, opt->handle); + return 0; + case TC_GRED_STATS: + return nfp_abm_gred_stats(alink, opt->handle, &opt->stats); + default: + return -EOPNOTSUPP; + } +} + static int nfp_abm_red_xstats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) { -- cgit From 174ab544e3bc0b0c944b8e642618203dd0c2ecdf Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 19 Nov 2018 15:21:49 -0800 Subject: 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: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 1 + 1 file changed, 1 insertion(+) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index e80a3d40a48b..8f6e43667757 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -197,6 +197,7 @@ nfp_abm_offload_compile_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, good_red = qdisc->type == NFP_QDISC_RED && qdisc->params_ok && qdisc->use_cnt == 1 && + !alink->has_prio && !qdisc->children[0]; good_gred = qdisc->type == NFP_QDISC_GRED && qdisc->params_ok && -- cgit From 340a4864d538ab718b0e888a1d5933bc13e6a372 Mon Sep 17 00:00:00 2001 From: Jakub Kicinski Date: Mon, 19 Nov 2018 15:21:50 -0800 Subject: nfp: abm: add support for more threshold actions Original FW only allowed us to perform ECN marking. Newer releases also support plain old drop. Add the ability to configure drop policy. This is particularly useful in combination with GRED, because different bands can have different ECN marking setting. Signed-off-by: Jakub Kicinski Reviewed-by: John Hurley Signed-off-by: David S. Miller --- drivers/net/ethernet/netronome/nfp/abm/qdisc.c | 28 ++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-) (limited to 'drivers/net/ethernet/netronome/nfp/abm/qdisc.c') diff --git a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c index 8f6e43667757..2473fb5f75e5 100644 --- a/drivers/net/ethernet/netronome/nfp/abm/qdisc.c +++ b/drivers/net/ethernet/netronome/nfp/abm/qdisc.c @@ -212,9 +212,15 @@ nfp_abm_offload_compile_red(struct nfp_abm_link *alink, struct nfp_qdisc *qdisc, if (!qdisc->offload_mark) return; - for (i = 0; i < alink->abm->num_bands; i++) + for (i = 0; i < alink->abm->num_bands; i++) { + enum nfp_abm_q_action act; + nfp_abm_ctrl_set_q_lvl(alink, i, queue, qdisc->red.band[i].threshold); + act = qdisc->red.band[i].ecn ? + NFP_ABM_ACT_MARK_DROP : NFP_ABM_ACT_DROP; + nfp_abm_ctrl_set_q_act(alink, i, queue, act); + } } static void @@ -535,11 +541,16 @@ nfp_abm_gred_check_params(struct nfp_abm_link *alink, if (!band->present) return false; - if (!band->is_ecn) { + if (!band->is_ecn && !nfp_abm_has_drop(abm)) { nfp_warn(cpp, "GRED offload failed - drop is not supported (ECN option required) (p:%08x h:%08x vq:%d)\n", opt->parent, opt->handle, i); return false; } + if (band->is_ecn && !nfp_abm_has_mark(abm)) { + nfp_warn(cpp, "GRED offload failed - ECN marking not supported (p:%08x h:%08x vq:%d)\n", + opt->parent, opt->handle, i); + return false; + } if (band->is_harddrop) { nfp_warn(cpp, "GRED offload failed - harddrop is not supported (p:%08x h:%08x vq:%d)\n", opt->parent, opt->handle, i); @@ -577,8 +588,10 @@ nfp_abm_gred_replace(struct net_device *netdev, struct nfp_abm_link *alink, qdisc->params_ok = nfp_abm_gred_check_params(alink, opt); if (qdisc->params_ok) { qdisc->red.num_bands = opt->set.dp_cnt; - for (i = 0; i < qdisc->red.num_bands; i++) + for (i = 0; i < qdisc->red.num_bands; i++) { + qdisc->red.band[i].ecn = opt->set.tab[i].is_ecn; qdisc->red.band[i].threshold = opt->set.tab[i].min; + } } if (qdisc->use_cnt) @@ -649,12 +662,18 @@ nfp_abm_red_check_params(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt) { struct nfp_cpp *cpp = alink->abm->app->cpp; + struct nfp_abm *abm = alink->abm; - if (!opt->set.is_ecn) { + if (!opt->set.is_ecn && !nfp_abm_has_drop(abm)) { nfp_warn(cpp, "RED offload failed - drop is not supported (ECN option required) (p:%08x h:%08x)\n", opt->parent, opt->handle); return false; } + if (opt->set.is_ecn && !nfp_abm_has_mark(abm)) { + nfp_warn(cpp, "RED offload failed - ECN marking not supported (p:%08x h:%08x)\n", + opt->parent, opt->handle); + return false; + } if (opt->set.is_harddrop) { nfp_warn(cpp, "RED offload failed - harddrop is not supported (p:%08x h:%08x)\n", opt->parent, opt->handle); @@ -703,6 +722,7 @@ nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink, qdisc->params_ok = nfp_abm_red_check_params(alink, opt); if (qdisc->params_ok) { qdisc->red.num_bands = 1; + qdisc->red.band[0].ecn = opt->set.is_ecn; qdisc->red.band[0].threshold = opt->set.min; } -- cgit