✨ feat(TSG-11819): VlanFlippingAdapter添加VWire处理流程

VlanFlippingAdapter添加VWire处理流程

1 files changed, 154 insertions, 205 deletions

diff --git a/service/src/node_shmdev.c b/service/src/node_shmdev.c
index 525f29a..f7f9960 100644
--- a/service/src/node_shmdev.c
+++ b/service/src/node_shmdev.c
@@ -1,3 +1,4 @@
+#include "rte_branch_prediction.h"
 #include <rte_debug.h>
 #include <rte_ethdev.h>
 #include <rte_ether.h>
@@ -5,59 +6,59 @@
 #include <rte_graph_worker.h>
 #include <rte_mbuf.h>
 
-#include <sc_node.h>
-#include <sc_vdev.h>
+#include <MESA_prof_load.h>
+#include <cJSON.h>
 #include <mrb_define.h>
+#include <sc_node.h>
 #include <sc_node_common.h>
+#include <sc_vdev.h>
 #include <sys/ucontext.h>
-#include <cJSON.h>
-#include <MESA_prof_load.h>
 
 #ifndef MR_VLAN_FLIPPING_ADAPTER_DISABLE
-#define MR_VLAN_FLIPPING_ADAPTER_DISABLE                    0
+#define MR_VLAN_FLIPPING_ADAPTER_DISABLE 0
 #endif
 
 #ifndef MR_VLAN_FLIPPING_ADAPTER_ENABLE
-#define MR_VLAN_FLIPPING_ADAPTER_ENABLE                     1
+#define MR_VLAN_FLIPPING_ADAPTER_ENABLE 1
 #endif
 
 #ifndef MR_VLAN_FLIPPING_ADAPTER_DEVICE_DISABLE
-#define MR_VLAN_FLIPPING_ADAPTER_DEVICE_DISABLE             MR_VLAN_FLIPPING_ADAPTER_DISABLE
+#define MR_VLAN_FLIPPING_ADAPTER_DEVICE_DISABLE MR_VLAN_FLIPPING_ADAPTER_DISABLE
 #endif
 
 #ifndef MR_VLAN_FLIPPING_ADAPTER_DEVICE_ENABLE
-#define MR_VLAN_FLIPPING_ADAPTER_DEVICE_ENABLE              MR_VLAN_FLIPPING_ADAPTER_ENABLE
+#define MR_VLAN_FLIPPING_ADAPTER_DEVICE_ENABLE MR_VLAN_FLIPPING_ADAPTER_ENABLE
 #endif
 
 #ifndef MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_UNINITIALIZED
-#define MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_UNINITIALIZED     MR_VLAN_FLIPPING_ADAPTER_DISABLE
+#define MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_UNINITIALIZED MR_VLAN_FLIPPING_ADAPTER_DISABLE
 #endif
 
 #ifndef MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_INITIALIZED
-#define MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_INITIALIZED       MR_VLAN_FLIPPING_ADAPTER_ENABLE
+#define MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_INITIALIZED MR_VLAN_FLIPPING_ADAPTER_ENABLE
 #endif
 
 #ifndef DEFAULT_ETHERFABRIC_VLAN_RANGE_START
-#define DEFAULT_ETHERFABRIC_VLAN_RANGE_START                1000
+#define DEFAULT_ETHERFABRIC_VLAN_RANGE_START 1000
 #endif
 
 #ifndef DEFAULT_ETHERFABRIC_VLAN_RANGE_END
-#define DEFAULT_ETHERFABRIC_VLAN_RANGE_END                  3047
+#define DEFAULT_ETHERFABRIC_VLAN_RANGE_END 3047
 #endif
 
 #ifndef DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_START
-#define DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_START               4000
+#define DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_START 4000
 #endif
 
 #ifndef DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_END
-#define DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_END                 6047
+#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)                                                                                                                  \
+#define MR_SHMDEV_STAT_ADD(st, graph_id, counter, value)                                                               \
+    do                                                                                                                 \
+    {                                                                                                                  \
+        st[graph_id].counter += value;                                                                                 \
+    } while (0)
 
 struct shmdev_rx_node_ctx
 {
@@ -118,7 +119,7 @@ struct shmdev_stat_per_lcore
     volatile uint64_t new_create_pkt;
 };
 
