app/testpmd: introduce new tunnel VXLAN-GPE

[dpdk.git] / app / test-pmd / config.c

diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
index 5a68d0a..02380dc 100644 (file)
--- a/app/test-pmd/config.c
+++ b/app/test-pmd/config.c
@@ -993,7 +993,8 @@ static const struct {
        MK_FLOW_ITEM(ANY, sizeof(struct rte_flow_item_any)),
        MK_FLOW_ITEM(PF, 0),
        MK_FLOW_ITEM(VF, sizeof(struct rte_flow_item_vf)),
-       MK_FLOW_ITEM(PORT, sizeof(struct rte_flow_item_port)),
+       MK_FLOW_ITEM(PHY_PORT, sizeof(struct rte_flow_item_phy_port)),
+       MK_FLOW_ITEM(PORT_ID, sizeof(struct rte_flow_item_port_id)),
        MK_FLOW_ITEM(RAW, sizeof(struct rte_flow_item_raw)),
        MK_FLOW_ITEM(ETH, sizeof(struct rte_flow_item_eth)),
        MK_FLOW_ITEM(VLAN, sizeof(struct rte_flow_item_vlan)),
@@ -1013,6 +1014,7 @@ static const struct {
        MK_FLOW_ITEM(GTPC, sizeof(struct rte_flow_item_gtp)),
        MK_FLOW_ITEM(GTPU, sizeof(struct rte_flow_item_gtp)),
        MK_FLOW_ITEM(GENEVE, sizeof(struct rte_flow_item_geneve)),
+       MK_FLOW_ITEM(VXLAN_GPE, sizeof(struct rte_flow_item_vxlan_gpe)),
 };
 
 /** Pattern item specification types. */
@@ -1091,6 +1093,8 @@ static const struct {
        MK_FLOW_ACTION(RSS, sizeof(struct rte_flow_action_rss)),
        MK_FLOW_ACTION(PF, 0),
        MK_FLOW_ACTION(VF, sizeof(struct rte_flow_action_vf)),
+       MK_FLOW_ACTION(PHY_PORT, sizeof(struct rte_flow_action_phy_port)),
+       MK_FLOW_ACTION(PORT_ID, sizeof(struct rte_flow_action_port_id)),
        MK_FLOW_ACTION(METER, sizeof(struct rte_flow_action_meter)),
 };
 
@@ -1117,40 +1121,29 @@ flow_action_conf_copy(void *buf, const struct rte_flow_action *action)
                off = 0;
                if (dst.rss)
                        *dst.rss = (struct rte_flow_action_rss){
-                               .num = src.rss->num,
+                               .func = src.rss->func,
+                               .level = src.rss->level,
+                               .types = src.rss->types,
+                               .key_len = src.rss->key_len,
+                               .queue_num = src.rss->queue_num,
                        };
                off += sizeof(*src.rss);
-               if (src.rss->num) {
+               if (src.rss->key_len) {
                        off = RTE_ALIGN_CEIL(off, sizeof(double));
-                       size = sizeof(*src.rss->queue) * src.rss->num;
+                       size = sizeof(*src.rss->key) * src.rss->key_len;
                        if (dst.rss)
-                               dst.rss->queue = memcpy
+                               dst.rss->key = memcpy
                                        ((void *)((uintptr_t)dst.rss + off),
-                                        src.rss->queue, size);
+                                        src.rss->key, size);
                        off += size;
                }
-               off = RTE_ALIGN_CEIL(off, sizeof(double));
-               if (dst.rss) {
-                       dst.rss->rss_conf = (void *)((uintptr_t)dst.rss + off);
-                       *(struct rte_eth_rss_conf *)(uintptr_t)
-                               dst.rss->rss_conf = (struct rte_eth_rss_conf){
-                               .rss_key_len = src.rss->rss_conf->rss_key_len,
-                               .rss_hf = src.rss->rss_conf->rss_hf,
-                       };
-               }
-               off += sizeof(*src.rss->rss_conf);
-               if (src.rss->rss_conf->rss_key_len) {
+               if (src.rss->queue_num) {
                        off = RTE_ALIGN_CEIL(off, sizeof(double));
-                       size = sizeof(*src.rss->rss_conf->rss_key) *
-                               src.rss->rss_conf->rss_key_len;
-                       if (dst.rss) {
-                               ((struct rte_eth_rss_conf *)(uintptr_t)
-                                dst.rss->rss_conf)->rss_key =
-                                       (void *)((uintptr_t)dst.rss + off);
-                               memcpy(dst.rss->rss_conf->rss_key,
-                                      src.rss->rss_conf->rss_key,
-                                      size);
-                       }
+                       size = sizeof(*src.rss->queue) * src.rss->queue_num;
+                       if (dst.rss)
+                               dst.rss->queue = memcpy
+                                       ((void *)((uintptr_t)dst.rss + off),
+                                        src.rss->queue, size);
                        off += size;
                }
                size = off;
@@ -1267,6 +1260,7 @@ port_flow_complain(struct rte_flow_error *error)
                [RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY] = "priority field",
                [RTE_FLOW_ERROR_TYPE_ATTR_INGRESS] = "ingress field",
                [RTE_FLOW_ERROR_TYPE_ATTR_EGRESS] = "egress field",
+               [RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER] = "transfer field",
                [RTE_FLOW_ERROR_TYPE_ATTR] = "attributes structure",
                [RTE_FLOW_ERROR_TYPE_ITEM_NUM] = "pattern length",
                [RTE_FLOW_ERROR_TYPE_ITEM_SPEC] = "item specification",
@@ -1532,12 +1526,13 @@ port_flow_list(portid_t port_id, uint32_t n, const uint32_t group[n])
                const struct rte_flow_item *item = pf->pattern;
                const struct rte_flow_action *action = pf->actions;
 
-               printf("%" PRIu32 "\t%" PRIu32 "\t%" PRIu32 "\t%c%c\t",
+               printf("%" PRIu32 "\t%" PRIu32 "\t%" PRIu32 "\t%c%c%c\t",
                       pf->id,
                       pf->attr.group,
                       pf->attr.priority,
                       pf->attr.ingress ? 'i' : '-',
-                      pf->attr.egress ? 'e' : '-');
+                      pf->attr.egress ? 'e' : '-',
+                      pf->attr.transfer ? 't' : '-');
                while (item->type != RTE_FLOW_ITEM_TYPE_END) {
                        if (item->type != RTE_FLOW_ITEM_TYPE_VOID)
                                printf("%s ", flow_item[item->type].name);
@@ -3138,6 +3133,7 @@ flowtype_to_str(uint16_t flow_type)
                {"vxlan", RTE_ETH_FLOW_VXLAN},
                {"geneve", RTE_ETH_FLOW_GENEVE},
                {"nvgre", RTE_ETH_FLOW_NVGRE},
+               {"vxlan-gpe", RTE_ETH_FLOW_VXLAN_GPE},
        };
 
        for (i = 0; i < RTE_DIM(flowtype_str_table); i++) {