🐞 fix(TSG-11429): 解决Classifier Rule 全量更新失败问题v4.6.2-20220914

解决Classifier Rule 全量更新失败问题

4 files changed, 82 insertions, 68 deletions

diff --git a/service/src/node_classifier.c b/service/src/node_classifier.c
index 7f7e317..78c6ec5 100644
--- a/service/src/node_classifier.c
+++ b/service/src/node_classifier.c
@@ -715,6 +715,7 @@ void dump_classifier_rule(struct classifier_rule * rule, struct mr_action * acti
         MR_INFO("     Proto                        : UDP");
         break;
     default:
+        MR_INFO("     Proto                        : ANY");
         break;
     }
 
@@ -791,6 +792,7 @@ uint16_t get_max_si_id(struct classifier_management * _classifier_management)
 int setup_classifier(struct classifier_management * _classifier_management)
 {
     int dim = 0, ret = 0;
+    uint32_t rule_item_id = 0;
     uint64_t rule_num = 0, add_rule_num = 0, def_size = 0, offset_unit = 0;
     char table_name[MR_STRING_MAX];
     struct rte_acl_param classifier_param;
@@ -832,10 +834,13 @@ int setup_classifier(struct classifier_management * _classifier_management)
     /* Add Classifier Rule */
     for (uint32_t i = 0; i < rule_num; i++)
     {
-        for (uint32_t rule_item_id = 0; rule_item_id < MAX_CLASSIFIER_RULE_NUM; rule_item_id++)
+        while (rule_item_id < MAX_CLASSIFIER_RULE_NUM)
         {
             if (classifier_action[rule_item_id].rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
+            {
+                rule_item_id++;
                 continue;
+            }
             struct rte_acl_rule * rule_item = (struct rte_acl_rule *)(classifier_rule + (offset_unit * rule_item_id));
             add_rule_num++;
             ret = rte_acl_add_rules(context, rule_item, 1);
@@ -845,6 +850,8 @@ int setup_classifier(struct classifier_management * _classifier_management)
                          classifier_action[rule_item_id].rule_id, rule_item_id);
                 return RT_ERR;
             }
+
+            rule_item_id++;
             break;
         }
     }
@@ -871,7 +878,7 @@ int setup_classifier(struct classifier_management * _classifier_management)
     }
 
     /* Dump The Context */
-    // rte_acl_dump(context);
+    rte_acl_dump(context);
 
     /* Save The Context */
     _classifier_management->classifier_acx = context;
@@ -1038,11 +1045,11 @@ int parse_classifier_rule_for_add(struct classifier_management * _classifier_man
         MR_ERROR("Classifier Rule Add Error,Rule Id '%u',The src IPv4 mask '%u' invalid .", rule_id, src_ip_mask_v4);
         return DYNAMIC_CLASSIFIER_RULE_ADD_SRC_IP_MASK_INVALID_V4;
     }
-    ret = inet_pton(AF_INET, cj_src_ip_addr_v4->valuestring, &src_ip_addr_v4);
+    ret = inet_pton(AF_INET, str_src_ip_addr_v4, &src_ip_addr_v4);
     if ((ret < 0) && (cj_src_ip_addr_v4 != NULL))
     {
         MR_ERROR("Classifier Rule Add Error,Rule Id '%u',The IPv4 src addr '%s' invalid .", rule_id,
-                 cj_src_ip_addr_v4->valuestring);
+                 str_src_ip_addr_v4);
         return DYNAMIC_CLASSIFIER_RULE_ADD_SRC_IP_INVALID_V4;
     }
 
@@ -1080,11 +1087,11 @@ int parse_classifier_rule_for_add(struct classifier_management * _classifier_man
         MR_ERROR("Classifier Rule Add Error,Rule Id '%u',The dst IPv4 mask '%u' invalid .", rule_id, dst_ip_mask_v4);
         return DYNAMIC_CLASSIFIER_RULE_ADD_DST_IP_MASK_INVALID_V4;
     }
-    ret = inet_pton(AF_INET, cj_dst_ip_addr_v4->valuestring, &dst_ip_addr_v4);
+    ret = inet_pton(AF_INET, str_dst_ip_addr_v4, &dst_ip_addr_v4);
     if ((ret < 0) && (cj_dst_ip_addr_v4 != NULL))
     {
         MR_ERROR("Classifier Rule Add Error,Rule Id '%u',The IPv4 dst addr '%s' invalid .", rule_id,
-                 cj_dst_ip_addr_v4->valuestring);
+                 str_dst_ip_addr_v4);
         return DYNAMIC_CLASSIFIER_RULE_ADD_DST_IP_INVALID_V4;
     }
 
