lib/ethdev: support inline calculating masked item value

-----Original Message-----
From: Stephen Hemminger <[email protected]>
Sent: Tuesday, November 18, 2025 1:25 AM
To: Bing Zhao <[email protected]>
Cc: Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU-Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: Re: [PATCH 1/2] lib/ethdev: support inline calculating masked item value

External email: Use caution opening links or attachments

lib/ethdev/rte_flow.c rte_flow_conv_action_conf(void *buf, const size_t

Quoted 5 lines · On Mon, 17 Nov 2025 09:54:07 +0200 Bing Zhao <[email protected]> wrote:

lib/ethdev/rte_flow.c index renamed from lib/ethdev/rte_flow.c +0 -0

fe8f43caff..b94f0e304d 100644

lib/ethdev/rte_flow.c +0 -0

@@ -831,6 +831,8 @@ rte_flow_conv_action_conf(void *buf, const size_t

size,

lib/ethdev/rte_flow.c rte_flow_conv_action_conf(void *buf, const size_t size, · line 838

Quoted 8 lines

lib/ethdev/rte_flow.c +2 -0

  *   RTE_FLOW_ITEM_TYPE_END is encountered.
  * @param[out] error
  *   Perform verbose error reporting if not NULL.
+ * @param[in] with_mask
+ *   If true, @p src mask will be applied to spec and last.
  *
  * @return
  *   A positive value representing the number of bytes needed to store

Sorry, this patch is submitted too late to make it into 25.11 release. Missing any release note.

This would be a good example of where to use API versioning in a later release.

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

---

-----Original Message-----
From: Stephen Hemminger <[email protected]>
Sent: Friday, February 6, 2026 12:43 AM
To: Bing Zhao <[email protected]>
Cc: Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU-Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: Re: [PATCH 1/2] lib/ethdev: support inline calculating masked item value

External email: Use caution opening links or attachments

Quoted 10 lines · On Mon, 17 Nov 2025 09:54:07 +0200 Bing Zhao <[email protected]> wrote:

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

Quoted 6 lines

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

---

Looked at this patch again:
1. No API/ABI breakage adding a single flow type is going to work great. rte_flow_conv_pattern is internal so changing is no
problem.
2. No need for release note for single flow change.

3. Do need a test to cover the new code. I know rte_flow is way under
tested
right now. Maybe a chance to use AI to generate a unit test for
rte_flow.
This is important because it is a bug trap to add code that is not
covered.

-----Original Message-----
From: Bing Zhao <[email protected]>
Sent: Monday, February 9, 2026 12:24 PM
To: Stephen Hemminger <[email protected]>
Cc: Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU-Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: RE: [PATCH 1/2] lib/ethdev: support inline calculating masked item value

Sure. I will add some tests.

Quoted 47 lines

-----Original Message-----
From: Stephen Hemminger <[email protected]>
Sent: Friday, February 6, 2026 12:43 AM
To: Bing Zhao <[email protected]>
Cc: Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU-Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: Re: [PATCH 1/2] lib/ethdev: support inline calculating masked item value

External email: Use caution opening links or attachments

Quoted 10 lines · On Mon, 17 Nov 2025 09:54:07 +0200 Bing Zhao <[email protected]> wrote:

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

Quoted 6 lines

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

---

Looked at this patch again:
1. No API/ABI breakage adding a single flow type is going to work great. rte_flow_conv_pattern is internal so changing is
no problem.
2. No need for release note for single flow change.

3. Do need a test to cover the new code. I know rte_flow is way
under tested
right now. Maybe a chance to use AI to generate a unit test for
rte_flow.
This is important because it is a bug trap to add code that is
not covered.

Hi Stephen,

Since there is no UT for the flow API. Such application would require some design discussions, and it is too short for -rc1. Could we focus on the change itself and try to close it? Thanks a lot.

Quoted 2 lines · On Mon, 9 Feb 2026 14:17:27 +0000 Bing Zhao <[email protected]> wrote:

Hi Stephen,

Quoted 4 lines

Since there is no UT for the flow API.
Such application would require some design discussions,
and it is too short for -rc1.
Could we focus on the change itself and try to close it? Thanks a lot.

I have discovered that AI does pretty good job of generating basic tests. That is all we need to get some basic CI coverage.

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

Reviewed-by Dariusz Sosnowski <[email protected]>

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

---

Subject: [PATCH v4] ethdev: support inline calculating masked item value

-----Original Message-----
From: Stephen Hemminger <[email protected]>
Sent: Monday, June 8, 2026 11:46 PM
To: Bing Zhao <[email protected]>
Cc: Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU-Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: Re: [PATCH v4] ethdev: support inline calculating masked item value

External email: Use caution opening links or attachments

Quoted 10 lines · On Wed, 3 Jun 2026 12:28:05 +0300 Bing Zhao <[email protected]> wrote:

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

Quoted 6 lines

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

---

More detailed AI review found some things that still need addressing.

Quoted 2 lines · Bing Zhao

Subject: [PATCH v4] ethdev: support inline calculating masked item value

Error: byte-wise masking corrupts embedded pointers in deep-copy item types (RAW, FLEX, GENEVE_OPT).

In rte_flow_conv_pattern(), the new mask application runs over the fixed item struct:

size_t item_mask_size = mask ? rte_flow_conv_item_mask_size(src) :

0;
        ...
        size_t mask_size = RTE_MIN(ret, item_mask_size);

        for (j = 0; j < mask_size; j++)
                c_spec[j] &= mask[j];

item_mask_size is rte_flow_desc_item[type].size, the size of the fixed item struct. For RTE_FLOW_ITEM_TYPE_RAW, FLEX, and GENEVE_OPT, that fixed struct ends in an embedded pointer that rte_flow_conv_item_spec() has just populated to point at the deep-copied trailing data (rte_flow_item_raw.pattern, rte_flow_item_flex.pattern, rte_flow_item_geneve_opt.data). Because the masked range covers the whole fixed struct, the loop ANDs the bytes of that pointer with the mask's corresponding bytes (typically a NULL mask pointer), zeroing or garbling it.

The converted item's pattern/data pointer is clobbered while the copied payload it should reference is left unreachable. A consumer that follows conv->pattern then dereferences NULL or a corrupt address. Plain value conv->items
(eth, ipv4, ...) are unaffected; only the deep-copy item types break, which is exactly what the test does not exercise.

Suggested fix: do not blind-mask the entire fixed struct for items that carry an embedded pointer / desc_fn deep copy. Either skip masking when rte_flow_desc_item[type].desc_fn != NULL, or mask only the leading plain- data region and leave the pointer field (and trailing copied bytes) intact.

Warning: the new test validates only an ETH pattern, so the RAW/FLEX/GENEVE_OPT path above is untested. A RAW item case would have surfaced the pointer corruption.

Info: the Doxygen block for RTE_FLOW_CONV_OP_PATTERN_MASKED uses @p mask, @p spec, @p last, but those are item fields, not parameters of the op; the neighboring enum entries only document the @p src / @p dst types.

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

Acked-by Dariusz Sosnowski <[email protected]>

---

Subject: [PATCH v5] ethdev: support inline calculating masked item value
v5: handle some items separately and add test for them

-----Original Message-----
From: Bing Zhao <[email protected]>
Sent: Wednesday, June 10, 2026 1:27 PM
To: Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; [email protected]
Cc: Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU- Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: [PATCH v5] ethdev: support inline calculating masked item value

External email: Use caution opening links or attachments

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

Acked-by Dariusz Sosnowski <[email protected]>

---
v3:
- add test code
- fix the issue found by AI
v4: reabse on top of the main
v5: handle some items separately and add test for them

---
 app/test/test_ethdev_api.c             | 76 ++++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_07.rst |  6 ++
 lib/ethdev/rte_flow.c                  | 46 ++++++++++++++--
 lib/ethdev/rte_flow.h                  | 13 +++++
 4 files changed, 135 insertions(+), 6 deletions(-)

app/test/test_ethdev_api.c index renamed from app/test/test_ethdev_api.c +0 -0

76afd0345c..5cae1cdc1d 100644

app/test/test_ethdev_api.c +12 -0

@@ -4,6 +4,7 @@
 
 #include <rte_log.h>
 #include <rte_ethdev.h>
+#include <rte_flow.h>
 
 #include <rte_test.h>
 #include "test.h"

@@ -15,6 +16,80 @@
 #define NUM_MBUF 1024
 #define MBUF_CACHE_SIZE 256
 
+static int32_t
+ethdev_api_flow_conv_pattern_masked(void)
+{
+       const struct rte_flow_item_eth spec = {
+               .hdr.dst_addr.addr_bytes = { 0x01, 0x02, 0x03, 0x04, 0x05,
 0x06 },
+               .hdr.src_addr.addr_bytes = { 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 0x0f },
+               .hdr.ether_type = RTE_BE16(0x1234),
+       };
+       const struct rte_flow_item_eth last = {
+               .hdr.dst_addr.addr_bytes = { 0x11, 0x12, 0x13, 0x14, 0x15,
 0x16 },
+               .hdr.src_addr.addr_bytes = { 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,

0x1f },

app/test/test_ethdev_api.c +4 -0

+               .hdr.ether_type = RTE_BE16(0x5678),
+       };
+       const struct rte_flow_item_eth mask = {
+               .hdr.dst_addr.addr_bytes = { 0xff, 0xff, 0x00, 0x00, 0xff,

0xff },
+ .hdr.src_addr.addr_bytes = { 0xff, 0x00, 0xff, 0x00, 0xff,
0x00 },

app/test/test_ethdev_api.c +23 -0

+               .hdr.ether_type = RTE_BE16(0xffff),
+       };
+       const struct rte_flow_item pattern[] = {
+               {
+                       .type = RTE_FLOW_ITEM_TYPE_ETH,
+                       .spec = &spec,
+                       .last = &last,
+                       .mask = &mask,
+               },
+               { .type = RTE_FLOW_ITEM_TYPE_END },
+       };
+       union {
+               struct rte_flow_item item;
+               struct rte_flow_item_eth eth;
+               double align;
+               uint8_t raw[256];
+       } dst;
+       const struct rte_flow_item *item;
+       const struct rte_flow_item_eth *conv_spec;
+       const struct rte_flow_item_eth *conv_last;
+       int ret;
+
+       ret = rte_flow_conv(RTE_FLOW_CONV_OP_PATTERN_MASKED, NULL, 0,

pattern, NULL);
+ TEST_ASSERT(ret > 0, "Masked pattern conversion size query
failed");

app/test/test_ethdev_api.c +35 -0

+       TEST_ASSERT((size_t)ret <= sizeof(dst.raw),
+                   "Masked pattern conversion needs too much storage");
+
+       memset(&dst, 0, sizeof(dst));
+       ret = rte_flow_conv(RTE_FLOW_CONV_OP_PATTERN_MASKED, dst.raw,
+                           sizeof(dst.raw), pattern, NULL);
+       TEST_ASSERT(ret > 0, "Masked pattern conversion failed");
+
+       item = (const struct rte_flow_item *)dst.raw;
+       conv_spec = item[0].spec;
+       conv_last = item[0].last;
+       TEST_ASSERT_NOT_NULL(conv_spec, "Converted spec must be set");
+       TEST_ASSERT_NOT_NULL(conv_last, "Converted last must be set");
+
+       TEST_ASSERT_EQUAL(conv_spec->hdr.dst_addr.addr_bytes[0], 0x01,
+                         "Masked spec dst byte 0 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.dst_addr.addr_bytes[2], 0x00,
+                         "Masked spec dst byte 2 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.src_addr.addr_bytes[1], 0x00,
+                         "Masked spec src byte 1 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.ether_type, RTE_BE16(0x1234),
+                         "Masked spec ether type mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.dst_addr.addr_bytes[0], 0x11,
+                         "Masked last dst byte 0 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.dst_addr.addr_bytes[2], 0x00,
+                         "Masked last dst byte 2 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.src_addr.addr_bytes[1], 0x00,
+                         "Masked last src byte 1 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.ether_type, RTE_BE16(0x5678),
+                         "Masked last ether type mismatch");
+
+       return TEST_SUCCESS;
+}
+
 static int32_t
 ethdev_api_queue_status(void)
 {

@@ -167,6 +242,7 @@ static struct unit_test_suite ethdev_api_testsuite = {
        .setup = NULL,
        .teardown = NULL,
        .unit_test_cases = {
+               TEST_CASE(ethdev_api_flow_conv_pattern_masked),
                TEST_CASE(ethdev_api_queue_status),
                /* TODO: Add deferred_start queue status test */
                TEST_CASES_END() /**< NULL terminate unit test array */

doc/guides/rel_notes/release_26_07.rst +6 -0

index b5285af5fe..4f5d21d576 100644
@@ -190,6 +190,12 @@ API Changes
   - ``rte_pmd_mlx5_enable_steering``
   - ``rte_pmd_mlx5_disable_steering``
 
+* ethdev: Added masked pattern conversion.
+
+  Added ``RTE_FLOW_CONV_OP_PATTERN_MASKED`` to ``rte_flow_conv()``  to
+ copy an entire pattern while applying each item's mask to its
+ ``spec`` and ``last`` fields.
+
 
 ABI Changes
 -----------

lib/ethdev/rte_flow.c index renamed from lib/ethdev/rte_flow.c +0 -0

ec0fe08355..c7a94a1194 100644

lib/ethdev/rte_flow.c +7 -0

@@ -178,6 +178,14 @@ static const struct rte_flow_desc_data
 rte_flow_desc_item[] = {
        MK_FLOW_ITEM(COMPARE, sizeof(struct rte_flow_item_compare)),  };
 
+static inline size_t
+rte_flow_conv_item_mask_size(const struct rte_flow_item *item) {
+       if ((int)item->type >= 0)
+               return rte_flow_desc_item[item->type].size;
+       return sizeof(void *);
+}
+
 /** Generate flow_action[] entry. */
 #define MK_FLOW_ACTION(t, s) \
        [RTE_FLOW_ACTION_TYPE_ ## t] = { \ @@ -835,6 +843,8 @@

rte_flow_conv_action_conf(void *buf, const size_t size,
* RTE_FLOW_ITEM_TYPE_END is encountered.
* @param[out] error
* Perform verbose error reporting if not NULL.
+ * @param[in] with_mask
+ * If true, @p src mask will be applied to spec and last.
*
* @return
* A positive value representing the number of bytes needed to store

lib/ethdev/rte_flow.c +27 -3

@@ -847,12 +857,13 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
                      const size_t size,
                      const struct rte_flow_item *src,
                      unsigned int num,
+                     bool with_mask,
                      struct rte_flow_error *error)  {
        uintptr_t data = (uintptr_t)dst;
        size_t off;
        size_t ret;
-       unsigned int i;
+       unsigned int i, j;
 
        for (i = 0, off = 0; !num || i != num; ++i, ++src, ++dst) {
                /**

@@ -876,15 +887,27 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
        src -= num;
        dst -= num;
        do {
+               uint8_t *c_spec = NULL, *c_last = NULL;
+               const uint8_t *mask = src->mask;
+               size_t item_mask_size = mask ?
+ rte_flow_conv_item_mask_size(src) : 0;
+
                if (src->spec) {
                        off = RTE_ALIGN_CEIL(off, sizeof(double));
                        ret = rte_flow_conv_item_spec
                                ((void *)(data + off),
                                 size > off ? size - off : 0, src,
                                 RTE_FLOW_CONV_ITEM_SPEC);
-                       if (size && size >= off + ret)
+                       if (size && size >= off + ret) {
                                dst->spec = (void *)(data + off);
+                               c_spec = (uint8_t *)(data + off);
+                       }
                        off += ret;
+                       if (with_mask && c_spec && mask) {
+                               size_t mask_size = RTE_MIN(ret,
+ item_mask_size);
+
+                               for (j = 0; j < mask_size; j++)
+                                       c_spec[j] &= mask[j];
+                       }
 
                }
                if (src->last) {

@@ -893,9 +916,17 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
                                ((void *)(data + off),
                                 size > off ? size - off : 0, src,
                                 RTE_FLOW_CONV_ITEM_LAST);
-                       if (size && size >= off + ret)
+                       if (size && size >= off + ret) {
                                dst->last = (void *)(data + off);
+                               c_last = (uint8_t *)(data + off);
+                       }
                        off += ret;
+                       if (with_mask && c_last && mask) {
+                               size_t mask_size = RTE_MIN(ret,
+ item_mask_size);
+
+                               for (j = 0; j < mask_size; j++)
+                                       c_last[j] &= mask[j];
+                       }
                }
                if (src->mask) {
                        off = RTE_ALIGN_CEIL(off, sizeof(double)); @@ -

1042,7 +1073,7 @@ rte_flow_conv_rule(struct rte_flow_conv_rule *dst,
off = RTE_ALIGN_CEIL(off, sizeof(double)); ret = rte_flow_conv_pattern((void *)((uintptr_t)dst +
off),
size > off ? size - off : 0,

lib/ethdev/rte_flow.c +2 -1

-                                           src->pattern_ro, 0, error);
+                                           src->pattern_ro, 0, false,
+ error);
                if (ret < 0)
                        return ret;
                if (size && size >= off + (size_t)ret) @@ -1143,7 +1174,7

@@ rte_flow_conv(enum rte_flow_conv_op op,

                ret = sizeof(*attr);
                break;
        case RTE_FLOW_CONV_OP_ITEM:

lib/ethdev/rte_flow.c +6 -3

-               ret = rte_flow_conv_pattern(dst, size, src, 1, error);
+               ret = rte_flow_conv_pattern(dst, size, src, 1, false,
+ error);
                break;
        case RTE_FLOW_CONV_OP_ITEM_MASK:
                item = src;

@@ -1158,7 +1189,7 @@ rte_flow_conv(enum rte_flow_conv_op op,
                ret = rte_flow_conv_actions(dst, size, src, 1, error);
                break;
        case RTE_FLOW_CONV_OP_PATTERN:
-               ret = rte_flow_conv_pattern(dst, size, src, 0, error);
+               ret = rte_flow_conv_pattern(dst, size, src, 0, false,
+ error);
                break;
        case RTE_FLOW_CONV_OP_ACTIONS:
                ret = rte_flow_conv_actions(dst, size, src, 0, error); @@
-1178,6 +1209,9 @@ rte_flow_conv(enum rte_flow_conv_op op,
        case RTE_FLOW_CONV_OP_ACTION_NAME_PTR:
                ret = rte_flow_conv_name(1, 1, dst, size, src, error);
                break;
+       case RTE_FLOW_CONV_OP_PATTERN_MASKED:
+               ret = rte_flow_conv_pattern(dst, size, src, 0, true,

error);

lib/ethdev/rte_flow.c +1 -0

+               break;
        default:
                ret = rte_flow_error_set
                (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,

lib/ethdev/rte_flow.h index renamed from lib/ethdev/rte_flow.h +0 -0

b495409406..959a2f903b 100644

lib/ethdev/rte_flow.h +5 -0

@@ -4556,6 +4556,19 @@ enum rte_flow_conv_op {
         *   @code const char ** @endcode
         */
        RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
+
+       /**
+        * Convert an entire pattern.
+        *
+        * Duplicates all pattern items at once, applying @p mask to @p

spec

lib/ethdev/rte_flow.h +8 -1

+        * and @p last.
+        *
+        * - @p src type:
+        *   @code const struct rte_flow_item * @endcode
+        * - @p dst type:
+        *   @code struct rte_flow_item * @endcode
+        */
+       RTE_FLOW_CONV_OP_PATTERN_MASKED,
 };
 
 /**
--

2.34.1

-----Original Message-----
From: Bing Zhao
Sent: Thursday, June 11, 2026 12:55 PM
To: 'Bing Zhao' <[email protected]>; Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; [email protected]
Cc: Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU- Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: RE: [PATCH v5] ethdev: support inline calculating masked item value

Hi,

In my local code,

lib/ethdev/rte_flow.c index renamed from lib/ethdev/rte_flow.c +0 -0

7cf9f6f6f3..7a2721af00 100644

lib/ethdev/rte_flow.c +0 -0

@@ -181,9 +181,18 @@ static const struct rte_flow_desc_data

rte_flow_desc_item[] = { static inline size_t rte_flow_conv_item_mask_size(const struct rte_flow_item *item) {

lib/ethdev/rte_flow.c +11 -2

-       if ((int)item->type >= 0)
+       if ((int)item->type < 0)
+               return sizeof(void *);
+       switch (item->type) {
+       case RTE_FLOW_ITEM_TYPE_RAW:
+               return offsetof(struct rte_flow_item_raw, pattern);
+       case RTE_FLOW_ITEM_TYPE_GENEVE_OPT:
+               return offsetof(struct rte_flow_item_geneve_opt, data);
+       default:
+               if (rte_flow_desc_item[item->type].desc_fn != NULL)
+                       return 0;
                return rte_flow_desc_item[item->type].size;
-       return sizeof(void *);
+       }
 }

// This is the code before my latest change.

Review

Quoted 7 lines

(quoted diff) +7 -0

+static inline size_t
+rte_flow_conv_item_mask_size(const struct rte_flow_item *item) {
+       if ((int)item->type >= 0)
+               return rte_flow_desc_item[item->type].size;
+       return sizeof(void *);
+}
+

I didn't understand why the patch I sent is still using the old code.

app/test/test_ethdev_api.c static struct unit_test_suite ethdev_api_testsuite =

Quoted 153 lines

-----Original Message-----
From: Bing Zhao <[email protected]>
Sent: Wednesday, June 10, 2026 1:27 PM
To: Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; [email protected]
Cc: Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU- Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: [PATCH v5] ethdev: support inline calculating masked item value

External email: Use caution opening links or attachments

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

Acked-by Dariusz Sosnowski <[email protected]>

---
v3:
- add test code
- fix the issue found by AI
v4: reabse on top of the main
v5: handle some items separately and add test for them

---
 app/test/test_ethdev_api.c             | 76 ++++++++++++++++++++++++++
 doc/guides/rel_notes/release_26_07.rst |  6 ++
 lib/ethdev/rte_flow.c                  | 46 ++++++++++++++--
 lib/ethdev/rte_flow.h                  | 13 +++++
 4 files changed, 135 insertions(+), 6 deletions(-)

app/test/test_ethdev_api.c +16 -0

index 76afd0345c..5cae1cdc1d 100644
@@ -4,6 +4,7 @@
 
 #include <rte_log.h>
 #include <rte_ethdev.h>
+#include <rte_flow.h>
 
 #include <rte_test.h>
 #include "test.h"

@@ -15,6 +16,80 @@
 #define NUM_MBUF 1024
 #define MBUF_CACHE_SIZE 256
 
+static int32_t
+ethdev_api_flow_conv_pattern_masked(void)
+{
+       const struct rte_flow_item_eth spec = {
+               .hdr.dst_addr.addr_bytes = { 0x01, 0x02, 0x03, 0x04,
+0x05,
 0x06 },
+               .hdr.src_addr.addr_bytes = { 0x0a, 0x0b, 0x0c, 0x0d,
+ 0x0e,
 0x0f },
+               .hdr.ether_type = RTE_BE16(0x1234),
+       };
+       const struct rte_flow_item_eth last = {
+               .hdr.dst_addr.addr_bytes = { 0x11, 0x12, 0x13, 0x14,
+ 0x15,
 0x16 },
+               .hdr.src_addr.addr_bytes = { 0x1a, 0x1b, 0x1c, 0x1d,
+ 0x1e,

0x1f },

app/test/test_ethdev_api.c +5 -0

+               .hdr.ether_type = RTE_BE16(0x5678),
+       };
+       const struct rte_flow_item_eth mask = {
+               .hdr.dst_addr.addr_bytes = { 0xff, 0xff, 0x00, 0x00,
+ 0xff,

0xff },
+ .hdr.src_addr.addr_bytes = { 0xff, 0x00, 0xff, 0x00,
+ 0xff,
0x00 },

app/test/test_ethdev_api.c +23 -0

+               .hdr.ether_type = RTE_BE16(0xffff),
+       };
+       const struct rte_flow_item pattern[] = {
+               {
+                       .type = RTE_FLOW_ITEM_TYPE_ETH,
+                       .spec = &spec,
+                       .last = &last,
+                       .mask = &mask,
+               },
+               { .type = RTE_FLOW_ITEM_TYPE_END },
+       };
+       union {
+               struct rte_flow_item item;
+               struct rte_flow_item_eth eth;
+               double align;
+               uint8_t raw[256];
+       } dst;
+       const struct rte_flow_item *item;
+       const struct rte_flow_item_eth *conv_spec;
+       const struct rte_flow_item_eth *conv_last;
+       int ret;
+
+       ret = rte_flow_conv(RTE_FLOW_CONV_OP_PATTERN_MASKED, NULL, 0,

pattern, NULL);
+ TEST_ASSERT(ret > 0, "Masked pattern conversion size query
failed");

app/test/test_ethdev_api.c +35 -0

+       TEST_ASSERT((size_t)ret <= sizeof(dst.raw),
+                   "Masked pattern conversion needs too much
+ storage");
+
+       memset(&dst, 0, sizeof(dst));
+       ret = rte_flow_conv(RTE_FLOW_CONV_OP_PATTERN_MASKED, dst.raw,
+                           sizeof(dst.raw), pattern, NULL);
+       TEST_ASSERT(ret > 0, "Masked pattern conversion failed");
+
+       item = (const struct rte_flow_item *)dst.raw;
+       conv_spec = item[0].spec;
+       conv_last = item[0].last;
+       TEST_ASSERT_NOT_NULL(conv_spec, "Converted spec must be set");
+       TEST_ASSERT_NOT_NULL(conv_last, "Converted last must be set");
+
+       TEST_ASSERT_EQUAL(conv_spec->hdr.dst_addr.addr_bytes[0], 0x01,
+                         "Masked spec dst byte 0 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.dst_addr.addr_bytes[2], 0x00,
+                         "Masked spec dst byte 2 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.src_addr.addr_bytes[1], 0x00,
+                         "Masked spec src byte 1 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.ether_type, RTE_BE16(0x1234),
+                         "Masked spec ether type mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.dst_addr.addr_bytes[0], 0x11,
+                         "Masked last dst byte 0 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.dst_addr.addr_bytes[2], 0x00,
+                         "Masked last dst byte 2 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.src_addr.addr_bytes[1], 0x00,
+                         "Masked last src byte 1 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.ether_type, RTE_BE16(0x5678),
+                         "Masked last ether type mismatch");
+
+       return TEST_SUCCESS;
+}
+
 static int32_t
 ethdev_api_queue_status(void)
 {

@@ -167,6 +242,7 @@ static struct unit_test_suite ethdev_api_testsuite =

{

Quoted 190 lines

app/test/test_ethdev_api.c +1 -0

        .setup = NULL,
        .teardown = NULL,
        .unit_test_cases = {
+               TEST_CASE(ethdev_api_flow_conv_pattern_masked),
                TEST_CASE(ethdev_api_queue_status),
                /* TODO: Add deferred_start queue status test */
                TEST_CASES_END() /**< NULL terminate unit test array

*/ diff --git a/doc/guides/rel_notes/release_26_07.rst b/doc/guides/rel_notes/release_26_07.rst index b5285af5fe..4f5d21d576 100644

doc/guides/rel_notes/release_26_07.rst +6 -0

@@ -190,6 +190,12 @@ API Changes
   - ``rte_pmd_mlx5_enable_steering``
   - ``rte_pmd_mlx5_disable_steering``
 
+* ethdev: Added masked pattern conversion.
+
+  Added ``RTE_FLOW_CONV_OP_PATTERN_MASKED`` to ``rte_flow_conv()``
+ to copy an entire pattern while applying each item's mask to its
+ ``spec`` and ``last`` fields.
+
 
 ABI Changes
 -----------

lib/ethdev/rte_flow.c index renamed from lib/ethdev/rte_flow.c +0 -0

ec0fe08355..c7a94a1194 100644

lib/ethdev/rte_flow.c +7 -0

@@ -178,6 +178,14 @@ static const struct rte_flow_desc_data
 rte_flow_desc_item[] = {
        MK_FLOW_ITEM(COMPARE, sizeof(struct rte_flow_item_compare)),
 };
 
+static inline size_t
+rte_flow_conv_item_mask_size(const struct rte_flow_item *item) {
+       if ((int)item->type >= 0)
+               return rte_flow_desc_item[item->type].size;
+       return sizeof(void *);
+}
+
 /** Generate flow_action[] entry. */
 #define MK_FLOW_ACTION(t, s) \
        [RTE_FLOW_ACTION_TYPE_ ## t] = { \ @@ -835,6 +843,8 @@

rte_flow_conv_action_conf(void *buf, const size_t size,
* RTE_FLOW_ITEM_TYPE_END is encountered.
* @param[out] error
* Perform verbose error reporting if not NULL.
+ * @param[in] with_mask
+ * If true, @p src mask will be applied to spec and last.
*
* @return
* A positive value representing the number of bytes needed to store

lib/ethdev/rte_flow.c +27 -4

@@ -847,12 +857,13 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
                      const size_t size,
                      const struct rte_flow_item *src,
                      unsigned int num,
+                     bool with_mask,
                      struct rte_flow_error *error)  {
        uintptr_t data = (uintptr_t)dst;
        size_t off;
        size_t ret;
-       unsigned int i;
+       unsigned int i, j;
 
        for (i = 0, off = 0; !num || i != num; ++i, ++src, ++dst) {
                /**

@@ -876,15 +887,27 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
        src -= num;
        dst -= num;
        do {
+               uint8_t *c_spec = NULL, *c_last = NULL;
+               const uint8_t *mask = src->mask;
+               size_t item_mask_size = mask ?
+ rte_flow_conv_item_mask_size(src) : 0;
+
                if (src->spec) {
                        off = RTE_ALIGN_CEIL(off, sizeof(double));
                        ret = rte_flow_conv_item_spec
                                ((void *)(data + off),
                                 size > off ? size - off : 0, src,
                                 RTE_FLOW_CONV_ITEM_SPEC);
-                       if (size && size >= off + ret)
+                       if (size && size >= off + ret) {
                                dst->spec = (void *)(data + off);
+                               c_spec = (uint8_t *)(data + off);
+                       }
                        off += ret;
+                       if (with_mask && c_spec && mask) {
+                               size_t mask_size = RTE_MIN(ret,
+ item_mask_size);
+
+                               for (j = 0; j < mask_size; j++)
+                                       c_spec[j] &= mask[j];
+                       }
 
                }
                if (src->last) {

@@ -893,9 +916,17 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
                                ((void *)(data + off),
                                 size > off ? size - off : 0, src,
                                 RTE_FLOW_CONV_ITEM_LAST);
-                       if (size && size >= off + ret)
+                       if (size && size >= off + ret) {
                                dst->last = (void *)(data + off);
+                               c_last = (uint8_t *)(data + off);
+                       }
                        off += ret;
+                       if (with_mask && c_last && mask) {
+                               size_t mask_size = RTE_MIN(ret,
+ item_mask_size);
+
+                               for (j = 0; j < mask_size; j++)
+                                       c_last[j] &= mask[j];
+                       }
                }
                if (src->mask) {
                        off = RTE_ALIGN_CEIL(off, sizeof(double)); @@
-

1042,7 +1073,7 @@ rte_flow_conv_rule(struct rte_flow_conv_rule *dst,
off = RTE_ALIGN_CEIL(off, sizeof(double)); ret = rte_flow_conv_pattern((void *)((uintptr_t)dst +
off),
size > off ? size - off : 0,

lib/ethdev/rte_flow.c +7 -3

-                                           src->pattern_ro, 0, error);
+                                           src->pattern_ro, 0, false,
+ error);
                if (ret < 0)
                        return ret;
                if (size && size >= off + (size_t)ret) @@ -1143,7
+1174,7 @@ rte_flow_conv(enum rte_flow_conv_op op,
                ret = sizeof(*attr);
                break;
        case RTE_FLOW_CONV_OP_ITEM:
-               ret = rte_flow_conv_pattern(dst, size, src, 1, error);
+               ret = rte_flow_conv_pattern(dst, size, src, 1, false,
+ error);
                break;
        case RTE_FLOW_CONV_OP_ITEM_MASK:
                item = src;

@@ -1158,7 +1189,7 @@ rte_flow_conv(enum rte_flow_conv_op op,
                ret = rte_flow_conv_actions(dst, size, src, 1, error);
                break;
        case RTE_FLOW_CONV_OP_PATTERN:
-               ret = rte_flow_conv_pattern(dst, size, src, 0, error);
+               ret = rte_flow_conv_pattern(dst, size, src, 0, false,
+ error);
                break;
        case RTE_FLOW_CONV_OP_ACTIONS:
                ret = rte_flow_conv_actions(dst, size, src, 0, error);

@@
-1178,6 +1209,9 @@ rte_flow_conv(enum rte_flow_conv_op op,

        case RTE_FLOW_CONV_OP_ACTION_NAME_PTR:
                ret = rte_flow_conv_name(1, 1, dst, size, src, error);
                break;

lib/ethdev/rte_flow.c +2 -0

+       case RTE_FLOW_CONV_OP_PATTERN_MASKED:
+               ret = rte_flow_conv_pattern(dst, size, src, 0, true,

error);
+ break;
default:
ret = rte_flow_error_set
(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
NULL, diff --git a/lib/ethdev/rte_flow.h b/lib/ethdev/rte_flow.h index b495409406..959a2f903b 100644

lib/ethdev/rte_flow.h +6 -0

@@ -4556,6 +4556,19 @@ enum rte_flow_conv_op {
         *   @code const char ** @endcode
         */
        RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
+
+       /**
+        * Convert an entire pattern.
+        *
+        * Duplicates all pattern items at once, applying @p mask to
+ @p

spec

lib/ethdev/rte_flow.h +8 -1

+        * and @p last.
+        *
+        * - @p src type:
+        *   @code const struct rte_flow_item * @endcode
+        * - @p dst type:
+        *   @code struct rte_flow_item * @endcode
+        */
+       RTE_FLOW_CONV_OP_PATTERN_MASKED,
 };
 
 /**
--

2.34.1

-----Original Message-----
From: Bing Zhao <[email protected]>
Sent: Thursday, October 8, 2026 12:58 AM
To: Slava Ovsiienko <[email protected]>; [email protected]; Raslan Darawsheh <[email protected]>; [email protected]
Cc: Ori Kam <[email protected]>; Dariusz Sosnowski <[email protected]>; Suanming Mou <[email protected]>; Matan Azrad <[email protected]>; NBU- Contact-Thomas Monjalon (EXTERNAL) <[email protected]>
Subject: [PATCH v6] ethdev: support inline calculating masked item value

External email: Use caution opening links or attachments

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

Acked-by Dariusz Sosnowski <[email protected]>

---
v3:
- add test code
- fix the issue found by AI
v4: reabse on top of the main
v5: handle some items separately and add test for them
v6: resend the correct version instead of v5 with AI defects resolved

---
 app/test/test_ethdev_api.c | 123 +++++++++++++++++++++++++++++++++++++
 lib/ethdev/rte_flow.c      |  55 +++++++++++++++--
 lib/ethdev/rte_flow.h      |  13 ++++
 3 files changed, 185 insertions(+), 6 deletions(-)

app/test/test_ethdev_api.c index renamed from app/test/test_ethdev_api.c +0 -0

00d6a5c614..ba3e785425 100644

app/test/test_ethdev_api.c +14 -0

@@ -2,8 +2,11 @@
  * Copyright (C) 2023, Advanced Micro Devices, Inc.
  */
 
+#include <string.h>
+
 #include <rte_log.h>
 #include <rte_ethdev.h>
+#include <rte_flow.h>
 
 #include <rte_test.h>
 #include "test.h"

@@ -15,6 +18,125 @@
 #define NUM_MBUF 1024
 #define MBUF_CACHE_SIZE 256
 
+static int32_t
+ethdev_api_flow_conv_pattern_masked(void)
+{
+       const struct rte_flow_item_eth spec = {
+               .hdr.dst_addr.addr_bytes = { 0x01, 0x02, 0x03, 0x04, 0x05,
 0x06 },
+               .hdr.src_addr.addr_bytes = { 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 0x0f },
+               .hdr.ether_type = RTE_BE16(0x1234),
+       };
+       const struct rte_flow_item_eth last = {
+               .hdr.dst_addr.addr_bytes = { 0x11, 0x12, 0x13, 0x14, 0x15,
 0x16 },
+               .hdr.src_addr.addr_bytes = { 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,

0x1f },

app/test/test_ethdev_api.c +4 -0

+               .hdr.ether_type = RTE_BE16(0x5678),
+       };
+       const struct rte_flow_item_eth mask = {
+               .hdr.dst_addr.addr_bytes = { 0xff, 0xff, 0x00, 0x00, 0xff,

0xff },
+ .hdr.src_addr.addr_bytes = { 0xff, 0x00, 0xff, 0x00, 0xff,
0x00 },

app/test/test_ethdev_api.c +48 -0

+               .hdr.ether_type = RTE_BE16(0xffff),
+       };
+       const uint8_t raw_pattern[] = { 0xaa, 0xbb, 0xcc, 0xdd };
+       const struct rte_flow_item_raw raw_spec = {
+               .relative = 1,
+               .search = 1,
+               .offset = 8,
+               .limit = 4,
+               .length = sizeof(raw_pattern),
+               .pattern = raw_pattern,
+       };
+       const struct rte_flow_item_raw raw_mask = {
+               .relative = 1,
+               .search = 0,
+               .reserved = 0x3fffffff,
+               .offset = 0xffffffff,
+               .limit = 0xffff,
+               .length = 0xffff,
+               .pattern = NULL,
+       };
+       const struct rte_flow_item pattern[] = {
+               {
+                       .type = RTE_FLOW_ITEM_TYPE_ETH,
+                       .spec = &spec,
+                       .last = &last,
+                       .mask = &mask,
+               },
+               {
+                       .type = RTE_FLOW_ITEM_TYPE_RAW,
+                       .spec = &raw_spec,
+                       .mask = &raw_mask,
+               },
+               { .type = RTE_FLOW_ITEM_TYPE_END },
+       };
+       union {
+               struct rte_flow_item item;
+               struct rte_flow_item_eth eth;
+               struct rte_flow_item_raw raw;
+               double align;
+               uint8_t buf[256];
+       } dst;
+       const struct rte_flow_item *item;
+       const struct rte_flow_item_eth *conv_spec;
+       const struct rte_flow_item_eth *conv_last;
+       const struct rte_flow_item_raw *conv_raw_spec;
+       int ret;
+
+       ret = rte_flow_conv(RTE_FLOW_CONV_OP_PATTERN_MASKED, NULL, 0,

pattern, NULL);
+ TEST_ASSERT(ret > 0, "Masked pattern conversion size query
failed");

app/test/test_ethdev_api.c +33 -0

+       TEST_ASSERT((size_t)ret <= sizeof(dst.buf),
+                   "Masked pattern conversion needs too much storage");
+
+       memset(&dst, 0, sizeof(dst));
+       ret = rte_flow_conv(RTE_FLOW_CONV_OP_PATTERN_MASKED, dst.buf,
+                           sizeof(dst.buf), pattern, NULL);
+       TEST_ASSERT(ret > 0, "Masked pattern conversion failed");
+
+       item = (const struct rte_flow_item *)dst.buf;
+       conv_spec = item[0].spec;
+       conv_last = item[0].last;
+       TEST_ASSERT_NOT_NULL(conv_spec, "Converted spec must be set");
+       TEST_ASSERT_NOT_NULL(conv_last, "Converted last must be set");
+
+       TEST_ASSERT_EQUAL(conv_spec->hdr.dst_addr.addr_bytes[0], 0x01,
+                         "Masked spec dst byte 0 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.dst_addr.addr_bytes[2], 0x00,
+                         "Masked spec dst byte 2 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.src_addr.addr_bytes[1], 0x00,
+                         "Masked spec src byte 1 mismatch");
+       TEST_ASSERT_EQUAL(conv_spec->hdr.ether_type, RTE_BE16(0x1234),
+                         "Masked spec ether type mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.dst_addr.addr_bytes[0], 0x11,
+                         "Masked last dst byte 0 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.dst_addr.addr_bytes[2], 0x00,
+                         "Masked last dst byte 2 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.src_addr.addr_bytes[1], 0x00,
+                         "Masked last src byte 1 mismatch");
+       TEST_ASSERT_EQUAL(conv_last->hdr.ether_type, RTE_BE16(0x5678),
+                         "Masked last ether type mismatch");
+
+       conv_raw_spec = item[1].spec;
+       TEST_ASSERT_NOT_NULL(conv_raw_spec, "Converted RAW spec must be

set");

app/test/test_ethdev_api.c +22 -0

+       TEST_ASSERT_NOT_NULL(conv_raw_spec->pattern,
+                            "Converted RAW pattern pointer must be set");
+       TEST_ASSERT(conv_raw_spec->pattern != raw_pattern,
+                   "Converted RAW pattern must be deep-copied");
+       TEST_ASSERT_EQUAL(conv_raw_spec->relative, 1,
+                         "Masked RAW relative mismatch");
+       TEST_ASSERT_EQUAL(conv_raw_spec->search, 0,
+                         "Masked RAW search mismatch");
+       TEST_ASSERT_EQUAL(conv_raw_spec->offset, raw_spec.offset,
+                         "Masked RAW offset mismatch");
+       TEST_ASSERT_EQUAL(conv_raw_spec->limit, raw_spec.limit,
+                         "Masked RAW limit mismatch");
+       TEST_ASSERT_EQUAL(conv_raw_spec->length, raw_spec.length,
+                         "Masked RAW length mismatch");
+       TEST_ASSERT_BUFFERS_ARE_EQUAL(conv_raw_spec->pattern, raw_pattern,
+                                     sizeof(raw_pattern),
+                                     "Converted RAW pattern mismatch");
+
+       return TEST_SUCCESS;
+}
+
 static int32_t
 ethdev_api_queue_status(void)
 {

@@ -167,6 +289,7 @@ static struct unit_test_suite ethdev_api_testsuite = {
        .setup = NULL,
        .teardown = NULL,
        .unit_test_cases = {
+               TEST_CASE(ethdev_api_flow_conv_pattern_masked),
                TEST_CASE(ethdev_api_queue_status),
                /* TODO: Add deferred_start queue status test */
                TEST_CASES_END() /**< NULL terminate unit test array */

lib/ethdev/rte_flow.c index renamed from lib/ethdev/rte_flow.c +0 -0

ca2f85c3fa..e4efcbf10f 100644

lib/ethdev/rte_flow.c +16 -0

@@ -175,6 +175,23 @@ static const struct rte_flow_desc_data
 rte_flow_desc_item[] = {
        MK_FLOW_ITEM(COMPARE, sizeof(struct rte_flow_item_compare)),  };
 
+static inline size_t
+rte_flow_conv_item_mask_size(const struct rte_flow_item *item) {
+       if ((int)item->type < 0)
+               return sizeof(void *);
+       switch (item->type) {
+       case RTE_FLOW_ITEM_TYPE_RAW:
+               return offsetof(struct rte_flow_item_raw, pattern);
+       case RTE_FLOW_ITEM_TYPE_GENEVE_OPT:
+               return offsetof(struct rte_flow_item_geneve_opt, data);
+       default:
+               if (rte_flow_desc_item[item->type].desc_fn != NULL)
+                       return 0;
+               return rte_flow_desc_item[item->type].size;
+       }
+}
+
 /** Generate flow_action[] entry. */
 #define MK_FLOW_ACTION(t, s) \
        [RTE_FLOW_ACTION_TYPE_ ## t] = { \ @@ -797,6 +814,8 @@

rte_flow_conv_action_conf(void *buf, const size_t size,
* RTE_FLOW_ITEM_TYPE_END is encountered.
* @param[out] error
* Perform verbose error reporting if not NULL.
+ * @param[in] with_mask
+ * If true, @p src mask will be applied to spec and last.
*
* @return
* A positive value representing the number of bytes needed to store

lib/ethdev/rte_flow.c +27 -3

@@ -809,12 +828,13 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
                      const size_t size,
                      const struct rte_flow_item *src,
                      unsigned int num,
+                     bool with_mask,
                      struct rte_flow_error *error)  {
        uintptr_t data = (uintptr_t)dst;
        size_t off;
        size_t ret;
-       unsigned int i;
+       unsigned int i, j;
 
        for (i = 0, off = 0; !num || i != num; ++i, ++src, ++dst) {
                /**

@@ -838,15 +858,27 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
        src -= num;
        dst -= num;
        do {
+               uint8_t *c_spec = NULL, *c_last = NULL;
+               const uint8_t *mask = src->mask;
+               size_t item_mask_size = mask ?
+ rte_flow_conv_item_mask_size(src) : 0;
+
                if (src->spec) {
                        off = RTE_ALIGN_CEIL(off, sizeof(double));
                        ret = rte_flow_conv_item_spec
                                ((void *)(data + off),
                                 size > off ? size - off : 0, src,
                                 RTE_FLOW_CONV_ITEM_SPEC);
-                       if (size && size >= off + ret)
+                       if (size && size >= off + ret) {
                                dst->spec = (void *)(data + off);
+                               c_spec = (uint8_t *)(data + off);
+                       }
                        off += ret;
+                       if (with_mask && c_spec && mask) {
+                               size_t mask_size = RTE_MIN(ret,
+ item_mask_size);
+
+                               for (j = 0; j < mask_size; j++)
+                                       c_spec[j] &= mask[j];
+                       }
 
                }
                if (src->last) {

@@ -855,9 +887,17 @@ rte_flow_conv_pattern(struct rte_flow_item *dst,
                                ((void *)(data + off),
                                 size > off ? size - off : 0, src,
                                 RTE_FLOW_CONV_ITEM_LAST);
-                       if (size && size >= off + ret)
+                       if (size && size >= off + ret) {
                                dst->last = (void *)(data + off);
+                               c_last = (uint8_t *)(data + off);
+                       }
                        off += ret;
+                       if (with_mask && c_last && mask) {
+                               size_t mask_size = RTE_MIN(ret,
+ item_mask_size);
+
+                               for (j = 0; j < mask_size; j++)
+                                       c_last[j] &= mask[j];
+                       }
                }
                if (src->mask) {
                        off = RTE_ALIGN_CEIL(off, sizeof(double)); @@ -

1004,7 +1044,7 @@ rte_flow_conv_rule(struct rte_flow_conv_rule *dst,
off = RTE_ALIGN_CEIL(off, sizeof(double)); ret = rte_flow_conv_pattern((void *)((uintptr_t)dst +
off),
size > off ? size - off : 0,

lib/ethdev/rte_flow.c +2 -1

-                                           src->pattern_ro, 0, error);
+                                           src->pattern_ro, 0, false,
+ error);
                if (ret < 0)
                        return ret;
                if (size && size >= off + (size_t)ret) @@ -1104,7 +1144,7

@@ rte_flow_conv(enum rte_flow_conv_op op,

                ret = sizeof(*attr);
                break;
        case RTE_FLOW_CONV_OP_ITEM:

lib/ethdev/rte_flow.c +6 -3

-               ret = rte_flow_conv_pattern(dst, size, src, 1, error);
+               ret = rte_flow_conv_pattern(dst, size, src, 1, false,
+ error);
                break;
        case RTE_FLOW_CONV_OP_ITEM_MASK:
                item = src;

@@ -1119,7 +1159,7 @@ rte_flow_conv(enum rte_flow_conv_op op,
                ret = rte_flow_conv_actions(dst, size, src, 1, error);
                break;
        case RTE_FLOW_CONV_OP_PATTERN:
-               ret = rte_flow_conv_pattern(dst, size, src, 0, error);
+               ret = rte_flow_conv_pattern(dst, size, src, 0, false,
+ error);
                break;
        case RTE_FLOW_CONV_OP_ACTIONS:
                ret = rte_flow_conv_actions(dst, size, src, 0, error); @@
-1139,6 +1179,9 @@ rte_flow_conv(enum rte_flow_conv_op op,
        case RTE_FLOW_CONV_OP_ACTION_NAME_PTR:
                ret = rte_flow_conv_name(1, 1, dst, size, src, error);
                break;
+       case RTE_FLOW_CONV_OP_PATTERN_MASKED:
+               ret = rte_flow_conv_pattern(dst, size, src, 0, true,

error);

lib/ethdev/rte_flow.c +1 -0

+               break;
        default:
                ret = rte_flow_error_set
                (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,

lib/ethdev/rte_flow.h index renamed from lib/ethdev/rte_flow.h +0 -0

f864578f80..2261d1ea06 100644

lib/ethdev/rte_flow.h +5 -0

@@ -4544,6 +4544,19 @@ enum rte_flow_conv_op {
         *   @code const char ** @endcode
         */
        RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
+
+       /**
+        * Convert an entire pattern.
+        *
+        * Duplicates all pattern items at once, applying each source item

mask

lib/ethdev/rte_flow.h +8 -1

+        * to its copied specification and range.
+        *
+        * - @p src type:
+        *   @code const struct rte_flow_item * @endcode
+        * - @p dst type:
+        *   @code struct rte_flow_item * @endcode
+        */
+       RTE_FLOW_CONV_OP_PATTERN_MASKED,
 };
 
 /**
--

2.43.0

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

Acked-by Dariusz Sosnowski <[email protected]>

---

In the asynchronous API definition and some drivers, the rte_flow_item spec value may not be calculated by the driver due to the reason of speed of light rule insertion rate and sometimes the input parameters will be copied and changed internally.

After copying, the spec and last will be protected by the keyword const and cannot be changed in the code itself. And also the driver needs some extra memory to do the calculation and extra conditions to understand the length of each item spec. This is not efficient.

To solve the issue and support usage of the following fix, a new OP was introduced to calculate the spec and last values after applying the mask inline.

Signed-off-by Bing Zhao <[email protected]>

Reviewed-by Dariusz Sosnowski <[email protected]>

---

Drivers implementing synchronous flow rules through the asynchronous template API need to apply item masks before creating a rule. The spec and last pointers are const, so this requires writable copies and per-item knowledge of their sizes.

Add RTE_FLOW_CONV_OP_PATTERN_MASKED to rte_flow_conv(). It copies the pattern like RTE_FLOW_CONV_OP_PATTERN and ANDs the inline fields of each copied spec and last with an explicit item mask. A NULL mask leaves the values unchanged; default masks are not substituted.

Preserve GENEVE_OPT.option_len and TAG.index because they describe the pointed-to data length and select the tag register, respectively. RAW pattern and GENEVE_OPT data are copied without applying their payload masks. Limit this operation to inline fields, leaving variable-length payload masking to the caller. FLEX, COMPARE and PMD private items are not masked.

Signed-off-by Bing Zhao <[email protected]>

Reviewed-by Dariusz Sosnowski <[email protected]>

---