✨ feat(TSG-13375): 实现 “Service Chaining” 功能

实现 “Service Chaining” 功能

1 files changed, 61 insertions, 277 deletions

diff --git a/service/src/node_shmdev.c b/service/src/node_shmdev.c
index fb5c88e..5d1d992 100644
--- a/service/src/node_shmdev.c
+++ b/service/src/node_shmdev.c
@@ -14,242 +14,30 @@
 #include <sc_vdev.h>
 #include <sys/ucontext.h>
 
-#ifndef DEFAULT_ETHERFABRIC_VLAN_RANGE_START
-#define DEFAULT_ETHERFABRIC_VLAN_RANGE_START 1000
-#endif
-
-#ifndef DEFAULT_ETHERFABRIC_VLAN_RANGE_END
-#define DEFAULT_ETHERFABRIC_VLAN_RANGE_END 3047
-#endif
-
-#ifndef DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_START
-#define DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_START 4000
-#endif
-
-#ifndef DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_END
-#define DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_END 6047
-#endif
-
 #define MR_SHMDEV_STAT_ADD(st, graph_id, counter, value)                                                               \
     do                                                                                                                 \
     {                                                                                                                  \
         st[graph_id].counter += value;                                                                                 \
     } while (0)
 
-struct default_si_table
+enum
 {
-    uint8_t dev_enable;
-    uint8_t init_flg;
-    uint16_t default_si;
+    SHMDEV_RX_NEXT_NODE_FORWARDER,
+    SHMDEV_RX_NEXT_NODE_HEALTH_CHECK,
+    SHMDEV_RX_NEXT_NODE_PKT_DROP,
+    SHMDEV_RX_NEXT_NODE_MAX
 };
-
-struct vlan_flipping_adapter
-{
-    uint8_t enable;
-    uint16_t etherfabric_vlan_range_start;
-    uint16_t etherfabric_vlan_range_end;
-    uint16_t virtual_wire_vlan_range_start;
-    uint16_t virtual_wire_vlan_range_end;
-    struct default_si_table default_si_table_array[MR_DEVICE_MAX];
-};
-
 struct shmdev_stat_per_lcore
 {
     volatile uint64_t total_tx_pkts;
     volatile uint64_t total_rx_pkts;
     volatile uint64_t original_pkt;
-    volatile uint64_t new_create_pkt;
-    volatile uint64_t no_eth_hdr_pkt;
-    volatile uint64_t to_eth_ingress_pkt;
+    volatile uint64_t nf_create_pkt;
+    volatile uint64_t to_eth_forwarder_pkt;
+    volatile uint64_t to_health_check_pkt;
 };
 
 struct shmdev_stat_per_lcore shmdev_graph_stat[RTE_MAX_LCORE];
