🎈 perf(TSG-11429): 优化Classifier动态删除规则解析流程

优化Classifier动态删除规则解析流程

1 files changed, 60 insertions, 82 deletions

diff --git a/service/src/node_classifier.c b/service/src/node_classifier.c
index 8698d1f..a513c5b 100644
--- a/service/src/node_classifier.c
+++ b/service/src/node_classifier.c
@@ -27,26 +27,14 @@
 #define MR_CLASSIFIER_DEFAULT_MAX_CATEGORIES                            1
 #endif
 
-#ifndef MR_CLASSIFIER_INVALID_RULE_ARG
-#define MR_CLASSIFIER_INVALID_RULE_ARG                                  0
-#endif
-
 #ifndef MR_CLASSIFIER_DEFAULT_SOCKET_ID
 #define MR_CLASSIFIER_DEFAULT_SOCKET_ID                                 0
 #endif
 
-#ifndef MR_CLASSIFIER_DEFAULT_RULE_ARG
-#define MR_CLASSIFIER_DEFAULT_RULE_ARG                                  0
-#endif
-
 #ifndef MR_CLASSIFIER_RULE_INVALID_FLAG
 #define MR_CLASSIFIER_RULE_INVALID_FLAG                                 0
 #endif
 
-#ifndef MR_CLASSIFIER_RULE_VALID_FLAG
-#define MR_CLASSIFIER_RULE_VALID_FLAG                                   1
-#endif
-
 #ifndef MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V4
 #define MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V4                            "0.0.0.0"
 #endif
@@ -108,21 +96,21 @@
 #endif
 
 #ifndef MR_CLASSIFIER_MAX_PKT_BURST
-#define MR_CLASSIFIER_MAX_PKT_BURST                                     4                              // Multiple Packet Process Num
+#define MR_CLASSIFIER_MAX_PKT_BURST                                     4                                                                       // Multiple Packet Process Num
 #endif
 
 #ifndef MR_CLASSIFIER_RULE_ID_INVALID_NUM
-#define MR_CLASSIFIER_RULE_ID_INVALID_NUM                               1                              // The Valid Classifier Rule Id Start From 0
+#define MR_CLASSIFIER_RULE_ID_INVALID_NUM                               1                                                                       // The Valid Classifier Rule Id Start From 0
 #endif
 
-#define MAX_CLASSIFIER_RULE_NUM 1024                                                                   // id 0 is invalid
-#define MAX_CLASSIFIER_RULE_ITEM_NUM (MAX_CLASSIFIER_RULE_NUM + MR_CLASSIFIER_RULE_ID_INVALID_NUM)     // id 0 is invalid
+#define MAX_CLASSIFIER_RULE_NUM                                         1024                                                                    // id 0 is invalid
+#define MAX_CLASSIFIER_RULE_ITEM_NUM                                    (MAX_CLASSIFIER_RULE_NUM + MR_CLASSIFIER_RULE_ID_INVALID_NUM)           // id 0 is invalid
 
+/* Dynamic Classifier Rule Field */
 #ifndef MR_CLASSIFIER_RPC_RESULT
 #define MR_CLASSIFIER_RPC_RESULT                                        "Result"
 #endif
 
-/* Dynamic Classifier Rule Field */
 #ifndef MR_CLASSIFIER_CJSON_KEY_RULE_ID
 #define MR_CLASSIFIER_CJSON_KEY_RULE_ID                                 "RuleId"
 #endif
@@ -283,7 +271,6 @@ struct match_field
     /* The SI Id Is Network Byte Order */
     uint16_t si;
     uint16_t ip_version;
-
     /* IPv4 Match Field */
     uint32_t src_addr_ipv4;
     uint32_t dst_addr_ipv4;
@@ -539,10 +526,10 @@ no_match_process:
                 goto node_enqueue;
                 break;
             default:
+                /* Send To Phydev On The Basis Of Shared Ctx,But Current No Support,Default Drop */
+                next_node_index = CLASSIFIER_NEXT_PKT_DROP;
                 break;
         }
-        /* Send To Phydev On The Basis Of Shared Ctx,But Current No Support,Default Drop */
-        next_node_index = CLASSIFIER_NEXT_PKT_DROP;
 
 node_enqueue:
         /* Judge The Next Index Whether To Change */