@@ -1472,7 +1479,7 @@ int classifier_rule_full_update(cJSON * c_rule, uint32_t * rule_id)
     rte_rcu_qsbr_synchronize(qsv, RTE_QSBR_THRID_INVALID);
     /* Free Old Classifier Management */
     free_classifier_management(old_rule_management);
-    // dump_classifier_rules(new_rule_management);
+    dump_classifier_rules(new_rule_management);
     MR_INFO("Classifier Rule Full Update Success,Total Rule Num '%d'. ", rule_num);
     goto add_success;
 
diff --git a/service/src/node_eth_ingress.c b/service/src/node_eth_ingress.c
index 8037175..4a99153 100644
--- a/service/src/node_eth_ingress.c
+++ b/service/src/node_eth_ingress.c
@@ -1,37 +1,37 @@
+#include <cJSON.h>
 #include <common.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <mrb_define.h>
-#include <sc_common.h>
-#include <sc_vdev.h>
-#include <sc_node.h>
 #include <ldbc.h>
+#include <mrb_define.h>
+#include <netinet/in.h>
 #include <rte_graph.h>
 #include <rte_graph_worker.h>
-#include <cJSON.h>
+#include <sc_common.h>
+#include <sc_node.h>
 #include <sc_node_common.h>
+#include <sc_vdev.h>
+#include <sys/socket.h>
 
 /* Global Config */
 #ifndef MR_ETH_INGRESS_MAX_LISTEN_IP
-#define MR_ETH_INGRESS_MAX_LISTEN_IP    1024
+#define MR_ETH_INGRESS_MAX_LISTEN_IP 1024
 #endif
 
 #ifndef MR_ETH_INGRESS_BFD_PORT
-#define MR_ETH_INGRESS_BFD_PORT         3784
+#define MR_ETH_INGRESS_BFD_PORT 3784
 #endif
 
-#define MR_ETH_INGRESS_STAT_ADD(st, graph_id, counter, value)                                                               \
-do                                                                                                                          \
-{                                                                                                                           \
-    st->graph_stat[graph_id].counter += value;                                                                              \
-} while(0)                                                                                                                  \
+#define MR_ETH_INGRESS_STAT_ADD(st, graph_id, counter, value)                                                          \
+    do                                                                                                                 \
+    {                                                                                                                  \
+        st->graph_stat[graph_id].counter += value;                                                                     \
+    } while (0)
 
 /* Eth Ingress Next Node */
 enum
 {
     ETH_INGRESS_NEXT_ETHERFABRIC_INGRESS = 0,
     ETH_INGRESS_NEXT_BFD,
-    ETH_INGRESS_NEXT_VWIRE_INGRESS,
+    // ETH_INGRESS_NEXT_VWIRE_INGRESS,
     ETH_INGRESS_NEXT_PKT_DROP,
     ETH_INGRESS_NEXT_MAX
 };
@@ -76,17 +76,18 @@ void dump_ip_listen_rule(struct eth_ingress_ip_listen_management * ip_listen_man
     {
         MR_INFO(" ");
         MR_INFO("Eth Ingress Config:");
-        MR_INFO("   Total Listen Ip Num            : %u",ip_listen_manage->listen_ip_num_v4);
+        MR_INFO("   Total Listen Ip Num            : %u", ip_listen_manage->listen_ip_num_v4);
         for (int i = 0; i < ip_listen_manage->listen_ip_num_v4; i++)
         {
             listen_addr.s_addr = ip_listen_manage->listen_ip_v4[i];
-            MR_INFO("    Listen Ip                     : %s",inet_ntoa(listen_addr));
+            MR_INFO("    Listen Ip                     : %s", inet_ntoa(listen_addr));
         }
     }
 }
 
 /* Local Ip Check */
