✨ feat(DPISDN-32): Classifier Node supports dynamically loading rules from mrglobal.dynamic.conf

Classifier Node supports dynamically loading rules from mrglobal.dynamic.conf

4 files changed, 69 insertions, 177 deletions

diff --git a/infra/include/pkt_classifier_engine.h b/infra/include/pkt_classifier_engine.h
index 0add045..3ce0393 100644
--- a/infra/include/pkt_classifier_engine.h
+++ b/infra/include/pkt_classifier_engine.h
@@ -44,13 +44,12 @@ struct rule_list_engine
     struct rule_field_engine rules[MAX_RULES];
 };
 
-typedef void pkt_classifier_engine_t;
-extern pkt_classifier_engine_t * pkt_classifier_engine_create(unsigned int nr_io_thread, cpu_set_t * cpu_set_io,
-                                                              uint32_t nr_domains, enum ruleset_type type);
-extern int pkt_classifier_engine_build(pkt_classifier_engine_t * engine, struct rule_list_engine * rule_list_engine,
-                                       char * str_error_reason, unsigned int sz_error_reason);
-extern int pkt_classifier_engine_multi_match(pkt_classifier_engine_t * engine_instance, uint32_t lcore_id,
-                                             struct rte_mbuf ** mbufs, uint16_t nr_mbufs,
-                                             uint16_t * pattern_group_id_list, struct match_result_engine * result);
-extern enum ruleset_type pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine_t * engine);
-extern void pkt_classifier_engine_info_dump(pkt_classifier_engine_t * engine_instance);
+struct pkt_classifier_engine;
+struct pkt_classifier_engine * pkt_classifier_engine_create(unsigned int nr_io_thread, cpu_set_t * cpu_set_io,
+                                                            uint32_t nr_domains, enum ruleset_type type);
+int pkt_classifier_engine_build(struct pkt_classifier_engine * engine, struct rule_list_engine * rule_list_engine);
+int pkt_classifier_engine_multi_match(struct pkt_classifier_engine * engine_instance, uint32_t lcore_id,
+                                      struct rte_mbuf ** mbufs, uint16_t nr_mbufs, uint16_t * pattern_group_id_list,
+                                      struct match_result_engine * result);
+enum ruleset_type pkt_classifier_engine_get_ruleset_type(struct pkt_classifier_engine * engine);
+void pkt_classifier_engine_info_dump(struct pkt_classifier_engine * engine_instance);
diff --git a/infra/include/rpc.h b/infra/include/rpc.h
index ce0a8a2..7288d5f 100644
--- a/infra/include/rpc.h
+++ b/infra/include/rpc.h
@@ -23,11 +23,6 @@
 #define RPC_CLIENT_SYNC_ERROR_RECV -3
 
 /************************************** Topic Field **************************************/
-/* Dynamic Classifier Rule Topic */
-#ifndef PKT_CLASSIFIER_RULE_FULL_UPDATE
-#define PKT_CLASSIFIER_RULE_FULL_UPDATE "FullUpdate"
-#endif
-
 /* Dynamic Load Balance Topic */
 #ifndef MR_LB_TOPIC_SINGLE_RULE_ADD
 #define MR_LB_TOPIC_SINGLE_RULE_ADD "LBSingleRuleAdd"
diff --git a/infra/src/pkt_classifier_engine.c b/infra/src/pkt_classifier_engine.c
index 4359b44..7cbd3d5 100644
--- a/infra/src/pkt_classifier_engine.c
+++ b/infra/src/pkt_classifier_engine.c
@@ -364,8 +364,7 @@ int rule_validity_check(struct rule_field_engine rules[], uint32_t nr_rules, uin
     return RT_SUCCESS;
 }
 
-int duplicate_rules_check(struct rule_field_engine * rules, uint32_t nr_rules, char * str_error_reason,
-                          unsigned int sz_error_reason)
+int duplicate_rules_check(struct rule_field_engine * rules, uint32_t nr_rules)
 {
     for (uint32_t rule_index = 0; rule_index < nr_rules; rule_index++)
     {
@@ -413,7 +412,7 @@ int duplicate_rules_check(struct rule_field_engine * rules, uint32_t nr_rules, c
                     continue;
             }
 
-            sprintf(str_error_reason, "Duplicate rule %d and %d", rule_index, index);
+            MR_ERROR("Pkt classifier engine build failed, reason: duplicate rules %d and %d.", rule_index, index);
             return RT_ERR;
         }
     }
@@ -926,8 +925,7 @@ void domain_array_free_for_linear_search(struct filter_engine * filter_engine)
 }
 
 /* Create domain array */
