From: Wisam Jaddo <wisamm@mellanox.com>
To: dev@dpdk.org, thomas@monjalon.net, asafp@mellanox.com,
akozyrev@nvidia.com, akozyrev@mellanox.com,
arybchenko@solarflare.com, jackmin@mellanox.com
Subject: [dpdk-dev] [PATCH 07/13] app/flow-perf: add raw encap/decap actions support
Date: Sun, 30 Aug 2020 11:15:38 +0000 [thread overview]
Message-ID: <20200830111544.4190-8-wisamm@mellanox.com> (raw)
In-Reply-To: <20200830111544.4190-1-wisamm@mellanox.com>
Introduce raw-encap and raw-decap actions.
The two actions are added in command line
options, and for the data to encap or decap
the user need to parse it within the command
line.
All values of raw-encap data is set to be fixed
values.
Usage example:
--raw-encap=ether,ipv4,udp,vxlan
Signed-off-by: Wisam Jaddo <wisamm@mellanox.com>
Acked-by: Alexander Kozyrev <akozyrev@nvidia.com>
---
app/test-flow-perf/actions_gen.c | 330 ++++++++++++++++++++++++-
app/test-flow-perf/actions_gen.h | 8 +-
app/test-flow-perf/flow_gen.c | 5 +-
app/test-flow-perf/flow_gen.h | 2 +
app/test-flow-perf/main.c | 70 +++++-
doc/guides/rel_notes/release_20_08.rst | 1 +
doc/guides/tools/flow-perf.rst | 10 +
7 files changed, 421 insertions(+), 5 deletions(-)
diff --git a/app/test-flow-perf/actions_gen.c b/app/test-flow-perf/actions_gen.c
index 99e47bf786..3ae6059fb1 100644
--- a/app/test-flow-perf/actions_gen.c
+++ b/app/test-flow-perf/actions_gen.c
@@ -10,6 +10,8 @@
#include <rte_malloc.h>
#include <rte_flow.h>
#include <rte_ethdev.h>
+#include <rte_vxlan.h>
+#include <rte_gtp.h>
#include "actions_gen.h"
#include "flow_gen.h"
@@ -22,6 +24,23 @@ struct additional_para {
uint16_t *queues;
uint16_t queues_number;
uint32_t counter;
+ uint64_t encap_data;
+ uint64_t decap_data;
+};
+
+/* Storage for struct rte_flow_action_raw_encap including external data. */
+struct action_raw_encap_data {
+ struct rte_flow_action_raw_encap conf;
+ uint8_t data[128];
+ uint8_t preserve[128];
+ uint16_t idx;
+};
+
+/* Storage for struct rte_flow_action_raw_decap including external data. */
+struct action_raw_decap_data {
+ struct rte_flow_action_raw_decap conf;
+ uint8_t data[128];
+ uint16_t idx;
};
/* Storage for struct rte_flow_action_rss including external data. */
@@ -437,9 +456,304 @@ add_flag(struct rte_flow_action *actions,
actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_FLAG;
}
+static void
+add_ether_header(uint8_t **header, uint64_t data,
+ __rte_unused struct additional_para para)
+{
+ struct rte_flow_item_eth eth_item;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_ETH)))
+ return;
+
+ memset(ð_item, 0, sizeof(struct rte_flow_item_eth));
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_VLAN))
+ eth_item.type = RTE_BE16(RTE_ETHER_TYPE_VLAN);
+ else if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_IPV4))
+ eth_item.type = RTE_BE16(RTE_ETHER_TYPE_IPV4);
+ else if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_IPV6))
+ eth_item.type = RTE_BE16(RTE_ETHER_TYPE_IPV6);
+ memcpy(*header, ð_item, sizeof(eth_item));
+ *header += sizeof(eth_item);
+}
+
+static void
+add_vlan_header(uint8_t **header, uint64_t data,
+ __rte_unused struct additional_para para)
+{
+ struct rte_flow_item_vlan vlan_item;
+ uint16_t vlan_value;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_VLAN)))
+ return;
+
+ vlan_value = VLAN_VALUE;
+
+ memset(&vlan_item, 0, sizeof(struct rte_flow_item_vlan));
+ vlan_item.tci = RTE_BE16(vlan_value);
+
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_IPV4))
+ vlan_item.inner_type = RTE_BE16(RTE_ETHER_TYPE_IPV4);
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_IPV6))
+ vlan_item.inner_type = RTE_BE16(RTE_ETHER_TYPE_IPV6);
+ memcpy(*header, &vlan_item, sizeof(vlan_item));
+ *header += sizeof(vlan_item);
+}
+
+static void
+add_ipv4_header(uint8_t **header, uint64_t data,
+ struct additional_para para)
+{
+ struct rte_flow_item_ipv4 ipv4_item;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_IPV4)))
+ return;
+
+ memset(&ipv4_item, 0, sizeof(struct rte_flow_item_ipv4));
+ ipv4_item.hdr.src_addr = RTE_IPV4(127, 0, 0, 1);
+ ipv4_item.hdr.dst_addr = RTE_BE32(para.counter);
+ ipv4_item.hdr.version_ihl = RTE_IPV4_VHL_DEF;
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_UDP))
+ ipv4_item.hdr.next_proto_id = RTE_IP_TYPE_UDP;
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_GRE))
+ ipv4_item.hdr.next_proto_id = RTE_IP_TYPE_GRE;
+ memcpy(*header, &ipv4_item, sizeof(ipv4_item));
+ *header += sizeof(ipv4_item);
+}
+
+static void
+add_ipv6_header(uint8_t **header, uint64_t data,
+ __rte_unused struct additional_para para)
+{
+ struct rte_flow_item_ipv6 ipv6_item;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_IPV6)))
+ return;
+
+ memset(&ipv6_item, 0, sizeof(struct rte_flow_item_ipv6));
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_UDP))
+ ipv6_item.hdr.proto = RTE_IP_TYPE_UDP;
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_GRE))
+ ipv6_item.hdr.proto = RTE_IP_TYPE_GRE;
+ memcpy(*header, &ipv6_item, sizeof(ipv6_item));
+ *header += sizeof(ipv6_item);
+}
+
+static void
+add_udp_header(uint8_t **header, uint64_t data,
+ __rte_unused struct additional_para para)
+{
+ struct rte_flow_item_udp udp_item;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_UDP)))
+ return;
+
+ memset(&udp_item, 0, sizeof(struct rte_flow_item_udp));
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_VXLAN))
+ udp_item.hdr.dst_port = RTE_BE16(RTE_VXLAN_DEFAULT_PORT);
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_VXLAN_GPE))
+ udp_item.hdr.dst_port = RTE_BE16(RTE_VXLAN_GPE_UDP_PORT);
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_GENEVE))
+ udp_item.hdr.dst_port = RTE_BE16(RTE_GENEVE_UDP_PORT);
+ if (data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_GTP))
+ udp_item.hdr.dst_port = RTE_BE16(RTE_GTPU_UDP_PORT);
+ memcpy(*header, &udp_item, sizeof(udp_item));
+ *header += sizeof(udp_item);
+}
+
+static void
+add_vxlan_header(uint8_t **header, uint64_t data,
+ struct additional_para para)
+{
+ struct rte_flow_item_vxlan vxlan_item;
+ uint32_t vni_value = para.counter;
+ uint8_t i;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_VXLAN)))
+ return;
+
+ memset(&vxlan_item, 0, sizeof(struct rte_flow_item_vxlan));
+
+ for (i = 0; i < 3; i++)
+ vxlan_item.vni[2 - i] = vni_value >> (i * 8);
+ vxlan_item.flags = 0x8;
+
+ memcpy(*header, &vxlan_item, sizeof(vxlan_item));
+ *header += sizeof(vxlan_item);
+}
+
+static void
+add_vxlan_gpe_header(uint8_t **header, uint64_t data,
+ struct additional_para para)
+{
+ struct rte_flow_item_vxlan_gpe vxlan_gpe_item;
+ uint32_t vni_value = para.counter;
+ uint8_t i;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_VXLAN_GPE)))
+ return;
+
+ memset(&vxlan_gpe_item, 0, sizeof(struct rte_flow_item_vxlan_gpe));
+
+ for (i = 0; i < 3; i++)
+ vxlan_gpe_item.vni[2 - i] = vni_value >> (i * 8);
+ vxlan_gpe_item.flags = 0x0c;
+
+ memcpy(*header, &vxlan_gpe_item, sizeof(vxlan_gpe_item));
+ *header += sizeof(vxlan_gpe_item);
+}
+
+static void
+add_gre_header(uint8_t **header, uint64_t data,
+ __rte_unused struct additional_para para)
+{
+ struct rte_flow_item_gre gre_item;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_GRE)))
+ return;
+
+ memset(&gre_item, 0, sizeof(struct rte_flow_item_gre));
+
+ gre_item.protocol = RTE_BE16(RTE_ETHER_TYPE_TEB);
+
+ memcpy(*header, &gre_item, sizeof(gre_item));
+ *header += sizeof(gre_item);
+}
+
+static void
+add_geneve_header(uint8_t **header, uint64_t data,
+ struct additional_para para)
+{
+ struct rte_flow_item_geneve geneve_item;
+ uint32_t vni_value = para.counter;
+ uint8_t i;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_GENEVE)))
+ return;
+
+ memset(&geneve_item, 0, sizeof(struct rte_flow_item_geneve));
+
+ for (i = 0; i < 3; i++)
+ geneve_item.vni[2 - i] = vni_value >> (i * 8);
+
+ memcpy(*header, &geneve_item, sizeof(geneve_item));
+ *header += sizeof(geneve_item);
+}
+
+static void
+add_gtp_header(uint8_t **header, uint64_t data,
+ struct additional_para para)
+{
+ struct rte_flow_item_gtp gtp_item;
+
+ if (!(data & FLOW_ITEM_MASK(RTE_FLOW_ITEM_TYPE_GTP)))
+ return;
+
+ memset(>p_item, 0, sizeof(struct rte_flow_item_gtp));
+
+ gtp_item.teid = RTE_BE32(para.counter);
+ gtp_item.msg_type = 255;
+
+ memcpy(*header, >p_item, sizeof(gtp_item));
+ *header += sizeof(gtp_item);
+}
+
+static const struct encap_decap_headers {
+ void (*funct)(
+ uint8_t **header,
+ uint64_t data,
+ struct additional_para para
+ );
+} headers[] = {
+ {.funct = add_ether_header},
+ {.funct = add_vlan_header},
+ {.funct = add_ipv4_header},
+ {.funct = add_ipv6_header},
+ {.funct = add_udp_header},
+ {.funct = add_vxlan_header},
+ {.funct = add_vxlan_gpe_header},
+ {.funct = add_gre_header},
+ {.funct = add_geneve_header},
+ {.funct = add_gtp_header},
+};
+
+static void
+add_raw_encap(struct rte_flow_action *actions,
+ uint8_t actions_counter,
+ struct additional_para para)
+{
+ static struct action_raw_encap_data *action_encap_data;
+ uint64_t encap_data = para.encap_data;
+ uint8_t *header;
+ uint8_t i;
+
+ /* Avoid double allocation. */
+ if (action_encap_data == NULL)
+ action_encap_data = rte_malloc("encap_data",
+ sizeof(struct action_raw_encap_data), 0);
+
+ /* Check if allocation failed. */
+ if (action_encap_data == NULL)
+ rte_exit(EXIT_FAILURE, "No Memory available!");
+
+ *action_encap_data = (struct action_raw_encap_data) {
+ .conf = (struct rte_flow_action_raw_encap) {
+ .data = action_encap_data->data,
+ },
+ .data = {},
+ };
+ header = action_encap_data->data;
+
+ for (i = 0; i < RTE_DIM(headers); i++)
+ headers[i].funct(&header, encap_data, para);
+
+ action_encap_data->conf.size = header -
+ action_encap_data->data;
+
+ actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_RAW_ENCAP;
+ actions[actions_counter].conf = &action_encap_data->conf;
+}
+
+static void
+add_raw_decap(struct rte_flow_action *actions,
+ uint8_t actions_counter,
+ struct additional_para para)
+{
+ static struct action_raw_decap_data *action_decap_data;
+ uint64_t decap_data = para.decap_data;
+ uint8_t *header;
+ uint8_t i;
+
+ /* Avoid double allocation. */
+ if (action_decap_data == NULL)
+ action_decap_data = rte_malloc("decap_data",
+ sizeof(struct action_raw_decap_data), 0);
+
+ /* Check if allocation failed. */
+ if (action_decap_data == NULL)
+ rte_exit(EXIT_FAILURE, "No Memory available!");
+
+ *action_decap_data = (struct action_raw_decap_data) {
+ .conf = (struct rte_flow_action_raw_decap) {
+ .data = action_decap_data->data,
+ },
+ .data = {},
+ };
+ header = action_decap_data->data;
+
+ for (i = 0; i < RTE_DIM(headers); i++)
+ headers[i].funct(&header, decap_data, para);
+
+ action_decap_data->conf.size = header -
+ action_decap_data->data;
+
+ actions[actions_counter].type = RTE_FLOW_ACTION_TYPE_RAW_DECAP;
+ actions[actions_counter].conf = &action_decap_data->conf;
+}
+
void
fill_actions(struct rte_flow_action *actions, uint64_t *flow_actions,
- uint32_t counter, uint16_t next_table, uint16_t hairpinq)
+ uint32_t counter, uint16_t next_table, uint16_t hairpinq,
+ uint64_t encap_data, uint64_t decap_data)
{
struct additional_para additional_para_data;
uint8_t actions_counter = 0;
@@ -459,6 +773,8 @@ fill_actions(struct rte_flow_action *actions, uint64_t *flow_actions,
.queues = queues,
.queues_number = RXQ_NUM,
.counter = counter,
+ .encap_data = encap_data,
+ .decap_data = decap_data,
};
if (hairpinq != 0) {
@@ -621,6 +937,18 @@ fill_actions(struct rte_flow_action *actions, uint64_t *flow_actions,
.mask = HAIRPIN_RSS_ACTION,
.funct = add_rss,
},
+ {
+ .mask = FLOW_ACTION_MASK(
+ RTE_FLOW_ACTION_TYPE_RAW_ENCAP
+ ),
+ .funct = add_raw_encap,
+ },
+ {
+ .mask = FLOW_ACTION_MASK(
+ RTE_FLOW_ACTION_TYPE_RAW_DECAP
+ ),
+ .funct = add_raw_decap,
+ },
};
for (j = 0; j < MAX_ACTIONS_NUM; j++) {
diff --git a/app/test-flow-perf/actions_gen.h b/app/test-flow-perf/actions_gen.h
index d6918a53a6..85e3176b09 100644
--- a/app/test-flow-perf/actions_gen.h
+++ b/app/test-flow-perf/actions_gen.h
@@ -12,7 +12,13 @@
#include "config.h"
+#define RTE_IP_TYPE_UDP 17
+#define RTE_IP_TYPE_GRE 47
+#define RTE_VXLAN_GPE_UDP_PORT 250
+#define RTE_GENEVE_UDP_PORT 6081
+
void fill_actions(struct rte_flow_action *actions, uint64_t *flow_actions,
- uint32_t counter, uint16_t next_table, uint16_t hairpinq);
+ uint32_t counter, uint16_t next_table, uint16_t hairpinq,
+ uint64_t encap_data, uint64_t decap_data);
#endif /* FLOW_PERF_ACTION_GEN */
diff --git a/app/test-flow-perf/flow_gen.c b/app/test-flow-perf/flow_gen.c
index b2c828c7df..a979b3856d 100644
--- a/app/test-flow-perf/flow_gen.c
+++ b/app/test-flow-perf/flow_gen.c
@@ -43,6 +43,8 @@ generate_flow(uint16_t port_id,
uint16_t next_table,
uint32_t outer_ip_src,
uint16_t hairpinq,
+ uint64_t encap_data,
+ uint64_t decap_data,
struct rte_flow_error *error)
{
struct rte_flow_attr attr;
@@ -57,7 +59,8 @@ generate_flow(uint16_t port_id,
fill_attributes(&attr, flow_attrs, group);
fill_actions(actions, flow_actions,
- outer_ip_src, next_table, hairpinq);
+ outer_ip_src, next_table, hairpinq,
+ encap_data, decap_data);
fill_items(items, flow_items, outer_ip_src);
diff --git a/app/test-flow-perf/flow_gen.h b/app/test-flow-perf/flow_gen.h
index 53469c659f..3d13737d65 100644
--- a/app/test-flow-perf/flow_gen.h
+++ b/app/test-flow-perf/flow_gen.h
@@ -32,6 +32,8 @@ generate_flow(uint16_t port_id,
uint16_t next_table,
uint32_t outer_ip_src,
uint16_t hairpinq,
+ uint64_t encap_data,
+ uint64_t decap_data,
struct rte_flow_error *error);
#endif /* FLOW_PERF_FLOW_GEN */
diff --git a/app/test-flow-perf/main.c b/app/test-flow-perf/main.c
index ae0d1a3be5..1b456e6922 100644
--- a/app/test-flow-perf/main.c
+++ b/app/test-flow-perf/main.c
@@ -45,6 +45,9 @@
struct rte_flow *flow;
static uint8_t flow_group;
+static uint64_t encap_data;
+static uint64_t decap_data;
+
static uint64_t flow_items[MAX_ITEMS_NUM];
static uint64_t flow_actions[MAX_ACTIONS_NUM];
static uint64_t flow_attrs[MAX_ATTRS_NUM];
@@ -171,12 +174,19 @@ usage(char *progname)
printf(" --set-ipv6-dscp: add set ipv6 dscp action to flow actions\n"
"ipv6 dscp value to be set is random each flow\n");
printf(" --flag: add flag action to flow actions\n");
+ printf(" --raw-encap=<data>: add raw encap action to flow actions\n"
+ "Data is the data needed to be encaped\n"
+ "Example: raw-encap=ether,ipv4,udp,vxlan\n");
+ printf(" --raw-decap=<data>: add raw decap action to flow actions\n"
+ "Data is the data needed to be decaped\n"
+ "Example: raw-decap=ether,ipv4,udp,vxlan\n");
}
static void
args_parse(int argc, char **argv)
{
char **argvopt;
+ char *token;
int n, opt;
int opt_idx;
size_t i;
@@ -532,6 +542,8 @@ args_parse(int argc, char **argv)
{ "set-ipv4-dscp", 0, 0, 0 },
{ "set-ipv6-dscp", 0, 0, 0 },
{ "flag", 0, 0, 0 },
+ { "raw-encap", 1, 0, 0 },
+ { "raw-decap", 1, 0, 0 },
};
hairpin_queues_num = 0;
@@ -593,6 +605,58 @@ args_parse(int argc, char **argv)
printf("hairpin-queue / ");
}
+ if (strcmp(lgopts[opt_idx].name, "raw-encap") == 0) {
+ printf("raw-encap ");
+ flow_actions[actions_idx++] =
+ FLOW_ITEM_MASK(
+ RTE_FLOW_ACTION_TYPE_RAW_ENCAP
+ );
+
+ token = strtok(optarg, ",");
+ while (token != NULL) {
+ for (i = 0; i < RTE_DIM(flow_options); i++) {
+ if (strcmp(flow_options[i].str, token) == 0) {
+ printf("%s,", token);
+ encap_data |= flow_options[i].mask;
+ break;
+ }
+ /* Reached last item with no match */
+ if (i == (RTE_DIM(flow_options) - 1)) {
+ fprintf(stderr, "Invalid encap item: %s\n", token);
+ usage(argv[0]);
+ rte_exit(EXIT_SUCCESS, "Invalid encap item\n");
+ }
+ }
+ token = strtok(NULL, ",");
+ }
+ printf(" / ");
+ }
+ if (strcmp(lgopts[opt_idx].name, "raw-decap") == 0) {
+ printf("raw-decap ");
+ flow_actions[actions_idx++] =
+ FLOW_ITEM_MASK(
+ RTE_FLOW_ACTION_TYPE_RAW_DECAP
+ );
+
+ token = strtok(optarg, ",");
+ while (token != NULL) {
+ for (i = 0; i < RTE_DIM(flow_options); i++) {
+ if (strcmp(flow_options[i].str, token) == 0) {
+ printf("%s,", token);
+ encap_data |= flow_options[i].mask;
+ break;
+ }
+ /* Reached last item with no match */
+ if (i == (RTE_DIM(flow_options) - 1)) {
+ fprintf(stderr, "Invalid decap item: %s\n", token);
+ usage(argv[0]);
+ rte_exit(EXIT_SUCCESS, "Invalid decap item\n");
+ }
+ }
+ token = strtok(NULL, ",");
+ }
+ printf(" / ");
+ }
/* Control */
if (strcmp(lgopts[opt_idx].name,
"flows-count") == 0) {
@@ -807,7 +871,7 @@ flows_handler(void)
*/
flow = generate_flow(port_id, 0, flow_attrs,
global_items, global_actions,
- flow_group, 0, 0, &error);
+ flow_group, 0, 0, 0, 0, &error);
if (flow == NULL) {
print_flow_error(error);
@@ -823,7 +887,9 @@ flows_handler(void)
flow = generate_flow(port_id, flow_group,
flow_attrs, flow_items, flow_actions,
JUMP_ACTION_TABLE, i,
- hairpin_queues_num, &error);
+ hairpin_queues_num,
+ encap_data, decap_data,
+ &error);
if (force_quit)
i = flows_count;
diff --git a/doc/guides/rel_notes/release_20_08.rst b/doc/guides/rel_notes/release_20_08.rst
index eed3900a8c..5a94eacded 100644
--- a/doc/guides/rel_notes/release_20_08.rst
+++ b/doc/guides/rel_notes/release_20_08.rst
@@ -282,6 +282,7 @@ New Features
* Start supporting header modify actions.
* Start supporting flag action.
+ * Start supporting raw-encap and raw-decap actions.
Removed Items
diff --git a/doc/guides/tools/flow-perf.rst b/doc/guides/tools/flow-perf.rst
index 69cdd1b222..10c0c422e4 100644
--- a/doc/guides/tools/flow-perf.rst
+++ b/doc/guides/tools/flow-perf.rst
@@ -306,3 +306,13 @@ Actions:
* ``--flag``
Add flag action to all flows actions.
+
+* ``--raw-encap=<DATA>``
+ Add raw encap action to all flows actions.
+ Data is the data needed to be encaped, with fixed values.
+ Example: raw-encap=ether,ipv4,udp,vxlan
+
+* ``--raw-decap=<DATA>``
+ Add raw decap action to all flows actions.
+ Data is the data needed to be decaped, with fixed values.
+ Example: raw-decap=ether,ipv4,gre
--
2.17.1
next prev parent reply other threads:[~2020-08-30 11:21 UTC|newest]
Thread overview: 16+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-08-30 11:15 [dpdk-dev] [PATCH 00/13] app/flow-perf: add support for new items/actions Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 01/13] app/flow-perf: fix actions mask macro usage Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 02/13] doc/flow-perf: fix app sections Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 03/13] app/flow-perf: start supporting user order Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 04/13] app/flow-perf: add header modify actions support Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 05/13] app/flow-perf: add flag action support Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 06/13] app/flow-perf: fix memory leak from RSS action Wisam Jaddo
2020-08-30 11:15 ` Wisam Jaddo [this message]
2020-08-30 11:15 ` [dpdk-dev] [PATCH 08/13] app/flow-perf: add VXLAN encap/decap actions support Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 09/13] app/flow-perf: fix source ipv4 matching Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 10/13] app/flow-perf: add random mark id values Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 11/13] app/flow-perf: add set port mask to options Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 12/13] app/flow-perf: add icmp matching support Wisam Jaddo
2020-08-30 11:15 ` [dpdk-dev] [PATCH 13/13] app/flow-perf: allow fixed values for actions Wisam Jaddo
2020-09-14 18:15 ` [dpdk-dev] [PATCH 00/13] app/flow-perf: add support for new items/actions Ferruh Yigit
2020-09-21 21:36 ` Thomas Monjalon
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20200830111544.4190-8-wisamm@mellanox.com \
--to=wisamm@mellanox.com \
--cc=akozyrev@mellanox.com \
--cc=akozyrev@nvidia.com \
--cc=arybchenko@solarflare.com \
--cc=asafp@mellanox.com \
--cc=dev@dpdk.org \
--cc=jackmin@mellanox.com \
--cc=thomas@monjalon.net \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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).