- struct shmdev_stat_per_lcore shmdev_graph_stat[RTE_MAX_LCORE];
+struct shmdev_stat_per_lcore shmdev_graph_stat[RTE_MAX_LCORE];
 
 static struct shmdev_rx_node_main __shmdev_rx_node_main;
 static struct shmdev_tx_node_main __shmdev_tx_node_main;
@@ -134,175 +135,128 @@ static_assert(sizeof(struct shmdev_tx_node_ctx) <= RTE_NODE_CTX_SZ,
 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);
 
-/*
- * 功能:字符串转uint
- */
-static int str2uint(const char *str, unsigned int  *val)
-{
-    unsigned int  tmpval;
-    char  *tmp_str=(char *)str;
-    char  check_str[16]={0};
-    if(tmp_str==NULL||strlen(tmp_str)<=0||strlen(tmp_str)>11||*tmp_str=='-')
-        return -1;
-    tmpval=(unsigned int)strtoul(str,NULL,0);
-    //tmpval=(unsigned int)atoi(tmp_str);
-    sprintf(check_str,"%u",tmpval);
-    if(*str=='+')
-        tmp_str++;
-    if(strncasecmp(tmp_str,check_str,strlen(tmp_str))==0)
-    {
-        *val=tmpval;
-        return 0;
-    }
-    else
-    {
-        return -1;
-    }
-}
-
 /* Parsing The Vlan Flipping Adapter Config */
 int parser_vlan_flipping_adapter_conf(struct sc_main * sc, struct vlan_flipping_adapter * _vlan_flipping_adapter)
 {
+    uint16_t default_si = 0;
     int ret = RT_SUCCESS;
-    uint32_t default_si = 0;
     unsigned int adapter_enable = MR_VLAN_FLIPPING_ADAPTER_DISABLE;
-    unsigned int  etherfabric_vlan_range_start ,etherfabric_vlan_range_end ,virtual_wire_vlan_range_start,virtual_wire_vlan_range_end;
+    unsigned int etherfabric_vlan_range_start, etherfabric_vlan_range_end, virtual_wire_vlan_range_start,
+        virtual_wire_vlan_range_end;
     char str_section[MR_STRING_MAX];
     char str_default_si_table[MR_STRING_MAX];
     char str_enable_devices[MR_STRING_MAX];
     struct vdev * vdev = NULL;
     struct default_si_table * _default_si_table_item = NULL;
 
-    for (int index = 0; index < MR_VDEV_MAX; index ++)
+    for (int index = 0; index < MR_VDEV_MAX; index++)
     {
         char * str_tokens[MR_TOKENS_MAX];
+        char * endptr = NULL;
         snprintf(str_section, sizeof(str_section), "default_si_table_%d", index);
-        ret = MESA_load_profile_string_nodef(sc->local_cfgfile, "vlan_flipping_adapter", str_section, str_default_si_table,sizeof(str_default_si_table));
+        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;
-        }
 
-        int nr_str_tokens = rte_strsplit(str_default_si_table, sizeof(str_default_si_table), 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);
+            MR_ERROR("Vlan Flipping Adapter : %s Invalid Arg Num.", str_section);
             return RT_ERR;
         }
 
         vdev = vdev_lookup(sc->vdev_main, str_tokens[0]);
         if (vdev == NULL)
         {
-            MR_ERROR("Vlan Flipping Adapter : %s Invalid Device Name %s.",str_section,str_tokens[0]);
+            MR_ERROR("Vlan Flipping Adapter : %s Invalid Device Name %s.", str_section, str_tokens[0]);
             return RT_ERR;
         }
 
-        if(str2uint(str_tokens[1],&default_si)<0)
+        default_si = strtoul(str_tokens[1], &endptr, 0);
+        if (default_si == 0)
         {
-            MR_ERROR("Vlan Flipping Adapter : %s Invalid Si %s.",str_section,str_tokens[1]);
+            MR_ERROR("Vlan Flipping Adapter : %s Invalid Si %s.", str_section, str_tokens[1]);
             return RT_ERR;
         }
 
         if (default_si > MR_NODE_COMMON_MAX_SI_ID)
         {
-            MR_ERROR("Vlan Flipping Adapter : %s Invalid Si %u.",str_section,default_si);
+            MR_ERROR("Vlan Flipping Adapter : %s Invalid Si %u.", str_section, default_si);
             return RT_ERR;
         }
 
         _default_si_table_item = &_vlan_flipping_adapter->default_si_table_array[vdev->port_id];
         if (_default_si_table_item->init_flg == MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_INITIALIZED)
         {
-            MR_ERROR("Vlan Flipping Adapter : %s Repeat Configuration.",str_section);
+            MR_ERROR("Vlan Flipping Adapter : %s Repeat Configuration.", str_section);
             return RT_ERR;
         }
 
         _default_si_table_item->init_flg = MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_INITIALIZED;
