🧪 test(TSG-17959): Add route ctx test for Etherfabric and Tera adapters.

Add route ctx test for Etherfabric and Tera adapters.

2 files changed, 275 insertions, 0 deletions

diff --git a/include/internal/adapter_define.h b/include/internal/adapter_define.h
new file mode 100644
index 0000000..4a56928
--- /dev/null
+++ b/include/internal/adapter_define.h
@@ -0,0 +1,19 @@
+#pragma once
+#include <rte_common.h>
+
+/* Adapter type */
+enum adapter_type
+{
+    ADAPTER_TYPE_EF = 0,
+    ADAPTER_TYPE_VWIRE,
+    ADAPTER_TYPE_TERA,
+    ADAPTER_TYPE_ALL,
+    ADAPTER_TYPE_NONE
+};
+
+unsigned int nr_ef_adapters_get();
+unsigned int nr_vwire_adapters_get();
+unsigned int nr_tera_adapters_get();
+int ef_adapter_id_check(uint32_t ef_adapter_id);
+int vwire_id_check(uint32_t vwire_id);
+int tera_adapter_id_check(uint32_t tera_adapter_id);
diff --git a/include/internal/metadata_define.h b/include/internal/metadata_define.h
new file mode 100644
index 0000000..e092810
--- /dev/null
+++ b/include/internal/metadata_define.h
@@ -0,0 +1,256 @@
+#pragma once
+
+#include <adapter_define.h>
+#include <marsio.h>
+#include <mrb_define.h>
+
+#include <rte_common.h>
+#include <rte_ether.h>
+#include <rte_mbuf.h>
+
+struct mrb_metadata_route_ctx
+{
+    uint8_t dir;
+    uint8_t adapter_type;
+    uint16_t traffic_link_id;
+    uint16_t port_ingress;
+    uint16_t port_egress;
+    uint32_t hash_usr;
+
+    union {
+        struct
+        {
+            uint16_t ef_peer_index;
+            uint16_t ef_link_id;
+        };
+        struct
+        {
+            uint16_t vlan_tci;
+            struct rte_ether_hdr eth_hdr;
+        };
+    };
+};
+
+int buffer_metadata_get(marsio_buff_t * m, enum mr_buff_metadata_type type, void * data, unsigned int sz_data)
+{
+    struct rte_mbuf * mbuf = (struct rte_mbuf *)m;
+    struct mrb_metadata * mrb_metadata = (struct mrb_metadata *)mrbuf_cz_data(mbuf, MR_NODE_CTRLZONE_ID);
+
+    switch (type)
+    {
+    case MR_BUFF_REHASH_INDEX:
+        if (unlikely(sz_data < sizeof(uint32_t)))
+        {
+            return -ENOMEM;
+        }
+
+        *(uint32_t *)(data) = (uint32_t)mbuf->hash.usr;
+        return sizeof(uint32_t);
+
+    case MR_BUFF_ROUTE_CTX: {
+        if (unlikely(sz_data < sizeof(struct mrb_metadata_route_ctx)))
+        {
+            return -ENOMEM;
+        }
+
+        struct mrb_metadata_route_ctx * route_ctx = (struct mrb_metadata_route_ctx *)data;
+        if (route_ctx == NULL)
+        {
+            return -EINVAL;
+        }
+
+        route_ctx->dir = mrb_metadata->dir;
+        route_ctx->adapter_type = mrb_metadata->adapter_type;
+        route_ctx->port_ingress = mrb_metadata->port_ingress;
+        route_ctx->port_egress = mrb_metadata->port_egress;
+        route_ctx->traffic_link_id = mrb_metadata->traffic_link_id;
+        route_ctx->hash_usr = mbuf->hash.usr;
+
+        if (mrb_metadata->adapter_type == ADAPTER_TYPE_EF)
+        {
+            route_ctx->ef_peer_index = mrb_metadata->ef_peer_index;
+            route_ctx->ef_link_id = mrb_metadata->ef_link_id;
+        }
+        else if (mrb_metadata->adapter_type == ADAPTER_TYPE_TERA)
+        {
+            const struct rte_ether_hdr * eth_hdr = rte_pktmbuf_mtod(mbuf, const struct rte_ether_hdr *);
+            const struct rte_vlan_hdr * vlan_hdr =
+                rte_pktmbuf_mtod_offset(mbuf, const struct rte_vlan_hdr *, sizeof(struct rte_ether_hdr));
+
+            route_ctx->vlan_tci = vlan_hdr->vlan_tci;
+            rte_memcpy(&route_ctx->eth_hdr, eth_hdr, sizeof(struct rte_ether_hdr));
+        }
+
+        return sizeof(struct mrb_metadata_route_ctx);
+    }
+
+    case MR_BUFF_DIR: {
+        if (unlikely(sz_data < sizeof(unsigned int)))
+        {
+            return -ENOMEM;
+        }
+
+        *(unsigned int *)(data) = (unsigned int)mrb_metadata->dir;
+        return sizeof(unsigned int);
+    }
+
+    case MR_BUFF_SESSION_ID: {
+        if (unlikely(sz_data < sizeof(uint64_t)))
+        {
+            return -ENOMEM;
+        }
+
+        *(uint64_t *)(data) = (uint64_t)mrb_metadata->session_id;
+        return sizeof(uint64_t);
+    }
+
+    case MR_BUFF_PAYLOAD_OFFSET: {
+        if (unlikely(sz_data < sizeof(uint16_t)))
+        {
+            return -ENOMEM;
+        }
+
+        *(uint16_t *)(data) = (uint16_t)mrb_metadata->payload_offset;
+        return sizeof(uint16_t);
+    }
+
+    case MR_BUFF_LINK_ID: {
+        if (unlikely(sz_data < sizeof(uint16_t)))
+        {
+            return -ENOMEM;
+        }
+
+        *(uint16_t *)(data) = (uint16_t)mrb_metadata->traffic_link_id;
+        return sizeof(uint16_t);
+    }
+
+    case MR_BUFF_USER_0: {
+        if (unlikely(sz_data < sizeof(uint16_t)))
+        {
+            return -ENOMEM;
+        }
+
+        *(uint16_t *)(data) = (uint16_t)mrb_metadata->user_0;
+        return sizeof(uint16_t);
+    }
+
+    default:
+        return -ENOTSUP;
+    }
+
+    return 0;
+}
+
+int buffer_metadata_set(marsio_buff_t * m, enum mr_buff_metadata_type type, void * data, unsigned int sz_data)
+{
+    struct rte_mbuf * mbuf = (struct rte_mbuf *)m;
+    struct mrb_metadata * mrb_metadata = (struct mrb_metadata *)mrbuf_cz_data(mbuf, MR_NODE_CTRLZONE_ID);
+
+    switch (type)
+    {
+    case MR_BUFF_REHASH_INDEX:
+        if (unlikely(sz_data < sizeof(uint32_t)))
+        {
+            return -ENOMEM;
+        }
+
+        mbuf->hash.usr = *(uint32_t *)data;
+        return 0;
+
+    case MR_BUFF_METADATA_VLAN_TCI: {
+        if (unlikely(sz_data < sizeof(uint16_t)))
+        {
+            return -ENOMEM;
+        }
+
+        /* we do not want to relay on the hardware offload capability */
+        struct rte_ether_hdr * ether_hdr = (struct rte_ether_hdr *)rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+        /* already has a vlan header */
+        if (ether_hdr->ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN))
+        {
+            struct rte_vlan_hdr * vlan_hdr = (struct rte_vlan_hdr *)(ether_hdr + 1);
+            vlan_hdr->vlan_tci = rte_cpu_to_be_16(*(uint16_t *)data);
+        }
+        else
+        {
+            mbuf->vlan_tci = *(uint16_t *)data;
+            rte_vlan_insert(&mbuf);
+        }
+
+        return 0;
+    }
+    case MR_BUFF_ROUTE_CTX: {
+        if (unlikely(sz_data < sizeof(struct mrb_metadata_route_ctx)))
+        {
+            return -ENOMEM;
+        }
+
+        struct mrb_metadata_route_ctx * route_ctx = (struct mrb_metadata_route_ctx *)data;
+        assert(route_ctx != NULL);
+
+        mrb_metadata->packet_create_from_nf = 1;
+        mrb_metadata->dir = route_ctx->dir;
+        mrb_metadata->adapter_type = route_ctx->adapter_type;
+        mrb_metadata->traffic_link_id = route_ctx->traffic_link_id;
+        mrb_metadata->port_ingress = route_ctx->port_ingress;
+        mrb_metadata->port_egress = route_ctx->port_egress;
+        mbuf->hash.usr = route_ctx->hash_usr;
+
+        if (route_ctx->adapter_type == ADAPTER_TYPE_EF)
+        {
+            mrb_metadata->ef_peer_index = route_ctx->ef_peer_index;
+            mrb_metadata->ef_link_id = route_ctx->ef_link_id;
+        }
+        else if (route_ctx->adapter_type == ADAPTER_TYPE_TERA)
+        {
+            /* Get original eth hdr */
+            struct rte_ether_hdr * ether_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+            /* Already has a vlan header */
+            if (ether_hdr->ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN))
+            {
+                struct rte_vlan_hdr * vlan_hdr = (struct rte_vlan_hdr *)(ether_hdr + 1);
+                vlan_hdr->vlan_tci = route_ctx->vlan_tci;
+            }
+            else
+            {
+                mbuf->vlan_tci = route_ctx->vlan_tci;
+                rte_vlan_insert(&mbuf);
+                ether_hdr = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+            }
+
+            /* Update the mac addr */
+            rte_memcpy(&ether_hdr->src_addr, &route_ctx->eth_hdr.src_addr, sizeof(struct rte_ether_addr));
+            rte_memcpy(&ether_hdr->dst_addr, &route_ctx->eth_hdr.dst_addr, sizeof(struct rte_ether_addr));
+        }
+
+        return 0;
+    }
+
+    case MR_BUFF_SESSION_ID: {
+        mrb_metadata->session_id = *(uint64_t *)data;
+        return 0;
+    }
+
+    case MR_BUFF_DIR: {
+        mrb_metadata->dir = *(unsigned int *)data;
+        return 0;
+    }
+
+    case MR_BUFF_PAYLOAD_OFFSET: {
+        mrb_metadata->payload_offset = *(uint16_t *)data;
+        return 0;
+    }
+
+    case MR_BUFF_USER_0: {
+        mrb_metadata->user_0 = *(uint16_t *)data;
+        return 0;
+    }
+
+    default:
+        return -ENOTSUP;
+    }
+
+    return 0;
+}