@@ -627,36 +614,43 @@ int classifier_v4_repeated_rule_check(struct classifier_management * _classifier
     {
         struct classifier_rule * rule_item = &_classifier_management->classifier_rule_array[i];
         struct mr_action * action_item = &_classifier_management->classifier_local_action[i];
-        if (action_item->rule_id != MR_CLASSIFIER_RULE_INVALID_FLAG)
-        {
-            /* Compare Rule Field */
-            if ((rule_item->field[CLASSIFIER_FIELD_IP_VERSION].value.u16 == rule->field[CLASSIFIER_FIELD_IP_VERSION].value.u16) && (rule_item->field[CLASSIFIER_FIELD_IP_VERSION].mask_range.u16 == rule->field[CLASSIFIER_FIELD_IP_VERSION].mask_range.u16))
-            {
-                if ((rule_item->field[CLASSIFIER_FIELD_SRC_IP_V4].value.u32 == rule->field[CLASSIFIER_FIELD_SRC_IP_V4].value.u32) && (rule_item->field[CLASSIFIER_FIELD_SRC_IP_V4].mask_range.u32 == rule->field[CLASSIFIER_FIELD_SRC_IP_V4].mask_range.u32))
-                {
-                    if ((rule_item->field[CLASSIFIER_FIELD_DST_IP_V4].value.u32 == rule->field[CLASSIFIER_FIELD_DST_IP_V4].value.u32) && (rule_item->field[CLASSIFIER_FIELD_DST_IP_V4].mask_range.u32 == rule->field[CLASSIFIER_FIELD_DST_IP_V4].mask_range.u32))
-                    {
-                        if ((rule_item->field[CLASSIFIER_FIELD_SRC_PORT].value.u16 == rule->field[CLASSIFIER_FIELD_SRC_PORT].value.u16) && (rule_item->field[CLASSIFIER_FIELD_SRC_PORT].mask_range.u16 == rule->field[CLASSIFIER_FIELD_SRC_PORT].mask_range.u16))
-                        {
-                            if ((rule_item->field[CLASSIFIER_FIELD_DST_PORT].value.u16 == rule->field[CLASSIFIER_FIELD_DST_PORT].value.u16) && (rule_item->field[CLASSIFIER_FIELD_DST_PORT].mask_range.u16 == rule->field[CLASSIFIER_FIELD_DST_PORT].mask_range.u16))
-                            {
-                                if ((rule_item->field[CLASSIFIER_FIELD_PROTO].value.u8 == rule->field[CLASSIFIER_FIELD_PROTO].value.u8) && (rule_item->field[CLASSIFIER_FIELD_PROTO].mask_range.u8 == rule->field[CLASSIFIER_FIELD_PROTO].mask_range.u8))
-                                {
-                                    if ((rule_item->field[CLASSIFIER_FIELD_SI].value.u16 == rule->field[CLASSIFIER_FIELD_SI].value.u16) && (rule_item->field[CLASSIFIER_FIELD_SI].mask_range.u16 == rule->field[CLASSIFIER_FIELD_SI].mask_range.u16))
-                                    {
-                                        /* Compare Rule Category Mask And Priority */
-                                        if ((rule_item->data.category_mask == rule->data.category_mask) && (rule_item->data.priority == rule->data.priority))
-                                        {
-                                            return RT_ERR;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
+
+        if (action_item->rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
+            continue;
+        /* Compare Rule Field */
+        if (rule_item->field[CLASSIFIER_FIELD_IP_VERSION].value.u16 != rule->field[CLASSIFIER_FIELD_IP_VERSION].value.u16)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_IP_VERSION].mask_range.u16 != rule->field[CLASSIFIER_FIELD_IP_VERSION].mask_range.u16)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_SRC_IP_V4].value.u32 != rule->field[CLASSIFIER_FIELD_SRC_IP_V4].value.u32)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_SRC_IP_V4].mask_range.u32 != rule->field[CLASSIFIER_FIELD_SRC_IP_V4].mask_range.u32)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_DST_IP_V4].value.u32 != rule->field[CLASSIFIER_FIELD_DST_IP_V4].value.u32)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_DST_IP_V4].mask_range.u32 != rule->field[CLASSIFIER_FIELD_DST_IP_V4].mask_range.u32)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_SRC_PORT].value.u16 != rule->field[CLASSIFIER_FIELD_SRC_PORT].value.u16)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_SRC_PORT].mask_range.u16 != rule->field[CLASSIFIER_FIELD_SRC_PORT].mask_range.u16)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_DST_PORT].value.u16 != rule->field[CLASSIFIER_FIELD_DST_PORT].value.u16)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_DST_PORT].mask_range.u16 != rule->field[CLASSIFIER_FIELD_DST_PORT].mask_range.u16)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_PROTO].value.u8 != rule->field[CLASSIFIER_FIELD_PROTO].value.u8)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_PROTO].mask_range.u8 != rule->field[CLASSIFIER_FIELD_PROTO].mask_range.u8)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_SI].value.u16 != rule->field[CLASSIFIER_FIELD_SI].value.u16)
+            continue;
+        if (rule_item->field[CLASSIFIER_FIELD_SI].mask_range.u16 != rule->field[CLASSIFIER_FIELD_SI].mask_range.u16)
+            continue;
+        if (rule_item->data.category_mask != rule->data.category_mask)
+            continue;
+        if (rule_item->data.priority != rule->data.priority)
+            continue;
+        return RT_ERR;
     }
     return RT_SUCCESS;
 }