-        _default_si_table_item->default_si = (uint16_t)default_si;
+        _default_si_table_item->default_si = default_si;
     }
 
-    ret = MESA_load_profile_string_nodef(sc->local_cfgfile, "vlan_flipping_adapter", "enable_devices", str_enable_devices,sizeof(str_enable_devices));
+    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, ',');
+        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++)
         {
             vdev = vdev_lookup(sc->vdev_main, str_devices[device_index]);
             if (vdev == NULL)
             {
-                MR_ERROR("Vlan Flipping Adapter : 'enable_devices' Invalid Device Name :%s.",str_devices[device_index]);
+                MR_ERROR("Vlan Flipping Adapter : 'enable_devices' Invalid Device Name :%s.",
+                         str_devices[device_index]);
                 return RT_ERR;
             }
             _default_si_table_item = &_vlan_flipping_adapter->default_si_table_array[vdev->port_id];
             if (_default_si_table_item->init_flg != MR_VLAN_FLIPPING_ADAPTER_SI_TABLE_INITIALIZED)
             {
-                MR_ERROR("Vlan Flipping Adapter :'enable_devices' The Device '%s' No Config 'default_si_table'.",str_devices[device_index]);
+                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->vdev_enable = MR_VLAN_FLIPPING_ADAPTER_DEVICE_ENABLE;
         }
     }
 
-    ret = MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "enable", &adapter_enable, MR_VLAN_FLIPPING_ADAPTER_DISABLE);
-    if (ret < 0)
-    {
-        _vlan_flipping_adapter->enable = MR_VLAN_FLIPPING_ADAPTER_DISABLE;
-    }
-    else
-    {
-        _vlan_flipping_adapter->enable = (adapter_enable == MR_VLAN_FLIPPING_ADAPTER_ENABLE) ? MR_VLAN_FLIPPING_ADAPTER_ENABLE : MR_VLAN_FLIPPING_ADAPTER_DISABLE;
-    }
-
-    ret = MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "etherfabric_vlan_range_start", &etherfabric_vlan_range_start, DEFAULT_ETHERFABRIC_VLAN_RANGE_START);
-    if (ret < 0)
-    {
-        _vlan_flipping_adapter->etherfabric_vlan_range_start = DEFAULT_ETHERFABRIC_VLAN_RANGE_START;
-    }
-    else
-    {
-        _vlan_flipping_adapter->etherfabric_vlan_range_start = etherfabric_vlan_range_start;
-    }
-
-    ret = MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "etherfabric_vlan_range_end", &etherfabric_vlan_range_end, DEFAULT_ETHERFABRIC_VLAN_RANGE_END);
-    if (ret < 0)
-    {
-        if (etherfabric_vlan_range_start != DEFAULT_ETHERFABRIC_VLAN_RANGE_START)
-        {
-            MR_ERROR("Vlan Flipping Adapter : 'etherfabric_vlan_range_end' No Config.");
-            return RT_ERR;
-        }
-        _vlan_flipping_adapter->etherfabric_vlan_range_end = DEFAULT_ETHERFABRIC_VLAN_RANGE_END;
-    }
-    else
-    {
-        _vlan_flipping_adapter->etherfabric_vlan_range_end = etherfabric_vlan_range_end;
-    }
-
-    ret = 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);
-    if (ret < 0)
+    MESA_load_profile_uint_def(sc->local_cfgfile, "vlan_flipping_adapter", "enable", &adapter_enable,
+                               MR_VLAN_FLIPPING_ADAPTER_DISABLE);
+    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);
+
+    if (etherfabric_vlan_range_start > etherfabric_vlan_range_end)
     {
-        _vlan_flipping_adapter->virtual_wire_vlan_range_start = DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_START;
+        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;
     }