-int listen_ip_check(struct node_eth_ingress_main * eth_ingress_main,struct pkt_head_info * _pkt_head_info,rte_graph_t graph_id)
+int listen_ip_check(struct node_eth_ingress_main * eth_ingress_main, struct pkt_head_info * _pkt_head_info,
+                    rte_graph_t graph_id)
 {
     struct eth_ingress_ip_listen_management * ip_listen_manage = &eth_ingress_main->ip_listen_manage;
 
@@ -96,22 +97,22 @@ int listen_ip_check(struct node_eth_ingress_main * eth_ingress_main,struct pkt_h
         {
             if (ip_listen_manage->listen_ip_v4[i] != _pkt_head_info->_ipv4_hdr->dst_addr)
                 continue;
-            MR_ETH_INGRESS_STAT_ADD(eth_ingress_main,graph_id,hit_pkts_v4,1);
+            MR_ETH_INGRESS_STAT_ADD(eth_ingress_main, graph_id, hit_pkts_v4, 1);
             return RT_SUCCESS;
         }
-        MR_ETH_INGRESS_STAT_ADD(eth_ingress_main,graph_id,miss_pkts_v4,1);
+        MR_ETH_INGRESS_STAT_ADD(eth_ingress_main, graph_id, miss_pkts_v4, 1);
     }
     else if (_pkt_head_info->ip_version == MR_NODE_COMMON_IP_VERSION_V6)
     {
         /* Check IPv6 Pkt But Current Not Support */
-        MR_ETH_INGRESS_STAT_ADD(eth_ingress_main,graph_id,miss_pkts_v6,1);
+        MR_ETH_INGRESS_STAT_ADD(eth_ingress_main, graph_id, miss_pkts_v6, 1);
         return RT_ERR;
     }
     return RT_ERR;
 }
 
 /* Device Attribute Table Init */
-void device_attribute_table_init(struct sc_main * sc,struct node_eth_ingress_main * eth_ingress_main)
+void device_attribute_table_init(struct sc_main * sc, struct node_eth_ingress_main * eth_ingress_main)
 {
     struct phydev * phydev_iter = NULL;
 
@@ -131,13 +132,13 @@ int eth_ingress_init(struct sc_main * sc)
 
     sc->eth_ingress_node_main = eth_ingress_main;
     global_eth_ingress_main = eth_ingress_main;
-    device_attribute_table_init(sc,eth_ingress_main);
+    device_attribute_table_init(sc, eth_ingress_main);
     return RT_SUCCESS;
 }
 
 /************************************* Eth Ingress Public Func **************************************/
 /* Eth Ingress Update IP Listen Number */
-int eth_ingress_update_ip_listen_num_v4(uint16_t num,uint32_t * listen_ip)
+int eth_ingress_update_ip_listen_num_v4(uint16_t num, uint32_t * listen_ip)
 {
     struct eth_ingress_ip_listen_management * ip_listen_manage = NULL;
     ip_listen_manage = &global_eth_ingress_main->ip_listen_manage;
@@ -147,7 +148,7 @@ int eth_ingress_update_ip_listen_num_v4(uint16_t num,uint32_t * listen_ip)
         if (ip_listen_manage->listen_ip_num_v4 >= MR_ETH_INGRESS_MAX_LISTEN_IP)
             return RT_ERR;
         ip_listen_manage->listen_ip_v4[ip_listen_manage->listen_ip_num_v4] = listen_ip[i];
-        ip_listen_manage->listen_ip_num_v4 ++;
+        ip_listen_manage->listen_ip_num_v4++;
     }
     dump_ip_listen_rule(ip_listen_manage);
     return RT_SUCCESS;
@@ -161,12 +162,13 @@ static int eth_ingress_node_init(const struct rte_graph * graph, struct rte_node
 }
 
 /* Eth Ingress Node Process Function */
