diff options
Diffstat (limited to 'service')
| -rw-r--r-- | service/include/sc_classifier_rule_parser.h | 21 | ||||
| -rw-r--r-- | service/src/classifier_rule_parser.c | 377 | ||||
| -rw-r--r-- | service/src/node_classifier.c | 44 |
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; |