-    else
+    if (virtual_wire_vlan_range_start > virtual_wire_vlan_range_end)
     {
-        _vlan_flipping_adapter->virtual_wire_vlan_range_start = virtual_wire_vlan_range_start;
+        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;
     }
 
-    ret = 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);
-    if (ret < 0)
-    {
-        if (virtual_wire_vlan_range_start != DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_START)
-        {
-            MR_ERROR("Vlan Flipping Adapter : 'virtual_wire_vlan_range_end' No Config.");
-            return RT_ERR;
-        }
-        _vlan_flipping_adapter->virtual_wire_vlan_range_end = DEFAULT_VIRTUAL_WIRE_VLAN_RANGE_END;
-    }
-    else
-    {
-        _vlan_flipping_adapter->virtual_wire_vlan_range_end = virtual_wire_vlan_range_end;
-    }
+    _vlan_flipping_adapter->enable = adapter_enable;
+    _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;
 }
 
@@ -313,42 +267,52 @@ int vlan_flipping_adapter_init(struct sc_main * sc)
     MR_VERIFY_MALLOC(_vlan_flipping_adapter);
 
     _global_vlan_flipping_adapter = _vlan_flipping_adapter;
-    ret = parser_vlan_flipping_adapter_conf(sc,_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)
+uint16_t vlan_flipping_adapter_encode(uint8_t dir, uint16_t fwd_table_index, uint16_t vlan_range_start)
 {
-    uint16_t vlan_id = 0 ;
+    uint16_t vlan_id = 0;
 
     vlan_id = ((fwd_table_index * 2) + dir + vlan_range_start);
     return vlan_id;
 }
 
