✨ feat: Add function to handle duplicate rules.v4.8.20-20240813

Add function to handle duplicate rules.

3 files changed, 317 insertions, 125 deletions

diff --git a/service/include/sc_classifier_rule_parser.h b/service/include/sc_classifier_rule_parser.h
index 2e8fe9f..c072559 100644
--- a/service/include/sc_classifier_rule_parser.h
+++ b/service/include/sc_classifier_rule_parser.h
@@ -23,6 +23,19 @@ enum action_type
     ACTION_MAX,
 };
 
+enum rule_attribute
+{
+    RULE_ATTR_STATIC = 0,
+    RULE_ATTR_DYNAMIC,
+};
+
+enum rule_state
+{
+    RULE_STATE_PENDING = 0,
+    RULE_STATE_ACTIVE,
+    RULE_STATE_INACTIVE,
+};
+
 struct adapter_info
 {
     enum adapter_type type;
@@ -32,7 +45,7 @@ struct adapter_info
 struct action
 {
     enum action_type type;
-    uint16_t rule_index;
+    uint32_t rule_id;
     union {
         uint16_t sid;
         uint16_t data;
@@ -44,6 +57,7 @@ struct rule_field_parser
     uint8_t proto;
     uint8_t proto_mask;
     uint8_t priority;
+    uint8_t rule_state;
     uint16_t ether_type;
     uint16_t src_port_start;
     uint16_t src_port_end;
@@ -52,6 +66,7 @@ struct rule_field_parser
     uint32_t src_addr_mask_len;
     uint32_t dst_addr_mask_len;
     uint32_t rule_id;
+    enum rule_attribute rule_attr;
 
     union {
         uint32_t src_addr_v4;
@@ -77,6 +92,6 @@ struct rule_list_parsed
     struct rule_field_parser rules[MAX_RULES];
 };
 
-int pkt_classifier_rule_parser(const struct sc_main * sc, enum ruleset_type ruleset_type, uint8_t cfg_file_type,
+int pkt_classifier_rule_parser(const struct sc_main * sc, enum ruleset_type ruleset_type, enum rule_attribute rule_attr,
                                struct rule_list_parsed * out_rule_list);
-void classifier_rule_dump(struct rule_list_parsed * rule_list);
+void classifier_rule_list_dump(struct rule_list_parsed * rule_list);
diff --git a/service/src/classifier_rule_parser.c b/service/src/classifier_rule_parser.c
index d30e4bd..08a7ec9 100644
--- a/service/src/classifier_rule_parser.c
+++ b/service/src/classifier_rule_parser.c
@@ -1,24 +1,287 @@
 #include <MESA_prof_load.h>
 #include <sc_classifier_rule_parser.h>
 
-int pkt_classifier_rule_parser(const struct sc_main * sc, enum ruleset_type ruleset_type, uint8_t cfg_file_type,
+/* Dump rule information. */
+void classifier_rule_dump(struct rule_field_parser * rule)
+{
+    char str_rule_info[2048] = {};
+    unsigned int max_len = sizeof(str_rule_info) - 1;
+
+    int len = snprintf(str_rule_info, max_len, "Pkt classifier,rule id:%u, ", rule->rule_id);
+
+    if (rule->ether_type == RTE_ETHER_TYPE_IPV4)
+    {
+        struct in_addr src_addr, dst_addr;
+        src_addr.s_addr = rule->src_addr_v4;
+        dst_addr.s_addr = rule->dst_addr_v4;
+
+        len += snprintf(str_rule_info + len, max_len - len, "IPv4, ");
+        len += snprintf(str_rule_info + len, max_len - len, "src addr: %s/%u, ", inet_ntoa(src_addr),
+                        rule->src_addr_mask_len);
+        len += snprintf(str_rule_info + len, max_len - len, "dst addr: %s/%u, ", inet_ntoa(dst_addr),
+                        rule->dst_addr_mask_len);
+    }
+    else if (rule->ether_type == RTE_ETHER_TYPE_IPV6)
+    {
+        char str_ipv6_src[INET6_ADDRSTRLEN] = {}, str_ipv6_dst[INET6_ADDRSTRLEN] = {};
+        inet_ntop(AF_INET6, rule->src_addr_v6, str_ipv6_src, INET6_ADDRSTRLEN);
+        inet_ntop(AF_INET6, rule->dst_addr_v6, str_ipv6_dst, INET6_ADDRSTRLEN);
+        len += snprintf(str_rule_info + len, max_len - len, "IPv6, ");
+        len += snprintf(str_rule_info + len, max_len - len, "src addr: %s/%u, ", str_ipv6_src, rule->src_addr_mask_len);
+        len += snprintf(str_rule_info + len, max_len - len, "dst addr: %s/%u, ", str_ipv6_dst, rule->dst_addr_mask_len);
+    }
+    else
+    {
+        len += snprintf(str_rule_info + len, max_len - len, "Any, ");
+    }
+
+    if (rule->proto == IPPROTO_TCP)
+    {
+        len += snprintf(str_rule_info + len, max_len - len, "proto: TCP, ");
+    }
+    else if (rule->proto == IPPROTO_UDP)
+    {
+        len += snprintf(str_rule_info + len, max_len - len, "proto: UDP, ");
+    }
+    else
+    {
+        len += snprintf(str_rule_info + len, max_len - len, "proto: Any, ");
+    }
+
+    len += snprintf(str_rule_info + len, max_len - len, "src port: %u~%u, ", rule->src_port_start, rule->src_port_end);
+
+    len += snprintf(str_rule_info + len, max_len - len, "dst port: %u~%u, ", rule->dst_port_start, rule->dst_port_end);
+
+    len += snprintf(str_rule_info + len, max_len - len, "priority: %u, ", rule->priority);
+
+    if (rule->action.type == ACTION_DROP)
+    {
+        len += snprintf(str_rule_info + len, max_len - len, "action: drop");
+    }
+    else if (rule->action.type == ACTION_NF_STEERING)
+    {
+        len += snprintf(str_rule_info + len, max_len - len, "action: nf_steering, sid: %u, ", rule->action.sid);
+
+        if (rule->adapter.type == ADAPTER_TYPE_EF)
+        {
+            len += snprintf(str_rule_info + len, max_len - len, "ef_adapter_id: %u", rule->adapter.id);
+        }
+        else if (rule->adapter.type == ADAPTER_TYPE_VWIRE)
+        {
+            len += snprintf(str_rule_info + len, max_len - len, "vwire_id: %u", rule->adapter.id);
+        }
+        else if (rule->adapter.type == ADAPTER_TYPE_TERA)
+        {
+            len += snprintf(str_rule_info + len, max_len - len, "tera_adapter_id: %u", rule->adapter.id);
+        }
+        else
+        {
+            len += snprintf(str_rule_info + len, max_len - len,
+                            "ef_adapter_id: all, vwire_id: all, tera_adapter_id: all");
+        }
+    }
+    MR_INFO("%s", str_rule_info);
+}
+
+/* Dump all rules information. */
+void classifier_rule_list_dump(struct rule_list_parsed * rule_list)
+{
+    /* Dump the total rule number */
+    MR_INFO(" ");
+    MR_INFO("Pkt classifier total rules: %u", rule_list->nr_rules);
+    MR_INFO("Pkt classifier total static rules: %u", rule_list->nr_static_rules);
+    MR_INFO("Pkt classifier total dynamic rules: %u", rule_list->nr_dynamic_rules);
+
+    for (uint16_t index = 0; index < rule_list->nr_rules; index++)
+    {
+        struct rule_field_parser * rule = &rule_list->rules[index];
+        classifier_rule_dump(rule);
+    }
+}
+
+uint16_t pkt_classifier_duplicate_rules_process(struct rule_list_parsed * rule_list)
+{
+    uint16_t nr_duplicate_rules = 0;
+
+    /* Iterate through all rules to check for duplicates */
+    for (uint16_t rule_index = 0; rule_index < rule_list->nr_rules; rule_index++)
+    {
+        struct rule_field_parser * rule = &rule_list->rules[rule_index];
+
+        /* Iterate through all rules to compare with the current rule */
+        rule->rule_state = RULE_STATE_ACTIVE;
+        for (uint16_t compare_index = 0; compare_index < rule_list->nr_rules; compare_index++)
+        {
+            struct rule_field_parser * compare_rule = &rule_list->rules[compare_index];
+
+            /* Skip the rule if it's the same rule */
+            if (rule_index == compare_index)
+            {
+                continue;
+            }
+
+            /* Skip the rule if it's not active */
+            if (compare_rule->rule_state != RULE_STATE_ACTIVE)
+            {
+                continue;
+            }
+
+            /* Compare the rules */
+            if (rule->adapter.type != compare_rule->adapter.type)
+            {
+                continue;
+            }
+
+            if (rule->adapter.id != compare_rule->adapter.id)
+            {
+                continue;
+            }
+
+            if (rule->proto != compare_rule->proto)
+            {
+                continue;
+            }
+
+            if (rule->proto_mask != compare_rule->proto_mask)
+            {
+                continue;
+            }
+
+            if (rule->priority != compare_rule->priority)
+            {
+                continue;
+            }
+
+            if (rule->ether_type != compare_rule->ether_type)
+            {
+                continue;
+            }
+
+            if (rule->src_port_start != compare_rule->src_port_start)
+            {
+                continue;
+            }
+
+            if (rule->src_port_end != compare_rule->src_port_end)
+            {
+                continue;
+            }
+
+            if (rule->dst_port_start != compare_rule->dst_port_start)
+            {
+                continue;
+            }
+
+            if (rule->dst_port_end != compare_rule->dst_port_end)
+            {
+                continue;
+            }
+
+            if (rule->src_addr_mask_len != compare_rule->src_addr_mask_len)
+            {
+                continue;
+            }
+
+            if (rule->dst_addr_mask_len != compare_rule->dst_addr_mask_len)
+            {
+                continue;
+            }
+
+            if (rule->ether_type == RTE_ETHER_TYPE_IPV4)
+            {
+                if ((rule->src_addr_v4 != compare_rule->src_addr_v4) ||
+                    (rule->dst_addr_v4 != compare_rule->dst_addr_v4))
+                {
+                    continue;
+                }
+            }
+            else if (rule->ether_type == RTE_ETHER_TYPE_IPV6)
+            {
+                if ((memcmp(rule->src_addr_v6, compare_rule->src_addr_v6, sizeof(rule->src_addr_v6)) != 0) ||
+                    (memcmp(rule->dst_addr_v6, compare_rule->dst_addr_v6, sizeof(rule->dst_addr_v6)) != 0))
+                {
+                    continue;
+                }
+            }
+
+            /* If the rules are identical, mark the current rule as inactive */
+            rule->rule_state = RULE_STATE_INACTIVE;
+            nr_duplicate_rules++;
+
+            /* Dump the duplicate rule information */
+            MR_INFO("\nPkt classifier, rule id: %u, is duplicate with rule id: %u.", rule->rule_id,
+                    compare_rule->rule_id);
+            MR_INFO("Packet classifier: rule id %u is marked as inactive and will not be loaded.", rule->rule_id);
+
+            classifier_rule_dump(rule);
+            classifier_rule_dump(compare_rule);
+
+            break;
+        }
+    }
+
+    /* If there are no duplicate rules, return */
+    if (nr_duplicate_rules == 0)
+    {
+        return nr_duplicate_rules;
+    }
+
+    /* Clean up rule_list by removing invalid rule configurations */
+    uint16_t new_nr_rules = 0;
+    uint16_t new_nr_static_rules = 0;
+    uint16_t new_nr_dynamic_rules = 0;
+    struct rule_field_parser new_rule_list[MAX_RULES] = {};
+
+    for (uint32_t rule_index = 0; rule_index < rule_list->nr_rules; rule_index++)
+    {
+        struct rule_field_parser * rule = &rule_list->rules[rule_index];
+
+        if (rule->rule_state == RULE_STATE_ACTIVE)
+        {
+            struct rule_field_parser * new_rule = &new_rule_list[new_nr_rules];
+            memcpy(new_rule, rule, sizeof(struct rule_field_parser));
+
+            if (rule->rule_attr == RULE_ATTR_STATIC)
+            {
+                new_nr_static_rules++;
+            }
+            else if (rule->rule_attr == RULE_ATTR_DYNAMIC)
+            {
+                new_nr_dynamic_rules++;
+            }
+
+            new_nr_rules++;
+        }
+    }
+
+    /* Update the rule list */
+    memset(rule_list->rules, 0, sizeof(rule_list->rules));
+    memcpy(rule_list->rules, new_rule_list, sizeof(new_rule_list));
+    rule_list->nr_rules = new_nr_rules;
+    rule_list->nr_static_rules = new_nr_static_rules;
+    rule_list->nr_dynamic_rules = new_nr_dynamic_rules;
+
+    return nr_duplicate_rules;
+}
+
+int pkt_classifier_rule_parser(const struct sc_main * sc, enum ruleset_type ruleset_type, enum rule_attribute rule_attr,
                                struct rule_list_parsed * out_rule_list)
 {
     const char * file_path = NULL;
     uint16_t * nr_rules_by_type = NULL;
 
-    switch (cfg_file_type)
+    switch (rule_attr)
     {
-    case 0:
+    case RULE_ATTR_STATIC:
         file_path = sc->local_cfgfile;
         nr_rules_by_type = &out_rule_list->nr_static_rules;
         break;
-    case 1:
+    case RULE_ATTR_DYNAMIC:
         file_path = sc->local_dyfile;
         nr_rules_by_type = &out_rule_list->nr_dynamic_rules;
         break;
     default:
-        MR_ERROR("Pkt classifier rule parser, cfg_file_type '%u' is invalid.", cfg_file_type);
+        MR_ERROR("Pkt classifier rule parser, cfg_file_type '%u' is invalid.", rule_attr);
         return RT_ERR;
     }
 
@@ -45,12 +308,14 @@ int pkt_classifier_rule_parser(const struct sc_main * sc, enum ruleset_type rule
 
         /* Initialize rule field with default values */
         struct rule_field_parser rule_field_parser = {};
+        rule_field_parser.rule_state = RULE_STATE_PENDING;
         rule_field_parser.src_port_start = 0;
         rule_field_parser.src_port_end = 65535;
         rule_field_parser.dst_port_start = 0;
         rule_field_parser.dst_port_end = 65535;
         rule_field_parser.ether_type = UINT16_MAX;
         rule_field_parser.rule_id = rule_id;
+        rule_field_parser.rule_attr = rule_attr;
 
         /* Retrieve the proto */
         uint32_t proto;
@@ -248,7 +513,7 @@ int pkt_classifier_rule_parser(const struct sc_main * sc, enum ruleset_type rule
         }
 
         rule_field_parser.action.type = action;
-        rule_field_parser.action.rule_index = out_rule_list->nr_rules;
+        rule_field_parser.action.rule_id = rule_id;
 
         /* Retrieve the Network Function Steering (NF steering) configuration */
         if (rule_field_parser.action.type == ACTION_NF_STEERING)
@@ -306,101 +571,13 @@ int pkt_classifier_rule_parser(const struct sc_main * sc, enum ruleset_type rule
             return RT_ERR;
         }
     }
-    return RT_SUCCESS;
-}
-
-/* Dump all rules information. */
-void classifier_rule_dump(struct rule_list_parsed * rule_list)
-{
-    /* Dump the total rule number */
-    MR_INFO(" ");
-    MR_INFO("Pkt classifier total rules: %u", rule_list->nr_rules);
-    MR_INFO("Pkt classifier total static rules: %u", rule_list->nr_static_rules);
-    MR_INFO("Pkt classifier total dynamic rules: %u", rule_list->nr_dynamic_rules);
 
-    for (uint16_t index = 0; index < rule_list->nr_rules; index++)
+    /* Check for duplicate rules */
+    uint16_t nr_duplicate_rules = pkt_classifier_duplicate_rules_process(out_rule_list);
+    if (nr_duplicate_rules > 0)
     {
-        char str_rule_info[2048] = {};
-        unsigned int max_len = sizeof(str_rule_info) - 1;
-        struct rule_field_parser * rule = &rule_list->rules[index];
-
-        int len = snprintf(str_rule_info, max_len, "Pkt classifier,rule index:%u, rule id:%u, ",
-                           rule->action.rule_index, rule->rule_id);
-        if (rule->ether_type == RTE_ETHER_TYPE_IPV4)
-        {
-            struct in_addr src_addr, dst_addr;
-            src_addr.s_addr = rule->src_addr_v4;
-            dst_addr.s_addr = rule->dst_addr_v4;
-
-            len += snprintf(str_rule_info + len, max_len - len, "IPv4, ");
-            len += snprintf(str_rule_info + len, max_len - len, "src addr: %s/%u, ", inet_ntoa(src_addr),
-                            rule->src_addr_mask_len);
-            len += snprintf(str_rule_info + len, max_len - len, "dst addr: %s/%u, ", inet_ntoa(dst_addr),
-                            rule->dst_addr_mask_len);
-        }
-        else if (rule->ether_type == RTE_ETHER_TYPE_IPV6)
-        {
-            char str_ipv6_src[INET6_ADDRSTRLEN] = {}, str_ipv6_dst[INET6_ADDRSTRLEN] = {};
-            inet_ntop(AF_INET6, rule->src_addr_v6, str_ipv6_src, INET6_ADDRSTRLEN);
-            inet_ntop(AF_INET6, rule->dst_addr_v6, str_ipv6_dst, INET6_ADDRSTRLEN);
-            len += snprintf(str_rule_info + len, max_len - len, "IPv6, ");
-            len += snprintf(str_rule_info + len, max_len - len, "src addr: %s/%u, ", str_ipv6_src,
-                            rule->src_addr_mask_len);
-            len += snprintf(str_rule_info + len, max_len - len, "dst addr: %s/%u, ", str_ipv6_dst,
-                            rule->dst_addr_mask_len);
-        }
-        else
-        {
-            len += snprintf(str_rule_info + len, max_len - len, "Any, ");
-        }
-
-        if (rule->proto == IPPROTO_TCP)
-        {
-            len += snprintf(str_rule_info + len, max_len - len, "proto: TCP, ");
-        }
-        else if (rule->proto == IPPROTO_UDP)
-        {
-            len += snprintf(str_rule_info + len, max_len - len, "proto: UDP, ");
-        }
-        else
-        {
-            len += snprintf(str_rule_info + len, max_len - len, "proto: Any, ");
-        }
-
-        len +=
-            snprintf(str_rule_info + len, max_len - len, "src port: %u~%u, ", rule->src_port_start, rule->src_port_end);
-
-        len +=
-            snprintf(str_rule_info + len, max_len - len, "dst port: %u~%u, ", rule->dst_port_start, rule->dst_port_end);
-
-        len += snprintf(str_rule_info + len, max_len - len, "priority: %u, ", rule->priority);
-
-        if (rule->action.type == ACTION_DROP)
-        {
-            len += snprintf(str_rule_info + len, max_len - len, "action: drop");
-        }
-        else if (rule->action.type == ACTION_NF_STEERING)
-        {
-            len += snprintf(str_rule_info + len, max_len - len, "action: nf_steering, sid: %u, ", rule->action.sid);
-
-            if (rule->adapter.type == ADAPTER_TYPE_EF)
-            {
-                len += snprintf(str_rule_info + len, max_len - len, "ef_adapter_id: %u", rule->adapter.id);
-            }
-            else if (rule->adapter.type == ADAPTER_TYPE_VWIRE)
-            {
-                len += snprintf(str_rule_info + len, max_len - len, "vwire_id: %u", rule->adapter.id);
-            }
-            else if (rule->adapter.type == ADAPTER_TYPE_TERA)
-            {
-                len += snprintf(str_rule_info + len, max_len - len, "tera_adapter_id: %u", rule->adapter.id);
-            }
-            else
-            {
-                len += snprintf(str_rule_info + len, max_len - len,
-                                "ef_adapter_id: all, vwire_id: all, tera_adapter_id: all");
-            }
-        }
-        MR_INFO("%s", str_rule_info);
+        MR_ERROR("Pkt classifier, duplicate rules found: %u", nr_duplicate_rules);
     }
+
+    return RT_SUCCESS;
 }
diff --git a/service/src/node_classifier.c b/service/src/node_classifier.c
index c7c54a7..e21cd4f 100644
--- a/service/src/node_classifier.c
+++ b/service/src/node_classifier.c
@@ -187,8 +187,8 @@ static inline void rule_list_engine_generator(struct rule_list_parsed * rule_lis
         rule_field_engine->dst_addr_mask_len = rule_field_parser->dst_addr_mask_len;
         rule_field_engine->rule_id = rule_field_parser->rule_id;
 
-        rule_field_engine->domain =
-            domain_field_generator_for_classifier(rule_field_parser->adapter.type, rule_field_parser->adapter.id);
+        rule_field_engine->domain = domain_field_generator_for_classifier(rule_field_parser->adapter.type,
+                                                                          rule_field_parser->adapter.id);
 
         switch (rule_field_parser->ether_type)
         {
@@ -220,8 +220,8 @@ int classifier_rule_update(struct sc_main * sc)
     struct rule_list_parsed rule_list_parsed = {};
 
     /* Parse static rules */
-    int ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine), 0,
-                                         &rule_list_parsed);
+    int ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine),
+                                         RULE_ATTR_STATIC, &rule_list_parsed);
 
     if (ret != RT_SUCCESS)
     {
@@ -230,8 +230,8 @@ int classifier_rule_update(struct sc_main * sc)
     }
 
     /* Parse dynamic rules */
-    ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine), 1,
-                                     &rule_list_parsed);
+    ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine),
+                                     RULE_ATTR_DYNAMIC, &rule_list_parsed);
 
     if (ret != RT_SUCCESS)
     {
@@ -269,7 +269,7 @@ int classifier_rule_update(struct sc_main * sc)
 
     /* Display information about the packet classifier rules. */
     memcpy(&classifier_main->rule_list_parsed, &rule_list_parsed, sizeof(struct rule_list_parsed));
-    classifier_rule_dump(&classifier_main->rule_list_parsed);
+    classifier_rule_list_dump(&classifier_main->rule_list_parsed);
     pkt_classifier_engine_info_dump(pkt_classifier_engine);
 
     return RT_SUCCESS;
@@ -297,8 +297,8 @@ int classifier_init(struct sc_main * sc)
     nr_domains += +classifier_main->nr_max_tera_adapters;
 
     /* Create pkt classifier engine */
-    struct pkt_classifier_engine * pkt_classifier_engine =
-        pkt_classifier_engine_create(sc->nr_io_thread, &sc->cpu_set_io, nr_domains, RULESET_TYPE_CLASSIFIER);
+    struct pkt_classifier_engine * pkt_classifier_engine = pkt_classifier_engine_create(
+        sc->nr_io_thread, &sc->cpu_set_io, nr_domains, RULESET_TYPE_CLASSIFIER);
 
     if (pkt_classifier_engine == NULL)
     {
@@ -312,8 +312,8 @@ int classifier_init(struct sc_main * sc)
 
     /* Parse static rules */
     struct rule_list_parsed rule_list_parsed = {};
-    int ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine), 0,
-                                         &rule_list_parsed);
+    int ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine),
+                                         RULE_ATTR_STATIC, &rule_list_parsed);
 
     if (ret != RT_SUCCESS)
     {
@@ -322,8 +322,8 @@ int classifier_init(struct sc_main * sc)
     }
 
     /* Parse dynamic rules */