-struct vlan_flipping_adapter * g_vlan_flipping_adapter = NULL;
-
-extern uint16_t etherfabric_get_service_index_for_fwd_id(uint16_t fwd_table_index);
-extern uint16_t etherfabric_get_port_index_for_service_id(uint16_t service_index);
-
-/* Parsing the vlan flipping adapter config */
-int parser_vlan_flipping_adapter_conf(struct sc_main * sc, struct vlan_flipping_adapter * _vlan_flipping_adapter)
-{
-    for (int index = 0; index < MR_DEVICE_MAX; index++)
-    {
-        char str_section[MR_STRING_MAX] = {};
-        snprintf(str_section, sizeof(str_section), "default_si_table_%d", index);
-
-        char str_default_si_table[MR_STRING_MAX] = {};
-        int ret = MESA_load_profile_string_nodef(sc->local_cfgfile, "vlan_flipping_adapter", str_section,
-                                                 str_default_si_table, sizeof(str_default_si_table));
-        if (ret < 0)
-            continue;
-
-        /* Parsing default si table */
-        char * str_tokens[MR_TOKENS_MAX] = {};
-        int nr_str_tokens =
-            rte_strsplit(str_default_si_table, sizeof(str_default_si_table), str_tokens, MR_TOKENS_MAX, ',');
-        if (nr_str_tokens != MR_NODE_COMMON_VLAN_FLIPPING_DEFAULT_ARG_NUM)
-        {
-            MR_ERROR("Vlan flipping adapter : %s ,invalid arg num.", str_section);
-            return RT_ERR;
-        }
-
-        /* Get dev desc */
-        struct mr_dev_desc * dev_desc = mr_dev_desc_lookup(sc->devmgr_main, str_tokens[0]);
-        if (dev_desc == NULL)
-        {
-            MR_ERROR("Vlan flipping adapter : %s ,invalid device name %s.", str_section, str_tokens[0]);
-            return RT_ERR;
-        }
-
-        /* Get default si */
-        char * endptr = NULL;
-        uint16_t default_si = strtoul(str_tokens[1], &endptr, 0);
-        if ((default_si == 0) && (memcmp(str_tokens[1], "0", sizeof("0")) != 0))
-        {
-            MR_ERROR("Vlan flipping adapter : %s ,invalid si %s.", str_section, str_tokens[1]);
-            return RT_ERR;
-        }
-
-        struct default_si_table * _default_si_table_item =
-            &_vlan_flipping_adapter->default_si_table_array[dev_desc->port_id];
-        if (_default_si_table_item->init_flg == 1)
-        {
-            MR_ERROR("Vlan flipping adapter : %s ,repeat configuration.", str_section);
-            return RT_ERR;
-        }
-
-        _default_si_table_item->init_flg = 1;
-        _default_si_table_item->default_si = default_si;
-    }
-
-    char str_enable_devices[MR_STRING_MAX];
-    int ret = MESA_load_profile_string_nodef(sc->local_cfgfile, "vlan_flipping_adapter", "enable_devices",
-                                             str_enable_devices, sizeof(str_enable_devices));
-    if (ret >= 0)
-    {
-
-        char * str_devices[MR_TOKENS_MAX] = {};
-        int nr_str_tokens =
-            rte_strsplit(str_enable_devices, sizeof(str_enable_devices), str_devices, MR_TOKENS_MAX, ',');
-
-        for (int device_index = 0; device_index < nr_str_tokens; device_index++)
-        {
-            /* Get dev desc */
-            struct mr_dev_desc * dev_desc = mr_dev_desc_lookup(sc->devmgr_main, str_devices[device_index]);
-            if (dev_desc == NULL)
-            {
-                MR_ERROR("Vlan flipping adapter : 'enable_devices',invalid device name :%s.",
-                         str_devices[device_index]);
-                return RT_ERR;
-            }
-
-            struct default_si_table * _default_si_table_item =
-                &_vlan_flipping_adapter->default_si_table_array[dev_desc->port_id];
-            if (_default_si_table_item->init_flg == 0)
-            {
-                MR_ERROR("Vlan flipping adapter : 'enable_devices',the device '%s' no config 'default_si_table'.",
-                         str_devices[device_index]);
-                return RT_ERR;
-            }
-
-            _default_si_table_item->dev_enable = 1;
-        }
-    }
-
-    /* Parsing enable config */
-    unsigned int en_adapter = 0;
-    MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "enable", &en_adapter, 0);
-
-    /* Parsing vlan range */
-    unsigned int etherfabric_vlan_range_start, etherfabric_vlan_range_end;
-    unsigned int virtual_wire_vlan_range_start, virtual_wire_vlan_range_end;
-    MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "etherfabric_vlan_range_start",
-                               &etherfabric_vlan_range_start, DEFAULT_ETHERFABRIC_VLAN_RANGE_START);
-    MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "etherfabric_vlan_range_end",
-                               &etherfabric_vlan_range_end, DEFAULT_ETHERFABRIC_VLAN_RANGE_END);
-    MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "virtual_wire_vlan_range_start",
-                               &virtual_wire_vlan_range_start, DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_START);
-    MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "virtual_wire_vlan_range_end",
-                               &virtual_wire_vlan_range_end, DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_END);
-
-    /* Check vlan range */
-    if (etherfabric_vlan_range_start > etherfabric_vlan_range_end)
-    {
-        MR_ERROR("Vlan flipping adapter : 'etherfabric_vlan_range_start:%u',must be less than "
-                 "'etherfabric_vlan_range_end:%u'.",
-                 etherfabric_vlan_range_start, etherfabric_vlan_range_end);
-        return RT_ERR;
-    }
-
-    if (virtual_wire_vlan_range_start > virtual_wire_vlan_range_end)
-    {
-        MR_ERROR("Vlan flipping adapter : 'virtual_wire_vlan_range_start:%u',must be less than "
-                 "'virtual_wire_vlan_range_end:%u'.",
-                 virtual_wire_vlan_range_start, virtual_wire_vlan_range_end);
-        return RT_ERR;
-    }
-
-    _vlan_flipping_adapter->enable = en_adapter;
-    _vlan_flipping_adapter->etherfabric_vlan_range_start = etherfabric_vlan_range_start;
-    _vlan_flipping_adapter->etherfabric_vlan_range_end = etherfabric_vlan_range_end;
-    _vlan_flipping_adapter->virtual_wire_vlan_range_start = virtual_wire_vlan_range_start;
-    _vlan_flipping_adapter->virtual_wire_vlan_range_end = virtual_wire_vlan_range_end;
-    return RT_SUCCESS;
-}
-
-int vlan_flipping_adapter_init(struct sc_main * sc)
-{
-    int ret = RT_SUCCESS;
-    struct vlan_flipping_adapter * _vlan_flipping_adapter = ZMALLOC(sizeof(struct vlan_flipping_adapter));
-    MR_VERIFY_MALLOC(_vlan_flipping_adapter);
-
-    g_vlan_flipping_adapter = _vlan_flipping_adapter;
-    ret = parser_vlan_flipping_adapter_conf(sc, _vlan_flipping_adapter);
-    return ret;
-}
-
-uint16_t vlan_flipping_adapter_encode(uint8_t dir, uint16_t fwd_table_index, uint16_t vlan_range_start)
-{
-    return ((fwd_table_index * 2) + dir + vlan_range_start);
-}
-
-void vlan_flipping_adapter_decode(struct private_data * private_ctrlzone, uint16_t vlan_id,
-                                  struct default_si_table * _default_si_table_item)
-{
-    uint8_t service_type = MR_NODE_COMMON_MAX_SERVICE;
-    uint16_t vlan_range_start = 0;
-
-    if ((vlan_id >= g_vlan_flipping_adapter->etherfabric_vlan_range_start) &&
-        (vlan_id <= g_vlan_flipping_adapter->etherfabric_vlan_range_end))
-    {
-        vlan_range_start = g_vlan_flipping_adapter->etherfabric_vlan_range_start;
-        service_type = MR_NODE_COMMON_ETHERFABRIC_SERVICE;
-    }
-    else if ((vlan_id >= g_vlan_flipping_adapter->virtual_wire_vlan_range_start) &&
-             (vlan_id <= g_vlan_flipping_adapter->virtual_wire_vlan_range_end))
-    {
-        vlan_range_start = g_vlan_flipping_adapter->virtual_wire_vlan_range_start;
-        service_type = MR_NODE_COMMON_VWIRE_SERVICE;
-    }
-
-    /* Decode */
-    uint8_t dir = (vlan_id - vlan_range_start) % 2;
-    uint16_t fwd_table_index = ((vlan_id - vlan_range_start) - (vlan_id - vlan_range_start) % 2) / 2;
-
-    if (service_type == MR_NODE_COMMON_ETHERFABRIC_SERVICE)
-    {
-        private_ctrlzone->tag.etherfabric.fwd_table_index = fwd_table_index;
-        private_ctrlzone->tag.etherfabric.dir = dir;
-    }
-    else if (service_type == MR_NODE_COMMON_VWIRE_SERVICE)
-    {
-        private_ctrlzone->tag.vwire.fwd_table_index = fwd_table_index;
-        private_ctrlzone->tag.vwire.dir = dir;
-    }
-
-    private_ctrlzone->service_type = service_type;
-    private_ctrlzone->si_id = _default_si_table_item->default_si + 1;
-}
 
 uint16_t shmdev_rx_node_process(struct rte_graph * graph, struct rte_node * node, void ** objs, uint16_t cnt)
 {
@@ -271,9 +59,17 @@ uint16_t shmdev_rx_node_process(struct rte_graph * graph, struct rte_node * node
     /* Save number of objects used */
     unsigned int n_left_from = node->idx = rx_nr_mbufs;
 
+    /* Get stream for the speculated next node */
+    unsigned int next_index = SHMDEV_RX_NEXT_NODE_FORWARDER;
+    void ** to_next = rte_node_next_stream_get(graph, node, next_index, rx_nr_mbufs);
+    void ** from = (void **)node->objs;
+    unsigned int last_spec = 0;
+    unsigned int held = 0;
+
     /* Deal all pkt */
     while (n_left_from > 0)
     {
+        unsigned int next0 = SHMDEV_RX_NEXT_NODE_FORWARDER;
         struct rte_mbuf * mbuf0 = mbufs[0];
         struct private_data * private_ctrlzone = mrbuf_cz_data(mbuf0, MR_NODE_CTRLZONE_ID);
 
@@ -285,15 +81,14 @@ uint16_t shmdev_rx_node_process(struct rte_graph * graph, struct rte_node * node
         n_left_from -= 1;
 
         /* Check pkt */
-        if (unlikely(private_ctrlzone->original_packet_flag == MR_NODE_COMMON_ORIGINAL_PKT))
+        if (likely(private_ctrlzone->packet_create_from_nf == 0))
         {
             MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, original_pkt, 1);
         }
         else
         {
             /* Update new create pkt */
-            MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, new_create_pkt, 1);
-            memset(private_ctrlzone, 0, sizeof(struct private_data));
+            MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, nf_create_pkt, 1);
 
             /* prepare to parse the ingress pkt */
             struct pkt_parser pkt_parser;
@@ -302,34 +97,55 @@ uint16_t shmdev_rx_node_process(struct rte_graph * graph, struct rte_node * node
             /* parse the packet, and copy the result to the private zone */
             complex_parser_ether(&pkt_parser, rte_pktmbuf_mtod(mbuf0, const char *));
             private_ctrlzone->pkt_parser_result = pkt_parser.result;
-
-            /* decode the si from vlan id */
-            struct default_si_table * _default_si_table_item =
-                &g_vlan_flipping_adapter->default_si_table_array[dev_desc->port_id];
-            if (g_vlan_flipping_adapter->enable && _default_si_table_item->dev_enable)
-            {
-                uint16_t vlan_id = mbuf0->vlan_tci;
-                if ((vlan_id % 2) == 1)
-                    vlan_id = vlan_id - 1;
-                else
-                    vlan_id = vlan_id + 1;
-
-                vlan_flipping_adapter_decode(private_ctrlzone, vlan_id, _default_si_table_item);
-                mbuf0->ol_flags = 0;
-                mbuf0->vlan_tci = 0;
-            }
         }
 
         /* Fill port ingress  */
         private_ctrlzone->port_ingress = dev_desc->port_id;
+
+        /* check health check pkt */
+        struct rte_ether_hdr * ether_hdr = rte_pktmbuf_mtod(mbuf0, struct rte_ether_hdr *);
+        if (unlikely(ether_hdr->ether_type == HEALTH_CHECK_PRIVATE))
+        {
+            MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, to_health_check_pkt, 1);
+            next0 = SHMDEV_RX_NEXT_NODE_HEALTH_CHECK;
+        }
+        else
+        {
+            MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, to_eth_forwarder_pkt, 1);
+        }
+
+        if (unlikely(next_index ^ next0))
+        {
+            /* Copy things successfully speculated till now */
+            rte_memcpy(to_next, from, last_spec * sizeof(from[0]));
+            from += last_spec;
+            to_next += last_spec;
+            held += last_spec;
+            last_spec = 0;
+
+            rte_node_enqueue_x1(graph, node, next0, from[0]);
+            from += 1;
+        }
+        else
+        {
+            last_spec += 1;
+        }
     }
 
     /* Update total rx pkts */
     MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, total_rx_pkts, rx_nr_mbufs);