-void etherfabric_vlan_id_decode(struct private_data * private_ctrlzone,uint16_t vlan_id,struct default_si_table * _default_si_table_item)
+void vlan_flipping_adapter_decode(struct private_data * private_ctrlzone, uint16_t vlan_id,
+                                  struct default_si_table * _default_si_table_item)
 {
     uint8_t dir = 0, service_type = MR_NODE_COMMON_MAX_SERVICE;
-    uint16_t fwd_table_index = 0, service_index = 0,vlan_range_start = 0,port_ingress = 0;
+    uint16_t fwd_table_index = 0, service_index = 0, vlan_range_start = 0, port_ingress = 0;
 
-    if ((vlan_id >= _global_vlan_flipping_adapter->etherfabric_vlan_range_start) && (vlan_id <= _global_vlan_flipping_adapter->etherfabric_vlan_range_end))
+    if ((vlan_id >= _global_vlan_flipping_adapter->etherfabric_vlan_range_start) &&
+        (vlan_id <= _global_vlan_flipping_adapter->etherfabric_vlan_range_end))
     {
         vlan_range_start = _global_vlan_flipping_adapter->etherfabric_vlan_range_start;
         service_type = MR_NODE_COMMON_ETHERFABRIC_SERVICE;
     }
+    else if ((vlan_id >= _global_vlan_flipping_adapter->virtual_wire_vlan_range_start) &&
+             (vlan_id <= _global_vlan_flipping_adapter->virtual_wire_vlan_range_end))
+    {
+        vlan_range_start = _global_vlan_flipping_adapter->virtual_wire_vlan_range_start;
+        service_type = MR_NODE_COMMON_VWIRE_SERVICE;
+    }
 
     dir = (vlan_id - vlan_range_start) % 2;
-    fwd_table_index =((vlan_id - vlan_range_start) - (vlan_id - vlan_range_start) % 2) / 2;
+    fwd_table_index = ((vlan_id - vlan_range_start) - (vlan_id - vlan_range_start) % 2) / 2;
 
-    switch (service_type)
+    if (service_type == MR_NODE_COMMON_ETHERFABRIC_SERVICE)
     {
-        case MR_NODE_COMMON_ETHERFABRIC_SERVICE:
-        {
-            service_index = etherfabric_get_service_index_for_fwd_id(fwd_table_index);
-            port_ingress = etherfabric_get_port_index_for_service_id(service_index);
-            private_ctrlzone->tag.etherfabric.fwd_table_index = fwd_table_index;
-            private_ctrlzone->tag.etherfabric.dir = dir;
-        }
-        break;
+        service_index = etherfabric_get_service_index_for_fwd_id(fwd_table_index);
+        port_ingress = etherfabric_get_port_index_for_service_id(service_index);
+        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)
+    {
+        port_ingress = 65535;
+        private_ctrlzone->tag.vwire.fwd_table_index = fwd_table_index;
+        private_ctrlzone->tag.vwire.dir = dir;
     }
 
     private_ctrlzone->service_type = service_type;
@@ -360,7 +324,8 @@ static __rte_always_inline uint16_t shmdev_rx_node_process(struct rte_graph * gr
                                                            void ** objs, uint16_t cnt)
 {
     struct shmdev_rx_node_ctx * ctx = (struct shmdev_rx_node_ctx *)node->ctx;
-    struct default_si_table * _default_si_table_item = &_global_vlan_flipping_adapter->default_si_table_array[ctx->vdev->port_id];
+    struct default_si_table * _default_si_table_item =
+        &_global_vlan_flipping_adapter->default_si_table_array[ctx->vdev->port_id];
     struct rte_mbuf ** mbufs = (struct rte_mbuf **)node->objs;
 
     RTE_SET_USED(objs);
@@ -369,33 +334,30 @@ static __rte_always_inline uint16_t shmdev_rx_node_process(struct rte_graph * gr
     unsigned int rx_nr_mbufs =
         vdev_collect(ctx->vdev, graph->id, (struct rte_mbuf **)node->objs, RTE_GRAPH_BURST_SIZE, VDEV_COLLECT_DATA);
 
-    if (rx_nr_mbufs == 0)
-    {
+    if (unlikely(rx_nr_mbufs == 0))
         return 0;
-    }
 
-    MR_SHMDEV_STAT_ADD(shmdev_graph_stat,graph->id,total_rx_pkts,rx_nr_mbufs);
+    MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, total_rx_pkts, rx_nr_mbufs);
     for (int i = 0; i < rx_nr_mbufs; i++)
     {
         struct private_data * private_ctrlzone = mrbuf_cz_data(mbufs[i], 0);
-        if (unlikely(private_ctrlzone->original_packet_flag != MR_NODE_COMMON_ORIGINAL_PKT))
+        if (unlikely(private_ctrlzone->original_packet_flag == MR_NODE_COMMON_ORIGINAL_PKT))
+            MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, original_pkt, 1);
+        else
         {
             struct pkt_parser * pkt_parser_ptr = &private_ctrlzone->pkt_parser;
+            MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, new_create_pkt, 1);
             pkt_parser_init(pkt_parser_ptr, LAYER_TYPE_ALL, MR_PKT_PARSE_RESULT_MAX);
-            complex_parser_ether(pkt_parser_ptr, rte_pktmbuf_mtod(mbufs[i],const char *));
+            complex_parser_ether(pkt_parser_ptr, rte_pktmbuf_mtod(mbufs[i], const char *));
 
-            if ((_global_vlan_flipping_adapter->enable == MR_VLAN_FLIPPING_ADAPTER_ENABLE) && (_default_si_table_item->vdev_enable == MR_VLAN_FLIPPING_ADAPTER_DEVICE_ENABLE))
+            if ((_global_vlan_flipping_adapter->enable == MR_VLAN_FLIPPING_ADAPTER_ENABLE) &&
+                (_default_si_table_item->vdev_enable == MR_VLAN_FLIPPING_ADAPTER_DEVICE_ENABLE))
             {
                 uint16_t vlan_id = mbufs[i]->vlan_tci;
-                etherfabric_vlan_id_decode(private_ctrlzone,vlan_id,_default_si_table_item);
+                vlan_flipping_adapter_decode(private_ctrlzone, vlan_id, _default_si_table_item);
                 mbufs[i]->ol_flags = 0;
                 mbufs[i]->vlan_tci = 0;
             }
-            MR_SHMDEV_STAT_ADD(shmdev_graph_stat,graph->id,new_create_pkt,1);
-        }
-        else
-        {
-            MR_SHMDEV_STAT_ADD(shmdev_graph_stat,graph->id,original_pkt,1);
         }
     }
 
