[dpdk-dev] [PATCH 61/62] net/sfc: support encap. flow items in transfer rules
Andrew Rybchenko
arybchenko at solarflare.com
Tue Oct 20 10:48:28 CEST 2020
From: Ivan Malov <ivan.malov at oktetlabs.ru>
Add support for flow items VXLAN, Geneve and NVGRE to
MAE-specific RTE flow implementation.
Having support for these items implies the ability to insert
so-called outer MAE rules and refer to them in MAE action rules.
The patch takes care of all necessary facilities to do that.
Signed-off-by: Ivan Malov <ivan.malov at oktetlabs.ru>
Signed-off-by: Andrew Rybchenko <arybchenko at solarflare.com>
Reviewed-by: Andy Moreton <amoreton at xilinx.com>
---
doc/guides/nics/sfc_efx.rst | 6 +
drivers/net/sfc/sfc_flow.c | 18 +-
drivers/net/sfc/sfc_flow.h | 2 +
drivers/net/sfc/sfc_mae.c | 603 ++++++++++++++++++++++++++++++++++--
drivers/net/sfc/sfc_mae.h | 34 ++
5 files changed, 630 insertions(+), 33 deletions(-)
diff --git a/doc/guides/nics/sfc_efx.rst b/doc/guides/nics/sfc_efx.rst
index e8f8fa987b..461120448c 100644
--- a/doc/guides/nics/sfc_efx.rst
+++ b/doc/guides/nics/sfc_efx.rst
@@ -212,6 +212,12 @@ Supported pattern items (***transfer*** rules):
- UDP (source/destination ports)
+- VXLAN (exact match of VXLAN network identifier)
+
+- GENEVE (exact match of virtual network identifier)
+
+- NVGRE (exact match of virtual subnet ID)
+
Supported actions (***transfer*** rules):
- OF_POP_VLAN
diff --git a/drivers/net/sfc/sfc_flow.c b/drivers/net/sfc/sfc_flow.c
index 6ccefef477..4321045d1a 100644
--- a/drivers/net/sfc/sfc_flow.c
+++ b/drivers/net/sfc/sfc_flow.c
@@ -1288,7 +1288,8 @@ sfc_flow_parse_pattern(const struct sfc_flow_item *flow_items,
break;
default:
- if (is_ifrm) {
+ if (parse_ctx->type == SFC_FLOW_PARSE_CTX_FILTER &&
+ is_ifrm) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
pattern,
@@ -2565,13 +2566,8 @@ sfc_flow_verify(struct sfc_adapter *sa, struct rte_flow *flow,
}
if (ops->verify != NULL) {
- /*
- * Use locking since verify method may need to
- * access the list of already created rules.
- */
- sfc_adapter_lock(sa);
+ SFC_ASSERT(sfc_adapter_is_locked(sa));
rc = ops->verify(sa, flow);
- sfc_adapter_unlock(sa);
}
if (rc != 0) {
@@ -2599,12 +2595,16 @@ sfc_flow_validate(struct rte_eth_dev *dev,
if (flow == NULL)
return -rte_errno;
+ sfc_adapter_lock(sa);
+
rc = sfc_flow_parse(dev, attr, pattern, actions, flow, error);
if (rc == 0)
rc = sfc_flow_verify(sa, flow, error);
sfc_flow_free(sa, flow);
+ sfc_adapter_unlock(sa);
+
return rc;
}
@@ -2623,12 +2623,12 @@ sfc_flow_create(struct rte_eth_dev *dev,
if (flow == NULL)
goto fail_no_mem;
+ sfc_adapter_lock(sa);
+
rc = sfc_flow_parse(dev, attr, pattern, actions, flow, error);
if (rc != 0)
goto fail_bad_value;
- sfc_adapter_lock(sa);
-
TAILQ_INSERT_TAIL(&sa->flow_list, flow, entries);
if (sa->state == SFC_ADAPTER_STARTED) {
diff --git a/drivers/net/sfc/sfc_flow.h b/drivers/net/sfc/sfc_flow.h
index e991ae132c..09105953ff 100644
--- a/drivers/net/sfc/sfc_flow.h
+++ b/drivers/net/sfc/sfc_flow.h
@@ -67,6 +67,8 @@ struct sfc_flow_spec_filter {
struct sfc_flow_spec_mae {
/* Desired priority level */
unsigned int priority;
+ /* Outer rule registry entry */
+ struct sfc_mae_outer_rule *outer_rule;
/* EFX match specification */
efx_mae_match_spec_t *match_spec;
/* Action set registry entry */
diff --git a/drivers/net/sfc/sfc_mae.c b/drivers/net/sfc/sfc_mae.c
index 3dd233c6dc..c78a376a88 100644
--- a/drivers/net/sfc/sfc_mae.c
+++ b/drivers/net/sfc/sfc_mae.c
@@ -81,7 +81,10 @@ sfc_mae_attach(struct sfc_adapter *sa)
goto fail_mae_assign_switch_port;
mae->status = SFC_MAE_STATUS_SUPPORTED;
+ mae->nb_outer_rule_prios_max = limits.eml_max_n_outer_prios;
mae->nb_action_rule_prios_max = limits.eml_max_n_action_prios;
+ mae->encap_types_supported = limits.eml_encap_types_supported;
+ TAILQ_INIT(&mae->outer_rules);
TAILQ_INIT(&mae->action_sets);
sfc_log_init(sa, "done");
@@ -119,6 +122,138 @@ sfc_mae_detach(struct sfc_adapter *sa)
sfc_log_init(sa, "done");
}
+static struct sfc_mae_outer_rule *
+sfc_mae_outer_rule_attach(struct sfc_adapter *sa,
+ const efx_mae_match_spec_t *match_spec,
+ efx_tunnel_protocol_t encap_type)
+{
+ struct sfc_mae_outer_rule *rule;
+ struct sfc_mae *mae = &sa->mae;
+
+ SFC_ASSERT(sfc_adapter_is_locked(sa));
+
+ TAILQ_FOREACH(rule, &mae->outer_rules, entries) {
+ if (efx_mae_match_specs_equal(rule->match_spec, match_spec) &&
+ rule->encap_type == encap_type) {
+ ++(rule->refcnt);
+ return rule;
+ }
+ }
+
+ return NULL;
+}
+
+static int
+sfc_mae_outer_rule_add(struct sfc_adapter *sa,
+ efx_mae_match_spec_t *match_spec,
+ efx_tunnel_protocol_t encap_type,
+ struct sfc_mae_outer_rule **rulep)
+{
+ struct sfc_mae_outer_rule *rule;
+ struct sfc_mae *mae = &sa->mae;
+
+ SFC_ASSERT(sfc_adapter_is_locked(sa));
+
+ rule = rte_zmalloc("sfc_mae_outer_rule", sizeof(*rule), 0);
+ if (rule == NULL)
+ return ENOMEM;
+
+ rule->refcnt = 1;
+ rule->match_spec = match_spec;
+ rule->encap_type = encap_type;
+
+ rule->fw_rsrc.rule_id.id = EFX_MAE_RSRC_ID_INVALID;
+
+ TAILQ_INSERT_TAIL(&mae->outer_rules, rule, entries);
+
+ *rulep = rule;
+
+ return 0;
+}
+
+static void
+sfc_mae_outer_rule_del(struct sfc_adapter *sa,
+ struct sfc_mae_outer_rule *rule)
+{
+ struct sfc_mae *mae = &sa->mae;
+
+ SFC_ASSERT(sfc_adapter_is_locked(sa));
+ SFC_ASSERT(rule->refcnt != 0);
+
+ --(rule->refcnt);
+
+ if (rule->refcnt != 0)
+ return;
+
+ SFC_ASSERT(rule->fw_rsrc.rule_id.id == EFX_MAE_RSRC_ID_INVALID);
+ SFC_ASSERT(rule->fw_rsrc.refcnt == 0);
+
+ efx_mae_match_spec_fini(sa->nic, rule->match_spec);
+
+ TAILQ_REMOVE(&mae->outer_rules, rule, entries);
+ rte_free(rule);
+}
+
+static int
+sfc_mae_outer_rule_enable(struct sfc_adapter *sa,
+ struct sfc_mae_outer_rule *rule,
+ efx_mae_match_spec_t *match_spec_action)
+{
+ struct sfc_mae_fw_rsrc *fw_rsrc = &rule->fw_rsrc;
+ int rc;
+
+ SFC_ASSERT(sfc_adapter_is_locked(sa));
+
+ if (fw_rsrc->refcnt == 0) {
+ SFC_ASSERT(fw_rsrc->rule_id.id == EFX_MAE_RSRC_ID_INVALID);
+ SFC_ASSERT(rule->match_spec != NULL);
+
+ rc = efx_mae_outer_rule_insert(sa->nic, rule->match_spec,
+ rule->encap_type,
+ &fw_rsrc->rule_id);
+ if (rc != 0)
+ return rc;
+ }
+
+ rc = efx_mae_match_spec_outer_rule_id_set(match_spec_action,
+ &fw_rsrc->rule_id);
+ if (rc != 0) {
+ if (fw_rsrc->refcnt == 0) {
+ (void)efx_mae_outer_rule_remove(sa->nic,
+ &fw_rsrc->rule_id);
+ }
+ return rc;
+ }
+
+ ++(fw_rsrc->refcnt);
+
+ return 0;
+}
+
+static int
+sfc_mae_outer_rule_disable(struct sfc_adapter *sa,
+ struct sfc_mae_outer_rule *rule)
+{
+ struct sfc_mae_fw_rsrc *fw_rsrc = &rule->fw_rsrc;
+ int rc;
+
+ SFC_ASSERT(sfc_adapter_is_locked(sa));
+ SFC_ASSERT(fw_rsrc->rule_id.id != EFX_MAE_RSRC_ID_INVALID);
+ SFC_ASSERT(fw_rsrc->refcnt != 0);
+
+ if (fw_rsrc->refcnt == 1) {
+ rc = efx_mae_outer_rule_remove(sa->nic, &fw_rsrc->rule_id);
+ if (rc != 0)
+ return rc;
+
+ fw_rsrc->rule_id.id = EFX_MAE_RSRC_ID_INVALID;
+ }
+
+ --(fw_rsrc->refcnt);
+
+ return 0;
+}
+
static struct sfc_mae_action_set *
sfc_mae_action_set_attach(struct sfc_adapter *sa,
const efx_mae_actions_t *spec)
@@ -253,6 +388,9 @@ sfc_mae_flow_cleanup(struct sfc_adapter *sa,
SFC_ASSERT(spec_mae->rule_id.id == EFX_MAE_RSRC_ID_INVALID);
+ if (spec_mae->outer_rule != NULL)
+ sfc_mae_outer_rule_del(sa, spec_mae->outer_rule);
+
if (spec_mae->action_set != NULL)
sfc_mae_action_set_del(sa, spec_mae->action_set);
@@ -263,8 +401,8 @@ sfc_mae_flow_cleanup(struct sfc_adapter *sa,
static int
sfc_mae_set_ethertypes(struct sfc_mae_parse_ctx *ctx)
{
- efx_mae_match_spec_t *efx_spec = ctx->match_spec_action;
struct sfc_mae_pattern_data *pdata = &ctx->pattern_data;
+ const efx_mae_field_id_t *fremap = ctx->field_ids_remap;
const efx_mae_field_id_t field_ids[] = {
EFX_MAE_FIELD_VLAN0_PROTO_BE,
EFX_MAE_FIELD_VLAN1_PROTO_BE,
@@ -279,7 +417,8 @@ sfc_mae_set_ethertypes(struct sfc_mae_parse_ctx *ctx)
* no L3 item, it's 0x0000/0x0000.
*/
et = &pdata->ethertypes[pdata->nb_vlan_tags];
- rc = efx_mae_match_spec_field_set(efx_spec, EFX_MAE_FIELD_ETHER_TYPE_BE,
+ rc = efx_mae_match_spec_field_set(ctx->match_spec,
+ fremap[EFX_MAE_FIELD_ETHER_TYPE_BE],
sizeof(et->value),
(const uint8_t *)&et->value,
sizeof(et->mask),
@@ -296,7 +435,8 @@ sfc_mae_set_ethertypes(struct sfc_mae_parse_ctx *ctx)
for (i = 0; i < pdata->nb_vlan_tags; ++i) {
et = &pdata->ethertypes[i];
- rc = efx_mae_match_spec_field_set(efx_spec, field_ids[i],
+ rc = efx_mae_match_spec_field_set(ctx->match_spec,
+ fremap[field_ids[i]],
sizeof(et->value),
(const uint8_t *)&et->value,
sizeof(et->mask),
@@ -312,7 +452,7 @@ static int
sfc_mae_rule_process_pattern_data(struct sfc_mae_parse_ctx *ctx,
struct rte_flow_error *error)
{
- efx_mae_match_spec_t *efx_spec = ctx->match_spec_action;
+ const efx_mae_field_id_t *fremap = ctx->field_ids_remap;
struct sfc_mae_pattern_data *pdata = &ctx->pattern_data;
struct sfc_mae_ethertype *ethertypes = pdata->ethertypes;
const rte_be16_t supported_tpids[] = {
@@ -411,7 +551,8 @@ sfc_mae_rule_process_pattern_data(struct sfc_mae_parse_ctx *ctx,
valuep = (const uint8_t *)&pdata->l3_next_proto_value;
maskp = (const uint8_t *)&pdata->l3_next_proto_mask;
- rc = efx_mae_match_spec_field_set(efx_spec, EFX_MAE_FIELD_IP_PROTO,
+ rc = efx_mae_match_spec_field_set(ctx->match_spec,
+ fremap[EFX_MAE_FIELD_IP_PROTO],
sizeof(pdata->l3_next_proto_value),
valuep,
sizeof(pdata->l3_next_proto_mask),
@@ -478,7 +619,7 @@ sfc_mae_rule_parse_item_port_id(const struct rte_flow_item *item,
"Can't find RTE ethdev by the port ID");
}
- rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec_action,
+ rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec,
&mport_sel, NULL);
if (rc != 0) {
return rte_flow_error_set(error, rc,
@@ -536,8 +677,7 @@ sfc_mae_rule_parse_item_phy_port(const struct rte_flow_item *item,
"Failed to convert the PHY_PORT index");
}
- rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec_action,
- &mport_v, NULL);
+ rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec, &mport_v, NULL);
if (rc != 0) {
return rte_flow_error_set(error, rc,
RTE_FLOW_ERROR_TYPE_ITEM, item,
@@ -573,8 +713,7 @@ sfc_mae_rule_parse_item_pf(const struct rte_flow_item *item,
"Failed to convert the PF ID");
}
- rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec_action,
- &mport_v, NULL);
+ rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec, &mport_v, NULL);
if (rc != 0) {
return rte_flow_error_set(error, rc,
RTE_FLOW_ERROR_TYPE_ITEM, item,
@@ -639,8 +778,7 @@ sfc_mae_rule_parse_item_vf(const struct rte_flow_item *item,
"Failed to convert the PF + VF IDs");
}
- rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec_action,
- &mport_v, NULL);
+ rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec, &mport_v, NULL);
if (rc != 0) {
return rte_flow_error_set(error, rc,
RTE_FLOW_ERROR_TYPE_ITEM, item,
@@ -689,9 +827,10 @@ sfc_mae_item_build_supp_mask(const struct sfc_mae_field_locator *field_locators,
static int
sfc_mae_parse_item(const struct sfc_mae_field_locator *field_locators,
unsigned int nb_field_locators, const uint8_t *spec,
- const uint8_t *mask, efx_mae_match_spec_t *efx_spec,
+ const uint8_t *mask, struct sfc_mae_parse_ctx *ctx,
struct rte_flow_error *error)
{
+ const efx_mae_field_id_t *fremap = ctx->field_ids_remap;
unsigned int i;
int rc = 0;
@@ -701,7 +840,8 @@ sfc_mae_parse_item(const struct sfc_mae_field_locator *field_locators,
if (fl->field_id == SFC_MAE_FIELD_HANDLING_DEFERRED)
continue;
- rc = efx_mae_match_spec_field_set(efx_spec, fl->field_id,
+ rc = efx_mae_match_spec_field_set(ctx->match_spec,
+ fremap[fl->field_id],
fl->size, spec + fl->ofst,
fl->size, mask + fl->ofst);
if (rc != 0)
@@ -782,7 +922,7 @@ sfc_mae_rule_parse_item_eth(const struct rte_flow_item *item,
}
return sfc_mae_parse_item(flocs_eth, RTE_DIM(flocs_eth), spec, mask,
- ctx_mae->match_spec_action, error);
+ ctx_mae, error);
}
static const struct sfc_mae_field_locator flocs_vlan[] = {
@@ -878,8 +1018,7 @@ sfc_mae_rule_parse_item_vlan(const struct rte_flow_item *item,
return 0;
}
- return sfc_mae_parse_item(flocs, nb_flocs, spec, mask,
- ctx_mae->match_spec_action, error);
+ return sfc_mae_parse_item(flocs, nb_flocs, spec, mask, ctx_mae, error);
}
static const struct sfc_mae_field_locator flocs_ipv4[] = {
@@ -956,7 +1095,7 @@ sfc_mae_rule_parse_item_ipv4(const struct rte_flow_item *item,
}
return sfc_mae_parse_item(flocs_ipv4, RTE_DIM(flocs_ipv4), spec, mask,
- ctx_mae->match_spec_action, error);
+ ctx_mae, error);
}
static const struct sfc_mae_field_locator flocs_ipv6[] = {
@@ -993,6 +1132,7 @@ sfc_mae_rule_parse_item_ipv6(const struct rte_flow_item *item,
{
rte_be16_t ethertype_ipv6_be = RTE_BE16(RTE_ETHER_TYPE_IPV6);
struct sfc_mae_parse_ctx *ctx_mae = ctx->mae;
+ const efx_mae_field_id_t *fremap = ctx_mae->field_ids_remap;
struct sfc_mae_pattern_data *pdata = &ctx_mae->pattern_data;
struct rte_flow_item_ipv6 supp_mask;
const uint8_t *spec = NULL;
@@ -1034,7 +1174,7 @@ sfc_mae_rule_parse_item_ipv6(const struct rte_flow_item *item,
}
rc = sfc_mae_parse_item(flocs_ipv6, RTE_DIM(flocs_ipv6), spec, mask,
- ctx_mae->match_spec_action, error);
+ ctx_mae, error);
if (rc != 0)
return rc;
@@ -1046,8 +1186,8 @@ sfc_mae_rule_parse_item_ipv6(const struct rte_flow_item *item,
vtc_flow = rte_be_to_cpu_32(vtc_flow_be);
tc_mask = (vtc_flow & RTE_IPV6_HDR_TC_MASK) >> RTE_IPV6_HDR_TC_SHIFT;
- rc = efx_mae_match_spec_field_set(ctx_mae->match_spec_action,
- EFX_MAE_FIELD_IP_TOS,
+ rc = efx_mae_match_spec_field_set(ctx_mae->match_spec,
+ fremap[EFX_MAE_FIELD_IP_TOS],
sizeof(tc_value), &tc_value,
sizeof(tc_mask), &tc_mask);
if (rc != 0) {
@@ -1094,6 +1234,16 @@ sfc_mae_rule_parse_item_tcp(const struct rte_flow_item *item,
const uint8_t *mask = NULL;
int rc;
+ /*
+ * When encountered among outermost items, item TCP is invalid.
+ * Check which match specification is being constructed now.
+ */
+ if (ctx_mae->match_spec != ctx_mae->match_spec_action) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "TCP in outer frame is invalid");
+ }
+
sfc_mae_item_build_supp_mask(flocs_tcp, RTE_DIM(flocs_tcp),
&supp_mask, sizeof(supp_mask));
@@ -1112,7 +1262,7 @@ sfc_mae_rule_parse_item_tcp(const struct rte_flow_item *item,
return 0;
return sfc_mae_parse_item(flocs_tcp, RTE_DIM(flocs_tcp), spec, mask,
- ctx_mae->match_spec_action, error);
+ ctx_mae, error);
}
static const struct sfc_mae_field_locator flocs_udp[] = {
@@ -1158,7 +1308,157 @@ sfc_mae_rule_parse_item_udp(const struct rte_flow_item *item,
return 0;
return sfc_mae_parse_item(flocs_udp, RTE_DIM(flocs_udp), spec, mask,
- ctx_mae->match_spec_action, error);
+ ctx_mae, error);
+}
+
+static const struct sfc_mae_field_locator flocs_tunnel[] = {
+ {
+ /*
+ * The size and offset values are relevant
+ * for Geneve and NVGRE, too.
+ */
+ .size = RTE_SIZEOF_FIELD(struct rte_flow_item_vxlan, vni),
+ .ofst = offsetof(struct rte_flow_item_vxlan, vni),
+ },
+};
+
+/*
+ * An auxiliary registry which allows using non-encap. field IDs
+ * directly when building a match specification of type ACTION.
+ *
+ * See sfc_mae_rule_parse_pattern() and sfc_mae_rule_parse_item_tunnel().
+ */
+static const efx_mae_field_id_t field_ids_no_remap[] = {
+#define FIELD_ID_NO_REMAP(_field) \
+ [EFX_MAE_FIELD_##_field] = EFX_MAE_FIELD_##_field
+
+ FIELD_ID_NO_REMAP(ETHER_TYPE_BE),
+ FIELD_ID_NO_REMAP(ETH_SADDR_BE),
+ FIELD_ID_NO_REMAP(ETH_DADDR_BE),
+ FIELD_ID_NO_REMAP(VLAN0_TCI_BE),
+ FIELD_ID_NO_REMAP(VLAN0_PROTO_BE),
+ FIELD_ID_NO_REMAP(VLAN1_TCI_BE),
+ FIELD_ID_NO_REMAP(VLAN1_PROTO_BE),
+ FIELD_ID_NO_REMAP(SRC_IP4_BE),
+ FIELD_ID_NO_REMAP(DST_IP4_BE),
+ FIELD_ID_NO_REMAP(IP_PROTO),
+ FIELD_ID_NO_REMAP(IP_TOS),
+ FIELD_ID_NO_REMAP(IP_TTL),
+ FIELD_ID_NO_REMAP(SRC_IP6_BE),
+ FIELD_ID_NO_REMAP(DST_IP6_BE),
+ FIELD_ID_NO_REMAP(L4_SPORT_BE),
+ FIELD_ID_NO_REMAP(L4_DPORT_BE),
+ FIELD_ID_NO_REMAP(TCP_FLAGS_BE),
+
+#undef FIELD_ID_NO_REMAP
+};
+
+/*
+ * An auxiliary registry which allows using "ENC" field IDs
+ * when building a match specification of type OUTER.
+ *
+ * See sfc_mae_rule_encap_parse_init().
+ */
+static const efx_mae_field_id_t field_ids_remap_to_encap[] = {
+#define FIELD_ID_REMAP_TO_ENCAP(_field) \
+ [EFX_MAE_FIELD_##_field] = EFX_MAE_FIELD_ENC_##_field
+
+ FIELD_ID_REMAP_TO_ENCAP(ETHER_TYPE_BE),
+ FIELD_ID_REMAP_TO_ENCAP(ETH_SADDR_BE),
+ FIELD_ID_REMAP_TO_ENCAP(ETH_DADDR_BE),
+ FIELD_ID_REMAP_TO_ENCAP(VLAN0_TCI_BE),
+ FIELD_ID_REMAP_TO_ENCAP(VLAN0_PROTO_BE),
+ FIELD_ID_REMAP_TO_ENCAP(VLAN1_TCI_BE),
+ FIELD_ID_REMAP_TO_ENCAP(VLAN1_PROTO_BE),
+ FIELD_ID_REMAP_TO_ENCAP(SRC_IP4_BE),
+ FIELD_ID_REMAP_TO_ENCAP(DST_IP4_BE),
+ FIELD_ID_REMAP_TO_ENCAP(IP_PROTO),
+ FIELD_ID_REMAP_TO_ENCAP(IP_TOS),
+ FIELD_ID_REMAP_TO_ENCAP(IP_TTL),
+ FIELD_ID_REMAP_TO_ENCAP(SRC_IP6_BE),
+ FIELD_ID_REMAP_TO_ENCAP(DST_IP6_BE),
+ FIELD_ID_REMAP_TO_ENCAP(L4_SPORT_BE),
+ FIELD_ID_REMAP_TO_ENCAP(L4_DPORT_BE),
+
+#undef FIELD_ID_REMAP_TO_ENCAP
+};
+
+static int
+sfc_mae_rule_parse_item_tunnel(const struct rte_flow_item *item,
+ struct sfc_flow_parse_ctx *ctx,
+ struct rte_flow_error *error)
+{
+ struct sfc_mae_parse_ctx *ctx_mae = ctx->mae;
+ uint8_t vnet_id_v[sizeof(uint32_t)] = {0};
+ uint8_t vnet_id_m[sizeof(uint32_t)] = {0};
+ const struct rte_flow_item_vxlan *vxp;
+ uint8_t supp_mask[sizeof(uint64_t)];
+ const uint8_t *spec = NULL;
+ const uint8_t *mask = NULL;
+ const void *def_mask;
+ int rc;
+
+ /*
+ * We're about to start processing inner frame items.
+ * Process pattern data that has been deferred so far
+ * and reset pattern data storage.
+ */
+ rc = sfc_mae_rule_process_pattern_data(ctx_mae, error);
+ if (rc != 0)
+ return rc;
+
+ memset(&ctx_mae->pattern_data, 0, sizeof(ctx_mae->pattern_data));
+
+ sfc_mae_item_build_supp_mask(flocs_tunnel, RTE_DIM(flocs_tunnel),
+ &supp_mask, sizeof(supp_mask));
+
+ /*
+ * This tunnel item was preliminarily detected by
+ * sfc_mae_rule_encap_parse_init(). Default mask
+ * was also picked by that helper. Use it here.
+ */
+ def_mask = ctx_mae->tunnel_def_mask;
+
+ rc = sfc_flow_parse_init(item,
+ (const void **)&spec, (const void **)&mask,
+ (const void *)&supp_mask, def_mask,
+ sizeof(def_mask), error);
+ if (rc != 0)
+ return rc;
+
+ /*
+ * This item and later ones comprise a
+ * match specification of type ACTION.
+ */
+ ctx_mae->match_spec = ctx_mae->match_spec_action;
+
+ /* This item and later ones use non-encap. EFX MAE field IDs. */
+ ctx_mae->field_ids_remap = field_ids_no_remap;
+
+ if (spec == NULL)
+ return 0;
+
+ /*
+ * Field EFX_MAE_FIELD_ENC_VNET_ID_BE is a 32-bit one.
+ * Copy 24-bit VNI, which is BE, at offset 1 in it.
+ * The extra byte is 0 both in the mask and in the value.
+ */
+ vxp = (const struct rte_flow_item_vxlan *)spec;
+ memcpy(vnet_id_v + 1, &vxp->vni, sizeof(vxp->vni));
+
+ vxp = (const struct rte_flow_item_vxlan *)mask;
+ memcpy(vnet_id_m + 1, &vxp->vni, sizeof(vxp->vni));
+
+ rc = efx_mae_match_spec_field_set(ctx_mae->match_spec,
+ EFX_MAE_FIELD_ENC_VNET_ID_BE,
+ sizeof(vnet_id_v), vnet_id_v,
+ sizeof(vnet_id_m), vnet_id_m);
+ if (rc != 0) {
+ rc = rte_flow_error_set(error, rc, RTE_FLOW_ERROR_TYPE_ITEM,
+ item, "Failed to set VXLAN VNI");
+ }
+
+ return rc;
}
static const struct sfc_flow_item sfc_flow_items[] = {
@@ -1248,8 +1548,178 @@ static const struct sfc_flow_item sfc_flow_items[] = {
.ctx_type = SFC_FLOW_PARSE_CTX_MAE,
.parse = sfc_mae_rule_parse_item_udp,
},
+ {
+ .type = RTE_FLOW_ITEM_TYPE_VXLAN,
+ .prev_layer = SFC_FLOW_ITEM_L4,
+ .layer = SFC_FLOW_ITEM_START_LAYER,
+ .ctx_type = SFC_FLOW_PARSE_CTX_MAE,
+ .parse = sfc_mae_rule_parse_item_tunnel,
+ },
+ {
+ .type = RTE_FLOW_ITEM_TYPE_GENEVE,
+ .prev_layer = SFC_FLOW_ITEM_L4,
+ .layer = SFC_FLOW_ITEM_START_LAYER,
+ .ctx_type = SFC_FLOW_PARSE_CTX_MAE,
+ .parse = sfc_mae_rule_parse_item_tunnel,
+ },
+ {
+ .type = RTE_FLOW_ITEM_TYPE_NVGRE,
+ .prev_layer = SFC_FLOW_ITEM_L3,
+ .layer = SFC_FLOW_ITEM_START_LAYER,
+ .ctx_type = SFC_FLOW_PARSE_CTX_MAE,
+ .parse = sfc_mae_rule_parse_item_tunnel,
+ },
};
+static int
+sfc_mae_rule_process_outer(struct sfc_adapter *sa,
+ struct sfc_mae_parse_ctx *ctx,
+ struct sfc_mae_outer_rule **rulep,
+ struct rte_flow_error *error)
+{
+ struct sfc_mae_outer_rule *rule;
+ int rc;
+
+ if (ctx->encap_type == EFX_TUNNEL_PROTOCOL_NONE) {
+ *rulep = NULL;
+ return 0;
+ }
+
+ SFC_ASSERT(ctx->match_spec_outer != NULL);
+
+ if (!efx_mae_match_spec_is_valid(sa->nic, ctx->match_spec_outer)) {
+ return rte_flow_error_set(error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ITEM, NULL,
+ "Inconsistent pattern (outer)");
+ }
+
+ *rulep = sfc_mae_outer_rule_attach(sa, ctx->match_spec_outer,
+ ctx->encap_type);
+ if (*rulep != NULL) {
+ efx_mae_match_spec_fini(sa->nic, ctx->match_spec_outer);
+ } else {
+ rc = sfc_mae_outer_rule_add(sa, ctx->match_spec_outer,
+ ctx->encap_type, rulep);
+ if (rc != 0) {
+ return rte_flow_error_set(error, rc,
+ RTE_FLOW_ERROR_TYPE_ITEM, NULL,
+ "Failed to process the pattern");
+ }
+ }
+
+ /*
+ * Depending on whether we reuse an existing outer rule or create a
+ * new one (see above), outer rule ID is either a valid value or
+ * EFX_MAE_RSRC_ID_INVALID. Set it in the action rule match
+ * specification (and the full mask, too) in order to have correct
+ * class comparisons of the new rule with existing ones.
+ * Also, action rule match specification will be validated shortly,
+ * and having the full mask set for outer rule ID indicates that we
+ * will use this field, and support for this field has to be checked.
+ */
+ rule = *rulep;
+ rc = efx_mae_match_spec_outer_rule_id_set(ctx->match_spec_action,
+ &rule->fw_rsrc.rule_id);
+ if (rc != 0) {
+ sfc_mae_outer_rule_del(sa, *rulep);
+ *rulep = NULL;
+
+ return rte_flow_error_set(error, rc,
+ RTE_FLOW_ERROR_TYPE_ITEM, NULL,
+ "Failed to process the pattern");
+ }
+
+ return 0;
+}
+
+static int
+sfc_mae_rule_encap_parse_init(struct sfc_adapter *sa,
+ const struct rte_flow_item pattern[],
+ struct sfc_mae_parse_ctx *ctx,
+ struct rte_flow_error *error)
+{
+ struct sfc_mae *mae = &sa->mae;
+ int rc;
+
+ if (pattern == NULL) {
+ rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM_NUM, NULL,
+ "NULL pattern");
+ return -rte_errno;
+ }
+
+ for (;;) {
+ switch (pattern->type) {
+ case RTE_FLOW_ITEM_TYPE_VXLAN:
+ ctx->encap_type = EFX_TUNNEL_PROTOCOL_VXLAN;
+ ctx->tunnel_def_mask = &rte_flow_item_vxlan_mask;
+ RTE_BUILD_BUG_ON(sizeof(ctx->tunnel_def_mask) !=
+ sizeof(rte_flow_item_vxlan_mask));
+ break;
+ case RTE_FLOW_ITEM_TYPE_GENEVE:
+ ctx->encap_type = EFX_TUNNEL_PROTOCOL_GENEVE;
+ ctx->tunnel_def_mask = &rte_flow_item_geneve_mask;
+ RTE_BUILD_BUG_ON(sizeof(ctx->tunnel_def_mask) !=
+ sizeof(rte_flow_item_geneve_mask));
+ break;
+ case RTE_FLOW_ITEM_TYPE_NVGRE:
+ ctx->encap_type = EFX_TUNNEL_PROTOCOL_NVGRE;
+ ctx->tunnel_def_mask = &rte_flow_item_nvgre_mask;
+ RTE_BUILD_BUG_ON(sizeof(ctx->tunnel_def_mask) !=
+ sizeof(rte_flow_item_nvgre_mask));
+ break;
+ case RTE_FLOW_ITEM_TYPE_END:
+ break;
+ default:
+ ++pattern;
+ continue;
+ };
+
+ break;
+ }
+
+ if (pattern->type == RTE_FLOW_ITEM_TYPE_END)
+ return 0;
+
+ if ((mae->encap_types_supported & (1U << ctx->encap_type)) == 0) {
+ return rte_flow_error_set(error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ITEM,
+ pattern, "Unsupported tunnel item");
+ }
+
+ if (ctx->priority >= mae->nb_outer_rule_prios_max) {
+ return rte_flow_error_set(error, ENOTSUP,
+ RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
+ NULL, "Unsupported priority level");
+ }
+
+ rc = efx_mae_match_spec_init(sa->nic, EFX_MAE_RULE_OUTER, ctx->priority,
+ &ctx->match_spec_outer);
+ if (rc != 0) {
+ return rte_flow_error_set(error, rc,
+ RTE_FLOW_ERROR_TYPE_ITEM, pattern,
+ "Failed to initialise outer rule match specification");
+ }
+
+ /* Outermost items comprise a match specification of type OUTER. */
+ ctx->match_spec = ctx->match_spec_outer;
+
+ /* Outermost items use "ENC" EFX MAE field IDs. */
+ ctx->field_ids_remap = field_ids_remap_to_encap;
+
+ return 0;
+}
+
+static void
+sfc_mae_rule_encap_parse_fini(struct sfc_adapter *sa,
+ struct sfc_mae_parse_ctx *ctx)
+{
+ if (ctx->encap_type == EFX_TUNNEL_PROTOCOL_NONE)
+ return;
+
+ efx_mae_match_spec_fini(sa->nic, ctx->match_spec_outer);
+}
+
int
sfc_mae_rule_parse_pattern(struct sfc_adapter *sa,
const struct rte_flow_item pattern[],
@@ -1261,6 +1731,7 @@ sfc_mae_rule_parse_pattern(struct sfc_adapter *sa,
int rc;
memset(&ctx_mae, 0, sizeof(ctx_mae));
+ ctx_mae.priority = spec->priority;
ctx_mae.sa = sa;
rc = efx_mae_match_spec_init(sa->nic, EFX_MAE_RULE_ACTION,
@@ -1273,9 +1744,24 @@ sfc_mae_rule_parse_pattern(struct sfc_adapter *sa,
goto fail_init_match_spec_action;
}
+ /*
+ * As a preliminary setting, assume that there is no encapsulation
+ * in the pattern. That is, pattern items are about to comprise a
+ * match specification of type ACTION and use non-encap. field IDs.
+ *
+ * sfc_mae_rule_encap_parse_init() below may override this.
+ */
+ ctx_mae.encap_type = EFX_TUNNEL_PROTOCOL_NONE;
+ ctx_mae.match_spec = ctx_mae.match_spec_action;
+ ctx_mae.field_ids_remap = field_ids_no_remap;
+
ctx.type = SFC_FLOW_PARSE_CTX_MAE;
ctx.mae = &ctx_mae;
+ rc = sfc_mae_rule_encap_parse_init(sa, pattern, &ctx_mae, error);
+ if (rc != 0)
+ goto fail_encap_parse_init;
+
rc = sfc_flow_parse_pattern(sfc_flow_items, RTE_DIM(sfc_flow_items),
pattern, &ctx, error);
if (rc != 0)
@@ -1285,6 +1771,10 @@ sfc_mae_rule_parse_pattern(struct sfc_adapter *sa,
if (rc != 0)
goto fail_process_pattern_data;
+ rc = sfc_mae_rule_process_outer(sa, &ctx_mae, &spec->outer_rule, error);
+ if (rc != 0)
+ goto fail_process_outer;
+
if (!efx_mae_match_spec_is_valid(sa->nic, ctx_mae.match_spec_action)) {
rc = rte_flow_error_set(error, ENOTSUP,
RTE_FLOW_ERROR_TYPE_ITEM, NULL,
@@ -1297,8 +1787,12 @@ sfc_mae_rule_parse_pattern(struct sfc_adapter *sa,
return 0;
fail_validate_match_spec_action:
+fail_process_outer:
fail_process_pattern_data:
fail_parse_pattern:
+ sfc_mae_rule_encap_parse_fini(sa, &ctx_mae);
+
+fail_encap_parse_init:
efx_mae_match_spec_fini(sa->nic, ctx_mae.match_spec_action);
fail_init_match_spec_action:
@@ -1670,6 +2164,37 @@ sfc_mae_rules_class_cmp(struct sfc_adapter *sa,
return (rc == 0) ? have_same_class : false;
}
+static int
+sfc_mae_outer_rule_class_verify(struct sfc_adapter *sa,
+ struct sfc_mae_outer_rule *rule)
+{
+ struct sfc_mae_fw_rsrc *fw_rsrc = &rule->fw_rsrc;
+ struct sfc_mae_outer_rule *entry;
+ struct sfc_mae *mae = &sa->mae;
+
+ if (fw_rsrc->rule_id.id != EFX_MAE_RSRC_ID_INVALID) {
+ /* An active rule is reused. It's class is wittingly valid. */
+ return 0;
+ }
+
+ TAILQ_FOREACH_REVERSE(entry, &mae->outer_rules,
+ sfc_mae_outer_rules, entries) {
+ const efx_mae_match_spec_t *left = entry->match_spec;
+ const efx_mae_match_spec_t *right = rule->match_spec;
+
+ if (entry == rule)
+ continue;
+
+ if (sfc_mae_rules_class_cmp(sa, left, right))
+ return 0;
+ }
+
+ sfc_info(sa, "for now, the HW doesn't support rule validation, and HW "
+ "support for outer frame pattern items is not guaranteed; "
+ "other than that, the items are valid from SW standpoint");
+ return 0;
+}
+
static int
sfc_mae_action_rule_class_verify(struct sfc_adapter *sa,
struct sfc_flow_spec_mae *spec)
@@ -1722,12 +2247,20 @@ sfc_mae_flow_verify(struct sfc_adapter *sa,
{
struct sfc_flow_spec *spec = &flow->spec;
struct sfc_flow_spec_mae *spec_mae = &spec->mae;
+ struct sfc_mae_outer_rule *outer_rule = spec_mae->outer_rule;
+ int rc;
SFC_ASSERT(sfc_adapter_is_locked(sa));
if (sa->state != SFC_ADAPTER_STARTED)
return EAGAIN;
+ if (outer_rule != NULL) {
+ rc = sfc_mae_outer_rule_class_verify(sa, outer_rule);
+ if (rc != 0)
+ return rc;
+ }
+
return sfc_mae_action_rule_class_verify(sa, spec_mae);
}
@@ -1737,6 +2270,7 @@ sfc_mae_flow_insert(struct sfc_adapter *sa,
{
struct sfc_flow_spec *spec = &flow->spec;
struct sfc_flow_spec_mae *spec_mae = &spec->mae;
+ struct sfc_mae_outer_rule *outer_rule = spec_mae->outer_rule;
struct sfc_mae_action_set *action_set = spec_mae->action_set;
struct sfc_mae_fw_rsrc *fw_rsrc = &action_set->fw_rsrc;
int rc;
@@ -1744,6 +2278,13 @@ sfc_mae_flow_insert(struct sfc_adapter *sa,
SFC_ASSERT(spec_mae->rule_id.id == EFX_MAE_RSRC_ID_INVALID);
SFC_ASSERT(action_set != NULL);
+ if (outer_rule != NULL) {
+ rc = sfc_mae_outer_rule_enable(sa, outer_rule,
+ spec_mae->match_spec);
+ if (rc != 0)
+ goto fail_outer_rule_enable;
+ }
+
rc = sfc_mae_action_set_enable(sa, action_set);
if (rc != 0)
goto fail_action_set_enable;
@@ -1760,6 +2301,10 @@ sfc_mae_flow_insert(struct sfc_adapter *sa,
(void)sfc_mae_action_set_disable(sa, action_set);
fail_action_set_enable:
+ if (outer_rule != NULL)
+ (void)sfc_mae_outer_rule_disable(sa, outer_rule);
+
+fail_outer_rule_enable:
return rc;
}
@@ -1770,6 +2315,7 @@ sfc_mae_flow_remove(struct sfc_adapter *sa,
struct sfc_flow_spec *spec = &flow->spec;
struct sfc_flow_spec_mae *spec_mae = &spec->mae;
struct sfc_mae_action_set *action_set = spec_mae->action_set;
+ struct sfc_mae_outer_rule *outer_rule = spec_mae->outer_rule;
int rc;
SFC_ASSERT(spec_mae->rule_id.id != EFX_MAE_RSRC_ID_INVALID);
@@ -1781,5 +2327,14 @@ sfc_mae_flow_remove(struct sfc_adapter *sa,
spec_mae->rule_id.id = EFX_MAE_RSRC_ID_INVALID;
- return sfc_mae_action_set_disable(sa, action_set);
+ rc = sfc_mae_action_set_disable(sa, action_set);
+ if (rc != 0) {
+ sfc_err(sa, "failed to disable the action set (rc = %d)", rc);
+ /* Despite the error, proceed with outer rule removal. */
+ }
+
+ if (outer_rule != NULL)
+ return sfc_mae_outer_rule_disable(sa, outer_rule);
+
+ return 0;
}
diff --git a/drivers/net/sfc/sfc_mae.h b/drivers/net/sfc/sfc_mae.h
index 8d9b4039f3..53ddead979 100644
--- a/drivers/net/sfc/sfc_mae.h
+++ b/drivers/net/sfc/sfc_mae.h
@@ -26,9 +26,21 @@ struct sfc_mae_fw_rsrc {
RTE_STD_C11
union {
efx_mae_aset_id_t aset_id;
+ efx_mae_rule_id_t rule_id;
};
};
+/** Outer rule registry entry */
+struct sfc_mae_outer_rule {
+ TAILQ_ENTRY(sfc_mae_outer_rule) entries;
+ unsigned int refcnt;
+ efx_mae_match_spec_t *match_spec;
+ efx_tunnel_protocol_t encap_type;
+ struct sfc_mae_fw_rsrc fw_rsrc;
+};
+
+TAILQ_HEAD(sfc_mae_outer_rules, sfc_mae_outer_rule);
+
/** Action set registry entry */
struct sfc_mae_action_set {
TAILQ_ENTRY(sfc_mae_action_set) entries;
@@ -53,8 +65,14 @@ struct sfc_mae {
uint16_t switch_port_id;
/** NIC support for MAE status */
enum sfc_mae_status status;
+ /** Priority level limit for MAE outer rules */
+ unsigned int nb_outer_rule_prios_max;
/** Priority level limit for MAE action rules */
unsigned int nb_action_rule_prios_max;
+ /** Encapsulation support status */
+ uint32_t encap_types_supported;
+ /** Outer rule registry */
+ struct sfc_mae_outer_rules outer_rules;
/** Action set registry */
struct sfc_mae_action_sets action_sets;
};
@@ -149,8 +167,24 @@ struct sfc_mae_pattern_data {
struct sfc_mae_parse_ctx {
struct sfc_adapter *sa;
efx_mae_match_spec_t *match_spec_action;
+ efx_mae_match_spec_t *match_spec_outer;
+ /*
+ * This points to either of the above two specifications depending
+ * on which part of the pattern is being parsed (outer / inner).
+ */
+ efx_mae_match_spec_t *match_spec;
+ /*
+ * This points to either "field_ids_remap_to_encap"
+ * or "field_ids_no_remap" (see sfc_mae.c) depending on
+ * which part of the pattern is being parsed.
+ */
+ const efx_mae_field_id_t *field_ids_remap;
+ /* This points to a tunnel-specific default mask. */
+ const void *tunnel_def_mask;
bool match_mport_set;
struct sfc_mae_pattern_data pattern_data;
+ efx_tunnel_protocol_t encap_type;
+ unsigned int priority;
};
int sfc_mae_attach(struct sfc_adapter *sa);
--
2.17.1
More information about the dev
mailing list