@@ -710,12 +704,10 @@ void dump_classifier_rule(struct classifier_rule * rule,struct mr_action * actio
         case CLASSIFIER_ACTION_DROP:
             MR_INFO("     Action                       : Drop");
             break;
-
         case CLASSIFIER_ACTION_NF_STEERING:
             MR_INFO("     Action                       : Network Function Steering");
             MR_INFO("     Next Group                   : %u",action->next_group_id);
             break;
-
         default:
             break;
     }
@@ -750,7 +742,6 @@ uint32_t get_free_rule_item_id(struct classifier_management * _classifier_manage
         {
             return i;
         }
-
     }
     return MR_CLASSIFIER_RULE_INVALID_FLAG;
 }
@@ -764,7 +755,6 @@ uint32_t get_rule_item_id_from_rule_id(struct classifier_management * _classifie
         {
             return i;
         }
-
     }
     return MR_CLASSIFIER_RULE_INVALID_FLAG;
 }
@@ -777,12 +767,10 @@ uint16_t get_max_si_id(struct classifier_management * _classifier_management)
     for (uint16_t i = 1; i < MAX_CLASSIFIER_RULE_ITEM_NUM; i++)
     {
         uint16_t si_id = _classifier_management->classifier_rule_array[i].field[CLASSIFIER_FIELD_SI].value.u16;
-
         if (si_id > max_si_id)
         {
             max_si_id = si_id;
         }
-
     }
     return max_si_id;
 }
@@ -791,7 +779,6 @@ 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;
@@ -834,29 +821,22 @@ int setup_classifier(struct classifier_management * _classifier_management)
     }
 
     /* Cuttent Use The Default Alg Config,So No Need Call "rte_acl_set_ctx_classify" */
-
     /* Add Classifier Rule */
     for (uint32_t i = 0; i < rule_num; i++)
     {
-        while (rule_item_id < MAX_CLASSIFIER_RULE_NUM)
+        for (uint32_t rule_item_id = 0; rule_item_id < MAX_CLASSIFIER_RULE_NUM; rule_item_id ++)
         {
-            if (classifier_action[rule_item_id].rule_id != MR_CLASSIFIER_RULE_INVALID_FLAG)
+            if (classifier_action[rule_item_id].rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
+                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);
+            if (ret < 0)
             {
-                struct rte_acl_rule * rule_item = (struct rte_acl_rule *)(classifier_rule + (offset_unit * rule_item_id));
-                rule_item_id ++;
-                add_rule_num ++;
-                ret = rte_acl_add_rules(context, rule_item, 1);
-                if (ret < 0)
-                {
-                    MR_ERROR("Set Classifier Table Add Rules Fail,Rule ID: %u  Rule Item Id: %u ",classifier_action[rule_item_id].rule_id,rule_item_id);
-                    return RT_ERR;
-                }
-                else
-                {
-                    break;
-                }
+                MR_ERROR("Set Classifier Table Add Rules Fail,Rule ID: %u  Rule Item Id: %u ",classifier_action[rule_item_id].rule_id,rule_item_id);
+                return RT_ERR;
             }
-            rule_item_id ++;
+            break;
         }
     }
 
