diff options
| -rw-r--r-- | .gitignore | 2 | ||||
| -rw-r--r-- | infra/include/pkt_classifier_engine.h | 19 | ||||
| -rw-r--r-- | infra/include/rpc.h | 5 | ||||
| -rw-r--r-- | infra/src/pkt_classifier_engine.c | 66 | ||||
| -rw-r--r-- | infra/test/TestPktClassifierEngine.cc | 156 | ||||
| -rw-r--r-- | service/include/sc_classifier_rule_parser.h | 6 | ||||
| -rw-r--r-- | service/include/sc_common.h | 2 | ||||
| -rw-r--r-- | service/src/classifier_rule_parser.c | 376 | ||||
| -rw-r--r-- | service/src/core.c | 6 | ||||
| -rw-r--r-- | service/src/node_classifier.c | 136 |
10 files changed, 153 insertions, 621 deletions
@@ -16,7 +16,7 @@ tags __pycache__ mpack*/ -mrglobal.conf +mrglobal*.conf build*/ test/test /*.opendb 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 diff --git a/service/include/sc_classifier_rule_parser.h b/service/include/sc_classifier_rule_parser.h index a2c3b41..cd07dbe 100644 --- a/service/include/sc_classifier_rule_parser.h +++ b/service/include/sc_classifier_rule_parser.h @@ -69,13 +69,11 @@ struct rule_field_parser struct rule_list_parsed { uint16_t nr_rules; - uint16_t nr_local_rules; - uint16_t nr_remote_rules; struct rule_field_parser rules[MAX_RULES]; }; -extern int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type ruleset_type, - struct rule_list_parsed * out_rule_list); +extern int pkt_classifier_rule_parser(struct sc_main * sc, enum ruleset_type ruleset_type, + struct rule_list_parsed * out_rule_list); extern int pkt_classifier_remote_rule_parser(cJSON * c_rule, struct rule_list_parsed * out_rule_list, char * str_error_reason, unsigned int sz_error_reason); extern void classifier_rule_dump(struct rule_list_parsed * rule_list); diff --git a/service/include/sc_common.h b/service/include/sc_common.h index feb7733..d345e10 100644 --- a/service/include/sc_common.h +++ b/service/include/sc_common.h @@ -134,8 +134,6 @@ struct sc_main struct vlan_base_fwd_main * vlan_base_fwd_main; /* Node Manager */ struct node_manager_main * node_mgr_main; - /* Classifier Node */ - struct node_classifier_main * node_classifier_main; /* Failover Node */ struct node_lb_main * lb_node_main; /* Etherfabric Node */ diff --git a/service/src/classifier_rule_parser.c b/service/src/classifier_rule_parser.c index 9ba95ab..f8ebd5c 100644 --- a/service/src/classifier_rule_parser.c +++ b/service/src/classifier_rule_parser.c @@ -3,8 +3,8 @@ #include <limits.h> #include <sc_classifier_rule_parser.h> -int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type ruleset_type, - struct rule_list_parsed * out_rule_list) +int pkt_classifier_rule_parser(struct sc_main * sc, enum ruleset_type ruleset_type, + struct rule_list_parsed * out_rule_list) { int ret = RT_SUCCESS; for (int rule_index = 0; rule_index < MAX_RULES; rule_index++) @@ -13,7 +13,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule uint32_t rule_id; char str_section[MR_SYMBOL_MAX] = {}; snprintf(str_section, sizeof(str_section), "classifier_rule:%d", rule_index); - ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "rule_id", &rule_id); + ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "rule_id", &rule_id); if (ret < 0) { continue; @@ -21,7 +21,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule /* Retrieve the ruleset type; if there's no configured ruleset, break the current rule */ char str_ruleset_type[MR_SYMBOL_MAX] = {}; - ret = MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "ruleset_type", str_ruleset_type, + ret = MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "ruleset_type", str_ruleset_type, sizeof(str_ruleset_type)); if (ret < 0) { @@ -61,7 +61,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule /* Retrieve the proto */ char str_proto[MR_SYMBOL_MAX] = {}; - MESA_load_profile_string_def(sc->local_cfgfile, str_section, "proto", str_proto, sizeof(str_proto), "any"); + MESA_load_profile_string_def(sc->local_dyfile, str_section, "proto", str_proto, sizeof(str_proto), "any"); if (strcmp(str_proto, "tcp") == 0) { rule_field_parser.proto = IPPROTO_TCP; @@ -81,10 +81,10 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule /* Retrieve source port start and end */ uint32_t src_port_range_start = 0, src_port_range_end = 0; - int ret_start = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_port_range_start", - &src_port_range_start, 0); - int ret_end = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_port_range_end", - &src_port_range_end, 65535); + int ret_start = + MESA_load_profile_uint_def(sc->local_dyfile, str_section, "src_port_range_start", &src_port_range_start, 0); + int ret_end = + MESA_load_profile_uint_def(sc->local_dyfile, str_section, "src_port_range_end", &src_port_range_end, 65535); if ((ret_start >= 0) && (ret_end < 0)) { src_port_range_end = src_port_range_start; @@ -99,10 +99,10 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule /* Retrieve destination port start and end */ uint32_t dst_port_range_start = 0, dst_port_range_end = 0; - ret_start = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_port_range_start", - &dst_port_range_start, 0); - ret_end = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_port_range_end", &dst_port_range_end, - 65535); + ret_start = + MESA_load_profile_uint_def(sc->local_dyfile, str_section, "dst_port_range_start", &dst_port_range_start, 0); + ret_end = + MESA_load_profile_uint_def(sc->local_dyfile, str_section, "dst_port_range_end", &dst_port_range_end, 65535); if ((ret_start >= 0) && (ret_end < 0)) { dst_port_range_end = dst_port_range_start; @@ -117,7 +117,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule /* Retrieve the priority */ uint32_t priority; - ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "priority", &priority); + ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "priority", &priority); if (ret < 0) { MR_ERROR("Pkt classifier rule name : %s ,must config the 'priority'.", str_section); @@ -134,7 +134,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule /* Retrieve the IPv4 source address and mask*/ char str_src_ip_addr_v4[MR_SYMBOL_MAX] = {}; - if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "src_ip_addr_v4", str_src_ip_addr_v4, + if (MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "src_ip_addr_v4", str_src_ip_addr_v4, sizeof(str_src_ip_addr_v4)) > 0) { rule_field_parser.ether_type = RTE_ETHER_TYPE_IPV4; @@ -147,13 +147,13 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule return RT_ERR; } - MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_ip_mask_v4", + MESA_load_profile_uint_def(sc->local_dyfile, str_section, "src_ip_mask_v4", &rule_field_parser.src_addr_mask_len, 32); } /* Retrieve the IPv4 destination address and mask */ char str_dst_ip_addr_v4[MR_SYMBOL_MAX] = {}; - if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "dst_ip_addr_v4", str_dst_ip_addr_v4, + if (MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "dst_ip_addr_v4", str_dst_ip_addr_v4, sizeof(str_dst_ip_addr_v4)) > 0) { rule_field_parser.ether_type = RTE_ETHER_TYPE_IPV4; @@ -165,13 +165,13 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule return RT_ERR; } - MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_ip_mask_v4", + MESA_load_profile_uint_def(sc->local_dyfile, str_section, "dst_ip_mask_v4", &rule_field_parser.dst_addr_mask_len, 32); } /* Retrieve the IPv6 source address and mask */ char str_src_ip_addr_v6[MR_SYMBOL_MAX] = {}; - if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "src_ip_addr_v6", str_src_ip_addr_v6, + if (MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "src_ip_addr_v6", str_src_ip_addr_v6, sizeof(str_src_ip_addr_v6)) > 0) { /* Verify the IP version */ @@ -190,13 +190,13 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule return RT_ERR; } - MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_ip_mask_v6", + MESA_load_profile_uint_def(sc->local_dyfile, str_section, "src_ip_mask_v6", &rule_field_parser.src_addr_mask_len, 128); } /* Retrieve the IPv6 destination address and mask */ char str_dst_ip_addr_v6[MR_SYMBOL_MAX] = {}; - if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "dst_ip_addr_v6", str_dst_ip_addr_v6, + if (MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "dst_ip_addr_v6", str_dst_ip_addr_v6, sizeof(str_dst_ip_addr_v6)) > 0) { /* Verify the IP version */ @@ -215,13 +215,13 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule return RT_ERR; } - MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_ip_mask_v6", + MESA_load_profile_uint_def(sc->local_dyfile, str_section, "dst_ip_mask_v6", &rule_field_parser.dst_addr_mask_len, 128); } /* Retrieve the action */ char str_action[MR_SYMBOL_MAX] = {}; - ret = MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "action", str_action, sizeof(str_action)); + ret = MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "action", str_action, sizeof(str_action)); if (ret < 0) { MR_ERROR("Pkt classifier rule name : %s ,no config the 'action'.", str_section); @@ -248,7 +248,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule { /* Retrieve the SID */ uint32_t sid = 0; - ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "sid", &sid); + ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "sid", &sid); if (ret < 0) { MR_ERROR("Pkt classifier rule name : %s ,no config the 'sid'.", str_section); @@ -261,9 +261,9 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule uint32_t ef_adapter_id = UINT32_MAX; uint32_t vwire_adapter_id = UINT32_MAX; uint32_t tera_adapter_id = UINT32_MAX; - int ef_ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "ef_id", &ef_adapter_id); - int vwire_ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "vwire_id", &vwire_adapter_id); - int tera_ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "tera_id", &tera_adapter_id); + int ef_ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "ef_id", &ef_adapter_id); + int vwire_ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "vwire_id", &vwire_adapter_id); + int tera_ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "tera_id", &tera_adapter_id); if (ef_ret >= 0) { @@ -292,7 +292,6 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule memcpy(rule_field_item, &rule_field_parser, sizeof(struct rule_field_parser)); out_rule_list->nr_rules++; - out_rule_list->nr_local_rules++; if (out_rule_list->nr_rules >= MAX_RULES) { MR_ERROR("Pkt classifier rule name : %s , ruleset type is '%s', rules is full.", str_section, @@ -303,325 +302,6 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule return RT_SUCCESS; } -int parse_ip_version_from_cjson(cJSON * c_rule, uint16_t * ip_version) -{ - cJSON * cj_src_ip_addr_v4 = cJSON_GetObjectItem(c_rule, "SrcIpV4"); - cJSON * cj_dst_ip_addr_v4 = cJSON_GetObjectItem(c_rule, "DstIpV4"); - cJSON * cj_src_ip_addr_v6 = cJSON_GetObjectItem(c_rule, "SrcIpV6"); - cJSON * cj_dst_ip_addr_v6 = cJSON_GetObjectItem(c_rule, "DstIpV6"); - - if (((cj_src_ip_addr_v4 != NULL) || (cj_dst_ip_addr_v4 != NULL)) && - ((cj_src_ip_addr_v6 != NULL) || (cj_dst_ip_addr_v6 != NULL))) - return RT_ERR; - - if ((cj_src_ip_addr_v4 != NULL) || (cj_dst_ip_addr_v4 != NULL)) - *ip_version = RTE_ETHER_TYPE_IPV4; - else if ((cj_src_ip_addr_v6 != NULL) || (cj_dst_ip_addr_v6 != NULL)) - *ip_version = RTE_ETHER_TYPE_IPV6; - else - *ip_version = UINT16_MAX; - - return RT_SUCCESS; -} - -int pkt_classifier_remote_rule_parser(cJSON * cjson_rule, struct rule_list_parsed * out_rule_list, - char * str_error_reason, unsigned int sz_error_reason) -{ - /* Retrieve the rule array */ - cJSON * cj_rule_array = cJSON_GetObjectItem(cjson_rule, "RuleArray"); - if (cj_rule_array == NULL) - { - snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error, no config 'RuleArray'."); - return RT_ERR; - } - - /* Retrieve the rules number */ - int nr_rules = cJSON_GetArraySize(cj_rule_array); - for (int rule_index = 0; rule_index < nr_rules; rule_index++) - { - /* Initialize rule field with default values */ - struct rule_field_parser rule_field_parser = {}; - 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; - - /* Get IP Version */ - cJSON * cj_rule_item = cJSON_GetArrayItem(cj_rule_array, rule_index); - int ret = parse_ip_version_from_cjson(cj_rule_item, &rule_field_parser.ether_type); - if (ret != RT_SUCCESS) - { - snprintf(str_error_reason, sz_error_reason - 1, - "Classifier rule add error, configuring both IPv4 and IPv6 simultaneously."); - return RT_ERR; - } - - /* Parse rule field information from the total JSON data */ - /* rule id */ - cJSON * cj_rule_id = cJSON_GetObjectItem(cj_rule_item, "RuleId"); - /* IP */ - cJSON * cj_src_ip_addr_v4 = cJSON_GetObjectItem(cj_rule_item, "SrcIpV4"); - cJSON * cj_dst_ip_addr_v4 = cJSON_GetObjectItem(cj_rule_item, "DstIpV4"); - cJSON * cj_src_ip_addr_v6 = cJSON_GetObjectItem(cj_rule_item, "SrcIpV6"); - cJSON * cj_dst_ip_addr_v6 = cJSON_GetObjectItem(cj_rule_item, "DstIpV6"); - /* IP Mask */ - cJSON * cj_src_ip_mask = cJSON_GetObjectItem(cj_rule_item, "SrcIpMask"); - cJSON * cj_dst_ip_mask = cJSON_GetObjectItem(cj_rule_item, "DstIpMask"); - /* Port */ - cJSON * cj_src_port_range_start = cJSON_GetObjectItem(cj_rule_item, "SrcPortLow"); - cJSON * cj_src_port_range_end = cJSON_GetObjectItem(cj_rule_item, "SrcPortHigh"); - cJSON * cj_dst_port_range_start = cJSON_GetObjectItem(cj_rule_item, "DstPortLow"); - cJSON * cj_dst_port_range_end = cJSON_GetObjectItem(cj_rule_item, "DstPortHigh"); - /* Proto */ - cJSON * cj_proto = cJSON_GetObjectItem(cj_rule_item, "Proto"); - /* Priority */ - // cJSON * cj_priority = cJSON_GetObjectItem(cj_rule_item, "Priority"); - /* Category */ - cJSON * cj_category = cJSON_GetObjectItem(cj_rule_item, "Category"); - /* Sid */ - cJSON * cj_sid = cJSON_GetObjectItem(cj_rule_item, "Sid"); - /* Vwire id */ - cJSON * cj_vwire_id = cJSON_GetObjectItem(cj_rule_item, "VwireId"); - /* Ef id */ - cJSON * cj_ef_id = cJSON_GetObjectItem(cj_rule_item, "EfId"); - /* Tera id */ - cJSON * cj_tera_id = cJSON_GetObjectItem(cj_rule_item, "TeraId"); - - /* Verify required rule field: rule ID */ - uint32_t rule_id; - if (cj_rule_id == NULL) - { - snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error,no config rule id ."); - return RT_ERR; - } - else - { - rule_id = (uint32_t)cj_rule_id->valuedouble; - } - - /* Verify required rule field: priority */ -#if 0 - if (cj_priority == NULL) - { - snprintf(str_error_reason, sz_error_reason - 1, - "Classifier rule add error, rule ID '%u', 'priority' not configured.", rule_id); - return RT_ERR; - } -#else - if (cj_category == NULL) - { - snprintf(str_error_reason, sz_error_reason - 1, - "Classifier rule add error, rule ID '%u', 'category' not configured.", rule_id); - return RT_ERR; - } -#endif - - /* Verify the mandatory rule field: SID */ - if (cj_sid == NULL) - { - snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error,rule id '%u',no config 'sid' .", - rule_id); - return RT_ERR; - } - - /* Retrieve protocol */ - if (cj_proto != NULL) - { - rule_field_parser.proto = (uint8_t)cj_proto->valuedouble; - rule_field_parser.proto_mask = UINT8_MAX; - } - - /* Retrieve source port start and end */ - if (cj_src_port_range_start != NULL) - rule_field_parser.src_port_start = (uint16_t)cj_src_port_range_start->valuedouble; - - if (cj_src_port_range_end != NULL) - rule_field_parser.src_port_end = (uint16_t)cj_src_port_range_end->valuedouble; - - if ((cj_src_port_range_start != NULL) && (cj_src_port_range_end == NULL)) - { - rule_field_parser.src_port_end = rule_field_parser.src_port_start; - } - else if ((cj_src_port_range_start == NULL) && (cj_src_port_range_end != NULL)) - { - rule_field_parser.src_port_start = rule_field_parser.src_port_end; - } - - /* Retrieve destination port start and end */ - if (cj_dst_port_range_start != NULL) - rule_field_parser.dst_port_start = (uint16_t)cj_dst_port_range_start->valuedouble; - - if (cj_dst_port_range_end != NULL) - rule_field_parser.dst_port_end = (uint16_t)cj_dst_port_range_end->valuedouble; - - if ((cj_dst_port_range_start != NULL) && (cj_dst_port_range_end == NULL)) - { - rule_field_parser.dst_port_end = rule_field_parser.dst_port_start; - } - else if ((cj_dst_port_range_start == NULL) && (cj_dst_port_range_end != NULL)) - { - rule_field_parser.dst_port_start = rule_field_parser.dst_port_end; - } - - /* Retrieve the priority */ -#if 0 - - rule_field_parser.priority = (uint16_t)cj_priority->valuedouble; -#else - rule_field_parser.priority = (uint8_t)cj_category->valuedouble; -#endif - - /* Retrieve the rule id */ - rule_field_parser.rule_id = rule_id; - - /* Retrieve IPv4 source address and mask */ - if (cj_src_ip_addr_v4 != NULL) - { - ret = inet_pton(AF_INET, cj_src_ip_addr_v4->valuestring, &rule_field_parser.src_addr_v4); - if ((!ret) && (strcmp(cj_src_ip_addr_v4->valuestring, "0.0.0.0") != 0)) - { - snprintf(str_error_reason, sz_error_reason - 1, - "Classifier rule add error, rule ID '%u', the IPv4 source address '%s' is invalid.", rule_id, - cj_src_ip_addr_v4->valuestring); - return RT_ERR; - } - - /* Retrieve the source address mask */ - if (cj_src_ip_mask != NULL) - rule_field_parser.src_addr_mask_len = (uint32_t)cj_src_ip_mask->valuedouble; - else - rule_field_parser.src_addr_mask_len = 32; - } - - /* Retrieve IPv4 destination address and mask */ - if (cj_dst_ip_addr_v4 != NULL) - { - ret = inet_pton(AF_INET, cj_dst_ip_addr_v4->valuestring, &rule_field_parser.dst_addr_v4); - if ((!ret) && (strcmp(cj_dst_ip_addr_v4->valuestring, "0.0.0.0") != 0)) - { - snprintf(str_error_reason, sz_error_reason - 1, - "Classifier rule add error, rule ID '%u', the IPv4 destination address '%s' is invalid.", - rule_id, cj_dst_ip_addr_v4->valuestring); - return RT_ERR; - } - - /* Retrieve the destination address mask */ - if (cj_dst_ip_mask != NULL) - rule_field_parser.dst_addr_mask_len = (uint32_t)cj_dst_ip_mask->valuedouble; - else - rule_field_parser.dst_addr_mask_len = 32; - } - - /* Retrieve IPv6 source address and mask */ - if (cj_src_ip_addr_v6 != NULL) - { - ret = inet_pton(AF_INET6, cj_src_ip_addr_v6->valuestring, &rule_field_parser.src_addr_v6); - if ((!ret) && (strcmp(cj_src_ip_addr_v6->valuestring, "::") != 0)) - { - snprintf(str_error_reason, sz_error_reason - 1, - "Classifier rule add error, rule ID '%u', the IPv6 source address '%s' is invalid.", rule_id, - cj_src_ip_addr_v6->valuestring); - return RT_ERR; - } - - /* Retrieve the source address mask */ - if (cj_src_ip_mask != NULL) - rule_field_parser.src_addr_mask_len = (uint32_t)cj_src_ip_mask->valuedouble; - else - rule_field_parser.src_addr_mask_len = 128; - } - - /* Retrieve IPv6 destination address and mask */ - if (cj_dst_ip_addr_v6 != NULL) - { - ret = inet_pton(AF_INET6, cj_dst_ip_addr_v6->valuestring, &rule_field_parser.dst_addr_v6); - if ((!ret) && (strcmp(cj_dst_ip_addr_v6->valuestring, "::") != 0)) - { - snprintf(str_error_reason, sz_error_reason - 1, - "Classifier rule add error, rule ID '%u', the IPv6 destination address '%s' is invalid.", - rule_id, cj_dst_ip_addr_v6->valuestring); - return RT_ERR; - } - - /* Retrieve the destination address mask */ - if (cj_dst_ip_mask != NULL) - rule_field_parser.dst_addr_mask_len = (uint32_t)cj_dst_ip_mask->valuedouble; - else - rule_field_parser.dst_addr_mask_len = 128; - } - - /* Retrieve the action */ -#if 0 - cJSON * cj_action = cJSON_GetObjectItem(cj_rule_item, "Action"); - if (cj_action == NULL) - { - snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error, rule ID '%u', no config 'action'.", - rule_id); - return RT_ERR; - } - - if (strcmp(cj_action->valuestring, "drop") == 0) - { - rule_field_parser.action.type = ACTION_DROP; - } - else if (strcmp(cj_action->valuestring, "nf_steering") == 0) - { - rule_field_parser.action.type = ACTION_NF_STEERING; - } - else - { - snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error, rule ID '%u', action '%s' invalid.", - rule_id, cj_action->valuestring); - return RT_ERR; - } -#else - rule_field_parser.action.type = ACTION_NF_STEERING; -#endif - if (rule_field_parser.action.type == ACTION_NF_STEERING) - { - /* Retrieve the SID */ - rule_field_parser.action.sid = (uint16_t)cj_sid->valuedouble; - - /* Retrieve the adapter type and ID */ - if (cj_vwire_id != NULL) - { - rule_field_parser.adapter.type = ADAPTER_TYPE_VWIRE; - rule_field_parser.adapter.id = (uint16_t)cj_vwire_id->valuedouble; - } - else if (cj_ef_id != NULL) - { - rule_field_parser.adapter.type = ADAPTER_TYPE_EF; - rule_field_parser.adapter.id = (uint16_t)cj_ef_id->valuedouble; - } - else if (cj_tera_id != NULL) - { - rule_field_parser.adapter.type = ADAPTER_TYPE_TERA; - rule_field_parser.adapter.id = (uint16_t)cj_tera_id->valuedouble; - } - else - { - rule_field_parser.adapter.type = ADAPTER_TYPE_ALL; - rule_field_parser.adapter.id = UINT16_MAX; - } - } - - /* Copy the rule field information to the output rule list */ - struct rule_field_parser * rule_field_item = &out_rule_list->rules[out_rule_list->nr_rules]; - memcpy(rule_field_item, &rule_field_parser, sizeof(struct rule_field_parser)); - - out_rule_list->nr_rules++; - out_rule_list->nr_remote_rules++; - if (out_rule_list->nr_rules >= MAX_RULES) - { - snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error, rule ID '%u', rules is full.", - rule_id); - return RT_ERR; - } - } - return RT_SUCCESS; -} - /* Dump all rules information. */ void classifier_rule_dump(struct rule_list_parsed * rule_list) { @@ -711,6 +391,4 @@ void classifier_rule_dump(struct rule_list_parsed * rule_list) /* Dump the total rule number */ MR_INFO("Pkt classifier total rules: %u", rule_list->nr_rules); - MR_INFO("Pkt classifier local rules: %u", rule_list->nr_local_rules); - MR_INFO("Pkt classifier remote rules: %u", rule_list->nr_remote_rules); } diff --git a/service/src/core.c b/service/src/core.c index 9cfaebf..9241b6a 100644 --- a/service/src/core.c +++ b/service/src/core.c @@ -9,10 +9,10 @@ #include <rte_service_component.h> #include <rte_version.h> #include <signal.h> -#include <sys/signalfd.h> #include <stdio.h> #include <stdlib.h> #include <sys/prctl.h> +#include <sys/signalfd.h> #include <unistd.h> #include <MESA_prof_load.h> @@ -188,6 +188,7 @@ int32_t sw_vlan_base_forward_service_entry(void * args); int32_t smartoffload_service_entry(void * args); int32_t node_manager_pkt_graph_service_entry(void * args); int olp_config_reload(struct sc_main * sc_main); +int classifier_rule_update(struct sc_main * sc); int sc_check_spinlock_loop(struct sc_main * sc_main) { @@ -889,7 +890,7 @@ void * config_reload_handler(void * arg) sleep(1); } - while(1) + while (1) { s = read(sfd, &fdsi, sizeof(fdsi)); if (s != sizeof(fdsi)) @@ -903,6 +904,7 @@ void * config_reload_handler(void * arg) } olp_config_reload(g_sc_main); + classifier_rule_update(g_sc_main); } close(sfd); diff --git a/service/src/node_classifier.c b/service/src/node_classifier.c index 4f37626..3c3fb86 100644 --- a/service/src/node_classifier.c +++ b/service/src/node_classifier.c @@ -35,29 +35,30 @@ struct node_classifier_main unsigned int nr_tera_adapters; unsigned int ignore_all_icmp_pkts; unsigned int ignore_all_icmp6_pkts; - pkt_classifier_engine_t * engine_instance; - struct classifier_stats stats_per_graph[RTE_MAX_LCORE]; + struct pkt_classifier_engine * pkt_classifier_engine; }; static struct node_classifier_main classifier_main = {0}; -struct node_classifier_main * node_classifier_main_get(void) +static struct classifier_stats stats_per_graph[RTE_MAX_LCORE] = {0}; + +static inline struct node_classifier_main * node_classifier_main_get(void) { return &classifier_main; } /* Each ruleset type should implement its own 'rules verify' function to validate its unique match fields. */ -int classifier_rules_verify(struct rule_list_parsed * rule_list, char * str_error_reason, unsigned int sz_error_reason) +static inline int classifier_rules_verify(const struct rule_list_parsed rule_list[]) { for (uint32_t index = 0; index < rule_list->nr_rules; index++) { /* Verify the adapter ID. */ - struct rule_field_parser * rule_field_parser = &rule_list->rules[index]; + const struct rule_field_parser * rule_field_parser = &rule_list->rules[index]; if (rule_field_parser->adapter.type == ADAPTER_TYPE_EF) { if (ef_adapter_id_check(rule_field_parser->adapter.id) == RT_ERR) { - snprintf(str_error_reason, sz_error_reason - 1, "The rule id '%u', config adapter id '%u' is invalid.", - rule_field_parser->rule_id, rule_field_parser->adapter.id); + MR_ERROR("The rule ID '%u' with configured ef adapter ID '%u' is invalid.", rule_field_parser->rule_id, + rule_field_parser->adapter.id); return RT_ERR; } } @@ -65,7 +66,7 @@ int classifier_rules_verify(struct rule_list_parsed * rule_list, char * str_erro { if (vwire_adapter_id_check(rule_field_parser->adapter.id) == RT_ERR) { - snprintf(str_error_reason, sz_error_reason - 1, "The rule id '%u', config adapter id '%u' is invalid.", + MR_ERROR("The rule ID '%u' with configured vwire adapter ID '%u' is invalid.", rule_field_parser->rule_id, rule_field_parser->adapter.id); return RT_ERR; } @@ -74,7 +75,7 @@ int classifier_rules_verify(struct rule_list_parsed * rule_list, char * str_erro { if (tera_adapter_id_check(rule_field_parser->adapter.id) == RT_ERR) { - snprintf(str_error_reason, sz_error_reason - 1, "The rule id '%u', config adapter id '%u' is invalid.", + MR_ERROR("The rule ID '%u' with configured tera adapter ID '%u' is invalid.", rule_field_parser->rule_id, rule_field_parser->adapter.id); return RT_ERR; } @@ -86,8 +87,8 @@ int classifier_rules_verify(struct rule_list_parsed * rule_list, char * str_erro /* Verify the sid. */ if (sid_check(rule_field_parser->action.sid) == RT_ERR) { - snprintf(str_error_reason, sz_error_reason - 1, "The rule id '%u', config action sid '%u' is invalid.", - rule_field_parser->rule_id, rule_field_parser->action.sid); + MR_ERROR("The rule ID '%u' with configured action SID '%u' is invalid.", rule_field_parser->rule_id, + rule_field_parser->action.sid); return RT_ERR; } } @@ -118,7 +119,8 @@ static inline uint16_t domain_field_generator_for_classifier(enum adapter_type t return domain_field; } -void rule_list_engine_generator(struct rule_list_parsed * rule_list_parsed, struct rule_list_engine * rule_list_engine) +static inline void rule_list_engine_generator(struct rule_list_parsed * rule_list_parsed, + struct rule_list_engine * rule_list_engine) { rule_list_engine->nr_rules = rule_list_parsed->nr_rules; for (uint32_t index = 0; index < rule_list_parsed->nr_rules; index++) @@ -163,36 +165,26 @@ void rule_list_engine_generator(struct rule_list_parsed * rule_list_parsed, stru } } -int classifier_rule_full_update(struct sc_main * sc, cJSON * c_rule, char * str_error_reason, - unsigned int sz_error_reason) +int classifier_rule_update(struct sc_main * sc) { /* Parse the local rules. */ struct node_classifier_main * classifier_main = node_classifier_main_get(); - pkt_classifier_engine_t * engine_instance = classifier_main->engine_instance; + struct pkt_classifier_engine * pkt_classifier_engine = classifier_main->pkt_classifier_engine; struct rule_list_parsed rule_list_parsed = {0}; - int ret = pkt_classifier_local_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(engine_instance), - &rule_list_parsed); - if (ret != RT_SUCCESS) - { - snprintf(str_error_reason, sz_error_reason - 1, "Pkt classifier rule parse failed for local."); - MR_ERROR("Pkt classifier rule parse failed for local."); - return RT_ERR; - } - /* Parse the remote rules. */ - ret = pkt_classifier_remote_rule_parser(c_rule, &rule_list_parsed, str_error_reason, sz_error_reason - 1); + int ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine), + &rule_list_parsed); if (ret != RT_SUCCESS) { - MR_ERROR("Pkt classifier rule parse failed for remote."); - MR_ERROR("%s", str_error_reason); + MR_ERROR("Parsing of packet classifier rule failed."); return RT_ERR; } /* Verify the classifier rule. */ - ret = classifier_rules_verify(&rule_list_parsed, str_error_reason, sz_error_reason); + ret = classifier_rules_verify(&rule_list_parsed); if (ret != RT_SUCCESS) { - MR_ERROR("Check classifier rules failed, reason: %s", str_error_reason); + MR_ERROR("Check classifier rules failed."); return RT_ERR; } @@ -201,57 +193,25 @@ int classifier_rule_full_update(struct sc_main * sc, cJSON * c_rule, char * str_ rule_list_engine_generator(&rule_list_parsed, &rule_list_engine); /* Construct the packet classifier engine. */ - ret = pkt_classifier_engine_build(engine_instance, &rule_list_engine, str_error_reason, sz_error_reason); + ret = pkt_classifier_engine_build(pkt_classifier_engine, &rule_list_engine); if (ret != RT_SUCCESS) { - MR_ERROR("Pkt classifier engine build failed, reason: %s", str_error_reason); + MR_ERROR("Pkt classifier engine build failed"); return RT_ERR; } /* Display information about the packet classifier rules. */ classifier_rule_dump(&rule_list_parsed); - pkt_classifier_engine_info_dump(engine_instance); + pkt_classifier_engine_info_dump(pkt_classifier_engine); return RT_SUCCESS; } -static int __classifier_rule_full_update_request_handler(cJSON * req, cJSON ** rsp, void * arg) -{ - struct sc_main * sc = (struct sc_main *)arg; - char str_error_reason[MR_STRING_MAX] = {}; - cJSON * response = cJSON_CreateObject(); - - int ret = classifier_rule_full_update(sc, req, str_error_reason, sizeof(str_error_reason)); - if (ret != RT_SUCCESS) - { - cJSON_AddNumberToObject(response, "Result", RT_ERR); - cJSON_AddStringToObject(response, "Reason", str_error_reason); - *rsp = response; - return 0; - } - else - { - cJSON_AddNumberToObject(response, "Result", RT_SUCCESS); - } - - *rsp = response; - return 0; -} - int classifier_init(struct sc_main * sc) { /* Initialize the main instance of the classifier. */ struct node_classifier_main * classifier_main = node_classifier_main_get(); memset(classifier_main, 0, sizeof(struct node_classifier_main)); - sc->node_classifier_main = classifier_main; - - /* Register the handler for full classifier rule updates. */ - if (rpc_server_recv_request_register(sc->rpc_srv_handler, PKT_CLASSIFIER_RULE_FULL_UPDATE, - __classifier_rule_full_update_request_handler, sc) != 0) - { - MR_ERROR("The '%s' Request Register Failed. ", PKT_CLASSIFIER_RULE_FULL_UPDATE); - return RT_ERR; - } /* Load to ignore icmp and icmpv6 options */ MESA_load_profile_uint_def(sc->local_cfgfile, "classifiers", "ignore_all_icmp_pkts", @@ -263,36 +223,41 @@ int classifier_init(struct sc_main * sc) classifier_main->nr_ef_adapters = nr_ef_adapters_get(); classifier_main->nr_vwire_adapters = nr_vwire_adapters_get(); classifier_main->nr_tera_adapters = nr_tera_adapters_get(); - uint16_t nr_domains = - classifier_main->nr_ef_adapters + classifier_main->nr_vwire_adapters + classifier_main->nr_tera_adapters; - pkt_classifier_engine_t * engine_instance = + + uint16_t nr_domains = classifier_main->nr_ef_adapters; + nr_domains += classifier_main->nr_vwire_adapters; + nr_domains += +classifier_main->nr_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); - if (engine_instance == NULL) + + if (pkt_classifier_engine == NULL) { MR_ERROR("Failed to create the packet classifier engine for the classifier node."); return RT_ERR; } else { - classifier_main->engine_instance = engine_instance; + classifier_main->pkt_classifier_engine = pkt_classifier_engine; } - /* Parse the local rules. */ + /* Parse the rules. */ struct rule_list_parsed rule_list_parsed = {0}; - int ret = pkt_classifier_local_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(engine_instance), - &rule_list_parsed); + int ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine), + &rule_list_parsed); + if (ret != RT_SUCCESS) { - MR_ERROR("Pkt classifier rule parse failed for local."); + MR_ERROR("Parsing of packet classifier rule failed."); return RT_ERR; } /* Verify the classifier rule. */ - char str_error_reason[MR_STRING_MAX]; - ret = classifier_rules_verify(&rule_list_parsed, str_error_reason, sizeof(str_error_reason)); + ret = classifier_rules_verify(&rule_list_parsed); if (ret != RT_SUCCESS) { - MR_ERROR("Check classifier rules failed, reason: %s", str_error_reason); + MR_ERROR("Check classifier rules failed."); return RT_ERR; } @@ -301,16 +266,16 @@ int classifier_init(struct sc_main * sc) rule_list_engine_generator(&rule_list_parsed, &rule_list_engine); /* Construct the packet classifier engine. */ - ret = pkt_classifier_engine_build(engine_instance, &rule_list_engine, str_error_reason, sizeof(str_error_reason)); + ret = pkt_classifier_engine_build(pkt_classifier_engine, &rule_list_engine); if (ret != RT_SUCCESS) { - MR_ERROR("Pkt classifier engine build failed, reason: %s", str_error_reason); + MR_ERROR("Pkt classifier engine build failed"); return RT_ERR; } /* Display information about the packet classifier rules. */ classifier_rule_dump(&rule_list_parsed); - pkt_classifier_engine_info_dump(engine_instance); + pkt_classifier_engine_info_dump(pkt_classifier_engine); return RT_SUCCESS; } @@ -319,7 +284,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g void ** objs, uint16_t cnt) { struct node_classifier_main * classifier_main = node_classifier_main_get(); - pkt_classifier_engine_t * engine_instance = classifier_main->engine_instance; + struct pkt_classifier_engine * pkt_classifier_engine = classifier_main->pkt_classifier_engine; unsigned int ignore_all_icmp_pkts = classifier_main->ignore_all_icmp_pkts; unsigned int ignore_all_icmp6_pkts = classifier_main->ignore_all_icmp6_pkts; @@ -348,8 +313,8 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g } struct match_result_engine result[FWDSTEP]; - pkt_classifier_engine_multi_match(engine_instance, lcore_id, pending_mbufs, FWDSTEP, domain_field_for_pkts, - result); + pkt_classifier_engine_multi_match(pkt_classifier_engine, lcore_id, pending_mbufs, FWDSTEP, + domain_field_for_pkts, result); /* All the ICMP packet, go direct to egress, not for nfs */ if (ignore_all_icmp_pkts) @@ -426,7 +391,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g 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); - pkt_classifier_engine_multi_match(engine_instance, lcore_id, &mbuf0, 1, &pattern_group_id, &result); + 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 */ if (ignore_all_icmp_pkts) @@ -486,7 +451,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g rte_node_next_stream_move(graph, node, CLASSIFIER_NEXT_FORWARDER); /* Update the graph statistics */ - struct classifier_stats * graph_stats = &classifier_main->stats_per_graph[graph->id]; + struct classifier_stats * graph_stats = &stats_per_graph[graph->id]; graph_stats->deal_pkts += cnt; graph_stats->hits += stats.hits; graph_stats->miss += stats.miss; @@ -511,11 +476,10 @@ cJSON * classifier_node_monit_loop(struct sc_main * sc) { cJSON * json_root = cJSON_CreateObject(); unsigned int nr_graph_total = sc->nr_io_thread; - struct node_classifier_main * classifier_main = sc->node_classifier_main; for (uint32_t graph_id = 0; graph_id < nr_graph_total; graph_id++) { - struct classifier_stats * graph_stats = &classifier_main->stats_per_graph[graph_id]; + struct classifier_stats * graph_stats = &stats_per_graph[graph_id]; if (graph_stats->deal_pkts == 0) continue; |