-    MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, to_eth_ingress_pkt, rx_nr_mbufs);
 
-    /* move to next node */
-    rte_node_next_stream_move(graph, node, 0);
+    /* home run */
+    if (likely(last_spec == rx_nr_mbufs))
+    {
+        rte_node_next_stream_move(graph, node, next_index);
+        return rx_nr_mbufs;
+    }
+
+    held += last_spec;
+    rte_memcpy(to_next, from, last_spec * sizeof(from[0]));
+    rte_node_next_stream_put(graph, node, next_index, held);
+
     return rx_nr_mbufs;
 }
 
@@ -340,38 +156,6 @@ uint16_t shmdev_tx_node_process(struct rte_graph * graph, struct rte_node * node
 
     struct mr_dev_desc * dev_desc = ctx->dev_desc;
     struct vdev * shm_dev_desc = dev_desc->shm_dev_desc;
-    struct default_si_table * _default_si_table_item =
-        &g_vlan_flipping_adapter->default_si_table_array[dev_desc->port_id];
-
-    if (g_vlan_flipping_adapter->enable && _default_si_table_item->dev_enable)
-    {
-        for (int i = 0; i < cnt; i++)
-        {
-            uint8_t dir = 0;
-            uint16_t fwd_table_index = 0;
-            uint16_t vlan_range_start = 0;
-
-            /* Get encode arg */
-            struct private_data * private_ctrlzone = mrbuf_cz_data(mbufs[i], MR_NODE_CTRLZONE_ID);
-            if (private_ctrlzone->service_type == MR_NODE_COMMON_ETHERFABRIC_SERVICE)
-            {
-                fwd_table_index = private_ctrlzone->tag.etherfabric.fwd_table_index;
-                dir = private_ctrlzone->tag.etherfabric.dir;
-                vlan_range_start = g_vlan_flipping_adapter->etherfabric_vlan_range_start;
-            }
-            else if (private_ctrlzone->service_type == MR_NODE_COMMON_VWIRE_SERVICE)
-            {
-                fwd_table_index = private_ctrlzone->tag.vwire.fwd_table_index;
-                dir = private_ctrlzone->tag.vwire.dir;
-                vlan_range_start = g_vlan_flipping_adapter->virtual_wire_vlan_range_start;
-            }
-
-            /* Pkt encode */
-            uint16_t vlan_id = vlan_flipping_adapter_encode(dir, fwd_table_index, vlan_range_start);
-            mbufs[i]->ol_flags = RTE_MBUF_F_RX_VLAN;
-            mbufs[i]->vlan_tci = vlan_id;
-        }
-    }
 
     MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, total_tx_pkts, cnt);
     vdev_dispatch(shm_dev_desc, graph->id, mbufs, cnt, 0);