-static __rte_always_inline uint16_t eth_ingress_node_process(struct rte_graph * graph, struct rte_node * node, void ** objs, uint16_t cnt)
+static __rte_always_inline uint16_t eth_ingress_node_process(struct rte_graph * graph, struct rte_node * node,
+                                                             void ** objs, uint16_t cnt)
 {
-    uint16_t n_left_from = 0, last_spec = 0,batch_next_node_index = 0,next_node_index = 0;
+    uint16_t n_left_from = 0, last_spec = 0, batch_next_node_index = 0, next_node_index = 0;
     rte_graph_t graph_id;
-    struct rte_mbuf * mbuf, ** pkts;
-    void  ** batch_pkts;
+    struct rte_mbuf *mbuf, **pkts;
+    void ** batch_pkts;
     struct node_eth_ingress_main * eth_ingress_main = NULL;
 
     /* Get Pkts Num And Pkts Buffer */
@@ -193,49 +195,53 @@ static __rte_always_inline uint16_t eth_ingress_node_process(struct rte_graph *
         private_ctrlzone = mrbuf_cz_data(mbuf, 0);
         pkt_parser_ptr = &private_ctrlzone->pkt_parser;
 
-        MR_ETH_INGRESS_STAT_ADD(eth_ingress_main,graph_id,total_pkts,1);
+        MR_ETH_INGRESS_STAT_ADD(eth_ingress_main, graph_id, total_pkts, 1);
 
-        set_parse_flg(head_flg,MR_PARSE_IP);
-        set_parse_flg(head_flg,MR_PARSE_PORT);
-        ret = get_pkt_head_info(pkt_parser_ptr,&pkt_head_info_item,head_flg);
+        set_parse_flg(head_flg, MR_PARSE_IP);
+        set_parse_flg(head_flg, MR_PARSE_PORT);
+        ret = get_pkt_head_info(pkt_parser_ptr, &pkt_head_info_item, head_flg);
         if (unlikely(ret == RT_ERR))
         {
-            MR_ETH_INGRESS_STAT_ADD(eth_ingress_main,graph_id,invalid_pkts,1);
+            MR_ETH_INGRESS_STAT_ADD(eth_ingress_main, graph_id, invalid_pkts, 1);
             next_node_index = ETH_INGRESS_NEXT_PKT_DROP;
             goto node_enqueue;
         }
 
         /* Listen IP Check */
-        if(unlikely(listen_ip_check(eth_ingress_main,&pkt_head_info_item,graph_id) != RT_SUCCESS))
+        if (unlikely(listen_ip_check(eth_ingress_main, &pkt_head_info_item, graph_id) != RT_SUCCESS))
         {
-            /* No Match Listen Ip Pkt,Need According Ingress Port Match Rout Type, But Current Not Support,Default Drop */
-            if (eth_ingress_main->device_attribute_table[private_ctrlzone->port_ingress] == MR_DEV_ATTRIBUTE_VIRTUAL_WIRE)
-                next_node_index = ETH_INGRESS_NEXT_VWIRE_INGRESS;
+            /* No Match Listen Ip Pkt,Need According Ingress Port Match Rout Type, But Current Not Support,Default Drop
+             */
+            if (eth_ingress_main->device_attribute_table[private_ctrlzone->port_ingress] ==
+                MR_DEV_ATTRIBUTE_VIRTUAL_WIRE)
+                // next_node_index = ETH_INGRESS_NEXT_VWIRE_INGRESS;
+                next_node_index = ETH_INGRESS_NEXT_PKT_DROP;
             else
                 next_node_index = ETH_INGRESS_NEXT_PKT_DROP;
             goto node_enqueue;
         }
 
         /* Check Whether Is Bfd Pkt */
-        if (unlikely((pkt_head_info_item.proto_id == IPPROTO_UDP) && (pkt_head_info_item.dst_port == ntohs(MR_ETH_INGRESS_BFD_PORT))))
+        if (unlikely((pkt_head_info_item.proto_id == IPPROTO_UDP) &&
+                     (pkt_head_info_item.dst_port == ntohs(MR_ETH_INGRESS_BFD_PORT))))
         {
             /* Bfd Pkt Should Send To Bfd Node */
-            MR_ETH_INGRESS_STAT_ADD(eth_ingress_main,graph_id,bfd_pkts,1);
+            MR_ETH_INGRESS_STAT_ADD(eth_ingress_main, graph_id, bfd_pkts, 1);
             next_node_index = ETH_INGRESS_NEXT_BFD;
         }
         else
         {
             /* Should Enter Local Deal Process,But Current Specify Next Node Is Etherfabric */
-            MR_ETH_INGRESS_STAT_ADD(eth_ingress_main,graph_id,etherfabric_pkts,1);
+            MR_ETH_INGRESS_STAT_ADD(eth_ingress_main, graph_id, etherfabric_pkts, 1);
             next_node_index = ETH_INGRESS_NEXT_ETHERFABRIC_INGRESS;
         }
 
-node_enqueue:
+    node_enqueue:
         /* Judge The Next Index Whether To Change */
         if (unlikely(batch_next_node_index != next_node_index))
         {
             /* If The Next Index Has Been Changed,Enqueue Last Pkts */
-            rte_node_enqueue(graph, node, batch_next_node_index, batch_pkts,last_spec);
+            rte_node_enqueue(graph, node, batch_next_node_index, batch_pkts, last_spec);
             batch_pkts += last_spec;
             last_spec = 1;
             batch_next_node_index = next_node_index;
@@ -243,13 +249,13 @@ node_enqueue:
         else
         {
             /* If The Next Index Not Change, Update The Lasts */
-            last_spec ++;
+            last_spec++;
         }
     }
 
     /* Process The Remaining Packets */
     if (likely(last_spec > 0))
-        rte_node_enqueue(graph, node, batch_next_node_index, batch_pkts,last_spec);
+        rte_node_enqueue(graph, node, batch_next_node_index, batch_pkts, last_spec);
     return cnt;
 }
 
@@ -259,12 +265,13 @@ static struct rte_node_register eth_ingress_node_base = {
     .name = "eth_ingress",
     .init = eth_ingress_node_init,
     .nb_edges = ETH_INGRESS_NEXT_MAX,
-    .next_nodes = {
-    [ETH_INGRESS_NEXT_ETHERFABRIC_INGRESS] = "etherfabric_ingress",
-    [ETH_INGRESS_NEXT_BFD] = "bfd",
-    [ETH_INGRESS_NEXT_VWIRE_INGRESS] = "vwire_ingress",
-    [ETH_INGRESS_NEXT_PKT_DROP] = "pkt_drop",
-    },
+    .next_nodes =
+        {
+            [ETH_INGRESS_NEXT_ETHERFABRIC_INGRESS] = "etherfabric_ingress",
+            [ETH_INGRESS_NEXT_BFD] = "bfd",
+            //[ETH_INGRESS_NEXT_VWIRE_INGRESS] = "vwire_ingress",
+            [ETH_INGRESS_NEXT_PKT_DROP] = "pkt_drop",
+        },
 };
 
 RTE_NODE_REGISTER(eth_ingress_node_base);
@@ -272,8 +279,8 @@ RTE_NODE_REGISTER(eth_ingress_node_base);
 /************************************** Eth Ingress Statistics **************************************/
 cJSON * eth_ingress_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;
     struct node_eth_ingress_main * eth_ingress_main = sc->eth_ingress_node_main;
     unsigned int nr_io_thread = sc->nr_io_thread;
     json_root = cJSON_CreateObject();
@@ -301,9 +308,9 @@ cJSON * eth_ingress_node_monit_loop(struct sc_main * sc)
         cJSON_AddNumberToObject(graph_obj, "bfd_pkts", stats);
         stats = stat_item->etherfabric_pkts;
         cJSON_AddNumberToObject(graph_obj, "etherfabric_pkts", stats);
-        sprintf(graph_index,"graph-%u",graph_num);
-        cJSON_AddItemToObject(json_root,graph_index,graph_obj);
-        graph_num ++;
+        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);
diff --git a/service/src/node_etherfabric.c b/service/src/node_etherfabric.c
index d99d73c..593b310 100644
--- a/service/src/node_etherfabric.c
+++ b/service/src/node_etherfabric.c
@@ -111,7 +111,7 @@ struct etherfabric_egress_stat_per_lcore
     volatile uint64_t invalid_pkts;
     volatile uint64_t ipv4_original_pkt;
     volatile uint64_t ipv4_new_create_pkt;
