From patchwork Wed Sep 29 20:57:28 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ivan Malov X-Patchwork-Id: 100028 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 1547DA0032; Wed, 29 Sep 2021 22:58:37 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 0B48B4114B; Wed, 29 Sep 2021 22:57:56 +0200 (CEST) Received: from shelob.oktetlabs.ru (shelob.oktetlabs.ru [91.220.146.113]) by mails.dpdk.org (Postfix) with ESMTP id 63754410F5 for ; Wed, 29 Sep 2021 22:57:46 +0200 (CEST) Received: from localhost.localdomain (unknown [5.144.122.192]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by shelob.oktetlabs.ru (Postfix) with ESMTPSA id 10D067F553; Wed, 29 Sep 2021 23:57:46 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 shelob.oktetlabs.ru 10D067F553 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=oktetlabs.ru; s=default; t=1632949066; bh=FnoO6VMZKhJ/HQri2dLDih5KKfTTN1Y3iRRvtUfwYso=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=hq7OrGj/uLvRRjp+OJadwkgyNSr7V6MCo/yZ8pzPiwdeQxf+EWKbkHcHqHBrNb+MY m6XjQhnUiPkHAgPir9kgKRNoOKSD8QvCuFncU1ApwHtvkKhWnPPMLMxNrDdtiSATqv cHgPY5X79ujgvuyzRhn4sfSUL6d5v7T+ZnYi4Lg0= From: Ivan Malov To: dev@dpdk.org Cc: Andrew Rybchenko Date: Wed, 29 Sep 2021 23:57:28 +0300 Message-Id: <20210929205730.775-9-ivan.malov@oktetlabs.ru> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210929205730.775-1-ivan.malov@oktetlabs.ru> References: <20210929205730.775-1-ivan.malov@oktetlabs.ru> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH 08/10] net/sfc: use action rules in tunnel offload JUMP rules X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" By design, JUMP flows should be represented solely by the outer rules. But the HW/FW hasn't got support for setting Rx mark from RECIRC_ID on outer rule lookup yet. Neither does it support outer rule counters. As a workaround, an action rule of lower priority is used to do the job. Signed-off-by: Ivan Malov Reviewed-by: Andrew Rybchenko --- drivers/net/sfc/sfc_flow.c | 11 +++++--- drivers/net/sfc/sfc_mae.c | 55 ++++++++++++++++++++++++++++++++------ 2 files changed, 54 insertions(+), 12 deletions(-) diff --git a/drivers/net/sfc/sfc_flow.c b/drivers/net/sfc/sfc_flow.c index c3e75bae84..b0dd7d7b6c 100644 --- a/drivers/net/sfc/sfc_flow.c +++ b/drivers/net/sfc/sfc_flow.c @@ -2561,17 +2561,20 @@ sfc_flow_parse_rte_to_mae(struct rte_eth_dev *dev, if (spec_mae->ft_rule_type == SFC_FT_RULE_JUMP) { /* - * This flow is represented solely by the outer rule. - * It is supposed to mark and count matching packets. + * By design, this flow should be represented solely by the + * outer rule. But the HW/FW hasn't got support for setting + * Rx mark from RECIRC_ID on outer rule lookup yet. Neither + * does it support outer rule counters. As a workaround, an + * action rule of lower priority is used to do the job. + * + * So don't skip sfc_mae_rule_parse_actions() below. */ - goto skip_action_rule; } rc = sfc_mae_rule_parse_actions(sa, actions, spec_mae, error); if (rc != 0) goto fail; -skip_action_rule: if (spec_mae->ft != NULL) { if (spec_mae->ft_rule_type == SFC_FT_RULE_JUMP) spec_mae->ft->jump_rule_is_set = B_TRUE; diff --git a/drivers/net/sfc/sfc_mae.c b/drivers/net/sfc/sfc_mae.c index 374ef29d71..faf3be522d 100644 --- a/drivers/net/sfc/sfc_mae.c +++ b/drivers/net/sfc/sfc_mae.c @@ -2467,6 +2467,7 @@ sfc_mae_rule_parse_pattern(struct sfc_adapter *sa, struct rte_flow_error *error) { struct sfc_mae_parse_ctx ctx_mae; + unsigned int priority_shift = 0; struct sfc_flow_parse_ctx ctx; int rc; @@ -2478,13 +2479,32 @@ sfc_mae_rule_parse_pattern(struct sfc_adapter *sa, switch (ctx_mae.ft_rule_type) { case SFC_FT_RULE_JUMP: - /* No action rule */ - break; + /* + * By design, this flow should be represented solely by the + * outer rule. But the HW/FW hasn't got support for setting + * Rx mark from RECIRC_ID on outer rule lookup yet. Neither + * does it support outer rule counters. As a workaround, an + * action rule of lower priority is used to do the job. + */ + priority_shift = 1; + + /* FALLTHROUGH */ case SFC_FT_RULE_GROUP: + if (ctx_mae.priority != 0) { + /* + * Because of the above workaround, deny the + * use of priorities to JUMP and GROUP rules. + */ + rc = rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY, NULL, + "tunnel offload: priorities are not supported"); + goto fail_priority_check; + } + /* FALLTHROUGH */ case SFC_FT_RULE_NONE: rc = efx_mae_match_spec_init(sa->nic, EFX_MAE_RULE_ACTION, - spec->priority, + spec->priority + priority_shift, &ctx_mae.match_spec_action); if (rc != 0) { rc = rte_flow_error_set(error, rc, @@ -2559,6 +2579,7 @@ sfc_mae_rule_parse_pattern(struct sfc_adapter *sa, efx_mae_match_spec_fini(sa->nic, ctx_mae.match_spec_action); fail_init_match_spec_action: +fail_priority_check: return rc; } @@ -3008,11 +3029,14 @@ sfc_mae_rule_parse_action_vxlan_encap( static int sfc_mae_rule_parse_action_mark(struct sfc_adapter *sa, const struct rte_flow_action_mark *conf, + const struct sfc_flow_spec_mae *spec_mae, efx_mae_actions_t *spec) { int rc; - if (conf->id > SFC_FT_USER_MARK_MASK) { + if (spec_mae->ft_rule_type == SFC_FT_RULE_JUMP) { + /* Workaround. See sfc_flow_parse_rte_to_mae() */ + } else if (conf->id > SFC_FT_USER_MARK_MASK) { sfc_err(sa, "the mark value is too large"); return EINVAL; } @@ -3182,11 +3206,12 @@ static const char * const action_names[] = { static int sfc_mae_rule_parse_action(struct sfc_adapter *sa, const struct rte_flow_action *action, - const struct sfc_mae_outer_rule *outer_rule, + const struct sfc_flow_spec_mae *spec_mae, struct sfc_mae_actions_bundle *bundle, efx_mae_actions_t *spec, struct rte_flow_error *error) { + const struct sfc_mae_outer_rule *outer_rule = spec_mae->outer_rule; const uint64_t rx_meta = sa->negotiated_rx_meta; bool custom_error = B_FALSE; int rc = 0; @@ -3250,9 +3275,10 @@ sfc_mae_rule_parse_action(struct sfc_adapter *sa, case RTE_FLOW_ACTION_TYPE_MARK: SFC_BUILD_SET_OVERFLOW(RTE_FLOW_ACTION_TYPE_MARK, bundle->actions_mask); - if ((rx_meta & RTE_ETH_RX_META_USER_MARK) != 0) { + if ((rx_meta & RTE_ETH_RX_META_USER_MARK) != 0 || + spec_mae->ft_rule_type == SFC_FT_RULE_JUMP) { rc = sfc_mae_rule_parse_action_mark(sa, action->conf, - spec); + spec_mae, spec); } else { rc = rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, @@ -3286,6 +3312,12 @@ sfc_mae_rule_parse_action(struct sfc_adapter *sa, bundle->actions_mask); rc = efx_mae_action_set_populate_drop(spec); break; + case RTE_FLOW_ACTION_TYPE_JUMP: + if (spec_mae->ft_rule_type == SFC_FT_RULE_JUMP) { + /* Workaround. See sfc_flow_parse_rte_to_mae() */ + break; + } + /* FALLTHROUGH */ default: return rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, NULL, @@ -3375,7 +3407,7 @@ sfc_mae_rule_parse_actions(struct sfc_adapter *sa, if (rc != 0) goto fail_rule_parse_action; - rc = sfc_mae_rule_parse_action(sa, action, spec_mae->outer_rule, + rc = sfc_mae_rule_parse_action(sa, action, spec_mae, &bundle, spec, error); if (rc != 0) goto fail_rule_parse_action; @@ -3399,6 +3431,12 @@ sfc_mae_rule_parse_actions(struct sfc_adapter *sa, switch (spec_mae->ft_rule_type) { case SFC_FT_RULE_NONE: break; + case SFC_FT_RULE_JUMP: + /* Workaround. See sfc_flow_parse_rte_to_mae() */ + rc = sfc_mae_rule_parse_action_pf_vf(sa, NULL, spec); + if (rc != 0) + goto fail_workaround_jump_delivery; + break; case SFC_FT_RULE_GROUP: /* * Packets that go to the rule's AR have FT mark set (from the @@ -3428,6 +3466,7 @@ sfc_mae_rule_parse_actions(struct sfc_adapter *sa, return 0; fail_action_set_add: +fail_workaround_jump_delivery: fail_nb_count: sfc_mae_encap_header_del(sa, encap_header);