-int domain_array_create(struct filter_engine * filter_engine, struct rule_field_engine * rules, uint32_t nr_rules,
-                        char * str_error_reason, unsigned int sz_error_reason)
+int domain_array_create(struct filter_engine * filter_engine, struct rule_field_engine * rules, uint32_t nr_rules)
 {
     /* Define the domain instance create function based on the engine type */
     domain_create fn_domain_create;
@@ -940,7 +938,7 @@ int domain_array_create(struct filter_engine * filter_engine, struct rule_field_
         fn_domain_create = domain_create_for_linear_search;
         break;
     default:
-        snprintf(str_error_reason, sz_error_reason - 1, "Unsupported engine type %d", filter_engine->type);
+        MR_ERROR("Pkt classifier engine build failed, reason: unsupported engine type %d.", filter_engine->type);
         return RT_ERR;
     }
 
@@ -968,8 +966,9 @@ int domain_array_create(struct filter_engine * filter_engine, struct rule_field_
         struct domain * domain = fn_domain_create(domain_rules, nr_rules_in_domain, domain_index);
         if (domain == NULL)
         {
-            snprintf(str_error_reason, sz_error_reason - 1, "Failed to create domain instance,the domain field is: %d",
-                     domain_index);
+            MR_ERROR(
+                "Pkt classifier engine build failed, reason: failed to create domain instance,the domain field is: %d.",
+                domain_index);
             return RT_ERR;
         }
 
@@ -995,8 +994,7 @@ void domain_array_free(struct filter_engine * filter_engine)
 
 /* Create a new filter engine instance based on the engine type and engine rule list. */
 struct filter_engine * filter_engine_create(struct rule_field_engine * rules, uint32_t nr_rules, uint32_t nr_domains,
-                                            enum engine_algo_type type, char * str_error_reason,
-                                            unsigned int sz_error_reason)
+                                            enum engine_algo_type type)
 {
     /* Allocate memory for the engine. */
     struct filter_engine * filter_engine = ZMALLOC(sizeof(struct filter_engine));
@@ -1005,7 +1003,7 @@ struct filter_engine * filter_engine_create(struct rule_field_engine * rules, ui
     filter_engine->nr_domains = nr_domains;
 
     /* Create the pattern groups based on the engine type and engine rule list. */
-    int ret = domain_array_create(filter_engine, rules, nr_rules, str_error_reason, sz_error_reason);
+    int ret = domain_array_create(filter_engine, rules, nr_rules);
     if (ret != RT_SUCCESS)
     {
         domain_array_free(filter_engine);
@@ -1022,8 +1020,8 @@ void filter_engine_free(struct filter_engine * filter_engine)
 }
 
 /* Public func */
-pkt_classifier_engine_t * pkt_classifier_engine_create(unsigned int nr_io_thread, cpu_set_t * cpu_set_io,
-                                                       uint32_t nr_domains, enum ruleset_type type)
+struct pkt_classifier_engine * pkt_classifier_engine_create(unsigned int nr_io_thread, cpu_set_t * cpu_set_io,
+                                                            uint32_t nr_domains, enum ruleset_type type)
 {
     /* Check the ruleset type */
     if (type >= RULESET_TYPE_MAX)
@@ -1050,22 +1048,22 @@ pkt_classifier_engine_t * pkt_classifier_engine_create(unsigned int nr_io_thread
         rte_rcu_qsbr_thread_register(engine->qsv, lcore_id);
     }
 
-    return (pkt_classifier_engine_t *)engine;
+    return engine;
 }
 
-enum ruleset_type pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine_t * engine)
+enum ruleset_type pkt_classifier_engine_get_ruleset_type(struct pkt_classifier_engine * engine)
 {
-    return ((struct pkt_classifier_engine *)engine)->ruleset_type;
+    return engine->ruleset_type;
 }
 
-enum engine_algo_type get_engine_type(pkt_classifier_engine_t * engine)
+enum engine_algo_type get_engine_type(struct pkt_classifier_engine * engine)
 {
-    return ((struct pkt_classifier_engine *)engine)->filter_engine->type;
+    return engine->filter_engine->type;
 }
 
-void pkt_classifier_engine_fast_match_info_dump(pkt_classifier_engine_t * engine)
+void pkt_classifier_engine_fast_match_info_dump(struct pkt_classifier_engine * engine)
 {
-    struct filter_engine * filter_engine = ((struct pkt_classifier_engine *)engine)->filter_engine;
+    struct filter_engine * filter_engine = engine->filter_engine;
     for (uint16_t index = 0; index < RTE_DIM(filter_engine->domains); index++)
     {
         char str_info[2048] = {};
@@ -1110,20 +1108,18 @@ void pkt_classifier_engine_fast_match_info_dump(pkt_classifier_engine_t * engine
 }
 
 /* Build the classifier engine based on 'rule_field_engine'. */
-int pkt_classifier_engine_build(pkt_classifier_engine_t * engine, struct rule_list_engine * rule_list_engine,
-                                char * str_error_reason, unsigned int sz_error_reason)
+int pkt_classifier_engine_build(struct pkt_classifier_engine * engine, struct rule_list_engine * rule_list_engine)
 {
     /* Rule validity check. */
-    struct pkt_classifier_engine * pkt_classifier_engine = (struct pkt_classifier_engine *)engine;
     uint16_t nr_rules = rule_list_engine->nr_rules;
-    uint32_t nr_domains = pkt_classifier_engine->nr_domains;
+    uint32_t nr_domains = engine->nr_domains;
     struct rule_field_engine * rules = rule_list_engine->rules;
     int ret = rule_validity_check(rules, nr_rules, nr_domains);
     if (ret != RT_SUCCESS)
         return RT_ERR;
 
     /* Duplicate rules check. */
-    ret = duplicate_rules_check(rules, nr_rules, str_error_reason, sz_error_reason);
+    ret = duplicate_rules_check(rules, nr_rules);
     if (ret != RT_SUCCESS)
         return RT_ERR;
 
@@ -1131,19 +1127,18 @@ int pkt_classifier_engine_build(pkt_classifier_engine_t * engine, struct rule_li
     enum engine_algo_type engine_algo_type = (nr_rules > 100) ? ENGINE_TYPE_TREE_SEARCH : ENGINE_TYPE_LINEAR_SEARCH;
 
     /* Initialize a new filter engine */
-    struct filter_engine * filter_engine_new =
-        filter_engine_create(rules, nr_rules, nr_domains, engine_algo_type, str_error_reason, sz_error_reason);
+    struct filter_engine * filter_engine_new = filter_engine_create(rules, nr_rules, nr_domains, engine_algo_type);
     if (filter_engine_new == NULL)
         return RT_ERR;
 
     /* Retrieve the old filter engine*/
-    struct filter_engine * filter_engine_old = pkt_classifier_engine->filter_engine;
+    struct filter_engine * filter_engine_old = engine->filter_engine;
 
     /* Update the filter engine */
-    pkt_classifier_engine->filter_engine = filter_engine_new;
+    engine->filter_engine = filter_engine_new;
 
     /* Synchronize RCU and free the old filter engine */
-    rte_rcu_qsbr_synchronize(pkt_classifier_engine->qsv, RTE_QSBR_THRID_INVALID);
+    rte_rcu_qsbr_synchronize(engine->qsv, RTE_QSBR_THRID_INVALID);
     if (filter_engine_old != NULL)
         filter_engine_free(filter_engine_old);
 
@@ -1500,7 +1495,7 @@ void packets_match(struct filter_engine * filter_engine, struct rte_mbuf * mbufs
 }
 
 /* Match multiple packets with the Packet Classifier Engine */
-int pkt_classifier_engine_multi_match(pkt_classifier_engine_t * engine_instance, uint32_t lcore_id,
+int pkt_classifier_engine_multi_match(struct pkt_classifier_engine * engine, uint32_t lcore_id,
                                       struct rte_mbuf * mbufs[], uint16_t nr_mbufs, uint16_t domain_field_for_pkts[],
                                       struct match_result_engine result[])
 {
@@ -1508,7 +1503,6 @@ int pkt_classifier_engine_multi_match(pkt_classifier_engine_t * engine_instance,
     assert(nr_mbufs <= 16);
 
     /* Set rcu thread online */
-    struct pkt_classifier_engine * engine = (struct pkt_classifier_engine *)engine_instance;
     struct rte_rcu_qsbr * qsv = engine->qsv;
     rte_rcu_qsbr_thread_online(qsv, lcore_id);
 
@@ -1523,13 +1517,13 @@ int pkt_classifier_engine_multi_match(pkt_classifier_engine_t * engine_instance,
 }
 
 /* Dump all rules information. */
-void pkt_classifier_engine_info_dump(pkt_classifier_engine_t * engine_instance)
+void pkt_classifier_engine_info_dump(struct pkt_classifier_engine * engine)
 {
     /* Dump the fast match info */
-    pkt_classifier_engine_fast_match_info_dump(engine_instance);
+    pkt_classifier_engine_fast_match_info_dump(engine);
 
     /* Dump the ruleset type */
-    enum ruleset_type ruleset_type = pkt_classifier_engine_get_ruleset_type(engine_instance);
+    enum ruleset_type ruleset_type = pkt_classifier_engine_get_ruleset_type(engine);
     if (ruleset_type == RULESET_TYPE_CLASSIFIER)
     {
         MR_INFO("Pkt classifier ruleset type: Classifier");
@@ -1540,7 +1534,7 @@ void pkt_classifier_engine_info_dump(pkt_classifier_engine_t * engine_instance)
     }
 
     /* Dump the engine type */
-    enum engine_algo_type engine_algo_type = get_engine_type(engine_instance);
+    enum engine_algo_type engine_algo_type = get_engine_type(engine);
     if (engine_algo_type == ENGINE_TYPE_TREE_SEARCH)
     {
         MR_INFO("Pkt classifier engine type: Tree search");
diff --git a/infra/test/TestPktClassifierEngine.cc b/infra/test/TestPktClassifierEngine.cc
index 03b4fd3..7652cc7 100644
--- a/infra/test/TestPktClassifierEngine.cc
+++ b/infra/test/TestPktClassifierEngine.cc
@@ -21,7 +21,7 @@ class TestCasePktClassifierEngine : public ::testing::Test
 {
   protected:
     static struct rte_mempool * pktmbuf_pool_;
-    static pkt_classifier_engine_t * engine_instance_;
+    static struct pkt_classifier_engine * engine_instance_;
     static void SetUpTestCase()
     {
         unsigned int sz_align_priv = RTE_ALIGN(64, RTE_MBUF_PRIV_ALIGN);
@@ -45,7 +45,7 @@ class TestCasePktClassifierEngine : public ::testing::Test
 };
 
 struct rte_mempool * TestCasePktClassifierEngine::pktmbuf_pool_ = nullptr;
-pkt_classifier_engine_t * TestCasePktClassifierEngine::engine_instance_ = nullptr;
+struct pkt_classifier_engine * TestCasePktClassifierEngine::engine_instance_ = nullptr;
 
 void construct_pkt_for_ipv4(struct rte_mbuf * mbuf, char * src_addr, char * dst_addr, uint8_t proto, uint16_t src_port,
                             uint16_t dst_port)
@@ -215,13 +215,7 @@ TEST_F(TestCasePktClassifierEngine, PktFullFieldMatchForLinearSearch)
     rule_list_engine_generator_for_full_field_match(100, &rule_list_engine);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -291,13 +285,7 @@ TEST_F(TestCasePktClassifierEngine, PktFullFieldMatchForTreeSearch)
     rule_list_engine_generator_for_full_field_match(200, &rule_list_engine);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -439,13 +427,7 @@ TEST_F(TestCasePktClassifierEngine, IPAddrTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:2:2:2:2:2", &rule->dst_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the packet */
@@ -636,13 +618,7 @@ TEST_F(TestCasePktClassifierEngine, IPAddrTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -813,13 +789,7 @@ TEST_F(TestCasePktClassifierEngine, ProtoTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:2:2:2:2:2", &rule->dst_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -986,13 +956,7 @@ TEST_F(TestCasePktClassifierEngine, ProtoTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1103,13 +1067,7 @@ TEST_F(TestCasePktClassifierEngine, PortTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1224,13 +1182,7 @@ TEST_F(TestCasePktClassifierEngine, PortTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1361,13 +1313,7 @@ TEST_F(TestCasePktClassifierEngine, DomainTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1534,13 +1480,7 @@ TEST_F(TestCasePktClassifierEngine, DomainTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1759,13 +1699,7 @@ TEST_F(TestCasePktClassifierEngine, PriorityTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -2000,13 +1934,7 @@ TEST_F(TestCasePktClassifierEngine, PriorityTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -2106,13 +2034,7 @@ TEST_F(TestCasePktClassifierEngine, RepeatBuildTest)
         }
 
         /* Build the engine */
-        char str_error_reason[MR_STRING_MAX];
-        int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason,
-                                              sizeof(str_error_reason));
-        if (ret != 0)
-        {
-            printf("error reason: %s\n", str_error_reason);
-        }
+        int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
         EXPECT_EQ(ret, 0);
     }
 }
@@ -2158,13 +2080,8 @@ TEST_F(TestCasePktClassifierEngine, DuplicateRulesCheckTest)
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
+
     EXPECT_EQ(ret, -1);
 }
 
@@ -2247,13 +2164,7 @@ TEST_F(TestCasePktClassifierEngine, IcmpTestForLinearSearch)
     rule->dst_addr_mask_len = 0;
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -2424,13 +2335,7 @@ TEST_F(TestCasePktClassifierEngine, IcmpTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -2529,9 +2434,8 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        ASSERT_DEATH(
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The proto mask is invalid */
@@ -2551,7 +2455,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The priority is invalid */
@@ -2571,7 +2475,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The domain is invalid */
@@ -2591,7 +2495,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The src port start is invalid */
@@ -2611,7 +2515,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The dst port start is invalid */
@@ -2631,7 +2535,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The ipv4 src addr mask len is invalid */
@@ -2651,7 +2555,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The ipv4 dst addr mask len is invalid */
@@ -2671,7 +2575,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 33;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The ipv6 src addr mask len is invalid */
@@ -2691,7 +2595,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The ipv6 dst addr mask len is invalid */
@@ -2711,7 +2615,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 129;
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 }
 #endif