From 6bafc7398b593ade4d077360af43ae083748aa41 Mon Sep 17 00:00:00 2001 From: Arsalan-Zanganeh Date: Tue, 7 Oct 2025 19:23:23 +0000 Subject: [PATCH 1/2] GTP1 implementation --- lib/gro/gro_gtp_tcp4.c | 501 +++++++++++++++++++++++++++++++++++++ lib/gro/gro_gtp_tcp4.h | 157 ++++++++++++ lib/gro/gro_gtp_udp4.c | 547 +++++++++++++++++++++++++++++++++++++++++ lib/gro/gro_gtp_udp4.h | 154 ++++++++++++ lib/gro/meson.build | 2 + lib/gro/rte_gro.c | 155 ++++++++++-- lib/gro/rte_gro.h | 6 + 7 files changed, 1507 insertions(+), 15 deletions(-) create mode 100644 lib/gro/gro_gtp_tcp4.c create mode 100644 lib/gro/gro_gtp_tcp4.h create mode 100644 lib/gro/gro_gtp_udp4.c create mode 100644 lib/gro/gro_gtp_udp4.h diff --git a/lib/gro/gro_gtp_tcp4.c b/lib/gro/gro_gtp_tcp4.c new file mode 100644 index 00000000000..499bd006994 --- /dev/null +++ b/lib/gro/gro_gtp_tcp4.c @@ -0,0 +1,501 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2018 Intel Corporation +*/ + +#include +#include +#include +#include + +#include "gro_gtp_tcp4.h" + +void * +gro_gtp_tcp4_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_gtp_tcp4_tbl *tbl; + size_t size; + uint32_t entries_num, i; + + entries_num = max_flow_num * max_item_per_flow; + entries_num = RTE_MIN(entries_num, GRO_GTP_TCP4_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_gtp_tcp4_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_gtp_tcp4_item) * entries_num; + tbl->items = rte_zmalloc_socket(__func__, + size, + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl->items == NULL) { + rte_free(tbl); + return NULL; + } + tbl->max_item_num = entries_num; + + size = sizeof(struct gro_gtp_tcp4_flow) * entries_num; + tbl->flows = rte_zmalloc_socket(__func__, + size, + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl->flows == NULL) { + rte_free(tbl->items); + rte_free(tbl); + return NULL; + } + + for (i = 0; i < entries_num; i++) + tbl->flows[i].start_index = INVALID_ARRAY_INDEX; + tbl->max_flow_num = entries_num; + + return tbl; +} + +void +gro_gtp_tcp4_tbl_destroy(void *tbl) +{ + struct gro_gtp_tcp4_tbl *gtp_tbl = tbl; + + if (gtp_tbl) { + rte_free(gtp_tbl->items); + rte_free(gtp_tbl->flows); + } + rte_free(gtp_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_gtp_tcp4_tbl *tbl) +{ + uint32_t max_item_num = tbl->max_item_num, i; + + for (i = 0; i < max_item_num; i++) + if (tbl->items[i].inner_item.firstseg == NULL) + return i; + return INVALID_ARRAY_INDEX; +} + +static inline uint32_t +find_an_empty_flow(struct gro_gtp_tcp4_tbl *tbl) +{ + uint32_t max_flow_num = tbl->max_flow_num, i; + + for (i = 0; i < max_flow_num; i++) + if (tbl->flows[i].start_index == INVALID_ARRAY_INDEX) + return i; + return INVALID_ARRAY_INDEX; +} + +static inline uint32_t +insert_new_item(struct gro_gtp_tcp4_tbl *tbl, + struct rte_mbuf *pkt, + uint64_t start_time, + uint32_t prev_idx, + uint32_t sent_seq, + uint16_t outer_ip_id, + uint16_t ip_id, + uint8_t outer_is_atomic, + uint8_t is_atomic) +{ + uint32_t item_idx; + + item_idx = find_an_empty_item(tbl); + if (unlikely(item_idx == INVALID_ARRAY_INDEX)) + return INVALID_ARRAY_INDEX; + + tbl->items[item_idx].inner_item.firstseg = pkt; + tbl->items[item_idx].inner_item.lastseg = rte_pktmbuf_lastseg(pkt); + tbl->items[item_idx].inner_item.start_time = start_time; + tbl->items[item_idx].inner_item.next_pkt_idx = INVALID_ARRAY_INDEX; + tbl->items[item_idx].inner_item.sent_seq = sent_seq; + tbl->items[item_idx].inner_item.l3.ip_id = ip_id; + tbl->items[item_idx].inner_item.nb_merged = 1; + tbl->items[item_idx].inner_item.is_atomic = is_atomic; + tbl->items[item_idx].outer_ip_id = outer_ip_id; + tbl->items[item_idx].outer_is_atomic = outer_is_atomic; + tbl->item_num++; + + /* If the previous packet exists, chain the new one with it. */ + if (prev_idx != INVALID_ARRAY_INDEX) { + tbl->items[item_idx].inner_item.next_pkt_idx = + tbl->items[prev_idx].inner_item.next_pkt_idx; + tbl->items[prev_idx].inner_item.next_pkt_idx = item_idx; + } + + return item_idx; +} + +static inline uint32_t +delete_item(struct gro_gtp_tcp4_tbl *tbl, + uint32_t item_idx, + uint32_t prev_item_idx) +{ + uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx; + + /* NULL indicates an empty item. */ + tbl->items[item_idx].inner_item.firstseg = NULL; + tbl->item_num--; + if (prev_item_idx != INVALID_ARRAY_INDEX) + tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx; + + return next_idx; +} + +static inline uint32_t +insert_new_flow(struct gro_gtp_tcp4_tbl *tbl, + struct gtp_tcp4_flow_key *src, + uint32_t item_idx) +{ + struct gtp_tcp4_flow_key *dst; + uint32_t flow_idx; + + flow_idx = find_an_empty_flow(tbl); + if (unlikely(flow_idx == INVALID_ARRAY_INDEX)) + return INVALID_ARRAY_INDEX; + + dst = &(tbl->flows[flow_idx].key); + + ASSIGN_COMMON_TCP_KEY((&(src->inner_key.cmn_key)), (&(dst->inner_key.cmn_key))); + dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr; + dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr; + + // dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags; + // dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni; + dst->gtp_hdr.teid = src->gtp_hdr.teid; + rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr)); + rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr)); + dst->outer_ip_src_addr = src->outer_ip_src_addr; + dst->outer_ip_dst_addr = src->outer_ip_dst_addr; + dst->outer_src_port = src->outer_src_port; + dst->outer_dst_port = src->outer_dst_port; + + tbl->flows[flow_idx].start_index = item_idx; + tbl->flow_num++; + + return flow_idx; +} + +static inline int +is_same_gtp_tcp4_flow(struct gtp_tcp4_flow_key k1, + struct gtp_tcp4_flow_key k2) +{ + return (rte_is_same_ether_addr(&k1.outer_eth_saddr, + &k2.outer_eth_saddr) && + rte_is_same_ether_addr(&k1.outer_eth_daddr, + &k2.outer_eth_daddr) && + (k1.outer_ip_src_addr == k2.outer_ip_src_addr) && + (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) && + (k1.outer_src_port == k2.outer_src_port) && + (k1.outer_dst_port == k2.outer_dst_port) && + // (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) && + // (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) && + (k1.gtp_hdr.teid == k2.gtp_hdr.teid) && + is_same_tcp4_flow(k1.inner_key, k2.inner_key)); +} + +static inline int +check_gtp_seq_option(struct gro_gtp_tcp4_item *item, + struct rte_tcp_hdr *tcp_hdr, + uint32_t sent_seq, + uint16_t outer_ip_id, + uint16_t ip_id, + uint16_t tcp_hl, + uint16_t tcp_dl, + uint8_t outer_is_atomic, + uint8_t is_atomic) +{ + struct rte_mbuf *pkt = item->inner_item.firstseg; + int cmp; + uint16_t l2_offset; + + /* Don't merge packets whose outer DF bits are different. */ + if (unlikely(item->outer_is_atomic ^ outer_is_atomic)) + return 0; + + l2_offset = pkt->outer_l2_len + pkt->outer_l3_len; + cmp = check_seq_option(&item->inner_item, tcp_hdr, sent_seq, ip_id, + tcp_hl, tcp_dl, l2_offset, is_atomic); + if ((cmp > 0) && (outer_is_atomic || + (outer_ip_id == item->outer_ip_id + 1))) + /* Append the new packet. */ + return 1; + else if ((cmp < 0) && (outer_is_atomic || + (outer_ip_id + item->inner_item.nb_merged == + item->outer_ip_id))) + /* Prepend the new packet. */ + return -1; + + return 0; +} + +static inline int +merge_two_gtp_tcp4_packets(struct gro_gtp_tcp4_item *item, + struct rte_mbuf *pkt, + int cmp, + uint32_t sent_seq, + uint8_t tcp_flags, + uint16_t outer_ip_id, + uint16_t ip_id) +{ + if (merge_two_tcp_packets(&item->inner_item, pkt, cmp, sent_seq, tcp_flags, + ip_id, pkt->outer_l2_len + + pkt->outer_l3_len)) { + /* Update the outer IPv4 ID to the large value. */ + item->outer_ip_id = cmp > 0 ? outer_ip_id : item->outer_ip_id; + return 1; + } + + return 0; +} + +static inline void +update_gtp_header(struct gro_gtp_tcp4_item *item) +{ + struct rte_ipv4_hdr *ipv4_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_mbuf *pkt = item->inner_item.firstseg; + uint16_t len; + + /* Update the outer IPv4 header. */ + len = pkt->pkt_len - pkt->outer_l2_len; + ipv4_hdr = rte_pktmbuf_mtod_offset(pkt, struct rte_ipv4_hdr *, + pkt->outer_l2_len); + ipv4_hdr->total_length = rte_cpu_to_be_16(len); + + /* Update the outer UDP header. */ + len -= pkt->outer_l3_len; + udp_hdr = (struct rte_udp_hdr *)((char *)ipv4_hdr + pkt->outer_l3_len); + udp_hdr->dgram_len = rte_cpu_to_be_16(len); + + /* Update the inner IPv4 header. */ + len -= pkt->l2_len; + ipv4_hdr = (struct rte_ipv4_hdr *)((char *)udp_hdr + pkt->l2_len); + ipv4_hdr->total_length = rte_cpu_to_be_16(len); +} + +int32_t +gro_gtp_tcp4_reassemble(struct rte_mbuf *pkt, + struct gro_gtp_tcp4_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ipv4_hdr *outer_ipv4_hdr, *ipv4_hdr; + struct rte_tcp_hdr *tcp_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_gtp_hdr *gtp_hdr; + uint32_t sent_seq; + int32_t tcp_dl; + uint16_t frag_off, outer_ip_id, ip_id; + uint8_t outer_is_atomic, is_atomic; + + struct gtp_tcp4_flow_key key; + uint32_t cur_idx, prev_idx, item_idx; + uint32_t i, max_flow_num, remaining_flow_num; + int cmp; + uint16_t hdr_len; + uint8_t find; + + /* + * Don't process the packet whose TCP header length is greater + * than 60 bytes or less than 20 bytes. + */ + if (unlikely(INVALID_TCP_HDRLEN(pkt->l4_len))) + return -1; + + outer_eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *); + outer_ipv4_hdr = (struct rte_ipv4_hdr *)((char *)outer_eth_hdr + + pkt->outer_l2_len); + udp_hdr = (struct rte_udp_hdr *)((char *)outer_ipv4_hdr + + pkt->outer_l3_len); + gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr + + sizeof(struct rte_udp_hdr)); + eth_hdr = (struct rte_ether_hdr *)((char *)gtp_hdr + + sizeof(struct rte_gtp_hdr)); + ipv4_hdr = (struct rte_ipv4_hdr *)((char *)udp_hdr + pkt->l2_len); + tcp_hdr = (struct rte_tcp_hdr *)((char *)ipv4_hdr + pkt->l3_len); + + /* + * Don't process the packet which has FIN, SYN, RST, PSH, URG, + * ECE or CWR set. + */ + if (tcp_hdr->tcp_flags != RTE_TCP_ACK_FLAG) + return -1; + + hdr_len = pkt->outer_l2_len + pkt->outer_l3_len + pkt->l2_len + + pkt->l3_len + pkt->l4_len; + /* + * Don't process the packet whose payload length is less than or + * equal to 0. + */ + tcp_dl = pkt->pkt_len - hdr_len; + if (tcp_dl <= 0) + return -1; + + /* + * Save IPv4 ID for the packet whose DF bit is 0. For the packet + * whose DF bit is 1, IPv4 ID is ignored. + */ + frag_off = rte_be_to_cpu_16(outer_ipv4_hdr->fragment_offset); + outer_is_atomic = + (frag_off & RTE_IPV4_HDR_DF_FLAG) == RTE_IPV4_HDR_DF_FLAG; + outer_ip_id = outer_is_atomic ? 0 : + rte_be_to_cpu_16(outer_ipv4_hdr->packet_id); + frag_off = rte_be_to_cpu_16(ipv4_hdr->fragment_offset); + is_atomic = (frag_off & RTE_IPV4_HDR_DF_FLAG) == RTE_IPV4_HDR_DF_FLAG; + ip_id = is_atomic ? 0 : rte_be_to_cpu_16(ipv4_hdr->packet_id); + + sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq); + + rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.cmn_key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.inner_key.cmn_key.eth_daddr)); + key.inner_key.ip_src_addr = ipv4_hdr->src_addr; + key.inner_key.ip_dst_addr = ipv4_hdr->dst_addr; + key.inner_key.cmn_key.recv_ack = tcp_hdr->recv_ack; + key.inner_key.cmn_key.src_port = tcp_hdr->src_port; + key.inner_key.cmn_key.dst_port = tcp_hdr->dst_port; + + // key.vxlan_hdr.vx_flags = vxlan_hdr->vx_flags; + // key.vxlan_hdr.vx_vni = vxlan_hdr->vx_vni; + key.gtp_hdr.teid = gtp_hdr->teid; + rte_ether_addr_copy(&(outer_eth_hdr->src_addr), &(key.outer_eth_saddr)); + rte_ether_addr_copy(&(outer_eth_hdr->dst_addr), &(key.outer_eth_daddr)); + key.outer_ip_src_addr = outer_ipv4_hdr->src_addr; + key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr; + key.outer_src_port = udp_hdr->src_port; + key.outer_dst_port = udp_hdr->dst_port; + + /* Search for a matched flow. */ + max_flow_num = tbl->max_flow_num; + remaining_flow_num = tbl->flow_num; + find = 0; + for (i = 0; i < max_flow_num && remaining_flow_num; i++) { + if (tbl->flows[i].start_index != INVALID_ARRAY_INDEX) { + if (is_same_gtp_tcp4_flow(tbl->flows[i].key, key)) { + find = 1; + break; + } + remaining_flow_num--; + } + } + + /* + * Can't find a matched flow. Insert a new flow and store the + * packet into the flow. + */ + if (find == 0) { + item_idx = insert_new_item(tbl, pkt, start_time, + INVALID_ARRAY_INDEX, sent_seq, outer_ip_id, + ip_id, outer_is_atomic, is_atomic); + if (item_idx == INVALID_ARRAY_INDEX) + return -1; + if (insert_new_flow(tbl, &key, item_idx) == + INVALID_ARRAY_INDEX) { + /* + * Fail to insert a new flow, so + * delete the inserted packet. + */ + delete_item(tbl, item_idx, INVALID_ARRAY_INDEX); + return -1; + } + return 0; + } + + /* Check all packets in the flow and try to find a neighbor. */ + cur_idx = tbl->flows[i].start_index; + prev_idx = cur_idx; + do { + cmp = check_gtp_seq_option(&(tbl->items[cur_idx]), tcp_hdr, + sent_seq, outer_ip_id, ip_id, pkt->l4_len, + tcp_dl, outer_is_atomic, is_atomic); + if (cmp) { + if (merge_two_gtp_tcp4_packets(&(tbl->items[cur_idx]), + pkt, cmp, sent_seq, tcp_hdr->tcp_flags, + outer_ip_id, ip_id)) + return 1; + /* + * Can't merge two packets, as the packet + * length will be greater than the max value. + * Insert the packet into the flow. + */ + if (insert_new_item(tbl, pkt, start_time, prev_idx, + sent_seq, outer_ip_id, + ip_id, outer_is_atomic, + is_atomic) == + INVALID_ARRAY_INDEX) + return -1; + return 0; + } + prev_idx = cur_idx; + cur_idx = tbl->items[cur_idx].inner_item.next_pkt_idx; + } while (cur_idx != INVALID_ARRAY_INDEX); + + /* Can't find neighbor. Insert the packet into the flow. */ + if (insert_new_item(tbl, pkt, start_time, prev_idx, sent_seq, + outer_ip_id, ip_id, outer_is_atomic, + is_atomic) == INVALID_ARRAY_INDEX) + return -1; + + return 0; +} + +uint16_t +gro_gtp_tcp4_tbl_timeout_flush(struct gro_gtp_tcp4_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out) +{ + uint16_t k = 0; + uint32_t i, j; + uint32_t max_flow_num = tbl->max_flow_num; + + for (i = 0; i < max_flow_num; i++) { + if (unlikely(tbl->flow_num == 0)) + return k; + + j = tbl->flows[i].start_index; + while (j != INVALID_ARRAY_INDEX) { + if (tbl->items[j].inner_item.start_time <= + flush_timestamp) { + out[k++] = tbl->items[j].inner_item.firstseg; + if (tbl->items[j].inner_item.nb_merged > 1) + update_gtp_header(&(tbl->items[j])); + /* + * Delete the item and get the next packet + * index. + */ + j = delete_item(tbl, j, INVALID_ARRAY_INDEX); + tbl->flows[i].start_index = j; + if (j == INVALID_ARRAY_INDEX) + tbl->flow_num--; + + if (unlikely(k == nb_out)) + return k; + } else + /* + * The left packets in the flow won't be + * timeout. Go to check other flows. + */ + break; + } + } + return k; +} + +uint32_t +gro_gtp_tcp4_tbl_pkt_count(void *tbl) +{ + struct gro_gtp_tcp4_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/gro/gro_gtp_tcp4.h b/lib/gro/gro_gtp_tcp4.h new file mode 100644 index 00000000000..5e4e943adaa --- /dev/null +++ b/lib/gro/gro_gtp_tcp4.h @@ -0,0 +1,157 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Intel Corporation + */ + + #ifndef _GRO_GTP_TCP4_H_ + #define _GRO_GTP_TCP4_H_ + + #include "gro_tcp4.h" + + #define GRO_GTP_TCP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + + /* Header fields representing a GTP flow */ + struct gtp_tcp4_flow_key { + struct tcp4_flow_key inner_key; + struct rte_gtp_hdr gtp_hdr; + + struct rte_ether_addr outer_eth_saddr; + struct rte_ether_addr outer_eth_daddr; + + uint32_t outer_ip_src_addr; + uint32_t outer_ip_dst_addr; + + /* Outer UDP ports */ + uint16_t outer_src_port; + uint16_t outer_dst_port; + + }; + + struct gro_gtp_tcp4_flow { + struct gtp_tcp4_flow_key key; + /* + * The index of the first packet in the flow. INVALID_ARRAY_INDEX + * indicates an empty flow. + */ + uint32_t start_index; + }; + + struct gro_gtp_tcp4_item { + struct gro_tcp_item inner_item; + /* IPv4 ID in the outer IPv4 header */ + uint16_t outer_ip_id; + /* Indicate if outer IPv4 ID can be ignored */ + uint8_t outer_is_atomic; + }; + + /* + * VxLAN (with an outer IPv4 header and an inner TCP/IPv4 packet) + * reassembly table structure + */ + struct gro_gtp_tcp4_tbl { + /* item array */ + struct gro_gtp_tcp4_item *items; + /* flow array */ + struct gro_gtp_tcp4_flow *flows; + /* current item number */ + uint32_t item_num; + /* current flow number */ + uint32_t flow_num; + /* the maximum item number */ + uint32_t max_item_num; + /* the maximum flow number */ + uint32_t max_flow_num; + }; + + /** + * This function creates a VxLAN reassembly table for VxLAN packets + * which have an outer IPv4 header and an inner TCP/IPv4 packet. + * + * @param socket_id + * Socket index for allocating the table + * @param max_flow_num + * The maximum number of flows in the table + * @param max_item_per_flow + * The maximum number of packets per flow + * + * @return + * - Return the table pointer on success. + * - Return NULL on failure. + */ + void *gro_gtp_tcp4_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + + /** + * This function destroys a VxLAN reassembly table. + * + * @param tbl + * Pointer pointing to the VxLAN reassembly table + */ + void gro_gtp_tcp4_tbl_destroy(void *tbl); + + /** + * This function merges a VxLAN packet which has an outer IPv4 header and + * an inner TCP/IPv4 packet. It doesn't process the packet, whose TCP + * header has SYN, FIN, RST, PSH, CWR, ECE or URG bit set, or which + * doesn't have payload. + * + * This function doesn't check if the packet has correct checksums and + * doesn't re-calculate checksums for the merged packet. Additionally, + * it assumes the packets are complete (i.e., MF==0 && frag_off==0), when + * IP fragmentation is possible (i.e., DF==0). It returns the packet, if + * the packet has invalid parameters (e.g. SYN bit is set) or there is no + * available space in the table. + * + * @param pkt + * Packet to reassemble + * @param tbl + * Pointer pointing to the VxLAN reassembly table + * @start_time + * The time when the packet is inserted into the table + * + * @return + * - Return a positive value if the packet is merged. + * - Return zero if the packet isn't merged but stored in the table. + * - Return a negative value for invalid parameters or no available + * space in the table. + */ + int32_t gro_gtp_tcp4_reassemble(struct rte_mbuf *pkt, + struct gro_gtp_tcp4_tbl *tbl, + uint64_t start_time); + + /** + * This function flushes timeout packets in the VxLAN reassembly table, + * and without updating checksums. + * + * @param tbl + * Pointer pointing to a VxLAN GRO table + * @param flush_timestamp + * This function flushes packets which are inserted into the table + * before or at the flush_timestamp. + * @param out + * Pointer array used to keep flushed packets + * @param nb_out + * The element number in 'out'. It also determines the maximum number of + * packets that can be flushed finally. + * + * @return + * The number of flushed packets + */ + uint16_t gro_gtp_tcp4_tbl_timeout_flush(struct gro_gtp_tcp4_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out); + + /** + * This function returns the number of the packets in a VxLAN + * reassembly table. + * + * @param tbl + * Pointer pointing to the VxLAN reassembly table + * + * @return + * The number of packets in the table + */ + uint32_t gro_gtp_tcp4_tbl_pkt_count(void *tbl); + #endif + \ No newline at end of file diff --git a/lib/gro/gro_gtp_udp4.c b/lib/gro/gro_gtp_udp4.c new file mode 100644 index 00000000000..8e1097af8c2 --- /dev/null +++ b/lib/gro/gro_gtp_udp4.c @@ -0,0 +1,547 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2020 Inspur Corporation +*/ + +#include +#include +#include +#include + +#include "gro_gtp_udp4.h" + +void * +gro_gtp_udp4_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_gtp_udp4_tbl *tbl; + size_t size; + uint32_t entries_num, i; + + entries_num = max_flow_num * max_item_per_flow; + entries_num = RTE_MIN(entries_num, GRO_GTP_UDP4_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_gtp_udp4_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_gtp_udp4_item) * entries_num; + tbl->items = rte_zmalloc_socket(__func__, + size, + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl->items == NULL) { + rte_free(tbl); + return NULL; + } + tbl->max_item_num = entries_num; + + size = sizeof(struct gro_gtp_udp4_flow) * entries_num; + tbl->flows = rte_zmalloc_socket(__func__, + size, + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl->flows == NULL) { + rte_free(tbl->items); + rte_free(tbl); + return NULL; + } + + for (i = 0; i < entries_num; i++) + tbl->flows[i].start_index = INVALID_ARRAY_INDEX; + tbl->max_flow_num = entries_num; + + return tbl; +} + +void +gro_gtp_udp4_tbl_destroy(void *tbl) +{ + struct gro_gtp_udp4_tbl *gtp_tbl = tbl; + + if (gtp_tbl) { + rte_free(gtp_tbl->items); + rte_free(gtp_tbl->flows); + } + rte_free(gtp_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_gtp_udp4_tbl *tbl) +{ + uint32_t max_item_num = tbl->max_item_num, i; + + for (i = 0; i < max_item_num; i++) + if (tbl->items[i].inner_item.firstseg == NULL) + return i; + return INVALID_ARRAY_INDEX; +} + +static inline uint32_t +find_an_empty_flow(struct gro_gtp_udp4_tbl *tbl) +{ + uint32_t max_flow_num = tbl->max_flow_num, i; + + for (i = 0; i < max_flow_num; i++) + if (tbl->flows[i].start_index == INVALID_ARRAY_INDEX) + return i; + return INVALID_ARRAY_INDEX; +} + +static inline uint32_t +insert_new_item(struct gro_gtp_udp4_tbl *tbl, + struct rte_mbuf *pkt, + uint64_t start_time, + uint32_t prev_idx, + uint16_t frag_offset, + uint8_t is_last_frag) +{ + uint32_t item_idx; + + item_idx = find_an_empty_item(tbl); + if (unlikely(item_idx == INVALID_ARRAY_INDEX)) + return INVALID_ARRAY_INDEX; + + tbl->items[item_idx].inner_item.firstseg = pkt; + tbl->items[item_idx].inner_item.lastseg = rte_pktmbuf_lastseg(pkt); + tbl->items[item_idx].inner_item.start_time = start_time; + tbl->items[item_idx].inner_item.next_pkt_idx = INVALID_ARRAY_INDEX; + tbl->items[item_idx].inner_item.frag_offset = frag_offset; + tbl->items[item_idx].inner_item.is_last_frag = is_last_frag; + tbl->items[item_idx].inner_item.nb_merged = 1; + tbl->item_num++; + + /* If the previous packet exists, chain the new one with it. */ + if (prev_idx != INVALID_ARRAY_INDEX) { + tbl->items[item_idx].inner_item.next_pkt_idx = + tbl->items[prev_idx].inner_item.next_pkt_idx; + tbl->items[prev_idx].inner_item.next_pkt_idx = item_idx; + } + + return item_idx; +} + +static inline uint32_t +delete_item(struct gro_gtp_udp4_tbl *tbl, + uint32_t item_idx, + uint32_t prev_item_idx) +{ + uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx; + + /* NULL indicates an empty item. */ + tbl->items[item_idx].inner_item.firstseg = NULL; + tbl->item_num--; + if (prev_item_idx != INVALID_ARRAY_INDEX) + tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx; + + return next_idx; +} + +static inline uint32_t +insert_new_flow(struct gro_gtp_udp4_tbl *tbl, + struct gtp_udp4_flow_key *src, + uint32_t item_idx) +{ + struct gtp_udp4_flow_key *dst; + uint32_t flow_idx; + + flow_idx = find_an_empty_flow(tbl); + if (unlikely(flow_idx == INVALID_ARRAY_INDEX)) + return INVALID_ARRAY_INDEX; + + dst = &(tbl->flows[flow_idx].key); + + rte_ether_addr_copy(&(src->inner_key.eth_saddr), + &(dst->inner_key.eth_saddr)); + rte_ether_addr_copy(&(src->inner_key.eth_daddr), + &(dst->inner_key.eth_daddr)); + dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr; + dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr; + dst->inner_key.ip_id = src->inner_key.ip_id; + + // dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags; + // dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni; + dst->gtp_hdr.teid = src->gtp_hdr.teid; + rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr)); + rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr)); + dst->outer_ip_src_addr = src->outer_ip_src_addr; + dst->outer_ip_dst_addr = src->outer_ip_dst_addr; + dst->outer_dst_port = src->outer_dst_port; + + tbl->flows[flow_idx].start_index = item_idx; + tbl->flow_num++; + + return flow_idx; +} + +static inline int +is_same_gtp_udp4_flow(struct gtp_udp4_flow_key k1, + struct gtp_udp4_flow_key k2) +{ + /* For GTP packet, outer udp src port is calculated from + * inner packet RSS hash, udp src port of the first UDP + * fragment is different from one of other UDP fragments + * even if they are same flow, so we have to skip outer udp + * src port comparison here. + */ + return (rte_is_same_ether_addr(&k1.outer_eth_saddr, + &k2.outer_eth_saddr) && + rte_is_same_ether_addr(&k1.outer_eth_daddr, + &k2.outer_eth_daddr) && + (k1.outer_ip_src_addr == k2.outer_ip_src_addr) && + (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) && + (k1.outer_dst_port == k2.outer_dst_port) && + // (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) && + // (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) && + (k1.gtp_hdr.teid == k2.gtp_hdr.teid) && + is_same_udp4_flow(k1.inner_key, k2.inner_key)); +} + +static inline int +udp4_check_gtp_neighbor(struct gro_gtp_udp4_item *item, + uint16_t frag_offset, + uint16_t ip_dl) +{ + struct rte_mbuf *pkt = item->inner_item.firstseg; + int cmp; + uint16_t l2_offset; + int ret = 0; + + /* Note: if outer DF bit is set, i.e outer_is_atomic is 0, + * we needn't compare outer_ip_id because they are same, + * for the case outer_is_atomic is 1, we also have no way + * to compare outer_ip_id because the difference between + * outer_ip_ids of two received packets isn't always +/-1. + * So skip outer_ip_id comparison here. + */ + + l2_offset = pkt->outer_l2_len + pkt->outer_l3_len; + cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl, + l2_offset); + if (cmp > 0) + /* Append the new packet. */ + ret = 1; + else if (cmp < 0) + /* Prepend the new packet. */ + ret = -1; + + return ret; +} + +static inline int +merge_two_gtp_udp4_packets(struct gro_gtp_udp4_item *item, + struct rte_mbuf *pkt, + int cmp, + uint16_t frag_offset, + uint8_t is_last_frag) +{ + if (merge_two_udp4_packets(&item->inner_item, pkt, cmp, frag_offset, + is_last_frag, + pkt->outer_l2_len + pkt->outer_l3_len)) { + return 1; + } + + return 0; +} + +static inline void +update_gtp_header(struct gro_gtp_udp4_item *item) +{ + struct rte_ipv4_hdr *ipv4_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_mbuf *pkt = item->inner_item.firstseg; + uint16_t len; + uint16_t frag_offset; + + /* Update the outer IPv4 header. */ + len = pkt->pkt_len - pkt->outer_l2_len; + ipv4_hdr = rte_pktmbuf_mtod_offset(pkt, struct rte_ipv4_hdr *, + pkt->outer_l2_len); + ipv4_hdr->total_length = rte_cpu_to_be_16(len); + + /* Update the outer UDP header. */ + len -= pkt->outer_l3_len; + udp_hdr = (struct rte_udp_hdr *)((char *)ipv4_hdr + pkt->outer_l3_len); + udp_hdr->dgram_len = rte_cpu_to_be_16(len); + + /* Update the inner IPv4 header. */ + len -= pkt->l2_len; + ipv4_hdr = (struct rte_ipv4_hdr *)((char *)udp_hdr + pkt->l2_len); + ipv4_hdr->total_length = rte_cpu_to_be_16(len); + + /* Clear MF bit if it is last fragment */ + if (item->inner_item.is_last_frag) { + frag_offset = rte_be_to_cpu_16(ipv4_hdr->fragment_offset); + ipv4_hdr->fragment_offset = + rte_cpu_to_be_16(frag_offset & ~RTE_IPV4_HDR_MF_FLAG); + } +} + +int32_t +gro_gtp_udp4_reassemble(struct rte_mbuf *pkt, + struct gro_gtp_udp4_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ipv4_hdr *outer_ipv4_hdr, *ipv4_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_gtp_hdr *gtp_hdr; + uint16_t frag_offset; + uint8_t is_last_frag; + int16_t ip_dl; + uint16_t ip_id; + + struct gtp_udp4_flow_key key; + uint32_t cur_idx, prev_idx, item_idx; + uint32_t i, max_flow_num, remaining_flow_num; + int cmp; + uint16_t hdr_len; + uint8_t find; + + outer_eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *); + outer_ipv4_hdr = (struct rte_ipv4_hdr *)((char *)outer_eth_hdr + + pkt->outer_l2_len); + + udp_hdr = (struct rte_udp_hdr *)((char *)outer_ipv4_hdr + + pkt->outer_l3_len); + gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr + + sizeof(struct rte_udp_hdr)); + eth_hdr = (struct rte_ether_hdr *)((char *)gtp_hdr + + sizeof(struct rte_gtp_hdr)); + /* l2_len = outer udp hdr len + gtp hdr len + inner l2 len */ + ipv4_hdr = (struct rte_ipv4_hdr *)((char *)udp_hdr + pkt->l2_len); + + /* + * Don't process the packet which has non-fragment inner IP. + */ + if (!is_ipv4_fragment(ipv4_hdr)) + return -1; + + hdr_len = pkt->outer_l2_len + pkt->outer_l3_len + pkt->l2_len + + pkt->l3_len; + /* + * Don't process the packet whose payload length is less than or + * equal to 0. + */ + if (pkt->pkt_len <= hdr_len) + return -1; + + ip_dl = pkt->pkt_len - hdr_len; + + ip_id = rte_be_to_cpu_16(ipv4_hdr->packet_id); + frag_offset = rte_be_to_cpu_16(ipv4_hdr->fragment_offset); + is_last_frag = ((frag_offset & RTE_IPV4_HDR_MF_FLAG) == 0) ? 1 : 0; + frag_offset = (uint16_t)(frag_offset & RTE_IPV4_HDR_OFFSET_MASK) << 3; + + rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.inner_key.eth_daddr)); + key.inner_key.ip_src_addr = ipv4_hdr->src_addr; + key.inner_key.ip_dst_addr = ipv4_hdr->dst_addr; + key.inner_key.ip_id = ip_id; + + // key.vxlan_hdr.vx_flags = vxlan_hdr->vx_flags; + // key.vxlan_hdr.vx_vni = vxlan_hdr->vx_vni; + key.gtp_hdr.teid = gtp_hdr->teid; + rte_ether_addr_copy(&(outer_eth_hdr->src_addr), &(key.outer_eth_saddr)); + rte_ether_addr_copy(&(outer_eth_hdr->dst_addr), &(key.outer_eth_daddr)); + key.outer_ip_src_addr = outer_ipv4_hdr->src_addr; + key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr; + /* Note: It is unnecessary to save outer_src_port here because it can + * be different for GTP UDP fragments from the same flow. + */ + key.outer_dst_port = udp_hdr->dst_port; + + /* Search for a matched flow. */ + max_flow_num = tbl->max_flow_num; + remaining_flow_num = tbl->flow_num; + find = 0; + for (i = 0; i < max_flow_num && remaining_flow_num; i++) { + if (tbl->flows[i].start_index != INVALID_ARRAY_INDEX) { + if (is_same_gtp_udp4_flow(tbl->flows[i].key, key)) { + find = 1; + break; + } + remaining_flow_num--; + } + } + + /* + * Can't find a matched flow. Insert a new flow and store the + * packet into the flow. + */ + if (find == 0) { + item_idx = insert_new_item(tbl, pkt, start_time, + INVALID_ARRAY_INDEX, frag_offset, + is_last_frag); + if (unlikely(item_idx == INVALID_ARRAY_INDEX)) + return -1; + if (insert_new_flow(tbl, &key, item_idx) == + INVALID_ARRAY_INDEX) { + /* + * Fail to insert a new flow, so + * delete the inserted packet. + */ + delete_item(tbl, item_idx, INVALID_ARRAY_INDEX); + return -1; + } + return 0; + } + + /* Check all packets in the flow and try to find a neighbor. */ + cur_idx = tbl->flows[i].start_index; + prev_idx = cur_idx; + do { + cmp = udp4_check_gtp_neighbor(&(tbl->items[cur_idx]), + frag_offset, ip_dl); + if (cmp) { + if (merge_two_gtp_udp4_packets( + &(tbl->items[cur_idx]), + pkt, cmp, frag_offset, + is_last_frag)) { + return 1; + } + /* + * Can't merge two packets, as the packet + * length will be greater than the max value. + * Insert the packet into the flow. + */ + if (insert_new_item(tbl, pkt, start_time, prev_idx, + frag_offset, is_last_frag) == + INVALID_ARRAY_INDEX) + return -1; + return 0; + } + + /* Ensure inserted items are ordered by frag_offset */ + if (frag_offset + < tbl->items[cur_idx].inner_item.frag_offset) { + break; + } + + prev_idx = cur_idx; + cur_idx = tbl->items[cur_idx].inner_item.next_pkt_idx; + } while (cur_idx != INVALID_ARRAY_INDEX); + + /* Can't find neighbor. Insert the packet into the flow. */ + if (cur_idx == tbl->flows[i].start_index) { + /* Insert it before the first packet of the flow */ + item_idx = insert_new_item(tbl, pkt, start_time, + INVALID_ARRAY_INDEX, frag_offset, + is_last_frag); + if (unlikely(item_idx == INVALID_ARRAY_INDEX)) + return -1; + tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx; + tbl->flows[i].start_index = item_idx; + } else { + if (insert_new_item(tbl, pkt, start_time, prev_idx, + frag_offset, is_last_frag + ) == INVALID_ARRAY_INDEX) + return -1; + } + + return 0; +} + +static int +gro_gtp_udp4_merge_items(struct gro_gtp_udp4_tbl *tbl, + uint32_t start_idx) +{ + uint16_t frag_offset; + uint8_t is_last_frag; + int16_t ip_dl; + struct rte_mbuf *pkt; + int cmp; + uint32_t item_idx; + uint16_t hdr_len; + + item_idx = tbl->items[start_idx].inner_item.next_pkt_idx; + while (item_idx != INVALID_ARRAY_INDEX) { + pkt = tbl->items[item_idx].inner_item.firstseg; + hdr_len = pkt->outer_l2_len + pkt->outer_l3_len + pkt->l2_len + + pkt->l3_len; + ip_dl = pkt->pkt_len - hdr_len; + frag_offset = tbl->items[item_idx].inner_item.frag_offset; + is_last_frag = tbl->items[item_idx].inner_item.is_last_frag; + cmp = udp4_check_gtp_neighbor(&(tbl->items[start_idx]), + frag_offset, ip_dl); + if (cmp) { + if (merge_two_gtp_udp4_packets( + &(tbl->items[start_idx]), + pkt, cmp, frag_offset, + is_last_frag)) { + item_idx = delete_item(tbl, item_idx, + INVALID_ARRAY_INDEX); + tbl->items[start_idx].inner_item.next_pkt_idx + = item_idx; + } else + return 0; + } else + return 0; + } + + return 0; +} + +uint16_t +gro_gtp_udp4_tbl_timeout_flush(struct gro_gtp_udp4_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out) +{ + uint16_t k = 0; + uint32_t i, j; + uint32_t max_flow_num = tbl->max_flow_num; + + for (i = 0; i < max_flow_num; i++) { + if (unlikely(tbl->flow_num == 0)) + return k; + + j = tbl->flows[i].start_index; + while (j != INVALID_ARRAY_INDEX) { + if (tbl->items[j].inner_item.start_time <= + flush_timestamp) { + gro_gtp_udp4_merge_items(tbl, j); + out[k++] = tbl->items[j].inner_item.firstseg; + if (tbl->items[j].inner_item.nb_merged > 1) + update_gtp_header(&(tbl->items[j])); + /* + * Delete the item and get the next packet + * index. + */ + j = delete_item(tbl, j, INVALID_ARRAY_INDEX); + tbl->flows[i].start_index = j; + if (j == INVALID_ARRAY_INDEX) + tbl->flow_num--; + + if (unlikely(k == nb_out)) + return k; + } else + /* + * Flushing packets does not strictly follow + * timestamp. It does not flush left packets of + * the flow this time once it finds one item + * whose start_time is greater than + * flush_timestamp. So go to check other flows. + */ + break; + } + } + return k; +} + +uint32_t +gro_gtp_udp4_tbl_pkt_count(void *tbl) +{ + struct gro_gtp_udp4_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/gro/gro_gtp_udp4.h b/lib/gro/gro_gtp_udp4.h new file mode 100644 index 00000000000..ea8cfc82c10 --- /dev/null +++ b/lib/gro/gro_gtp_udp4.h @@ -0,0 +1,154 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Inspur Corporation + */ + + #ifndef _GRO_GTP_UDP4_H_ + #define _GRO_GTP_UDP4_H_ + + #include "gro_udp4.h" + + #define GRO_GTP_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + + /* Header fields representing a GTP flow */ + struct gtp_udp4_flow_key { + struct udp4_flow_key inner_key; + struct rte_gtp_hdr gtp_hdr; + + struct rte_ether_addr outer_eth_saddr; + struct rte_ether_addr outer_eth_daddr; + + uint32_t outer_ip_src_addr; + uint32_t outer_ip_dst_addr; + + /* Note: It is unnecessary to save outer_src_port here because it can + * be different for GTP UDP fragments from the same flow. + */ + uint16_t outer_dst_port; + }; + + struct gro_gtp_udp4_flow { + struct gtp_udp4_flow_key key; + /* + * The index of the first packet in the flow. INVALID_ARRAY_INDEX + * indicates an empty flow. + */ + uint32_t start_index; + }; + + struct gro_gtp_udp4_item { + struct gro_udp4_item inner_item; + /* Note: GTP UDP/IPv4 GRO needn't check outer_ip_id because + * the difference between outer_ip_ids of two received packets + * isn't always +/-1 in case of OVS DPDK. So no outer_ip_id + * and outer_is_atomic fields here. + */ + }; + + /* + * GTP (with an outer IPv4 header and an inner UDP/IPv4 packet) + * reassembly table structure + */ + struct gro_gtp_udp4_tbl { + /* item array */ + struct gro_gtp_udp4_item *items; + /* flow array */ + struct gro_gtp_udp4_flow *flows; + /* current item number */ + uint32_t item_num; + /* current flow number */ + uint32_t flow_num; + /* the maximum item number */ + uint32_t max_item_num; + /* the maximum flow number */ + uint32_t max_flow_num; + }; + + /** + * This function creates a GTP reassembly table for GTP packets + * which have an outer IPv4 header and an inner UDP/IPv4 packet. + * + * @param socket_id + * Socket index for allocating the table + * @param max_flow_num + * The maximum number of flows in the table + * @param max_item_per_flow + * The maximum number of packets per flow + * + * @return + * - Return the table pointer on success. + * - Return NULL on failure. + */ + void *gro_gtp_udp4_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + + /** + * This function destroys a GTP reassembly table. + * + * @param tbl + * Pointer pointing to the GTP reassembly table + */ + void gro_gtp_udp4_tbl_destroy(void *tbl); + + /** + * This function merges a GTP packet which has an outer IPv4 header and + * an inner UDP/IPv4 packet. It does not process the packet which does not + * have payload. + * + * This function does not check if the packet has correct checksums and + * does not re-calculate checksums for the merged packet. It returns the + * packet if there is no available space in the table. + * + * @param pkt + * Packet to reassemble + * @param tbl + * Pointer pointing to the GTP reassembly table + * @start_time + * The time when the packet is inserted into the table + * + * @return + * - Return a positive value if the packet is merged. + * - Return zero if the packet isn't merged but stored in the table. + * - Return a negative value for invalid parameters or no available + * space in the table. + */ + int32_t gro_gtp_udp4_reassemble(struct rte_mbuf *pkt, + struct gro_gtp_udp4_tbl *tbl, + uint64_t start_time); + + /** + * This function flushes timeout packets in the GTP reassembly table, + * and without updating checksums. + * + * @param tbl + * Pointer pointing to a GTP GRO table + * @param flush_timestamp + * This function flushes packets which are inserted into the table + * before or at the flush_timestamp. + * @param out + * Pointer array used to keep flushed packets + * @param nb_out + * The element number in 'out'. It also determines the maximum number of + * packets that can be flushed finally. + * + * @return + * The number of flushed packets + */ + uint16_t gro_gtp_udp4_tbl_timeout_flush(struct gro_gtp_udp4_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out); + + /** + * This function returns the number of the packets in a GTP + * reassembly table. + * + * @param tbl + * Pointer pointing to the GTP reassembly table + * + * @return + * The number of packets in the table + */ + uint32_t gro_gtp_udp4_tbl_pkt_count(void *tbl); + #endif + \ No newline at end of file diff --git a/lib/gro/meson.build b/lib/gro/meson.build index dbce05220db..208441e2a3e 100644 --- a/lib/gro/meson.build +++ b/lib/gro/meson.build @@ -8,6 +8,8 @@ sources = files( 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', + 'gro_gtp_tcp4.c', + 'gro_gtp_udp4.c', ) headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/gro/rte_gro.c b/lib/gro/rte_gro.c index 578cc9b8010..ba5826fe102 100644 --- a/lib/gro/rte_gro.c +++ b/lib/gro/rte_gro.c @@ -2,7 +2,6 @@ * Copyright(c) 2017 Intel Corporation */ -#include #include #include #include @@ -13,6 +12,8 @@ #include "gro_udp4.h" #include "gro_vxlan_tcp4.h" #include "gro_vxlan_udp4.h" +#include "gro_gtp_tcp4.h" +#include "gro_gtp_udp4.h" typedef void *(*gro_tbl_create_fn)(uint16_t socket_id, uint16_t max_flow_num, @@ -22,17 +23,18 @@ typedef uint32_t (*gro_tbl_pkt_count_fn)(void *tbl); static gro_tbl_create_fn tbl_create_fn[RTE_GRO_TYPE_MAX_NUM] = { gro_tcp4_tbl_create, gro_vxlan_tcp4_tbl_create, - gro_udp4_tbl_create, gro_vxlan_udp4_tbl_create, gro_tcp6_tbl_create, NULL}; + gro_udp4_tbl_create, gro_vxlan_udp4_tbl_create, gro_tcp6_tbl_create, + gro_gtp_tcp4_tbl_create, gro_gtp_udp4_tbl_create, NULL}; static gro_tbl_destroy_fn tbl_destroy_fn[RTE_GRO_TYPE_MAX_NUM] = { gro_tcp4_tbl_destroy, gro_vxlan_tcp4_tbl_destroy, gro_udp4_tbl_destroy, gro_vxlan_udp4_tbl_destroy, - gro_tcp6_tbl_destroy, - NULL}; + gro_tcp6_tbl_destroy, gro_gtp_tcp4_tbl_destroy, + gro_gtp_udp4_tbl_destroy, NULL}; static gro_tbl_pkt_count_fn tbl_pkt_count_fn[RTE_GRO_TYPE_MAX_NUM] = { gro_tcp4_tbl_pkt_count, gro_vxlan_tcp4_tbl_pkt_count, gro_udp4_tbl_pkt_count, gro_vxlan_udp4_tbl_pkt_count, - gro_tcp6_tbl_pkt_count, - NULL}; + gro_tcp6_tbl_pkt_count, gro_gtp_tcp4_tbl_pkt_count, + gro_gtp_udp4_tbl_pkt_count, NULL}; #define IS_IPV4_TCP_PKT(ptype) (RTE_ETH_IS_IPV4_HDR(ptype) && \ ((ptype & RTE_PTYPE_L4_TCP) == RTE_PTYPE_L4_TCP) && \ @@ -76,6 +78,33 @@ static gro_tbl_pkt_count_fn tbl_pkt_count_fn[RTE_GRO_TYPE_MAX_NUM] = { ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN))) +#define IS_IPV4_GTP_UDP4_PKT(ptype) (RTE_ETH_IS_IPV4_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + ((ptype & RTE_PTYPE_TUNNEL_GTPU) == \ + RTE_PTYPE_TUNNEL_GTPU) && \ + ((ptype & RTE_PTYPE_INNER_L4_UDP) == \ + RTE_PTYPE_INNER_L4_UDP) && \ + (((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV4) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV4_EXT) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN))) + +#define IS_IPV4_GTP_TCP4_PKT(ptype) (RTE_ETH_IS_IPV4_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + ((ptype & RTE_PTYPE_L4_FRAG) != RTE_PTYPE_L4_FRAG) && \ + ((ptype & RTE_PTYPE_TUNNEL_GTPU) == \ + RTE_PTYPE_TUNNEL_GTPU) && \ + ((ptype & RTE_PTYPE_INNER_L4_TCP) == \ + RTE_PTYPE_INNER_L4_TCP) && \ + (((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV4) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV4_EXT) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN))) + /* * GRO context structure. It keeps the table structures, which are * used to merge packets, for different GRO types. Before using @@ -89,7 +118,6 @@ struct gro_ctx { void *tbls[RTE_GRO_TYPE_MAX_NUM]; }; -RTE_EXPORT_SYMBOL(rte_gro_ctx_create) void * rte_gro_ctx_create(const struct rte_gro_param *param) { @@ -131,7 +159,6 @@ rte_gro_ctx_create(const struct rte_gro_param *param) return gro_ctx; } -RTE_EXPORT_SYMBOL(rte_gro_ctx_destroy) void rte_gro_ctx_destroy(void *ctx) { @@ -151,7 +178,6 @@ rte_gro_ctx_destroy(void *ctx) rte_free(gro_ctx); } -RTE_EXPORT_SYMBOL(rte_gro_reassemble_burst) uint16_t rte_gro_reassemble_burst(struct rte_mbuf **pkts, uint16_t nb_pkts, @@ -183,15 +209,30 @@ rte_gro_reassemble_burst(struct rte_mbuf **pkts, struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + /* Allocate a reassembly table for GTP TCP GRO */ + struct gro_gtp_tcp4_tbl gtp_tcp_tbl; + struct gro_gtp_tcp4_flow gtp_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_gtp_tcp4_item gtp_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM] + = {{{0}, 0, 0} }; + + /* Allocate a reassembly table for GTP UDP GRO */ + struct gro_gtp_udp4_tbl gtp_udp_tbl; + struct gro_gtp_udp4_flow gtp_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_gtp_udp4_item gtp_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] + = {{{0}} }; + uint32_t item_num; int32_t ret; uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts; uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0, - do_vxlan_udp_gro = 0, do_tcp6_gro = 0; + do_vxlan_udp_gro = 0, do_tcp6_gro = 0, do_gtp_tcp_gro = 0, + do_gtp_udp_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | RTE_GRO_TCP_IPV6 | RTE_GRO_IPV4_VXLAN_UDP_IPV4 | + RTE_GRO_IPV4_GTP_TCP_IPV4 | + RTE_GRO_IPV4_GTP_UDP_IPV4 | RTE_GRO_UDP_IPV4)) == 0)) return nb_pkts; @@ -226,6 +267,32 @@ rte_gro_reassemble_burst(struct rte_mbuf **pkts, do_vxlan_udp_gro = 1; } + if (param->gro_types & RTE_GRO_IPV4_GTP_TCP_IPV4) { + for (i = 0; i < item_num; i++) + gtp_tcp_flows[i].start_index = INVALID_ARRAY_INDEX; + + gtp_tcp_tbl.flows = gtp_tcp_flows; + gtp_tcp_tbl.items = gtp_tcp_items; + gtp_tcp_tbl.flow_num = 0; + gtp_tcp_tbl.item_num = 0; + gtp_tcp_tbl.max_flow_num = item_num; + gtp_tcp_tbl.max_item_num = item_num; + do_gtp_tcp_gro = 1; + } + + if (param->gro_types & RTE_GRO_IPV4_GTP_UDP_IPV4) { + for (i = 0; i < item_num; i++) + gtp_udp_flows[i].start_index = INVALID_ARRAY_INDEX; + + gtp_udp_tbl.flows = gtp_udp_flows; + gtp_udp_tbl.items = gtp_udp_items; + gtp_udp_tbl.flow_num = 0; + gtp_udp_tbl.item_num = 0; + gtp_udp_tbl.max_flow_num = item_num; + gtp_udp_tbl.max_item_num = item_num; + do_gtp_udp_gro = 1; + } + if (param->gro_types & RTE_GRO_TCP_IPV4) { for (i = 0; i < item_num; i++) tcp_flows[i].start_index = INVALID_ARRAY_INDEX; @@ -288,6 +355,24 @@ rte_gro_reassemble_burst(struct rte_mbuf **pkts, nb_after_gro--; else if (ret < 0) pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV4_GTP_TCP4_PKT(pkts[i]->packet_type) && + do_gtp_tcp_gro) { + ret = gro_gtp_tcp4_reassemble(pkts[i], + >p_tcp_tbl, 0); + if (ret > 0) + /* Merge successfully */ + nb_after_gro--; + else if (ret < 0) + pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV4_GTP_UDP4_PKT(pkts[i]->packet_type) && + do_gtp_udp_gro) { + ret = gro_gtp_udp4_reassemble(pkts[i], + >p_udp_tbl, 0); + if (ret > 0) + /* Merge successfully */ + nb_after_gro--; + else if (ret < 0) + pkts[unprocess_num++] = pkts[i]; } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) && do_tcp4_gro) { ret = gro_tcp4_reassemble(pkts[i], &tcp_tbl, 0); @@ -333,6 +418,16 @@ rte_gro_reassemble_burst(struct rte_mbuf **pkts, } + if (do_gtp_tcp_gro) { + i += gro_gtp_tcp4_tbl_timeout_flush(>p_tcp_tbl, + 0, &pkts[i], nb_pkts - i); + } + + if (do_gtp_udp_gro) { + i += gro_gtp_udp4_tbl_timeout_flush(>p_udp_tbl, + 0, &pkts[i], nb_pkts - i); + } + if (do_tcp4_gro) { i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0, &pkts[i], nb_pkts - i); @@ -352,21 +447,23 @@ rte_gro_reassemble_burst(struct rte_mbuf **pkts, return nb_after_gro; } -RTE_EXPORT_SYMBOL(rte_gro_reassemble) uint16_t rte_gro_reassemble(struct rte_mbuf **pkts, uint16_t nb_pkts, void *ctx) { struct gro_ctx *gro_ctx = ctx; - void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_tbl; + void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_tbl, *gtp_tcp_tbl, *gtp_udp_tbl; uint64_t current_time; uint16_t i, unprocess_num = 0; - uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro, do_tcp6_gro; + uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro, do_tcp6_gro, + do_gtp_tcp_gro, do_gtp_udp_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | RTE_GRO_TCP_IPV6 | RTE_GRO_IPV4_VXLAN_UDP_IPV4 | + RTE_GRO_IPV4_GTP_TCP_IPV4 | + RTE_GRO_IPV4_GTP_UDP_IPV4 | RTE_GRO_UDP_IPV4)) == 0)) return nb_pkts; @@ -374,6 +471,8 @@ rte_gro_reassemble(struct rte_mbuf **pkts, vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX]; udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX]; vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX]; + gtp_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_GTP_TCP_IPV4_INDEX]; + gtp_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_GTP_UDP_IPV4_INDEX]; tcp6_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV6_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == @@ -384,6 +483,10 @@ rte_gro_reassemble(struct rte_mbuf **pkts, RTE_GRO_UDP_IPV4; do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) == RTE_GRO_IPV4_VXLAN_UDP_IPV4; + do_gtp_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_GTP_TCP_IPV4) == + RTE_GRO_IPV4_GTP_TCP_IPV4; + do_gtp_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_GTP_UDP_IPV4) == + RTE_GRO_IPV4_GTP_UDP_IPV4; do_tcp6_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV6) == RTE_GRO_TCP_IPV6; current_time = rte_rdtsc(); @@ -399,6 +502,16 @@ rte_gro_reassemble(struct rte_mbuf **pkts, if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl, current_time) < 0) pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV4_GTP_TCP4_PKT(pkts[i]->packet_type) && + do_gtp_tcp_gro) { + if (gro_gtp_tcp4_reassemble(pkts[i], gtp_tcp_tbl, + current_time) < 0) + pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV4_GTP_UDP4_PKT(pkts[i]->packet_type) && + do_gtp_udp_gro) { + if (gro_gtp_udp4_reassemble(pkts[i], gtp_udp_tbl, + current_time) < 0) + pkts[unprocess_num++] = pkts[i]; } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) && do_tcp4_gro) { if (gro_tcp4_reassemble(pkts[i], tcp_tbl, @@ -421,7 +534,6 @@ rte_gro_reassemble(struct rte_mbuf **pkts, return unprocess_num; } -RTE_EXPORT_SYMBOL(rte_gro_timeout_flush) uint16_t rte_gro_timeout_flush(void *ctx, uint64_t timeout_cycles, @@ -451,6 +563,20 @@ rte_gro_timeout_flush(void *ctx, left_nb_out = max_nb_out - num; } + if (gro_types & RTE_GRO_IPV4_GTP_TCP_IPV4) { + num = gro_gtp_tcp4_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_IPV4_GTP_TCP_IPV4_INDEX], + flush_timestamp, out, left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_IPV4_GTP_UDP_IPV4) && left_nb_out > 0) { + num += gro_gtp_udp4_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_IPV4_GTP_UDP_IPV4_INDEX], + flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + /* If no available space in 'out', stop flushing. */ if ((gro_types & RTE_GRO_TCP_IPV4) && left_nb_out > 0) { num += gro_tcp4_tbl_timeout_flush( @@ -480,7 +606,6 @@ rte_gro_timeout_flush(void *ctx, return num; } -RTE_EXPORT_SYMBOL(rte_gro_get_pkt_count) uint64_t rte_gro_get_pkt_count(void *ctx) { diff --git a/lib/gro/rte_gro.h b/lib/gro/rte_gro.h index c83dfd9ad14..d6f235fd35c 100644 --- a/lib/gro/rte_gro.h +++ b/lib/gro/rte_gro.h @@ -41,6 +41,12 @@ extern "C" { #define RTE_GRO_TCP_IPV6_INDEX 4 #define RTE_GRO_TCP_IPV6 (1ULL << RTE_GRO_TCP_IPV6_INDEX) /**< TCP/IPv6 GRO flag. */ +#define RTE_GRO_IPV4_GTP_TCP_IPV4_INDEX 5 +#define RTE_GRO_IPV4_GTP_TCP_IPV4 (1ULL << RTE_GRO_IPV4_GTP_TCP_IPV4_INDEX) +/**< GTP TCP/IPv4 GRO flag. */ +#define RTE_GRO_IPV4_GTP_UDP_IPV4_INDEX 6 +#define RTE_GRO_IPV4_GTP_UDP_IPV4 (1ULL << RTE_GRO_IPV4_GTP_UDP_IPV4_INDEX) +/**< GTP UDP/IPv4 GRO flag. */ /** * Structure used to create GRO context objects or used to pass From e7dd2827e958aca1cd889c822787b774e6d1d648 Mon Sep 17 00:00:00 2001 From: Arsalan-Zanganeh Date: Wed, 8 Oct 2025 09:34:16 +0000 Subject: [PATCH 2/2] inner eth removal --- lib/gro/gro_gtp_tcp4.c | 12 ++++++------ lib/gro/gro_gtp_udp4.c | 20 ++++++++++---------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/lib/gro/gro_gtp_tcp4.c b/lib/gro/gro_gtp_tcp4.c index 499bd006994..ed47fd14ad8 100644 --- a/lib/gro/gro_gtp_tcp4.c +++ b/lib/gro/gro_gtp_tcp4.c @@ -286,7 +286,7 @@ gro_gtp_tcp4_reassemble(struct rte_mbuf *pkt, struct gro_gtp_tcp4_tbl *tbl, uint64_t start_time) { - struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ether_hdr *outer_eth_hdr; //, *eth_hdr; struct rte_ipv4_hdr *outer_ipv4_hdr, *ipv4_hdr; struct rte_tcp_hdr *tcp_hdr; struct rte_udp_hdr *udp_hdr; @@ -317,8 +317,8 @@ gro_gtp_tcp4_reassemble(struct rte_mbuf *pkt, pkt->outer_l3_len); gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr + sizeof(struct rte_udp_hdr)); - eth_hdr = (struct rte_ether_hdr *)((char *)gtp_hdr + - sizeof(struct rte_gtp_hdr)); + // eth_hdr = (struct rte_ether_hdr *)((char *)gtp_hdr + + // sizeof(struct rte_gtp_hdr)); ipv4_hdr = (struct rte_ipv4_hdr *)((char *)udp_hdr + pkt->l2_len); tcp_hdr = (struct rte_tcp_hdr *)((char *)ipv4_hdr + pkt->l3_len); @@ -329,7 +329,7 @@ gro_gtp_tcp4_reassemble(struct rte_mbuf *pkt, if (tcp_hdr->tcp_flags != RTE_TCP_ACK_FLAG) return -1; - hdr_len = pkt->outer_l2_len + pkt->outer_l3_len + pkt->l2_len + + hdr_len = pkt->outer_l2_len + pkt->outer_l3_len + // pkt->l2_len + pkt->l3_len + pkt->l4_len; /* * Don't process the packet whose payload length is less than or @@ -354,8 +354,8 @@ gro_gtp_tcp4_reassemble(struct rte_mbuf *pkt, sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq); - rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.cmn_key.eth_saddr)); - rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.inner_key.cmn_key.eth_daddr)); + // rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.cmn_key.eth_saddr)); + // rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.inner_key.cmn_key.eth_daddr)); key.inner_key.ip_src_addr = ipv4_hdr->src_addr; key.inner_key.ip_dst_addr = ipv4_hdr->dst_addr; key.inner_key.cmn_key.recv_ack = tcp_hdr->recv_ack; diff --git a/lib/gro/gro_gtp_udp4.c b/lib/gro/gro_gtp_udp4.c index 8e1097af8c2..1d20bb4687c 100644 --- a/lib/gro/gro_gtp_udp4.c +++ b/lib/gro/gro_gtp_udp4.c @@ -157,10 +157,10 @@ insert_new_flow(struct gro_gtp_udp4_tbl *tbl, dst = &(tbl->flows[flow_idx].key); - rte_ether_addr_copy(&(src->inner_key.eth_saddr), - &(dst->inner_key.eth_saddr)); - rte_ether_addr_copy(&(src->inner_key.eth_daddr), - &(dst->inner_key.eth_daddr)); + // rte_ether_addr_copy(&(src->inner_key.eth_saddr), + // &(dst->inner_key.eth_saddr)); + // rte_ether_addr_copy(&(src->inner_key.eth_daddr), + // &(dst->inner_key.eth_daddr)); dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr; dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr; dst->inner_key.ip_id = src->inner_key.ip_id; @@ -288,7 +288,7 @@ gro_gtp_udp4_reassemble(struct rte_mbuf *pkt, struct gro_gtp_udp4_tbl *tbl, uint64_t start_time) { - struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ether_hdr *outer_eth_hdr; //, *eth_hdr; struct rte_ipv4_hdr *outer_ipv4_hdr, *ipv4_hdr; struct rte_udp_hdr *udp_hdr; struct rte_gtp_hdr *gtp_hdr; @@ -312,8 +312,8 @@ gro_gtp_udp4_reassemble(struct rte_mbuf *pkt, pkt->outer_l3_len); gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr + sizeof(struct rte_udp_hdr)); - eth_hdr = (struct rte_ether_hdr *)((char *)gtp_hdr + - sizeof(struct rte_gtp_hdr)); + // eth_hdr = (struct rte_ether_hdr *)((char *)gtp_hdr + + // sizeof(struct rte_gtp_hdr)); /* l2_len = outer udp hdr len + gtp hdr len + inner l2 len */ ipv4_hdr = (struct rte_ipv4_hdr *)((char *)udp_hdr + pkt->l2_len); @@ -323,7 +323,7 @@ gro_gtp_udp4_reassemble(struct rte_mbuf *pkt, if (!is_ipv4_fragment(ipv4_hdr)) return -1; - hdr_len = pkt->outer_l2_len + pkt->outer_l3_len + pkt->l2_len + + hdr_len = pkt->outer_l2_len + pkt->outer_l3_len + // pkt->l2_len + pkt->l3_len; /* * Don't process the packet whose payload length is less than or @@ -339,8 +339,8 @@ gro_gtp_udp4_reassemble(struct rte_mbuf *pkt, is_last_frag = ((frag_offset & RTE_IPV4_HDR_MF_FLAG) == 0) ? 1 : 0; frag_offset = (uint16_t)(frag_offset & RTE_IPV4_HDR_OFFSET_MASK) << 3; - rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.eth_saddr)); - rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.inner_key.eth_daddr)); + // rte_ether_addr_copy(&(eth_hdr->src_addr), &(key.inner_key.eth_saddr)); + // rte_ether_addr_copy(&(eth_hdr->dst_addr), &(key.inner_key.eth_daddr)); key.inner_key.ip_src_addr = ipv4_hdr->src_addr; key.inner_key.ip_dst_addr = ipv4_hdr->dst_addr; key.inner_key.ip_id = ip_id;