@@ -416,9 +200,9 @@ cJSON * shmdev_rx_node_monit_loop(struct sc_main * sc)
         cJSON * graph_obj = cJSON_CreateObject();
         cJSON_AddNumberToObject(graph_obj, "total_rx_pkts", stat_item->total_rx_pkts);
         cJSON_AddNumberToObject(graph_obj, "original_pkt", stat_item->original_pkt);
-        cJSON_AddNumberToObject(graph_obj, "new_create_pkt", stat_item->new_create_pkt);
-        cJSON_AddNumberToObject(graph_obj, "no_eth_hdr_pkt", stat_item->no_eth_hdr_pkt);
-        cJSON_AddNumberToObject(graph_obj, "to_eth_ingress_pkt", stat_item->to_eth_ingress_pkt);
+        cJSON_AddNumberToObject(graph_obj, "nf_create_pkt", stat_item->nf_create_pkt);
+        cJSON_AddNumberToObject(graph_obj, "to_eth_forwarder_pkt", stat_item->to_eth_forwarder_pkt);
+        cJSON_AddNumberToObject(graph_obj, "to_health_check_pkt", stat_item->to_health_check_pkt);
 
         char graph_index[MR_STRING_MAX] = {};
         sprintf(graph_index, "graph-%u", graph_id);