-    volatile uint64_t no_suport_pkt;
+    volatile uint64_t no_support_pkt;
     volatile uint64_t link_index_invalid;
     volatile uint64_t service_index_invalid;
 };
@@ -834,7 +834,7 @@ static __rte_always_inline uint16_t etherfabric_egress_node_process(struct rte_g
         else
         {
             /* Current Not Support IPv6 */
-            MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main, graph_id, no_suport_pkt, 1);
+            MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main, graph_id, no_support_pkt, 1);
             next_node_index = ETHERFABRIC_EGRESS_NEXT_PKT_DROP;
         }
 
@@ -942,8 +942,8 @@ cJSON * etherfabric_egress_node_monit_loop(struct sc_main * sc)
         cJSON_AddNumberToObject(graph_obj, "ipv4_original_pkt", stats);
         stats = stat_item->ipv4_new_create_pkt;
         cJSON_AddNumberToObject(graph_obj, "ipv4_new_create_pkt", stats);
-        stats = stat_item->no_suport_pkt;
-        cJSON_AddNumberToObject(graph_obj, "no_suport_pkt", stats);
+        stats = stat_item->no_support_pkt;
+        cJSON_AddNumberToObject(graph_obj, "no_support_pkt", stats);
         sprintf(graph_index, "graph-%u", graph_num);
         cJSON_AddItemToObject(json_root, graph_index, graph_obj);
         graph_num++;
diff --git a/service/src/node_shmdev.c b/service/src/node_shmdev.c
index b52e0e2..e287cd5 100644
--- a/service/src/node_shmdev.c
+++ b/service/src/node_shmdev.c
@@ -175,7 +175,7 @@ int parser_vlan_flipping_adapter_conf(struct sc_main * sc, struct vlan_flipping_
         }
 
         default_si = strtoul(str_tokens[1], &endptr, 0);
-        if (default_si == 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;