* [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows
@ 2023-08-10 18:06 Ivan Malov
2023-08-10 18:06 ` [PATCH 2/2] net/sfc: support updating indirect VXLAN encap action Ivan Malov
` (2 more replies)
0 siblings, 3 replies; 6+ messages in thread
From: Ivan Malov @ 2023-08-10 18:06 UTC (permalink / raw)
To: dev; +Cc: Andrew Rybchenko, Ferruh Yigit, Andy Moreton
Parsing inline action VXLAN_ENCAP repeating in many flows is
expensive, so offer support for its indirect version. Query
operation is not supported for this action. The next patch
will add a means to update the encapsulation header data.
Signed-off-by: Ivan Malov <ivan.malov@arknetworks.am>
Reviewed-by: Andy Moreton <andy.moreton@amd.com>
---
.mailmap | 2 +-
doc/guides/rel_notes/release_23_11.rst | 4 ++
drivers/net/sfc/sfc_flow.h | 1 +
drivers/net/sfc/sfc_mae.c | 51 ++++++++++++++++++++++++++
drivers/net/sfc/sfc_mae.h | 1 +
5 files changed, 58 insertions(+), 1 deletion(-)
diff --git a/.mailmap b/.mailmap
index 864d33ee46..ec31ab8bd0 100644
--- a/.mailmap
+++ b/.mailmap
@@ -106,7 +106,7 @@ Andriy Berestovskyy <aber@semihalf.com> <andriy.berestovskyy@caviumnetworks.com>
Andrzej Ostruszka <amo@semihalf.com> <aostruszka@marvell.com>
Andy Gospodarek <andrew.gospodarek@broadcom.com> <gospo@broadcom.com>
Andy Green <andy@warmcat.com>
-Andy Moreton <amoreton@xilinx.com> <amoreton@solarflare.com>
+Andy Moreton <andy.moreton@amd.com> <amoreton@xilinx.com> <amoreton@solarflare.com>
Andy Pei <andy.pei@intel.com>
Anirudh Venkataramanan <anirudh.venkataramanan@intel.com>
Ankur Dwivedi <adwivedi@marvell.com> <ankur.dwivedi@caviumnetworks.com> <ankur.dwivedi@cavium.com>
diff --git a/doc/guides/rel_notes/release_23_11.rst b/doc/guides/rel_notes/release_23_11.rst
index 6b4dd21fd0..dd10110fff 100644
--- a/doc/guides/rel_notes/release_23_11.rst
+++ b/doc/guides/rel_notes/release_23_11.rst
@@ -55,6 +55,10 @@ New Features
Also, make sure to start the actual text at the margin.
=======================================================
+* **Updated Solarflare network PMD.**
+
+ * Added support for transfer flow action INDIRECT with subtype VXLAN_ENCAP.
+
Removed Items
-------------
diff --git a/drivers/net/sfc/sfc_flow.h b/drivers/net/sfc/sfc_flow.h
index 601f93e540..95fcb5abe0 100644
--- a/drivers/net/sfc/sfc_flow.h
+++ b/drivers/net/sfc/sfc_flow.h
@@ -98,6 +98,7 @@ struct rte_flow_action_handle {
enum rte_flow_action_type type;
union {
+ struct sfc_mae_encap_header *encap_header;
struct sfc_mae_counter *counter;
};
};
diff --git a/drivers/net/sfc/sfc_mae.c b/drivers/net/sfc/sfc_mae.c
index f5fe55b46f..45a66307d2 100644
--- a/drivers/net/sfc/sfc_mae.c
+++ b/drivers/net/sfc/sfc_mae.c
@@ -663,6 +663,9 @@ sfc_mae_encap_header_attach(struct sfc_adapter *sa,
SFC_ASSERT(sfc_adapter_is_locked(sa));
TAILQ_FOREACH(encap_header, &mae->encap_headers, entries) {
+ if (encap_header->indirect)
+ continue;
+
if (encap_header->size == bounce_eh->size &&
memcmp(encap_header->buf, bounce_eh->buf,
bounce_eh->size) == 0) {
@@ -4057,6 +4060,9 @@ sfc_mae_rule_parse_action_vxlan_encap(
/* Take care of the masks. */
sfc_mae_header_force_item_masks(buf, parsed_items, nb_parsed_items);
+ if (spec == NULL)
+ return 0;
+
rc = efx_mae_action_set_populate_encap(spec);
if (rc != 0) {
rc = rte_flow_error_set(error, rc, RTE_FLOW_ERROR_TYPE_ACTION,
@@ -4160,6 +4166,23 @@ sfc_mae_rule_parse_action_indirect(struct sfc_adapter *sa,
sfc_dbg(sa, "attaching to indirect_action=%p", entry);
switch (entry->type) {
+ case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP:
+ if (ctx->encap_header != NULL) {
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
+ "cannot have multiple actions VXLAN_ENCAP in one flow");
+ }
+
+ rc = efx_mae_action_set_populate_encap(ctx->spec);
+ if (rc != 0) {
+ return rte_flow_error_set(error, rc,
+ RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
+ "failed to add ENCAP to MAE action set");
+ }
+
+ ctx->encap_header = entry->encap_header;
+ ++(ctx->encap_header->refcnt);
+ break;
case RTE_FLOW_ACTION_TYPE_COUNT:
if (ft_rule_type != SFC_FT_RULE_NONE) {
return rte_flow_error_set(error, EINVAL,
@@ -5182,12 +5205,31 @@ sfc_mae_indir_action_create(struct sfc_adapter *sa,
struct rte_flow_action_handle *handle,
struct rte_flow_error *error)
{
+ struct sfc_mae *mae = &sa->mae;
+ bool custom_error = false;
int ret;
SFC_ASSERT(sfc_adapter_is_locked(sa));
SFC_ASSERT(handle != NULL);
switch (action->type) {
+ case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP:
+ /* Cleanup after previous encap. header bounce buffer usage. */
+ sfc_mae_bounce_eh_invalidate(&mae->bounce_eh);
+
+ ret = sfc_mae_rule_parse_action_vxlan_encap(mae, action->conf,
+ NULL, error);
+ if (ret != 0) {
+ custom_error = true;
+ break;
+ }
+
+ ret = sfc_mae_encap_header_add(sa, &mae->bounce_eh,
+ &handle->encap_header);
+ if (ret == 0)
+ handle->encap_header->indirect = true;
+ break;
+
case RTE_FLOW_ACTION_TYPE_COUNT:
ret = sfc_mae_rule_parse_action_count(sa, action->conf,
EFX_COUNTER_TYPE_ACTION,
@@ -5199,6 +5241,9 @@ sfc_mae_indir_action_create(struct sfc_adapter *sa,
ret = ENOTSUP;
}
+ if (custom_error)
+ return ret;
+
if (ret != 0) {
return rte_flow_error_set(error, ret,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
@@ -5219,6 +5264,12 @@ sfc_mae_indir_action_destroy(struct sfc_adapter *sa,
SFC_ASSERT(handle != NULL);
switch (handle->type) {
+ case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP:
+ if (handle->encap_header->refcnt != 1)
+ goto fail;
+
+ sfc_mae_encap_header_del(sa, handle->encap_header);
+ break;
case RTE_FLOW_ACTION_TYPE_COUNT:
if (handle->counter->refcnt != 1)
goto fail;
diff --git a/drivers/net/sfc/sfc_mae.h b/drivers/net/sfc/sfc_mae.h
index 059718e383..4b928f876b 100644
--- a/drivers/net/sfc/sfc_mae.h
+++ b/drivers/net/sfc/sfc_mae.h
@@ -60,6 +60,7 @@ TAILQ_HEAD(sfc_mae_mac_addrs, sfc_mae_mac_addr);
struct sfc_mae_encap_header {
TAILQ_ENTRY(sfc_mae_encap_header) entries;
unsigned int refcnt;
+ bool indirect;
uint8_t *buf;
size_t size;
efx_tunnel_protocol_t type;
--
2.31.1
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 2/2] net/sfc: support updating indirect VXLAN encap action
2023-08-10 18:06 [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows Ivan Malov
@ 2023-08-10 18:06 ` Ivan Malov
2023-09-22 6:33 ` Andrew Rybchenko
2023-09-21 15:42 ` [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows Ferruh Yigit
2023-09-22 6:32 ` Andrew Rybchenko
2 siblings, 1 reply; 6+ messages in thread
From: Ivan Malov @ 2023-08-10 18:06 UTC (permalink / raw)
To: dev; +Cc: Andrew Rybchenko, Ferruh Yigit, Andy Moreton
Such updates are helpful as they let applications avoid
costly flow re-insertions when the header data changes.
Signed-off-by: Ivan Malov <ivan.malov@arknetworks.am>
Reviewed-by: Andy Moreton <andy.moreton@amd.com>
---
drivers/common/sfc_efx/base/efx.h | 9 +++
drivers/common/sfc_efx/base/efx_mae.c | 80 ++++++++++++++++++++++++
drivers/common/sfc_efx/version.map | 1 +
drivers/net/sfc/sfc_flow.c | 35 +++++++++++
drivers/net/sfc/sfc_mae.c | 88 +++++++++++++++++++++++++++
drivers/net/sfc/sfc_mae.h | 5 ++
6 files changed, 218 insertions(+)
diff --git a/drivers/common/sfc_efx/base/efx.h b/drivers/common/sfc_efx/base/efx.h
index efefea717f..b4d8cfe9d8 100644
--- a/drivers/common/sfc_efx/base/efx.h
+++ b/drivers/common/sfc_efx/base/efx.h
@@ -4811,6 +4811,15 @@ efx_mae_encap_header_alloc(
__in size_t header_size,
__out efx_mae_eh_id_t *eh_idp);
+LIBEFX_API
+extern __checkReturn efx_rc_t
+efx_mae_encap_header_update(
+ __in efx_nic_t *enp,
+ __in efx_mae_eh_id_t *eh_idp,
+ __in efx_tunnel_protocol_t encap_type,
+ __in_bcount(header_size) const uint8_t *header_data,
+ __in size_t header_size);
+
LIBEFX_API
extern __checkReturn efx_rc_t
efx_mae_encap_header_free(
diff --git a/drivers/common/sfc_efx/base/efx_mae.c b/drivers/common/sfc_efx/base/efx_mae.c
index d36cdc71be..0d7b24d351 100644
--- a/drivers/common/sfc_efx/base/efx_mae.c
+++ b/drivers/common/sfc_efx/base/efx_mae.c
@@ -2937,6 +2937,86 @@ efx_mae_encap_header_alloc(
EFSYS_PROBE(fail6);
fail5:
EFSYS_PROBE(fail5);
+fail4:
+ EFSYS_PROBE(fail4);
+fail3:
+ EFSYS_PROBE(fail3);
+fail2:
+ EFSYS_PROBE(fail2);
+fail1:
+ EFSYS_PROBE1(fail1, efx_rc_t, rc);
+ return (rc);
+}
+
+ __checkReturn efx_rc_t
+efx_mae_encap_header_update(
+ __in efx_nic_t *enp,
+ __in efx_mae_eh_id_t *eh_idp,
+ __in efx_tunnel_protocol_t encap_type,
+ __in_bcount(header_size) const uint8_t *header_data,
+ __in size_t header_size)
+{
+ const efx_nic_cfg_t *encp = efx_nic_cfg_get(enp);
+ efx_mcdi_req_t req;
+ EFX_MCDI_DECLARE_BUF(payload,
+ MC_CMD_MAE_ENCAP_HEADER_UPDATE_IN_LENMAX_MCDI2,
+ MC_CMD_MAE_ENCAP_HEADER_UPDATE_OUT_LEN);
+ uint32_t encap_type_mcdi;
+ efx_rc_t rc;
+
+ if (encp->enc_mae_supported == B_FALSE) {
+ rc = ENOTSUP;
+ goto fail1;
+ }
+
+ switch (encap_type) {
+ case EFX_TUNNEL_PROTOCOL_NONE:
+ encap_type_mcdi = MAE_MCDI_ENCAP_TYPE_NONE;
+ break;
+ case EFX_TUNNEL_PROTOCOL_VXLAN:
+ encap_type_mcdi = MAE_MCDI_ENCAP_TYPE_VXLAN;
+ break;
+ case EFX_TUNNEL_PROTOCOL_GENEVE:
+ encap_type_mcdi = MAE_MCDI_ENCAP_TYPE_GENEVE;
+ break;
+ case EFX_TUNNEL_PROTOCOL_NVGRE:
+ encap_type_mcdi = MAE_MCDI_ENCAP_TYPE_NVGRE;
+ break;
+ default:
+ rc = ENOTSUP;
+ goto fail2;
+ }
+
+ if (header_size >
+ MC_CMD_MAE_ENCAP_HEADER_UPDATE_IN_HDR_DATA_MAXNUM_MCDI2) {
+ rc = EINVAL;
+ goto fail3;
+ }
+
+ req.emr_cmd = MC_CMD_MAE_ENCAP_HEADER_UPDATE;
+ req.emr_in_buf = payload;
+ req.emr_in_length = MC_CMD_MAE_ENCAP_HEADER_UPDATE_IN_LEN(header_size);
+ req.emr_out_buf = payload;
+ req.emr_out_length = MC_CMD_MAE_ENCAP_HEADER_UPDATE_OUT_LEN;
+
+ MCDI_IN_SET_DWORD(req,
+ MAE_ENCAP_HEADER_UPDATE_IN_EH_ID, eh_idp->id);
+
+ MCDI_IN_SET_DWORD(req,
+ MAE_ENCAP_HEADER_UPDATE_IN_ENCAP_TYPE, encap_type_mcdi);
+
+ memcpy(MCDI_IN2(req, uint8_t, MAE_ENCAP_HEADER_UPDATE_IN_HDR_DATA),
+ header_data, header_size);
+
+ efx_mcdi_execute(enp, &req);
+
+ if (req.emr_rc != 0) {
+ rc = req.emr_rc;
+ goto fail4;
+ }
+
+ return (0);
+
fail4:
EFSYS_PROBE(fail4);
fail3:
diff --git a/drivers/common/sfc_efx/version.map b/drivers/common/sfc_efx/version.map
index 40c97ad2b4..43e8e52ab9 100644
--- a/drivers/common/sfc_efx/version.map
+++ b/drivers/common/sfc_efx/version.map
@@ -123,6 +123,7 @@ INTERNAL {
efx_mae_counters_stream_stop;
efx_mae_encap_header_alloc;
efx_mae_encap_header_free;
+ efx_mae_encap_header_update;
efx_mae_fini;
efx_mae_get_limits;
efx_mae_init;
diff --git a/drivers/net/sfc/sfc_flow.c b/drivers/net/sfc/sfc_flow.c
index a35f20770d..1b50aefe5c 100644
--- a/drivers/net/sfc/sfc_flow.c
+++ b/drivers/net/sfc/sfc_flow.c
@@ -2864,6 +2864,40 @@ sfc_flow_action_handle_destroy(struct rte_eth_dev *dev,
return rc;
}
+static int
+sfc_flow_action_handle_update(struct rte_eth_dev *dev,
+ struct rte_flow_action_handle *handle,
+ const void *update, struct rte_flow_error *error)
+{
+ struct sfc_adapter *sa = sfc_adapter_by_eth_dev(dev);
+ struct rte_flow_action_handle *entry;
+ int rc = EINVAL;
+
+ sfc_adapter_lock(sa);
+
+ TAILQ_FOREACH(entry, &sa->flow_indir_actions, entries) {
+ if (entry != handle)
+ continue;
+
+ if (entry->transfer) {
+ rc = sfc_mae_indir_action_update(sa, handle,
+ update, error);
+ } else {
+ SFC_ASSERT(B_FALSE);
+ }
+
+ goto exit;
+ }
+
+ rc = rte_flow_error_set(error, ENOENT,
+ RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
+ "indirect action handle not found");
+
+exit:
+ sfc_adapter_unlock(sa);
+ return rc;
+}
+
static int
sfc_flow_action_handle_query(struct rte_eth_dev *dev,
const struct rte_flow_action_handle *handle,
@@ -2907,6 +2941,7 @@ const struct rte_flow_ops sfc_flow_ops = {
.isolate = sfc_flow_isolate,
.action_handle_create = sfc_flow_action_handle_create,
.action_handle_destroy = sfc_flow_action_handle_destroy,
+ .action_handle_update = sfc_flow_action_handle_update,
.action_handle_query = sfc_flow_action_handle_query,
.tunnel_decap_set = sfc_ft_decap_set,
.tunnel_match = sfc_ft_match,
diff --git a/drivers/net/sfc/sfc_mae.c b/drivers/net/sfc/sfc_mae.c
index 45a66307d2..2bfb918275 100644
--- a/drivers/net/sfc/sfc_mae.c
+++ b/drivers/net/sfc/sfc_mae.c
@@ -749,6 +749,50 @@ sfc_mae_encap_header_del(struct sfc_adapter *sa,
sfc_dbg(sa, "deleted encap_header=%p", encap_header);
}
+static int
+sfc_mae_encap_header_update(struct sfc_adapter *sa,
+ struct sfc_mae_encap_header *encap_header)
+{
+ const struct sfc_mae_bounce_eh *bounce_eh = &sa->mae.bounce_eh;
+ struct sfc_mae_fw_rsrc *fw_rsrc;
+ uint8_t *buf;
+ int ret;
+
+ if (bounce_eh->type != encap_header->type ||
+ bounce_eh->size == 0)
+ return EINVAL;
+
+ buf = rte_malloc("sfc_mae_encap_header_buf", bounce_eh->size, 0);
+ if (buf == NULL)
+ return ENOMEM;
+
+ rte_memcpy(buf, bounce_eh->buf, bounce_eh->size);
+
+ fw_rsrc = &encap_header->fw_rsrc;
+
+ if (fw_rsrc->refcnt > 0) {
+ SFC_ASSERT(fw_rsrc->eh_id.id != EFX_MAE_RSRC_ID_INVALID);
+
+ ret = efx_mae_encap_header_update(sa->nic, &fw_rsrc->eh_id,
+ encap_header->type, buf,
+ bounce_eh->size);
+ if (ret != 0) {
+ sfc_err(sa, "failed to update encap_header=%p: %s",
+ encap_header, strerror(ret));
+ rte_free(buf);
+ return ret;
+ }
+ }
+
+ encap_header->size = bounce_eh->size;
+ rte_free(encap_header->buf);
+ encap_header->buf = buf;
+
+ sfc_dbg(sa, "updated encap_header=%p", encap_header);
+
+ return 0;
+}
+
static int
sfc_mae_encap_header_enable(struct sfc_adapter *sa,
struct sfc_mae_encap_header *encap_header,
@@ -5288,6 +5332,50 @@ sfc_mae_indir_action_destroy(struct sfc_adapter *sa,
NULL, "indirect action is still in use");
}
+int
+sfc_mae_indir_action_update(struct sfc_adapter *sa,
+ struct rte_flow_action_handle *handle,
+ const void *update, struct rte_flow_error *error)
+{
+ const struct rte_flow_action *action = update;
+ struct sfc_mae *mae = &sa->mae;
+ bool custom_error = false;
+ int ret;
+
+ SFC_ASSERT(sfc_adapter_is_locked(sa));
+ SFC_ASSERT(action != NULL);
+ SFC_ASSERT(handle != NULL);
+
+ switch (handle->type) {
+ case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP:
+ /* Cleanup after previous encap. header bounce buffer usage. */
+ sfc_mae_bounce_eh_invalidate(&mae->bounce_eh);
+
+ ret = sfc_mae_rule_parse_action_vxlan_encap(mae, action->conf,
+ NULL, error);
+ if (ret != 0) {
+ custom_error = true;
+ break;
+ }
+
+ ret = sfc_mae_encap_header_update(sa, handle->encap_header);
+ break;
+ default:
+ ret = ENOTSUP;
+ }
+
+ if (custom_error)
+ return ret;
+
+ if (ret != 0) {
+ return rte_flow_error_set(error, ret,
+ RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
+ "failed to parse indirect action to mae object");
+ }
+
+ return 0;
+}
+
int
sfc_mae_indir_action_query(struct sfc_adapter *sa,
const struct rte_flow_action_handle *handle,
diff --git a/drivers/net/sfc/sfc_mae.h b/drivers/net/sfc/sfc_mae.h
index 4b928f876b..7f4c3324bd 100644
--- a/drivers/net/sfc/sfc_mae.h
+++ b/drivers/net/sfc/sfc_mae.h
@@ -422,6 +422,11 @@ int sfc_mae_indir_action_destroy(struct sfc_adapter *sa,
const struct rte_flow_action_handle *handle,
struct rte_flow_error *error);
+int sfc_mae_indir_action_update(struct sfc_adapter *sa,
+ struct rte_flow_action_handle *handle,
+ const void *update,
+ struct rte_flow_error *error);
+
int sfc_mae_indir_action_query(struct sfc_adapter *sa,
const struct rte_flow_action_handle *handle,
void *data, struct rte_flow_error *error);
--
2.31.1
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows
2023-08-10 18:06 [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows Ivan Malov
2023-08-10 18:06 ` [PATCH 2/2] net/sfc: support updating indirect VXLAN encap action Ivan Malov
@ 2023-09-21 15:42 ` Ferruh Yigit
2023-09-22 6:32 ` Andrew Rybchenko
2 siblings, 0 replies; 6+ messages in thread
From: Ferruh Yigit @ 2023-09-21 15:42 UTC (permalink / raw)
To: Ivan Malov, dev; +Cc: Andrew Rybchenko, Andy Moreton
On 8/10/2023 7:06 PM, Ivan Malov wrote:
> Parsing inline action VXLAN_ENCAP repeating in many flows is
> expensive, so offer support for its indirect version. Query
> operation is not supported for this action. The next patch
> will add a means to update the encapsulation header data.
>
> Signed-off-by: Ivan Malov <ivan.malov@arknetworks.am>
> Reviewed-by: Andy Moreton <andy.moreton@amd.com>
>
Hi Andrew,
Are you planning to review the set, or do you want me proceed with
Andy's review. Please advise how to progress.
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows
2023-08-10 18:06 [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows Ivan Malov
2023-08-10 18:06 ` [PATCH 2/2] net/sfc: support updating indirect VXLAN encap action Ivan Malov
2023-09-21 15:42 ` [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows Ferruh Yigit
@ 2023-09-22 6:32 ` Andrew Rybchenko
2023-09-22 9:34 ` Ferruh Yigit
2 siblings, 1 reply; 6+ messages in thread
From: Andrew Rybchenko @ 2023-09-22 6:32 UTC (permalink / raw)
To: Ivan Malov, dev; +Cc: Ferruh Yigit, Andy Moreton
On 8/10/23 21:06, Ivan Malov wrote:
> Parsing inline action VXLAN_ENCAP repeating in many flows is
> expensive, so offer support for its indirect version. Query
> operation is not supported for this action. The next patch
> will add a means to update the encapsulation header data.
>
> Signed-off-by: Ivan Malov <ivan.malov@arknetworks.am>
> Reviewed-by: Andy Moreton <andy.moreton@amd.com>
Acked-by: Andrew Rybchenko <andrew.rybchenko@oktetlabs.ru>
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] net/sfc: support updating indirect VXLAN encap action
2023-08-10 18:06 ` [PATCH 2/2] net/sfc: support updating indirect VXLAN encap action Ivan Malov
@ 2023-09-22 6:33 ` Andrew Rybchenko
0 siblings, 0 replies; 6+ messages in thread
From: Andrew Rybchenko @ 2023-09-22 6:33 UTC (permalink / raw)
To: Ivan Malov, dev; +Cc: Ferruh Yigit, Andy Moreton
On 8/10/23 21:06, Ivan Malov wrote:
> Such updates are helpful as they let applications avoid
> costly flow re-insertions when the header data changes.
>
> Signed-off-by: Ivan Malov <ivan.malov@arknetworks.am>
> Reviewed-by: Andy Moreton <andy.moreton@amd.com>
Acked-by: Andrew Rybchenko <andrew.rybchenko@oktetlabs.ru>
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows
2023-09-22 6:32 ` Andrew Rybchenko
@ 2023-09-22 9:34 ` Ferruh Yigit
0 siblings, 0 replies; 6+ messages in thread
From: Ferruh Yigit @ 2023-09-22 9:34 UTC (permalink / raw)
To: Andrew Rybchenko, Ivan Malov, dev; +Cc: Andy Moreton
On 9/22/2023 7:32 AM, Andrew Rybchenko wrote:
> On 8/10/23 21:06, Ivan Malov wrote:
>> Parsing inline action VXLAN_ENCAP repeating in many flows is
>> expensive, so offer support for its indirect version. Query
>> operation is not supported for this action. The next patch
>> will add a means to update the encapsulation header data.
>>
>> Signed-off-by: Ivan Malov <ivan.malov@arknetworks.am>
>> Reviewed-by: Andy Moreton <andy.moreton@amd.com>
>
> Acked-by: Andrew Rybchenko <andrew.rybchenko@oktetlabs.ru>
>
>
Series applied to dpdk-next-net/main, thanks.
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2023-09-22 9:34 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-08-10 18:06 [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows Ivan Malov
2023-08-10 18:06 ` [PATCH 2/2] net/sfc: support updating indirect VXLAN encap action Ivan Malov
2023-09-22 6:33 ` Andrew Rybchenko
2023-09-21 15:42 ` [PATCH 1/2] net/sfc: offer indirect VXLAN encap action in transfer flows Ferruh Yigit
2023-09-22 6:32 ` Andrew Rybchenko
2023-09-22 9:34 ` Ferruh Yigit
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).