@@ -1002,6 +982,7 @@ int parse_classifier_rule_for_add(struct classifier_management * _classifier_man
         return DYNAMIC_CLASSIFIER_RULE_ADD_ACTION_INVALID;
     }
 
+    /* Save The Si Id And Action Type */
     si_id = (uint16_t)cj_si_id->valuedouble;
     action_type = (uint8_t)cj_action->valuedouble;
 
@@ -1382,7 +1363,7 @@ int single_rule_delete(cJSON * c_rule)
     {
         goto del_err;
     }
-
+    /* Classifier Table Setup */
     if (new_rule_management->classifier_rule_num > 0)
     {
         ret = setup_classifier(new_rule_management);
@@ -1421,10 +1402,8 @@ static int __classifier_single_rule_add_request_handler(cJSON *req, cJSON **rsp,
     cJSON *response = cJSON_CreateObject();
 
     ret = single_rule_add(req);
-
     cJSON_AddNumberToObject(response, MR_CLASSIFIER_RPC_RESULT, ret);
     *rsp = response;
-
     return 0;
 }
 
@@ -1468,7 +1447,7 @@ int parser_classifier_rule(struct sc_main * sc, struct classifier_management * _
         struct mr_action * action;
 
         snprintf(str_section, sizeof(str_section), "classifier_rule_%d", rule_index);
-        ret = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "rule_id", &rule_id, MR_CLASSIFIER_INVALID_RULE_ARG);
+        ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "rule_id", &rule_id);
         if (ret < 0)
         {
             continue;
@@ -1532,7 +1511,7 @@ int parser_classifier_rule(struct sc_main * sc, struct classifier_management * _
         int ret_dst_ip_v4 = MESA_load_profile_string_def(sc->local_cfgfile, str_section, "dst_ip_addr_v4", str_dst_ip_addr_v4,
                                                         sizeof(str_dst_ip_addr_v4),MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V4);
         int ret_dst_ip_v4_mask = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_ip_mask_v4",
-                                                        &dst_ip_mask_v4, MR_CLASSIFIER_INVALID_RULE_ARG);
+                                                        &dst_ip_mask_v4, MR_CLASSIFIER_DEFAULT_IP_MASK_0);
 
         if (ret_dst_ip_v4 > 0)
         {
@@ -1566,7 +1545,7 @@ int parser_classifier_rule(struct sc_main * sc, struct classifier_management * _
         int ret_src_ip_v6 = MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "src_ip_addr_v6",
                                                         str_src_ip_addr_v6, sizeof(str_src_ip_addr_v6));
         int ret_src_ip_v6_mask = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_ip_mask_v6",
-                                                        &src_ip_mask_v6, MR_CLASSIFIER_INVALID_RULE_ARG);
+                                                        &src_ip_mask_v6, MR_CLASSIFIER_DEFAULT_IP_MASK_0);
         if ((ret_src_ip_v6 > 0 ) || (ret_src_ip_v6_mask > 0))
         {
             ip_version = MR_NODE_COMMON_IP_VERSION_V6;
@@ -1579,7 +1558,7 @@ int parser_classifier_rule(struct sc_main * sc, struct classifier_management * _
         int ret_dst_ip_v6 = MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "dst_ip_addr_v6",
                                                             str_dst_ip_addr_v6, sizeof(str_dst_ip_addr_v6));
         int ret_dst_ip_v6_mask = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_ip_mask_v6",
-                                                            &dst_ip_mask_v6, MR_CLASSIFIER_INVALID_RULE_ARG);
+                                                            &dst_ip_mask_v6, MR_CLASSIFIER_DEFAULT_IP_MASK_0);
         if ((ret_dst_ip_v6 > 0 ) || (ret_dst_ip_v6_mask > 0))
         {
             ip_version = MR_NODE_COMMON_IP_VERSION_V6;
@@ -1792,7 +1771,6 @@ int classifier_init(struct sc_main * sc)
         MR_ERROR("The '%s' Request Register Failed . ",MR_CLASSIFIER_TOPIC_SINGLE_RULE_ADD);
         return RT_ERR;
     }
-
     if(rpc_server_recv_request_register(sc->rpc_srv_handler, MR_CLASSIFIER_TOPIC_SINGLE_RULE_DEL, __classifier_single_rule_del_request_handler, sc) != 0)
     {
         MR_ERROR("The '%s' Request Register Failed . ",MR_CLASSIFIER_TOPIC_SINGLE_RULE_DEL);