-    ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine), 1,
-                                     &rule_list_parsed);
+    ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine),
+                                     RULE_ATTR_DYNAMIC, &rule_list_parsed);
 
     if (ret != RT_SUCCESS)
     {
@@ -353,7 +353,7 @@ int classifier_init(struct sc_main * sc)
 
     /* Display information about the packet classifier rules. */
     memcpy(&classifier_main->rule_list_parsed, &rule_list_parsed, sizeof(struct rule_list_parsed));
-    classifier_rule_dump(&classifier_main->rule_list_parsed);
+    classifier_rule_list_dump(&classifier_main->rule_list_parsed);
     pkt_classifier_engine_info_dump(pkt_classifier_engine);
     return RT_SUCCESS;
 }
@@ -393,8 +393,8 @@ static __rte_always_inline void gen_store_trace_info(struct rte_node * node, str
         for (uint8_t i = 0; i < result->nr_actions; i++)
         {
             struct action * action = &result->actions[i];
-            len += snprintf(str_record + len, sizeof(str_record) - len, ", [idx:%u, prio:%u, prep sid:%u]",
-                            action->rule_index, i, action->sid);
+            len += snprintf(str_record + len, sizeof(str_record) - len, ", [id:%u, prio:%u, prep sid:%u]",
+                            action->rule_id, i, action->sid);
         }
     }
 