@@ -409,9 +371,11 @@ static __rte_always_inline uint16_t shmdev_tx_node_process(struct rte_graph * gr
 {
     struct shmdev_tx_node_ctx * ctx = (struct shmdev_tx_node_ctx *)node->ctx;
     struct rte_mbuf ** mbufs = (struct rte_mbuf **)objs;
-    struct default_si_table * _default_si_table_item = &_global_vlan_flipping_adapter->default_si_table_array[ctx->vdev->port_id];
+    struct default_si_table * _default_si_table_item =
+        &_global_vlan_flipping_adapter->default_si_table_array[ctx->vdev->port_id];
 
-    if ((_global_vlan_flipping_adapter->enable == MR_VLAN_FLIPPING_ADAPTER_ENABLE) && (_default_si_table_item->vdev_enable == MR_VLAN_FLIPPING_ADAPTER_DEVICE_ENABLE))
+    if ((_global_vlan_flipping_adapter->enable == MR_VLAN_FLIPPING_ADAPTER_ENABLE) &&
+        (_default_si_table_item->vdev_enable == MR_VLAN_FLIPPING_ADAPTER_DEVICE_ENABLE))
     {
         uint8_t dir = 0;
         uint16_t fwd_table_index = 0;
@@ -420,24 +384,26 @@ static __rte_always_inline uint16_t shmdev_tx_node_process(struct rte_graph * gr
         for (int i = 0; i < cnt; i++)
         {
             struct private_data * private_ctrlzone = mrbuf_cz_data(mbufs[i], 0);
-            switch (private_ctrlzone->service_type)
+            if (private_ctrlzone->service_type == MR_NODE_COMMON_ETHERFABRIC_SERVICE)
             {
-                case MR_NODE_COMMON_ETHERFABRIC_SERVICE:
-                {
-                    fwd_table_index = private_ctrlzone->tag.etherfabric.fwd_table_index;
-                    dir = private_ctrlzone->tag.etherfabric.dir;
-                    vlan_range_start = _global_vlan_flipping_adapter->etherfabric_vlan_range_start;
-                }
-                break;
+                fwd_table_index = private_ctrlzone->tag.etherfabric.fwd_table_index;
+                dir = private_ctrlzone->tag.etherfabric.dir;
+                vlan_range_start = _global_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 = _global_vlan_flipping_adapter->virtual_wire_vlan_range_start;
             }
 
-            vlan_id = vlan_flipping_adapter_encode(dir,fwd_table_index,vlan_range_start);
+            vlan_id = vlan_flipping_adapter_encode(dir, fwd_table_index, vlan_range_start);
             mbufs[i]->ol_flags = PKT_RX_VLAN;
             mbufs[i]->vlan_tci = vlan_id;
         }
     }
 
-    MR_SHMDEV_STAT_ADD(shmdev_graph_stat,graph->id,total_tx_pkts,cnt);
+    MR_SHMDEV_STAT_ADD(shmdev_graph_stat, graph->id, total_tx_pkts, cnt);
     vdev_dispatch(ctx->vdev, graph->id, mbufs, cnt, 0);
     return cnt;
 }
@@ -492,9 +458,10 @@ static struct rte_node_register shmdev_tx_node_base = {
     .name = "shmdev_tx",
     .init = shmdev_tx_node_init,
     .nb_edges = 1,
-    .next_nodes = {
-        [0] = "pkt_drop",
-    },
+    .next_nodes =
+        {
+            [0] = "pkt_drop",
+        },
     //.flags = RTE_NODE_SOURCE_F,
 };
 
@@ -538,7 +505,7 @@ int node_manager_shmdev_init(struct sc_main * sc, struct node_manager_main * nod
         const char * edge_node = tx_node_name;
         snprintf(tx_node_name, sizeof(tx_node_name), "shmdev_tx-%s", vdev_iter->symbol);
         update_node_id = rte_node_from_name("eth_egress");
-        rte_node_edge_update(update_node_id, RTE_EDGE_ID_INVALID,&edge_node, 1);
+        rte_node_edge_update(update_node_id, RTE_EDGE_ID_INVALID, &edge_node, 1);
 
         tx_node_elem->nid = tx_node_id;
         tx_node_elem->ctx.vdev = vdev_iter;
@@ -548,7 +515,7 @@ int node_manager_shmdev_init(struct sc_main * sc, struct node_manager_main * nod
     }
 
     /* join all rx/tx nodes to all workers */
-    if(nr_vdevs > 0)
+    if (nr_vdevs > 0)
     {
         node_setup_desc_add_for_all_workers(node_mgr_main, "shmdev_rx-*");
         node_setup_desc_add_for_all_workers(node_mgr_main, "shmdev_tx-*");
@@ -565,35 +532,26 @@ int node_manager_shmdev_deinit(struct node_manager_main * node_mgr_main)
 /************************************** Shmdev Statistics **************************************/
 cJSON * shmdev_tx_node_monit_loop(struct sc_main * sc)
 {
-    uint32_t graph_id = 0,graph_num = 0;
-    cJSON * json_root = NULL,* graph_obj = NULL;
+    uint32_t graph_id = 0, graph_num = 0;
+    cJSON *json_root = NULL, *graph_obj = NULL;
     unsigned int nr_io_thread = sc->nr_io_thread;
-
     json_root = cJSON_CreateObject();
 
     for (graph_id = 0; graph_id < nr_io_thread; graph_id++)
     {
         char graph_index[MR_STRING_MAX];
         uint64_t stats = 0;
-        graph_obj = cJSON_CreateObject();
-
-         struct shmdev_stat_per_lcore * stat_item = &shmdev_graph_stat[graph_id];
 
+        struct shmdev_stat_per_lcore * stat_item = &shmdev_graph_stat[graph_id];
         stats = stat_item->total_tx_pkts;
-
-        if (stats > 0)
-        {
-            cJSON_AddNumberToObject(graph_obj, "total_tx_pkts", stats);
-        }
-        else
-        {
-            cJSON_Delete(graph_obj);
+        if (stats == 0)
             continue;
-        }
 
-        sprintf(graph_index,"graph-%u",graph_num);
-        cJSON_AddItemToObject(json_root,graph_index,graph_obj);
-        graph_num ++;
+        graph_obj = cJSON_CreateObject();
+        cJSON_AddNumberToObject(graph_obj, "total_tx_pkts", stats);
+        sprintf(graph_index, "graph-%u", graph_num);
+        cJSON_AddItemToObject(json_root, graph_index, graph_obj);
+        graph_num++;
     }
 
     cJSON_AddNumberToObject(json_root, "total_graph_num", graph_num);
@@ -602,39 +560,30 @@ cJSON * shmdev_tx_node_monit_loop(struct sc_main * sc)
 
 cJSON * shmdev_rx_node_monit_loop(struct sc_main * sc)
 {
-    uint32_t graph_id = 0,graph_num = 0;
-    cJSON * json_root = NULL,* graph_obj = NULL;
+    uint32_t graph_id = 0, graph_num = 0;
+    cJSON *json_root = NULL, *graph_obj = NULL;
     unsigned int nr_io_thread = sc->nr_io_thread;
-
     json_root = cJSON_CreateObject();
 
     for (graph_id = 0; graph_id < nr_io_thread; graph_id++)
     {
         char graph_index[MR_STRING_MAX];
         uint64_t stats = 0;
-        graph_obj = cJSON_CreateObject();
-
-         struct shmdev_stat_per_lcore * stat_item = &shmdev_graph_stat[graph_id];
+        struct shmdev_stat_per_lcore * stat_item = &shmdev_graph_stat[graph_id];
 
         stats = stat_item->total_rx_pkts;
-
-        if (stats > 0)
-        {
-            cJSON_AddNumberToObject(graph_obj, "total_rx_pkts", stats);
-            stats = stat_item->original_pkt;
-            cJSON_AddNumberToObject(graph_obj, "original_pkt", stats);
-            stats = stat_item->new_create_pkt;
-            cJSON_AddNumberToObject(graph_obj, "new_create_pkt", stats);
-        }
-        else
-        {
-            cJSON_Delete(graph_obj);
+        if (stats == 0)
             continue;
-        }
 
-        sprintf(graph_index,"graph-%u",graph_num);
-        cJSON_AddItemToObject(json_root,graph_index,graph_obj);
-        graph_num ++;
+        graph_obj = cJSON_CreateObject();
+        cJSON_AddNumberToObject(graph_obj, "total_rx_pkts", stats);
+        stats = stat_item->original_pkt;
+        cJSON_AddNumberToObject(graph_obj, "original_pkt", stats);
+        stats = stat_item->new_create_pkt;
+        cJSON_AddNumberToObject(graph_obj, "new_create_pkt", stats);
+        sprintf(graph_index, "graph-%u", graph_num);
+        cJSON_AddItemToObject(json_root, graph_index, graph_obj);
+        graph_num++;
     }
 
     cJSON_AddNumberToObject(json_root, "total_graph_num", graph_num);