@@ -437,8 +437,8 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
         for (uint8_t pkt_idx = 0; pkt_idx < FWDSTEP; pkt_idx++)
         {
             struct mrb_metadata * metadata = mrb_metadata[pkt_idx];
-            domain_field_for_pkts[pkt_idx] =
-                domain_field_generator_for_classifier(metadata->adapter_type, metadata->adapter_id);
+            domain_field_for_pkts[pkt_idx] = domain_field_generator_for_classifier(metadata->adapter_type,
+                                                                                   metadata->adapter_id);
         }
 
         struct match_result_engine results[FWDSTEP];
@@ -546,8 +546,8 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
 
         struct match_result_engine result;
         struct mrb_metadata * mrb_metadata = mrbuf_cz_data(mbuf0, MR_NODE_CTRLZONE_ID);
-        uint16_t pattern_group_id =
-            domain_field_generator_for_classifier(mrb_metadata->adapter_type, mrb_metadata->adapter_id);
+        uint16_t pattern_group_id = domain_field_generator_for_classifier(mrb_metadata->adapter_type,
+                                                                          mrb_metadata->adapter_id);
         pkt_classifier_engine_multi_match(pkt_classifier_engine, lcore_id, &mbuf0, 1, &pattern_group_id, &result);
 
         /* All the ICMP packet, go direct to egress, not for nfs */
@@ -555,8 +555,8 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
         if (ignore_all_icmp_pkts)
         {
             struct pkt_parser_result * pkt_parser_result = &mrb_metadata->pkt_parser_result;
-            void * icmp_start =
-                complex_layer_jump_to_outermost(pkt_parser_result, rte_pktmbuf_mtod(mbuf0, void *), LAYER_TYPE_ID_ICMP);
+            void * icmp_start = complex_layer_jump_to_outermost(pkt_parser_result, rte_pktmbuf_mtod(mbuf0, void *),
+                                                                LAYER_TYPE_ID_ICMP);
             if (unlikely(icmp_start != NULL))
             {
                 ignore_icmp_pkt = 1;