From patchwork Mon Dec 21 03:50:45 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: yang_y_yi X-Patchwork-Id: 85573 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id DDA30A09FE; Mon, 21 Dec 2020 04:51:20 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 45F3ACB7A; Mon, 21 Dec 2020 04:51:01 +0100 (CET) Received: from mail-m972.mail.163.com (mail-m972.mail.163.com [123.126.97.2]) by dpdk.org (Postfix) with ESMTP id AE2BCCACA for ; Mon, 21 Dec 2020 04:50:57 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id:MIME-Version; bh=KjCD6 LqiRvtO8tUdrIX6aoYWlLPBVmPlPI77PfNdknw=; b=JomZ5sArk+bybVyUjBax6 +wXZSHAmCEwAydXLR3nMUzdlNQH9iurhCe2obdH422S9hDmfrLjdR8JcEy4Fkt/Z Qzop7l6hrH9GwRczL+p385qoB8KynYvl1yWQv7bESsy3m74jyQrl5fE1f+5Ksu9f fahaC5ilR47v3tuBiIQ1I4= Received: from yangyi0100.home.langchao.com (unknown [111.207.123.53]) by smtp2 (Coremail) with SMTP id GtxpCgD3vb6cG+BfUOf7Fw--.755S3; Mon, 21 Dec 2020 11:50:54 +0800 (CST) From: yang_y_yi@163.com To: dev@dpdk.org Cc: jiayu.hu@intel.com, konstantin.ananyev@intel.com, thomas@monjalon.net, yangyi01@inspur.com, yang_y_yi@163.com Date: Mon, 21 Dec 2020 11:50:45 +0800 Message-Id: <20201221035052.128292-2-yang_y_yi@163.com> X-Mailer: git-send-email 2.19.2.windows.1 In-Reply-To: <20201221035052.128292-1-yang_y_yi@163.com> References: <20201221035052.128292-1-yang_y_yi@163.com> MIME-Version: 1.0 X-CM-TRANSID: GtxpCgD3vb6cG+BfUOf7Fw--.755S3 X-Coremail-Antispam: 1Uf129KBjvAXoWfuF4rGw4fZry8Aw4kAFy8Grg_yoW5WF1UKo WxZw15C34v9rnYvr40yr1vgF42g3W8W3WfZr4YgrWvqan2yryDG393Ww43Aay7Zr43tFnY v34xJayxXF4fArZ3n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxU5NVkUUUUU X-Originating-IP: [111.207.123.53] X-CM-SenderInfo: 51dqwsp1b1xqqrwthudrp/1tbiEB4Ci18YEc33RAAAsv Subject: [dpdk-dev] [PATCH v1 1/8] gro: support TCP/IPv6 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Yi Yang TCP/IPv6 GRO can help improve TCP/IPv6 performance. With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM TCP/IPv6 performance, it will merge small adjacent TCP/IPv6 segments to a big TCP/IPv6 segment immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VLAN use case. Signed-off-by: Yi Yang --- .../prog_guide/generic_receive_offload_lib.rst | 10 +- doc/guides/rel_notes/release_21_02.rst | 5 + lib/librte_gro/gro_tcp6.c | 368 +++++++++++++++++++++ lib/librte_gro/gro_tcp6.h | 314 ++++++++++++++++++ lib/librte_gro/meson.build | 2 +- lib/librte_gro/rte_gro.c | 74 ++++- lib/librte_gro/rte_gro.h | 3 + 7 files changed, 762 insertions(+), 14 deletions(-) create mode 100644 lib/librte_gro/gro_tcp6.c create mode 100644 lib/librte_gro/gro_tcp6.h diff --git a/doc/guides/prog_guide/generic_receive_offload_lib.rst b/doc/guides/prog_guide/generic_receive_offload_lib.rst index 98a5d29..fee856e 100644 --- a/doc/guides/prog_guide/generic_receive_offload_lib.rst +++ b/doc/guides/prog_guide/generic_receive_offload_lib.rst @@ -30,9 +30,9 @@ assumes the packets are complete (i.e., MF==0 && frag_off==0), when IP fragmentation is possible (i.e., DF==0). Additionally, it complies RFC 6864 to process the IPv4 ID field. -Currently, the GRO library provides GRO supports for TCP/IPv4 and UDP/IPv4 -packets as well as VxLAN packets which contain an outer IPv4 header and an -inner TCP/IPv4 or UDP/IPv4 packet. +Currently, the GRO library provides GRO supports for TCP/IPv4, UDP/IPv4, +and TCP/IPv6 packets as well as VxLAN packets which contain an outer IPv4 +header and an inner TCP/IPv4 or UDP/IPv4 packet. Two Sets of API --------------- @@ -83,8 +83,8 @@ Reassembly Algorithm The reassembly algorithm is used for reassembling packets. In the GRO library, different GRO types can use different algorithms. In this -section, we will introduce an algorithm, which is used by TCP/IPv4 GRO -and VxLAN GRO. +section, we will introduce an algorithm, which is used by TCP/IPv4 GRO, +TCP/IPv6 GRO and VxLAN GRO. Challenges ~~~~~~~~~~ diff --git a/doc/guides/rel_notes/release_21_02.rst b/doc/guides/rel_notes/release_21_02.rst index 638f981..1a1aeff 100644 --- a/doc/guides/rel_notes/release_21_02.rst +++ b/doc/guides/rel_notes/release_21_02.rst @@ -55,6 +55,11 @@ New Features Also, make sure to start the actual text at the margin. ======================================================= +* **Added TCP/IPv6 GRO support for non-VXLAN packets.** + + Added TCP/IPv6 GRO support for non-VXLAN packets, this enabled TCP/IPv6 + GRO support for VLAN use case. + Removed Items ------------- diff --git a/lib/librte_gro/gro_tcp6.c b/lib/librte_gro/gro_tcp6.c new file mode 100644 index 0000000..4a4df34 --- /dev/null +++ b/lib/librte_gro/gro_tcp6.c @@ -0,0 +1,368 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#include +#include +#include +#include + +#include "gro_tcp6.h" + +void * +gro_tcp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_tcp6_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_TCP6_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_tcp6_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_tcp6_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_tcp6_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; + } + /* INVALID_ARRAY_INDEX indicates an empty flow */ + 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_tcp6_tbl_destroy(void *tbl) +{ + struct gro_tcp6_tbl *tcp_tbl = tbl; + + if (tcp_tbl) { + rte_free(tcp_tbl->items); + rte_free(tcp_tbl->flows); + } + rte_free(tcp_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_tcp6_tbl *tbl) +{ + uint32_t i; + uint32_t max_item_num = tbl->max_item_num; + + for (i = 0; i < max_item_num; i++) + if (tbl->items[i].firstseg == NULL) + return i; + return INVALID_ARRAY_INDEX; +} + +static inline uint32_t +find_an_empty_flow(struct gro_tcp6_tbl *tbl) +{ + uint32_t i; + uint32_t max_flow_num = tbl->max_flow_num; + + 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_tcp6_tbl *tbl, + struct rte_mbuf *pkt, + uint64_t start_time, + uint32_t prev_idx, + uint32_t sent_seq) +{ + uint32_t item_idx; + + item_idx = find_an_empty_item(tbl); + if (item_idx == INVALID_ARRAY_INDEX) + return INVALID_ARRAY_INDEX; + + tbl->items[item_idx].firstseg = pkt; + tbl->items[item_idx].lastseg = rte_pktmbuf_lastseg(pkt); + tbl->items[item_idx].start_time = start_time; + tbl->items[item_idx].next_pkt_idx = INVALID_ARRAY_INDEX; + tbl->items[item_idx].sent_seq = sent_seq; + tbl->items[item_idx].nb_merged = 1; + tbl->item_num++; + + /* if the previous packet exists, chain them together. */ + if (prev_idx != INVALID_ARRAY_INDEX) { + tbl->items[item_idx].next_pkt_idx = + tbl->items[prev_idx].next_pkt_idx; + tbl->items[prev_idx].next_pkt_idx = item_idx; + } + + return item_idx; +} + +static inline uint32_t +delete_item(struct gro_tcp6_tbl *tbl, uint32_t item_idx, + uint32_t prev_item_idx) +{ + uint32_t next_idx = tbl->items[item_idx].next_pkt_idx; + + /* NULL indicates an empty item */ + tbl->items[item_idx].firstseg = NULL; + tbl->item_num--; + if (prev_item_idx != INVALID_ARRAY_INDEX) + tbl->items[prev_item_idx].next_pkt_idx = next_idx; + + return next_idx; +} + +static inline uint32_t +insert_new_flow(struct gro_tcp6_tbl *tbl, + struct tcp6_flow_key *src, + uint32_t item_idx) +{ + struct tcp6_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->eth_saddr), &(dst->eth_saddr)); + rte_ether_addr_copy(&(src->eth_daddr), &(dst->eth_daddr)); + gro_ipv6_addr_copy(src->ip_saddr, dst->ip_saddr); + gro_ipv6_addr_copy(src->ip_daddr, dst->ip_daddr); + dst->recv_ack = src->recv_ack; + dst->src_port = src->src_port; + dst->dst_port = src->dst_port; + + tbl->flows[flow_idx].start_index = item_idx; + tbl->flow_num++; + + return flow_idx; +} + +/* + * update the packet length for the flushed packet. + */ +static inline void +update_header(struct gro_tcp6_item *item) +{ + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_mbuf *pkt = item->firstseg; + + ipv6_hdr = (struct rte_ipv6_hdr *)(rte_pktmbuf_mtod(pkt, char *) + + pkt->l2_len); + ipv6_hdr->payload_len = rte_cpu_to_be_16(pkt->pkt_len - + pkt->l2_len - pkt->l3_len); +} + +int32_t +gro_tcp6_reassemble(struct rte_mbuf *pkt, + struct gro_tcp6_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *eth_hdr; + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_tcp_hdr *tcp_hdr; + uint32_t sent_seq; + int32_t tcp_dl; + uint16_t hdr_len; + + struct tcp6_flow_key key; + uint32_t cur_idx, prev_idx, item_idx; + uint32_t i, max_flow_num, remaining_flow_num; + int cmp; + 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; + + eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *); + ipv6_hdr = (struct rte_ipv6_hdr *)((char *)eth_hdr + pkt->l2_len); + tcp_hdr = (struct rte_tcp_hdr *)((char *)ipv6_hdr + pkt->l3_len); + hdr_len = pkt->l2_len + pkt->l3_len + pkt->l4_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; + /* + * Don't process the packet whose payload length is less than or + * equal to 0. + */ + if (pkt->pkt_len <= hdr_len) + return -1; + tcp_dl = pkt->pkt_len - hdr_len; + + /* + * Save IPv6 ID for the packet whose DF bit is 0. For the packet + * whose DF bit is 1, IPv6 ID is ignored. + */ + sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq); + + rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.eth_daddr)); + gro_ipv6_addr_copy(ipv6_hdr->src_addr, key.ip_saddr); + gro_ipv6_addr_copy(ipv6_hdr->dst_addr, key.ip_daddr); + key.src_port = tcp_hdr->src_port; + key.dst_port = tcp_hdr->dst_port; + key.recv_ack = tcp_hdr->recv_ack; + + /* 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_tcp6_flow(tbl->flows[i].key, key)) { + find = 1; + break; + } + remaining_flow_num--; + } + } + + /* + * Fail to 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); + 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 + * stored 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 for + * the input packet. + */ + cur_idx = tbl->flows[i].start_index; + prev_idx = cur_idx; + do { + cmp = check_seq_option_v6(&(tbl->items[cur_idx]), tcp_hdr, + sent_seq, pkt->l4_len, tcp_dl, 0); + if (cmp) { + if (merge_two_tcp6_packets(&(tbl->items[cur_idx]), + pkt, cmp, sent_seq, 0)) + return 1; + /* + * Fail to merge the two packets, as the packet + * length is greater than the max value. Store + * the packet into the flow. + */ + if (insert_new_item(tbl, pkt, start_time, prev_idx, + sent_seq) == + INVALID_ARRAY_INDEX) + return -1; + return 0; + } + prev_idx = cur_idx; + cur_idx = tbl->items[cur_idx].next_pkt_idx; + } while (cur_idx != INVALID_ARRAY_INDEX); + + /* Fail to find a neighbor, so store the packet into the flow. */ + if (insert_new_item(tbl, pkt, start_time, prev_idx, sent_seq + ) == INVALID_ARRAY_INDEX) + return -1; + + return 0; +} + +uint16_t +gro_tcp6_tbl_timeout_flush(struct gro_tcp6_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].start_time <= flush_timestamp) { + out[k++] = tbl->items[j].firstseg; + if (tbl->items[j].nb_merged > 1) + update_header(&(tbl->items[j])); + /* + * Delete the packet and get the next + * packet in the flow. + */ + 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 this flow won't be + * timeout. Go to check other flows. + */ + break; + } + } + return k; +} + +uint32_t +gro_tcp6_tbl_pkt_count(void *tbl) +{ + struct gro_tcp6_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/librte_gro/gro_tcp6.h b/lib/librte_gro/gro_tcp6.h new file mode 100644 index 0000000..a9dec7b --- /dev/null +++ b/lib/librte_gro/gro_tcp6.h @@ -0,0 +1,314 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#ifndef _GRO_TCP6_H_ +#define _GRO_TCP6_H_ + +#include +#include +#include + +#define INVALID_ARRAY_INDEX 0xffffffffUL +#define GRO_TCP6_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + +/* + * The max length of a IPv6 packet, which includes the length of the L3 + * header, the L4 header and the data payload. + */ +#define MAX_IPV6_PKT_LENGTH UINT16_MAX + +/* The maximum TCP header length */ +#define MAX_TCP_HLEN 60 +#define INVALID_TCP_HDRLEN(len) \ + (((len) < sizeof(struct rte_tcp_hdr)) || ((len) > MAX_TCP_HLEN)) + +/* Header fields representing a TCP/IPv6 flow */ +struct tcp6_flow_key { + struct rte_ether_addr eth_saddr; + struct rte_ether_addr eth_daddr; + uint8_t ip_saddr[16]; /**< IPv6 address of source host. */ + uint8_t ip_daddr[16]; /**< IPv6 address of destination host(s). */ + + uint32_t recv_ack; + uint16_t src_port; + uint16_t dst_port; +}; + +struct gro_tcp6_flow { + struct tcp6_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_tcp6_item { + /* + * The first MBUF segment of the packet. If the value + * is NULL, it means the item is empty. + */ + struct rte_mbuf *firstseg; + /* The last MBUF segment of the packet */ + struct rte_mbuf *lastseg; + /* + * The time when the first packet is inserted into the table. + * This value won't be updated, even if the packet is merged + * with other packets. + */ + uint64_t start_time; + /* + * next_pkt_idx is used to chain the packets that + * are in the same flow but can't be merged together + * (e.g. caused by packet reordering). + */ + uint32_t next_pkt_idx; + /* TCP sequence number of the packet */ + uint32_t sent_seq; + /* the number of merged packets */ + uint16_t nb_merged; +}; + +/* + * TCP/IPv6 reassembly table structure. + */ +struct gro_tcp6_tbl { + /* item array */ + struct gro_tcp6_item *items; + /* flow array */ + struct gro_tcp6_flow *flows; + /* current item number */ + uint32_t item_num; + /* current flow num */ + uint32_t flow_num; + /* item array size */ + uint32_t max_item_num; + /* flow array size */ + uint32_t max_flow_num; +}; + +/** + * This function creates a TCP/IPv6 reassembly table. + * + * @param socket_id + * Socket index for allocating the TCP/IPv6 reassemble table + * @param max_flow_num + * The maximum number of flows in the TCP/IPv6 GRO 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_tcp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + +/** + * This function destroys a TCP/IPv6 reassembly table. + * + * @param tbl + * Pointer pointing to the TCP/IPv6 reassembly table. + */ +void gro_tcp6_tbl_destroy(void *tbl); + +/** + * This function merges a TCP/IPv6 packet. It does not process the packet, + * which has SYN, FIN, RST, PSH, CWR, ECE or URG set, or 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. 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 TCP/IPv6 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_tcp6_reassemble(struct rte_mbuf *pkt, + struct gro_tcp6_tbl *tbl, + uint64_t start_time); + +/** + * This function flushes timeout packets in a TCP/IPv6 reassembly table, + * and without updating checksums. + * + * @param tbl + * TCP/IPv6 reassembly table pointer + * @param flush_timestamp + * Flush 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_tcp6_tbl_timeout_flush(struct gro_tcp6_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out); + +/** + * This function returns the number of the packets in a TCP/IPv6 + * reassembly table. + * + * @param tbl + * TCP/IPv6 reassembly table pointer + * + * @return + * The number of packets in the table + */ +uint32_t gro_tcp6_tbl_pkt_count(void *tbl); + +/* + * Check if two IPv6 address is same. + */ +static inline int rte_is_same_ipv6_addr(const uint8_t *ipv6_a1, + const uint8_t *ipv6_a2) +{ + const uint64_t *w1 = (const uint64_t *)ipv6_a1; + const uint64_t *w2 = (const uint64_t *)ipv6_a2; + + return ((w1[0] ^ w2[0]) | (w1[1] ^ w2[1])) == 0; +} + +/* Copy IPv6 addr */ +static inline void gro_ipv6_addr_copy(const uint8_t *ipv6_from, + uint8_t *ipv6_to) +{ + const uint64_t *from_words = (const uint64_t *)ipv6_from; + uint64_t *to_words = (uint64_t *)ipv6_to; + + to_words[0] = from_words[0]; + to_words[1] = from_words[1]; +} + +/* + * Check if two TCP/IPv6 packets belong to the same flow. + */ +static inline int +is_same_tcp6_flow(struct tcp6_flow_key k1, struct tcp6_flow_key k2) +{ + return (rte_is_same_ether_addr(&k1.eth_saddr, &k2.eth_saddr) && + rte_is_same_ether_addr(&k1.eth_daddr, &k2.eth_daddr) && + rte_is_same_ipv6_addr(k1.ip_saddr, k2.ip_saddr) && + rte_is_same_ipv6_addr(k1.ip_daddr, k2.ip_daddr) && + (k1.recv_ack == k2.recv_ack) && + (k1.src_port == k2.src_port) && + (k1.dst_port == k2.dst_port)); +} + +/* + * Merge two TCP/IPv6, packets without updating checksums. + * If cmp is larger than 0, append the new packet to the + * original packet. Otherwise, pre-pend the new packet to + * the original packet. + */ +static inline int +merge_two_tcp6_packets(struct gro_tcp6_item *item, + struct rte_mbuf *pkt, + int cmp, + uint32_t sent_seq, + uint16_t l2_offset) +{ + struct rte_mbuf *pkt_head, *pkt_tail, *lastseg; + uint16_t hdr_len, l2_len; + + if (cmp > 0) { + pkt_head = item->firstseg; + pkt_tail = pkt; + } else { + pkt_head = pkt; + pkt_tail = item->firstseg; + } + + /* check if the IPv6 packet length is greater than the max value */ + hdr_len = l2_offset + pkt_head->l2_len + pkt_head->l3_len + + pkt_head->l4_len; + l2_len = l2_offset > 0 ? pkt_head->outer_l2_len : pkt_head->l2_len; + if (unlikely(pkt_head->pkt_len - l2_len + pkt_tail->pkt_len - + hdr_len > MAX_IPV6_PKT_LENGTH)) + return 0; + + /* remove the packet header for the tail packet */ + rte_pktmbuf_adj(pkt_tail, hdr_len); + + /* chain two packets together */ + if (cmp > 0) { + item->lastseg->next = pkt; + item->lastseg = rte_pktmbuf_lastseg(pkt); + } else { + lastseg = rte_pktmbuf_lastseg(pkt); + lastseg->next = item->firstseg; + item->firstseg = pkt; + /* update sent_seq to the smaller value */ + item->sent_seq = sent_seq; + } + item->nb_merged++; + + /* update MBUF metadata for the merged packet */ + pkt_head->nb_segs += pkt_tail->nb_segs; + pkt_head->pkt_len += pkt_tail->pkt_len; + + return 1; +} + +/* + * Check if two TCP/IPv6 packets are neighbors. + */ +static inline int +check_seq_option_v6(struct gro_tcp6_item *item, + struct rte_tcp_hdr *tcph, + uint32_t sent_seq, + uint16_t tcp_hl, + uint16_t tcp_dl, + uint16_t l2_offset) +{ + struct rte_mbuf *pkt_orig = item->firstseg; + struct rte_ipv6_hdr *iph_orig; + struct rte_tcp_hdr *tcph_orig; + uint16_t len, tcp_hl_orig; + + iph_orig = (struct rte_ipv6_hdr *)(rte_pktmbuf_mtod(pkt_orig, char *) + + l2_offset + pkt_orig->l2_len); + tcph_orig = (struct rte_tcp_hdr *)((char *)iph_orig + pkt_orig->l3_len); + tcp_hl_orig = pkt_orig->l4_len; + + /* Check if TCP option fields equal */ + len = RTE_MAX(tcp_hl, tcp_hl_orig) - sizeof(struct rte_tcp_hdr); + if ((tcp_hl != tcp_hl_orig) || ((len > 0) && + (memcmp(tcph + 1, tcph_orig + 1, + len) != 0))) + return 0; + + /* check if the two packets are neighbors */ + len = pkt_orig->pkt_len - l2_offset - pkt_orig->l2_len - + pkt_orig->l3_len - tcp_hl_orig; + if (sent_seq == item->sent_seq + len) + /* append the new packet */ + return 1; + else if (sent_seq + tcp_dl == item->sent_seq) + /* pre-pend the new packet */ + return -1; + + return 0; +} +#endif diff --git a/lib/librte_gro/meson.build b/lib/librte_gro/meson.build index ea8b45c..6143dd0 100644 --- a/lib/librte_gro/meson.build +++ b/lib/librte_gro/meson.build @@ -1,6 +1,6 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c') +sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c') headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c index 8ca4da6..86958d5 100644 --- a/lib/librte_gro/rte_gro.c +++ b/lib/librte_gro/rte_gro.c @@ -9,6 +9,7 @@ #include "rte_gro.h" #include "gro_tcp4.h" +#include "gro_tcp6.h" #include "gro_udp4.h" #include "gro_vxlan_tcp4.h" #include "gro_vxlan_udp4.h" @@ -21,15 +22,16 @@ 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, NULL}; + gro_udp4_tbl_create, gro_vxlan_udp4_tbl_create, + gro_tcp6_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, - NULL}; + gro_tcp6_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, - NULL}; + gro_tcp6_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) && \ @@ -65,6 +67,10 @@ ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN))) +#define IS_IPV6_TCP_PKT(ptype) (RTE_ETH_IS_IPV6_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_TCP) == RTE_PTYPE_L4_TCP) && \ + (RTE_ETH_IS_TUNNEL_PKT(ptype) == 0)) + /* * GRO context structure. It keeps the table structures, which are * used to merge packets, for different GRO types. Before using @@ -165,17 +171,24 @@ struct gro_ctx { struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + /* allocate a reassembly table for TCP/IPv6 GRO */ + struct gro_tcp6_tbl tcp6_tbl; + struct gro_tcp6_flow tcp6_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_tcp6_item tcp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} }; + + struct rte_mbuf *unprocess_pkts[nb_pkts]; 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_vxlan_udp_gro = 0, do_tcp6_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | RTE_GRO_IPV4_VXLAN_UDP_IPV4 | - RTE_GRO_UDP_IPV4)) == 0)) + RTE_GRO_UDP_IPV4 | + RTE_GRO_TCP_IPV6)) == 0)) return nb_pkts; /* Get the maximum number of packets */ @@ -235,6 +248,20 @@ struct gro_ctx { do_udp4_gro = 1; } + if (param->gro_types & RTE_GRO_TCP_IPV6) { + for (i = 0; i < item_num; i++) + tcp6_flows[i].start_index = INVALID_ARRAY_INDEX; + + tcp6_tbl.flows = tcp6_flows; + tcp6_tbl.items = tcp6_items; + tcp6_tbl.flow_num = 0; + tcp6_tbl.item_num = 0; + tcp6_tbl.max_flow_num = item_num; + tcp6_tbl.max_item_num = item_num; + do_tcp6_gro = 1; + } + + for (i = 0; i < nb_pkts; i++) { /* @@ -275,6 +302,14 @@ struct gro_ctx { nb_after_gro--; else if (ret < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_TCP_PKT(pkts[i]->packet_type) && + do_tcp6_gro) { + ret = gro_tcp6_reassemble(pkts[i], &tcp6_tbl, 0); + if (ret > 0) + /* merge successfully */ + nb_after_gro--; + else if (ret < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -303,6 +338,12 @@ struct gro_ctx { i += gro_udp4_tbl_timeout_flush(&udp_tbl, 0, &pkts[i], nb_pkts - i); } + + if (do_tcp6_gro) { + i += gro_tcp6_tbl_timeout_flush(&tcp6_tbl, 0, + &pkts[i], nb_pkts - i); + } + /* Copy unprocessed packets */ if (unprocess_num > 0) { memcpy(&pkts[i], unprocess_pkts, @@ -322,21 +363,24 @@ struct gro_ctx { { struct rte_mbuf *unprocess_pkts[nb_pkts]; struct gro_ctx *gro_ctx = ctx; - void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl; + void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_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; + uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro, + do_tcp6_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | RTE_GRO_IPV4_VXLAN_UDP_IPV4 | - RTE_GRO_UDP_IPV4)) == 0)) + RTE_GRO_UDP_IPV4 | + RTE_GRO_TCP_IPV6)) == 0)) return nb_pkts; tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX]; 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]; + tcp6_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV6_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == RTE_GRO_TCP_IPV4; @@ -346,6 +390,8 @@ struct gro_ctx { 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_tcp6_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV6) == + RTE_GRO_TCP_IPV6; current_time = rte_rdtsc(); @@ -370,6 +416,11 @@ struct gro_ctx { if (gro_udp4_reassemble(pkts[i], udp_tbl, current_time) < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_TCP_PKT(pkts[i]->packet_type) && + do_tcp6_gro) { + if (gro_tcp6_reassemble(pkts[i], tcp6_tbl, + current_time) < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -425,6 +476,13 @@ struct gro_ctx { gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX], flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_TCP_IPV6) && left_nb_out > 0) { + num += gro_tcp6_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_TCP_IPV6_INDEX], + flush_timestamp, &out[num], left_nb_out); } return num; diff --git a/lib/librte_gro/rte_gro.h b/lib/librte_gro/rte_gro.h index 9f9ed49..39b57e8 100644 --- a/lib/librte_gro/rte_gro.h +++ b/lib/librte_gro/rte_gro.h @@ -38,6 +38,9 @@ #define RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX 3 #define RTE_GRO_IPV4_VXLAN_UDP_IPV4 (1ULL << RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX) /**< VxLAN UDP/IPv4 GRO flag. */ +#define RTE_GRO_TCP_IPV6_INDEX 4 +#define RTE_GRO_TCP_IPV6 (1ULL << RTE_GRO_TCP_IPV6_INDEX) +/**< TCP/IPv6 GRO flag */ /** * Structure used to create GRO context objects or used to pass From patchwork Mon Dec 21 03:50:46 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: yang_y_yi X-Patchwork-Id: 85575 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 04BDCA09FE; Mon, 21 Dec 2020 04:52:00 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id A48AACBD5; Mon, 21 Dec 2020 04:51:04 +0100 (CET) Received: from mail-m972.mail.163.com (mail-m972.mail.163.com [123.126.97.2]) by dpdk.org (Postfix) with ESMTP id B34B9CACE for ; Mon, 21 Dec 2020 04:50:57 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id:MIME-Version; bh=gLyuV BBm6loJ4YsRN++WaCat+TJ7iIORIVNV7wpta0c=; b=P86ypse7LOT9QQEUdTyfL Rn6e+m/QkJ/FnQrN3/5zCQB/vJOuDdme4RzN6O/HjzwjEVarkHtBh8WQeSYvYBXW vS6XJbbJHQRWJYZrItDqzXvuFE/ZPSc9TCnO9WHeTfyEdzpex2qxiaEGSdKrvM94 Edt6jBIn3MNq/h95zHJsM8= Received: from yangyi0100.home.langchao.com (unknown [111.207.123.53]) by smtp2 (Coremail) with SMTP id GtxpCgD3vb6cG+BfUOf7Fw--.755S4; Mon, 21 Dec 2020 11:50:54 +0800 (CST) From: yang_y_yi@163.com To: dev@dpdk.org Cc: jiayu.hu@intel.com, konstantin.ananyev@intel.com, thomas@monjalon.net, yangyi01@inspur.com, yang_y_yi@163.com Date: Mon, 21 Dec 2020 11:50:46 +0800 Message-Id: <20201221035052.128292-3-yang_y_yi@163.com> X-Mailer: git-send-email 2.19.2.windows.1 In-Reply-To: <20201221035052.128292-1-yang_y_yi@163.com> References: <20201221035052.128292-1-yang_y_yi@163.com> MIME-Version: 1.0 X-CM-TRANSID: GtxpCgD3vb6cG+BfUOf7Fw--.755S4 X-Coremail-Antispam: 1Uf129KBjvAXoWfuF45GFWxJFWrZFW8Kw17ZFb_yoW5Cr15Ao WxXws0gr109r15tr4jyr1I9r4jgw10g3ZrArs8KrW8XwnFy3yDGrZ3Ww4fAa17Xr43ZFn5 u3s7Gay7XF4Iyrs3n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxU7WlkDUUUU X-Originating-IP: [111.207.123.53] X-CM-SenderInfo: 51dqwsp1b1xqqrwthudrp/1tbiFh4Ci144OkMuxAAAs0 Subject: [dpdk-dev] [PATCH v1 2/8] gro: support IPv4 VXLAN TCP/IPv6 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Yi Yang IPv4 VXLAN TCP/IPv6 GRO can help improve TCP/IPv6 performance in IPv4 VXLAN use case. With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM TCP/IPv6 performance, it will merge small adjacent IPv4 VXLAN TCP/IPv6 packets to a big IPv4 VXLAN TCP/IPv6 packet immediate after they are received from a physical NIC. It is very helpful in OVS DPDK IPv4 VXLAN use case. Signed-off-by: Yi Yang --- .../prog_guide/generic_receive_offload_lib.rst | 6 +- doc/guides/rel_notes/release_21_02.rst | 5 + lib/librte_gro/gro_vxlan_tcp6.c | 496 +++++++++++++++++++++ lib/librte_gro/gro_vxlan_tcp6.h | 156 +++++++ lib/librte_gro/meson.build | 2 +- lib/librte_gro/rte_gro.c | 81 +++- lib/librte_gro/rte_gro.h | 3 + 7 files changed, 736 insertions(+), 13 deletions(-) create mode 100644 lib/librte_gro/gro_vxlan_tcp6.c create mode 100644 lib/librte_gro/gro_vxlan_tcp6.h diff --git a/doc/guides/prog_guide/generic_receive_offload_lib.rst b/doc/guides/prog_guide/generic_receive_offload_lib.rst index fee856e..ecb5909 100644 --- a/doc/guides/prog_guide/generic_receive_offload_lib.rst +++ b/doc/guides/prog_guide/generic_receive_offload_lib.rst @@ -32,7 +32,7 @@ fragmentation is possible (i.e., DF==0). Additionally, it complies RFC Currently, the GRO library provides GRO supports for TCP/IPv4, UDP/IPv4, and TCP/IPv6 packets as well as VxLAN packets which contain an outer IPv4 -header and an inner TCP/IPv4 or UDP/IPv4 packet. +header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 packet. Two Sets of API --------------- @@ -161,8 +161,8 @@ Header fields deciding if two packets are neighbors include: - IPv4 ID. The IPv4 ID fields of the packets, whose DF bit is 0, should be increased by 1. -VxLAN GRO ---------- +IPv4 VxLAN TCP/IPv4 GRO +----------------------- The table structure used by VxLAN GRO, which is in charge of processing VxLAN packets with an outer IPv4 header and inner TCP/IPv4 packet, is diff --git a/doc/guides/rel_notes/release_21_02.rst b/doc/guides/rel_notes/release_21_02.rst index 1a1aeff..035d774 100644 --- a/doc/guides/rel_notes/release_21_02.rst +++ b/doc/guides/rel_notes/release_21_02.rst @@ -60,6 +60,11 @@ New Features Added TCP/IPv6 GRO support for non-VXLAN packets, this enabled TCP/IPv6 GRO support for VLAN use case. +* **Added TCP/IPv6 GRO support for IPv4 VXLAN packets.** + + Added TCP/IPv6 GRO support for IPv4 VXLAN packets, this enabled TCP/IPv6 + GRO support for IPv4 VXLAN use case. + Removed Items ------------- diff --git a/lib/librte_gro/gro_vxlan_tcp6.c b/lib/librte_gro/gro_vxlan_tcp6.c new file mode 100644 index 0000000..d49a2dd --- /dev/null +++ b/lib/librte_gro/gro_vxlan_tcp6.c @@ -0,0 +1,496 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#include +#include +#include +#include +#include + +#include "gro_vxlan_tcp6.h" + +void * +gro_vxlan_tcp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_vxlan_tcp6_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_VXLAN_TCP6_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_vxlan_tcp6_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_vxlan_tcp6_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_vxlan_tcp6_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_vxlan_tcp6_tbl_destroy(void *tbl) +{ + struct gro_vxlan_tcp6_tbl *vxlan_tbl = tbl; + + if (vxlan_tbl) { + rte_free(vxlan_tbl->items); + rte_free(vxlan_tbl->flows); + } + rte_free(vxlan_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_vxlan_tcp6_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_vxlan_tcp6_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_vxlan_tcp6_tbl *tbl, + struct rte_mbuf *pkt, + uint64_t start_time, + uint32_t prev_idx, + uint32_t sent_seq, + uint16_t outer_ip_id, + uint8_t outer_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.nb_merged = 1; + 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_vxlan_tcp6_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_vxlan_tcp6_tbl *tbl, + struct vxlan_tcp6_flow_key *src, + uint32_t item_idx) +{ + struct vxlan_tcp6_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)); + gro_ipv6_addr_copy(src->inner_key.ip_saddr, dst->inner_key.ip_saddr); + gro_ipv6_addr_copy(src->inner_key.ip_daddr, dst->inner_key.ip_daddr); + dst->inner_key.recv_ack = src->inner_key.recv_ack; + dst->inner_key.src_port = src->inner_key.src_port; + dst->inner_key.dst_port = src->inner_key.dst_port; + + dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags; + dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni; + 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_vxlan_tcp6_flow(struct vxlan_tcp6_flow_key k1, + struct vxlan_tcp6_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) && + is_same_tcp6_flow(k1.inner_key, k2.inner_key)); +} + +static inline int +check_vxlan_seq_option_v6(struct gro_vxlan_tcp6_item *item, + struct rte_tcp_hdr *tcp_hdr, + uint32_t sent_seq, + uint16_t outer_ip_id, + uint16_t tcp_hl, + uint16_t tcp_dl, + uint8_t outer_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_v6(&item->inner_item, tcp_hdr, sent_seq, + tcp_hl, tcp_dl, l2_offset); + 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_vxlan_tcp6_packets(struct gro_vxlan_tcp6_item *item, + struct rte_mbuf *pkt, + int cmp, + uint32_t sent_seq, + uint16_t outer_ip_id) +{ + if (merge_two_tcp6_packets(&item->inner_item, pkt, cmp, sent_seq, + 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_vxlan_header(struct gro_vxlan_tcp6_item *item) +{ + struct rte_ipv4_hdr *ipv4_hdr; + struct rte_ipv6_hdr *ipv6_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 = (struct rte_ipv4_hdr *)(rte_pktmbuf_mtod(pkt, char *) + + 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 IPv6 header. */ + len -= pkt->l2_len; + ipv6_hdr = (struct rte_ipv6_hdr *)((char *)udp_hdr + pkt->l2_len); + /* IPv6 payload_len does not include IPv6 header. */ + ipv6_hdr->payload_len = rte_cpu_to_be_16(len - pkt->l3_len); +} + +int32_t +gro_vxlan_tcp6_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan_tcp6_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ipv4_hdr *outer_ipv4_hdr; + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_tcp_hdr *tcp_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_vxlan_hdr *vxlan_hdr; + uint32_t sent_seq; + int32_t tcp_dl; + uint16_t frag_off, outer_ip_id; + uint8_t outer_is_atomic; + + struct vxlan_tcp6_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); + vxlan_hdr = (struct rte_vxlan_hdr *)((char *)udp_hdr + + sizeof(struct rte_udp_hdr)); + eth_hdr = (struct rte_ether_hdr *)((char *)vxlan_hdr + + sizeof(struct rte_vxlan_hdr)); + ipv6_hdr = (struct rte_ipv6_hdr *)((char *)udp_hdr + pkt->l2_len); + tcp_hdr = (struct rte_tcp_hdr *)((char *)ipv6_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. + */ + if (pkt->pkt_len <= hdr_len) + return -1; + tcp_dl = pkt->pkt_len - hdr_len; + + /* + * 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); + + sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq); + + rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.inner_key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.inner_key.eth_daddr)); + gro_ipv6_addr_copy(ipv6_hdr->src_addr, key.inner_key.ip_saddr); + gro_ipv6_addr_copy(ipv6_hdr->dst_addr, key.inner_key.ip_daddr); + key.inner_key.recv_ack = tcp_hdr->recv_ack; + key.inner_key.src_port = tcp_hdr->src_port; + key.inner_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; + rte_ether_addr_copy(&(outer_eth_hdr->s_addr), &(key.outer_eth_saddr)); + rte_ether_addr_copy(&(outer_eth_hdr->d_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_vxlan_tcp6_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, + outer_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_vxlan_seq_option_v6(&(tbl->items[cur_idx]), tcp_hdr, + sent_seq, outer_ip_id, pkt->l4_len, + tcp_dl, outer_is_atomic); + if (cmp) { + if (merge_two_vxlan_tcp6_packets(&(tbl->items[cur_idx]), + pkt, cmp, sent_seq, + outer_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, + outer_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, outer_is_atomic + ) == INVALID_ARRAY_INDEX) + return -1; + + return 0; +} + +uint16_t +gro_vxlan_tcp6_tbl_timeout_flush(struct gro_vxlan_tcp6_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_vxlan_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_vxlan_tcp6_tbl_pkt_count(void *tbl) +{ + struct gro_vxlan_tcp6_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/librte_gro/gro_vxlan_tcp6.h b/lib/librte_gro/gro_vxlan_tcp6.h new file mode 100644 index 0000000..87d03d8 --- /dev/null +++ b/lib/librte_gro/gro_vxlan_tcp6.h @@ -0,0 +1,156 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#ifndef _GRO_VXLAN_TCP6_H_ +#define _GRO_VXLAN_TCP6_H_ + +#include "gro_tcp6.h" + +#define GRO_VXLAN_TCP6_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + +/* Header fields representing a VxLAN flow */ +struct vxlan_tcp6_flow_key { + struct tcp6_flow_key inner_key; + struct rte_vxlan_hdr vxlan_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_vxlan_tcp6_flow { + struct vxlan_tcp6_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_vxlan_tcp6_item { + struct gro_tcp6_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/IPv6 packet) + * reassembly table structure + */ +struct gro_vxlan_tcp6_tbl { + /* item array */ + struct gro_vxlan_tcp6_item *items; + /* flow array */ + struct gro_vxlan_tcp6_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/IPv6 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_vxlan_tcp6_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_vxlan_tcp6_tbl_destroy(void *tbl); + +/** + * This function merges a VxLAN packet which has an outer IPv4 header and + * an inner TCP/IPv6 packet. It does not process the packet, whose TCP + * header has SYN, FIN, RST, PSH, CWR, ECE or URG bit set, or 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. 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_vxlan_tcp6_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan_tcp6_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_vxlan_tcp6_tbl_timeout_flush(struct gro_vxlan_tcp6_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_vxlan_tcp6_tbl_pkt_count(void *tbl); +#endif diff --git a/lib/librte_gro/meson.build b/lib/librte_gro/meson.build index 6143dd0..020e7e8 100644 --- a/lib/librte_gro/meson.build +++ b/lib/librte_gro/meson.build @@ -1,6 +1,6 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c') +sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c') headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c index 86958d5..89fed3c 100644 --- a/lib/librte_gro/rte_gro.c +++ b/lib/librte_gro/rte_gro.c @@ -12,6 +12,7 @@ #include "gro_tcp6.h" #include "gro_udp4.h" #include "gro_vxlan_tcp4.h" +#include "gro_vxlan_tcp6.h" #include "gro_vxlan_udp4.h" typedef void *(*gro_tbl_create_fn)(uint16_t socket_id, @@ -23,15 +24,16 @@ 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_tcp6_tbl_create, gro_vxlan_tcp6_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_vxlan_tcp6_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_vxlan_tcp6_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) && \ @@ -71,6 +73,19 @@ ((ptype & RTE_PTYPE_L4_TCP) == RTE_PTYPE_L4_TCP) && \ (RTE_ETH_IS_TUNNEL_PKT(ptype) == 0)) +#define IS_IPV4_VXLAN_TCP6_PKT(ptype) (RTE_ETH_IS_IPV4_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + ((ptype & RTE_PTYPE_TUNNEL_VXLAN) == \ + RTE_PTYPE_TUNNEL_VXLAN) && \ + ((ptype & RTE_PTYPE_INNER_L4_TCP) == \ + RTE_PTYPE_INNER_L4_TCP) && \ + (((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6_EXT) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN))) + /* * GRO context structure. It keeps the table structures, which are * used to merge packets, for different GRO types. Before using @@ -176,19 +191,25 @@ struct gro_ctx { struct gro_tcp6_flow tcp6_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; struct gro_tcp6_item tcp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} }; + /* Allocate a reassembly table for VXLAN TCP/IPv6 GRO */ + struct gro_vxlan_tcp6_tbl vxlan_tcp6_tbl; + struct gro_vxlan_tcp6_flow vxlan_tcp6_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_vxlan_tcp6_item vxlan_tcp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] + = {{{0}, 0, 0} }; struct rte_mbuf *unprocess_pkts[nb_pkts]; 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_vxlan_tcp6_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | RTE_GRO_IPV4_VXLAN_UDP_IPV4 | RTE_GRO_UDP_IPV4 | - RTE_GRO_TCP_IPV6)) == 0)) + RTE_GRO_TCP_IPV6 | + RTE_GRO_IPV4_VXLAN_TCP_IPV6)) == 0)) return nb_pkts; /* Get the maximum number of packets */ @@ -261,7 +282,18 @@ struct gro_ctx { do_tcp6_gro = 1; } - + if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV6) { + for (i = 0; i < item_num; i++) + vxlan_tcp6_flows[i].start_index = INVALID_ARRAY_INDEX; + + vxlan_tcp6_tbl.flows = vxlan_tcp6_flows; + vxlan_tcp6_tbl.items = vxlan_tcp6_items; + vxlan_tcp6_tbl.flow_num = 0; + vxlan_tcp6_tbl.item_num = 0; + vxlan_tcp6_tbl.max_flow_num = item_num; + vxlan_tcp6_tbl.max_item_num = item_num; + do_vxlan_tcp6_gro = 1; + } for (i = 0; i < nb_pkts; i++) { /* @@ -310,6 +342,15 @@ struct gro_ctx { nb_after_gro--; else if (ret < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV4_VXLAN_TCP6_PKT(pkts[i]->packet_type) && + do_vxlan_tcp6_gro) { + ret = gro_vxlan_tcp6_reassemble(pkts[i], + &vxlan_tcp6_tbl, 0); + if (ret > 0) + /* Merge successfully */ + nb_after_gro--; + else if (ret < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -344,6 +385,11 @@ struct gro_ctx { &pkts[i], nb_pkts - i); } + if (do_vxlan_tcp6_gro) { + i += gro_vxlan_tcp6_tbl_timeout_flush(&vxlan_tcp6_tbl, + 0, &pkts[i], nb_pkts - i); + } + /* Copy unprocessed packets */ if (unprocess_num > 0) { memcpy(&pkts[i], unprocess_pkts, @@ -363,17 +409,19 @@ struct gro_ctx { { struct rte_mbuf *unprocess_pkts[nb_pkts]; 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, + *vxlan_tcp6_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; + do_tcp6_gro, do_vxlan_tcp6_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | RTE_GRO_IPV4_VXLAN_UDP_IPV4 | RTE_GRO_UDP_IPV4 | - RTE_GRO_TCP_IPV6)) == 0)) + RTE_GRO_TCP_IPV6 | + RTE_GRO_IPV4_VXLAN_TCP_IPV6)) == 0)) return nb_pkts; tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX]; @@ -381,6 +429,7 @@ struct gro_ctx { udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX]; vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX]; tcp6_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV6_INDEX]; + vxlan_tcp6_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == RTE_GRO_TCP_IPV4; @@ -392,6 +441,8 @@ struct gro_ctx { RTE_GRO_IPV4_VXLAN_UDP_IPV4; do_tcp6_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV6) == RTE_GRO_TCP_IPV6; + do_vxlan_tcp6_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV6) + == RTE_GRO_IPV4_VXLAN_TCP_IPV6; current_time = rte_rdtsc(); @@ -421,6 +472,11 @@ struct gro_ctx { if (gro_tcp6_reassemble(pkts[i], tcp6_tbl, current_time) < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV4_VXLAN_TCP6_PKT(pkts[i]->packet_type) && + do_vxlan_tcp6_gro) { + if (gro_vxlan_tcp6_reassemble(pkts[i], vxlan_tcp6_tbl, + current_time) < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -483,6 +539,13 @@ struct gro_ctx { num += gro_tcp6_tbl_timeout_flush(gro_ctx->tbls[ RTE_GRO_TCP_IPV6_INDEX], flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV6) && left_nb_out > 0) { + num += gro_vxlan_tcp6_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX], + flush_timestamp, &out[num], left_nb_out); } return num; diff --git a/lib/librte_gro/rte_gro.h b/lib/librte_gro/rte_gro.h index 39b57e8..41a2bec 100644 --- a/lib/librte_gro/rte_gro.h +++ b/lib/librte_gro/rte_gro.h @@ -41,6 +41,9 @@ #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_VXLAN_TCP_IPV6_INDEX 5 +#define RTE_GRO_IPV4_VXLAN_TCP_IPV6 (1ULL << RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX) +/**< IPv4 VxLAN TCP/IPv6 GRO flag. */ /** * Structure used to create GRO context objects or used to pass From patchwork Mon Dec 21 03:50:47 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: yang_y_yi X-Patchwork-Id: 85574 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 1FEB4A09FE; Mon, 21 Dec 2020 04:51:41 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 404E9CB9F; Mon, 21 Dec 2020 04:51:03 +0100 (CET) Received: from mail-m972.mail.163.com (mail-m972.mail.163.com [123.126.97.2]) by dpdk.org (Postfix) with ESMTP id D213ACAE2 for ; Mon, 21 Dec 2020 04:50:57 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id:MIME-Version; bh=akuGC FiRBHgVcGCQmOKA2RA9chWt2RbkWod1Moy3fAk=; b=dt4R1Fqwv860j0Orq5wN6 s7Hp7jvQS+O1NryjsRrJ0d2iHM2MeTPH5uS7o/ojZlDI+gJYmeJtYlOEknttmV0k JJwz2erB/3/DnewFimoHE6sA81kiMYoHjkGnwpfDvnLOLsVR2fRcTGOdX6GDU4Qo RB+cBY2mL77F/45MTwvGAM= Received: from yangyi0100.home.langchao.com (unknown [111.207.123.53]) by smtp2 (Coremail) with SMTP id GtxpCgD3vb6cG+BfUOf7Fw--.755S5; Mon, 21 Dec 2020 11:50:54 +0800 (CST) From: yang_y_yi@163.com To: dev@dpdk.org Cc: jiayu.hu@intel.com, konstantin.ananyev@intel.com, thomas@monjalon.net, yangyi01@inspur.com, yang_y_yi@163.com Date: Mon, 21 Dec 2020 11:50:47 +0800 Message-Id: <20201221035052.128292-4-yang_y_yi@163.com> X-Mailer: git-send-email 2.19.2.windows.1 In-Reply-To: <20201221035052.128292-1-yang_y_yi@163.com> References: <20201221035052.128292-1-yang_y_yi@163.com> MIME-Version: 1.0 X-CM-TRANSID: GtxpCgD3vb6cG+BfUOf7Fw--.755S5 X-Coremail-Antispam: 1Uf129KBjvAXoWfuF4rKFy3Xw1kKrWDXr1kXwb_yoW5CFyUZo WxXw4Ygr1v9r1Yyr40yr1xury2gw18K3ZxAws8Kr48WwnFyrWUJrZ3Ww4fAa17XrWSvF9Y 9wn7Gay7XF42yrZ7n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxU4RwZUUUUU X-Originating-IP: [111.207.123.53] X-CM-SenderInfo: 51dqwsp1b1xqqrwthudrp/1tbiMx4Ci1Xl7k1rgAAAsc Subject: [dpdk-dev] [PATCH v1 3/8] gro: support IPv6 VXLAN TCP/IPv4 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Yi Yang IPv6 VXLAN TCP/IPv4 GRO can help improve TCP/IPv4 performance in IPv6 VXLAN use case. With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM TCP/IPv4 performance, it will merge small adjacent IPv6 VXLAN TCP/IPv4 packets to a big IPv6 VXLAN TCP/IPv4 packet immediate after they are received from a physical NIC. It is very helpful in OVS DPDK IPv6 VXLAN use case. Signed-off-by: Yi Yang --- .../prog_guide/generic_receive_offload_lib.rst | 3 +- doc/guides/rel_notes/release_21_02.rst | 4 + lib/librte_gro/gro_vxlan6_tcp4.c | 507 +++++++++++++++++++++ lib/librte_gro/gro_vxlan6_tcp4.h | 153 +++++++ lib/librte_gro/meson.build | 2 +- lib/librte_gro/rte_gro.c | 86 +++- lib/librte_gro/rte_gro.h | 3 + 7 files changed, 747 insertions(+), 11 deletions(-) create mode 100644 lib/librte_gro/gro_vxlan6_tcp4.c create mode 100644 lib/librte_gro/gro_vxlan6_tcp4.h diff --git a/doc/guides/prog_guide/generic_receive_offload_lib.rst b/doc/guides/prog_guide/generic_receive_offload_lib.rst index ecb5909..a822eaf 100644 --- a/doc/guides/prog_guide/generic_receive_offload_lib.rst +++ b/doc/guides/prog_guide/generic_receive_offload_lib.rst @@ -32,7 +32,8 @@ fragmentation is possible (i.e., DF==0). Additionally, it complies RFC Currently, the GRO library provides GRO supports for TCP/IPv4, UDP/IPv4, and TCP/IPv6 packets as well as VxLAN packets which contain an outer IPv4 -header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 packet. +header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 packet or an outer IPv6 +header and an inner TCP/IPv4 packet. Two Sets of API --------------- diff --git a/doc/guides/rel_notes/release_21_02.rst b/doc/guides/rel_notes/release_21_02.rst index 035d774..3b98915 100644 --- a/doc/guides/rel_notes/release_21_02.rst +++ b/doc/guides/rel_notes/release_21_02.rst @@ -65,6 +65,10 @@ New Features Added TCP/IPv6 GRO support for IPv4 VXLAN packets, this enabled TCP/IPv6 GRO support for IPv4 VXLAN use case. +* **Added TCP/IPv4 GRO support for IPv6 VXLAN packets.** + + Added TCP/IPv4 GRO support for IPv6 VXLAN packets, this enabled TCP/IPv4 + GRO support for IPv6 VXLAN use case. Removed Items ------------- diff --git a/lib/librte_gro/gro_vxlan6_tcp4.c b/lib/librte_gro/gro_vxlan6_tcp4.c new file mode 100644 index 0000000..1e17c1a --- /dev/null +++ b/lib/librte_gro/gro_vxlan6_tcp4.c @@ -0,0 +1,507 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#include +#include +#include +#include +#include + +#include "gro_vxlan6_tcp4.h" + +/* + * Check if two IPv6 address is same. + */ +static inline int rte_is_same_ipv6_addr(const uint8_t *ipv6_a1, + const uint8_t *ipv6_a2) +{ + const uint64_t *w1 = (const uint64_t *)ipv6_a1; + const uint64_t *w2 = (const uint64_t *)ipv6_a2; + + return ((w1[0] ^ w2[0]) | (w1[1] ^ w2[1])) == 0; +} + +/* Copy IPv6 addr */ +static inline void gro_ipv6_addr_copy(const uint8_t *ipv6_from, + uint8_t *ipv6_to) +{ + const uint64_t *from_words = (const uint64_t *)ipv6_from; + uint64_t *to_words = (uint64_t *)ipv6_to; + + to_words[0] = from_words[0]; + to_words[1] = from_words[1]; +} + +void * +gro_vxlan6_tcp4_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_vxlan6_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_VXLAN6_TCP4_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_vxlan6_tcp4_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_vxlan6_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_vxlan6_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_vxlan6_tcp4_tbl_destroy(void *tbl) +{ + struct gro_vxlan6_tcp4_tbl *vxlan6_tbl = tbl; + + if (vxlan6_tbl) { + rte_free(vxlan6_tbl->items); + rte_free(vxlan6_tbl->flows); + } + rte_free(vxlan6_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_vxlan6_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_vxlan6_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_vxlan6_tcp4_tbl *tbl, + struct rte_mbuf *pkt, + uint64_t start_time, + uint32_t prev_idx, + uint32_t sent_seq, + uint16_t ip_id, + 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.ip_id = ip_id; + tbl->items[item_idx].inner_item.nb_merged = 1; + tbl->items[item_idx].inner_item.is_atomic = 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_vxlan6_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_vxlan6_tcp4_tbl *tbl, + struct vxlan6_tcp4_flow_key *src, + uint32_t item_idx) +{ + struct vxlan6_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); + + 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.recv_ack = src->inner_key.recv_ack; + dst->inner_key.src_port = src->inner_key.src_port; + dst->inner_key.dst_port = src->inner_key.dst_port; + + dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags; + dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni; + rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr)); + rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr)); + gro_ipv6_addr_copy(src->outer_ip_saddr, dst->outer_ip_saddr); + gro_ipv6_addr_copy(src->outer_ip_daddr, dst->outer_ip_daddr); + 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_vxlan6_tcp4_flow(struct vxlan6_tcp4_flow_key k1, + struct vxlan6_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) && + rte_is_same_ipv6_addr(k1.outer_ip_saddr, + k2.outer_ip_saddr) && + rte_is_same_ipv6_addr(k1.outer_ip_daddr, + k2.outer_ip_daddr) && + (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) && + is_same_tcp4_flow(k1.inner_key, k2.inner_key)); +} + +static inline int +check_vxlan6_seq_option(struct gro_vxlan6_tcp4_item *item, + struct rte_tcp_hdr *tcp_hdr, + uint32_t sent_seq, + uint16_t ip_id, + uint16_t tcp_hl, + uint16_t tcp_dl, + uint8_t is_atomic) +{ + struct rte_mbuf *pkt = item->inner_item.firstseg; + int cmp; + uint16_t l2_offset; + + 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) + /* Append the new packet. */ + return 1; + else if (cmp < 0) + /* Prepend the new packet. */ + return -1; + + return 0; +} + +static inline int +merge_two_vxlan6_tcp4_packets(struct gro_vxlan6_tcp4_item *item, + struct rte_mbuf *pkt, + int cmp, + uint32_t sent_seq, + uint16_t ip_id) +{ + if (merge_two_tcp4_packets(&item->inner_item, pkt, cmp, sent_seq, + ip_id, pkt->outer_l2_len + + pkt->outer_l3_len)) + return 1; + + return 0; +} + +static inline void +update_vxlan6_header(struct gro_vxlan6_tcp4_item *item) +{ + struct rte_ipv6_hdr *ipv6_hdr; + 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 IPv6 header. */ + len = pkt->pkt_len - pkt->outer_l2_len; + ipv6_hdr = (struct rte_ipv6_hdr *)(rte_pktmbuf_mtod(pkt, char *) + + pkt->outer_l2_len); + ipv6_hdr->payload_len = rte_cpu_to_be_16(len - pkt->outer_l3_len); + + /* Update the outer UDP header. */ + len -= pkt->outer_l3_len; + udp_hdr = (struct rte_udp_hdr *)((char *)ipv6_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_vxlan6_tcp4_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan6_tcp4_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ipv6_hdr *outer_ipv6_hdr; + struct rte_ipv4_hdr *ipv4_hdr; + struct rte_tcp_hdr *tcp_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_vxlan_hdr *vxlan_hdr; + uint32_t sent_seq; + int32_t tcp_dl; + uint16_t frag_off, ip_id; + uint8_t is_atomic; + + struct vxlan6_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_ipv6_hdr = (struct rte_ipv6_hdr *)((char *)outer_eth_hdr + + pkt->outer_l2_len); + udp_hdr = (struct rte_udp_hdr *)((char *)outer_ipv6_hdr + + pkt->outer_l3_len); + vxlan_hdr = (struct rte_vxlan_hdr *)((char *)udp_hdr + + sizeof(struct rte_udp_hdr)); + eth_hdr = (struct rte_ether_hdr *)((char *)vxlan_hdr + + sizeof(struct rte_vxlan_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. + */ + if (pkt->pkt_len <= hdr_len) + return -1; + tcp_dl = pkt->pkt_len - hdr_len; + + /* + * 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(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->s_addr), &(key.inner_key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->d_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.recv_ack = tcp_hdr->recv_ack; + key.inner_key.src_port = tcp_hdr->src_port; + key.inner_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; + rte_ether_addr_copy(&(outer_eth_hdr->s_addr), &(key.outer_eth_saddr)); + rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr)); + gro_ipv6_addr_copy(outer_ipv6_hdr->src_addr, key.outer_ip_saddr); + gro_ipv6_addr_copy(outer_ipv6_hdr->dst_addr, key.outer_ip_daddr); + 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_vxlan6_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, + ip_id, 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_vxlan6_seq_option(&(tbl->items[cur_idx]), tcp_hdr, + sent_seq, ip_id, pkt->l4_len, + tcp_dl, is_atomic); + if (cmp) { + if (merge_two_vxlan6_tcp4_packets( + &(tbl->items[cur_idx]), + pkt, cmp, sent_seq, 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, ip_id, 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, + ip_id, is_atomic) + == INVALID_ARRAY_INDEX) + return -1; + + return 0; +} + +uint16_t +gro_vxlan6_tcp4_tbl_timeout_flush(struct gro_vxlan6_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_vxlan6_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_vxlan6_tcp4_tbl_pkt_count(void *tbl) +{ + struct gro_vxlan6_tcp4_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/librte_gro/gro_vxlan6_tcp4.h b/lib/librte_gro/gro_vxlan6_tcp4.h new file mode 100644 index 0000000..2516429 --- /dev/null +++ b/lib/librte_gro/gro_vxlan6_tcp4.h @@ -0,0 +1,153 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#ifndef _GRO_VXLAN6_TCP4_H_ +#define _GRO_VXLAN6_TCP4_H_ + +#include "gro_tcp4.h" + +#define GRO_VXLAN6_TCP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + +/* Header fields representing a IPv6 VxLAN flow */ +struct vxlan6_tcp4_flow_key { + struct tcp4_flow_key inner_key; + struct rte_vxlan_hdr vxlan_hdr; + + struct rte_ether_addr outer_eth_saddr; + struct rte_ether_addr outer_eth_daddr; + + uint8_t outer_ip_saddr[16]; + uint8_t outer_ip_daddr[16]; + + /* Outer UDP ports */ + uint16_t outer_src_port; + uint16_t outer_dst_port; + +}; + +struct gro_vxlan6_tcp4_flow { + struct vxlan6_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_vxlan6_tcp4_item { + struct gro_tcp4_item inner_item; +}; + +/* + * IPv6 VxLAN (with an outer IPv6 header and an inner TCP/IPv4 packet) + * reassembly table structure + */ +struct gro_vxlan6_tcp4_tbl { + /* item array */ + struct gro_vxlan6_tcp4_item *items; + /* flow array */ + struct gro_vxlan6_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 IPv6 VxLAN reassembly table for IPv6 VxLAN packets + * which have an outer IPv6 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_vxlan6_tcp4_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + +/** + * This function destroys a IPv6 VxLAN reassembly table. + * + * @param tbl + * Pointer pointing to the IPv6 VxLAN reassembly table + */ +void gro_vxlan6_tcp4_tbl_destroy(void *tbl); + +/** + * This function merges a IPv6 VxLAN packet which has an outer IPv6 header and + * an inner TCP/IPv4 packet. It does not process the packet, whose TCP + * header has SYN, FIN, RST, PSH, CWR, ECE or URG bit set, or which + * does not have payload. + * + * This function doesi not check if the packet has correct checksums and + * does not 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 IPv6 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_vxlan6_tcp4_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan6_tcp4_tbl *tbl, + uint64_t start_time); + +/** + * This function flushes timeout packets in the IPv6 VxLAN reassembly table, + * and without updating checksums. + * + * @param tbl + * Pointer pointing to a IPv6 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_vxlan6_tcp4_tbl_timeout_flush(struct gro_vxlan6_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 IPv6 VxLAN + * reassembly table. + * + * @param tbl + * Pointer pointing to the IPv6 VxLAN reassembly table + * + * @return + * The number of packets in the table + */ +uint32_t gro_vxlan6_tcp4_tbl_pkt_count(void *tbl); +#endif diff --git a/lib/librte_gro/meson.build b/lib/librte_gro/meson.build index 020e7e8..994ee06 100644 --- a/lib/librte_gro/meson.build +++ b/lib/librte_gro/meson.build @@ -1,6 +1,6 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c') +sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c') headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c index 89fed3c..12ed3b2 100644 --- a/lib/librte_gro/rte_gro.c +++ b/lib/librte_gro/rte_gro.c @@ -11,6 +11,7 @@ #include "gro_tcp4.h" #include "gro_tcp6.h" #include "gro_udp4.h" +#include "gro_vxlan6_tcp4.h" #include "gro_vxlan_tcp4.h" #include "gro_vxlan_tcp6.h" #include "gro_vxlan_udp4.h" @@ -24,16 +25,18 @@ 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, gro_vxlan_tcp6_tbl_create, NULL}; + gro_tcp6_tbl_create, gro_vxlan_tcp6_tbl_create, + gro_vxlan6_tcp4_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, gro_vxlan_tcp6_tbl_destroy, NULL}; + gro_tcp6_tbl_destroy, gro_vxlan_tcp6_tbl_destroy, + gro_vxlan6_tcp4_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, gro_vxlan_tcp6_tbl_pkt_count, - NULL}; + gro_vxlan6_tcp4_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) && \ @@ -86,6 +89,19 @@ ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN))) +#define IS_IPV6_VXLAN_TCP4_PKT(ptype) (RTE_ETH_IS_IPV6_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + ((ptype & RTE_PTYPE_TUNNEL_VXLAN) == \ + RTE_PTYPE_TUNNEL_VXLAN) && \ + ((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 @@ -174,7 +190,7 @@ struct gro_ctx { struct gro_udp4_flow udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} }; - /* Allocate a reassembly table for VXLAN TCP GRO */ + /* Allocate a reassembly table for IPv4 VXLAN TCP/IPv4 GRO */ struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl; struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM] @@ -197,19 +213,28 @@ struct gro_ctx { struct gro_vxlan_tcp6_item vxlan_tcp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}, 0, 0} }; + /* Allocate a reassembly table for IPv6 VXLAN TCP/IPv4 GRO */ + struct gro_vxlan6_tcp4_tbl vxlan6_tcp4_tbl; + struct gro_vxlan6_tcp4_flow + vxlan6_tcp4_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_vxlan6_tcp4_item + vxlan6_tcp4_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + struct rte_mbuf *unprocess_pkts[nb_pkts]; 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_tcp6_gro = 0; + do_vxlan_udp_gro = 0, do_tcp6_gro = 0, do_vxlan_tcp6_gro = 0, + do_vxlan6_tcp4_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | RTE_GRO_IPV4_VXLAN_UDP_IPV4 | RTE_GRO_UDP_IPV4 | RTE_GRO_TCP_IPV6 | - RTE_GRO_IPV4_VXLAN_TCP_IPV6)) == 0)) + RTE_GRO_IPV4_VXLAN_TCP_IPV6 | + RTE_GRO_IPV6_VXLAN_TCP_IPV4)) == 0)) return nb_pkts; /* Get the maximum number of packets */ @@ -295,6 +320,19 @@ struct gro_ctx { do_vxlan_tcp6_gro = 1; } + if (param->gro_types & RTE_GRO_IPV6_VXLAN_TCP_IPV4) { + for (i = 0; i < item_num; i++) + vxlan6_tcp4_flows[i].start_index = INVALID_ARRAY_INDEX; + + vxlan6_tcp4_tbl.flows = vxlan6_tcp4_flows; + vxlan6_tcp4_tbl.items = vxlan6_tcp4_items; + vxlan6_tcp4_tbl.flow_num = 0; + vxlan6_tcp4_tbl.item_num = 0; + vxlan6_tcp4_tbl.max_flow_num = item_num; + vxlan6_tcp4_tbl.max_item_num = item_num; + do_vxlan6_tcp4_gro = 1; + } + for (i = 0; i < nb_pkts; i++) { /* * The timestamp is ignored, since all packets @@ -351,6 +389,15 @@ struct gro_ctx { nb_after_gro--; else if (ret < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_VXLAN_TCP4_PKT(pkts[i]->packet_type) && + do_vxlan6_tcp4_gro) { + ret = gro_vxlan6_tcp4_reassemble(pkts[i], + &vxlan6_tcp4_tbl, 0); + if (ret > 0) + /* Merge successfully */ + nb_after_gro--; + else if (ret < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -390,6 +437,11 @@ struct gro_ctx { 0, &pkts[i], nb_pkts - i); } + if (do_vxlan6_tcp4_gro) { + i += gro_vxlan6_tcp4_tbl_timeout_flush(&vxlan6_tcp4_tbl, + 0, &pkts[i], nb_pkts - i); + } + /* Copy unprocessed packets */ if (unprocess_num > 0) { memcpy(&pkts[i], unprocess_pkts, @@ -410,18 +462,19 @@ struct gro_ctx { struct rte_mbuf *unprocess_pkts[nb_pkts]; struct gro_ctx *gro_ctx = ctx; void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_tbl, - *vxlan_tcp6_tbl; + *vxlan_tcp6_tbl, *vxlan6_tcp4_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, do_vxlan_tcp6_gro; + do_tcp6_gro, do_vxlan_tcp6_gro, do_vxlan6_tcp4_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | RTE_GRO_IPV4_VXLAN_UDP_IPV4 | RTE_GRO_UDP_IPV4 | RTE_GRO_TCP_IPV6 | - RTE_GRO_IPV4_VXLAN_TCP_IPV6)) == 0)) + RTE_GRO_IPV4_VXLAN_TCP_IPV6 | + RTE_GRO_IPV6_VXLAN_TCP_IPV4)) == 0)) return nb_pkts; tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX]; @@ -430,6 +483,7 @@ struct gro_ctx { vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX]; tcp6_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV6_INDEX]; vxlan_tcp6_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX]; + vxlan6_tcp4_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == RTE_GRO_TCP_IPV4; @@ -443,6 +497,8 @@ struct gro_ctx { RTE_GRO_TCP_IPV6; do_vxlan_tcp6_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV6) == RTE_GRO_IPV4_VXLAN_TCP_IPV6; + do_vxlan6_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_IPV6_VXLAN_TCP_IPV4) + == RTE_GRO_IPV6_VXLAN_TCP_IPV4; current_time = rte_rdtsc(); @@ -477,6 +533,11 @@ struct gro_ctx { if (gro_vxlan_tcp6_reassemble(pkts[i], vxlan_tcp6_tbl, current_time) < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_VXLAN_TCP4_PKT(pkts[i]->packet_type) && + do_vxlan6_tcp4_gro) { + if (gro_vxlan6_tcp4_reassemble(pkts[i], vxlan6_tcp4_tbl, + current_time) < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -546,6 +607,13 @@ struct gro_ctx { num += gro_vxlan_tcp6_tbl_timeout_flush(gro_ctx->tbls[ RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX], flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_IPV6_VXLAN_TCP_IPV4) && left_nb_out > 0) { + num += gro_vxlan6_tcp4_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX], + flush_timestamp, &out[num], left_nb_out); } return num; diff --git a/lib/librte_gro/rte_gro.h b/lib/librte_gro/rte_gro.h index 41a2bec..2949980 100644 --- a/lib/librte_gro/rte_gro.h +++ b/lib/librte_gro/rte_gro.h @@ -44,6 +44,9 @@ #define RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX 5 #define RTE_GRO_IPV4_VXLAN_TCP_IPV6 (1ULL << RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX) /**< IPv4 VxLAN TCP/IPv6 GRO flag. */ +#define RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX 6 +#define RTE_GRO_IPV6_VXLAN_TCP_IPV4 (1ULL << RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX) +/**< IPv6 VxLAN TCP/IPv4 GRO flag. */ /** * Structure used to create GRO context objects or used to pass From patchwork Mon Dec 21 03:50:48 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: yang_y_yi X-Patchwork-Id: 85578 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id EF05CA09FE; Mon, 21 Dec 2020 04:53:10 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 83015CCB1; Mon, 21 Dec 2020 04:51:10 +0100 (CET) Received: from mail-m972.mail.163.com (mail-m972.mail.163.com [123.126.97.2]) by dpdk.org (Postfix) with ESMTP id BA146CACF for ; Mon, 21 Dec 2020 04:50:58 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id:MIME-Version; bh=16387 SI341k4rXlqRJEqR8AQJPRQv/T4A4ZBoldeSTI=; b=nLWSAnMic4fxavHnVDVS4 S0IC1ssqgkUi2QbWgpQI/7F8eF05CtIUmp4OQWKU3UsmZ36BqHYJv2OqTgJbjoGJ /iDX2rL48nzKaNlXqgb7EpF0nWrKk3P7VUJb+TescjqIJZvEuizgUX8oP5rX6z65 gl/zqCgcIQwLMLkFmAdBYc= Received: from yangyi0100.home.langchao.com (unknown [111.207.123.53]) by smtp2 (Coremail) with SMTP id GtxpCgD3vb6cG+BfUOf7Fw--.755S6; Mon, 21 Dec 2020 11:50:55 +0800 (CST) From: yang_y_yi@163.com To: dev@dpdk.org Cc: jiayu.hu@intel.com, konstantin.ananyev@intel.com, thomas@monjalon.net, yangyi01@inspur.com, yang_y_yi@163.com Date: Mon, 21 Dec 2020 11:50:48 +0800 Message-Id: <20201221035052.128292-5-yang_y_yi@163.com> X-Mailer: git-send-email 2.19.2.windows.1 In-Reply-To: <20201221035052.128292-1-yang_y_yi@163.com> References: <20201221035052.128292-1-yang_y_yi@163.com> MIME-Version: 1.0 X-CM-TRANSID: GtxpCgD3vb6cG+BfUOf7Fw--.755S6 X-Coremail-Antispam: 1Uf129KBjvAXoWfCFyxWFyfJFyUAryxuw45Jrb_yoW5AF1Uto WxXw4Ygr109r1Yyr4jyr1xuryjgw10ganxArs8KrW8WwsFyrWUJrZ3Ww4fAa17X3ySyF95 uwn7Gay7ZF4Iyrs7n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxUOnmRDUUUU X-Originating-IP: [111.207.123.53] X-CM-SenderInfo: 51dqwsp1b1xqqrwthudrp/1tbiFh8Ci144OkMuygAAs7 Subject: [dpdk-dev] [PATCH v1 4/8] gro: support IPv6 VXLAN TCP/IPv6 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Yi Yang IPv6 VXLAN TCP/IPv6 GRO can help improve TCP/IPv6 performance in IPv6 VXLAN use case. With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM TCP/IPv6 performance, it will merge small adjacent IPv6 VXLAN TCP/IPv6 packets to a big IPv6 VXLAN TCP/IPv6 packet immediate after they are received from a physical NIC. It is very helpful in OVS DPDK IPv6 VXLAN use case. Signed-off-by: Yi Yang --- .../prog_guide/generic_receive_offload_lib.rst | 2 +- doc/guides/rel_notes/release_21_02.rst | 5 + lib/librte_gro/gro_vxlan6_tcp6.c | 464 +++++++++++++++++++++ lib/librte_gro/gro_vxlan6_tcp6.h | 153 +++++++ lib/librte_gro/meson.build | 2 +- lib/librte_gro/rte_gro.c | 87 +++- lib/librte_gro/rte_gro.h | 3 + 7 files changed, 706 insertions(+), 10 deletions(-) create mode 100644 lib/librte_gro/gro_vxlan6_tcp6.c create mode 100644 lib/librte_gro/gro_vxlan6_tcp6.h diff --git a/doc/guides/prog_guide/generic_receive_offload_lib.rst b/doc/guides/prog_guide/generic_receive_offload_lib.rst index a822eaf..0efade3 100644 --- a/doc/guides/prog_guide/generic_receive_offload_lib.rst +++ b/doc/guides/prog_guide/generic_receive_offload_lib.rst @@ -33,7 +33,7 @@ fragmentation is possible (i.e., DF==0). Additionally, it complies RFC Currently, the GRO library provides GRO supports for TCP/IPv4, UDP/IPv4, and TCP/IPv6 packets as well as VxLAN packets which contain an outer IPv4 header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 packet or an outer IPv6 -header and an inner TCP/IPv4 packet. +header and an inner TCP/IPv4 or TCP/IPv6 packet. Two Sets of API --------------- diff --git a/doc/guides/rel_notes/release_21_02.rst b/doc/guides/rel_notes/release_21_02.rst index 3b98915..a5bc2f1 100644 --- a/doc/guides/rel_notes/release_21_02.rst +++ b/doc/guides/rel_notes/release_21_02.rst @@ -70,6 +70,11 @@ New Features Added TCP/IPv4 GRO support for IPv6 VXLAN packets, this enabled TCP/IPv4 GRO support for IPv6 VXLAN use case. +* **Added TCP/IPv6 GRO support for IPv6 VXLAN packets.** + + Added TCP/IPv6 GRO support for IPv6 VXLAN packets, this enabled TCP/IPv6 + GRO support for IPv6 VXLAN use case. + Removed Items ------------- diff --git a/lib/librte_gro/gro_vxlan6_tcp6.c b/lib/librte_gro/gro_vxlan6_tcp6.c new file mode 100644 index 0000000..5b9dee4 --- /dev/null +++ b/lib/librte_gro/gro_vxlan6_tcp6.c @@ -0,0 +1,464 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#include +#include +#include +#include +#include + +#include "gro_vxlan6_tcp6.h" + +void * +gro_vxlan6_tcp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_vxlan6_tcp6_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_VXLAN6_TCP6_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_vxlan6_tcp6_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_vxlan6_tcp6_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_vxlan6_tcp6_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_vxlan6_tcp6_tbl_destroy(void *tbl) +{ + struct gro_vxlan6_tcp6_tbl *vxlan6_tbl = tbl; + + if (vxlan6_tbl) { + rte_free(vxlan6_tbl->items); + rte_free(vxlan6_tbl->flows); + } + rte_free(vxlan6_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_vxlan6_tcp6_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_vxlan6_tcp6_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_vxlan6_tcp6_tbl *tbl, + struct rte_mbuf *pkt, + uint64_t start_time, + uint32_t prev_idx, + uint32_t sent_seq) +{ + 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.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_vxlan6_tcp6_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_vxlan6_tcp6_tbl *tbl, + struct vxlan6_tcp6_flow_key *src, + uint32_t item_idx) +{ + struct vxlan6_tcp6_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)); + gro_ipv6_addr_copy(src->inner_key.ip_saddr, dst->inner_key.ip_saddr); + gro_ipv6_addr_copy(src->inner_key.ip_daddr, dst->inner_key.ip_daddr); + dst->inner_key.recv_ack = src->inner_key.recv_ack; + dst->inner_key.src_port = src->inner_key.src_port; + dst->inner_key.dst_port = src->inner_key.dst_port; + + dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags; + dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni; + rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr)); + rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr)); + gro_ipv6_addr_copy(src->outer_ip_saddr, dst->outer_ip_saddr); + gro_ipv6_addr_copy(src->outer_ip_daddr, dst->outer_ip_daddr); + 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_vxlan6_tcp6_flow(struct vxlan6_tcp6_flow_key k1, + struct vxlan6_tcp6_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) && + rte_is_same_ipv6_addr(k1.outer_ip_saddr, + k2.outer_ip_saddr) && + rte_is_same_ipv6_addr(k1.outer_ip_daddr, + k2.outer_ip_daddr) && + (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) && + is_same_tcp6_flow(k1.inner_key, k2.inner_key)); +} + +static inline int +check_vxlan_seq_option_v6(struct gro_vxlan6_tcp6_item *item, + struct rte_tcp_hdr *tcp_hdr, + uint32_t sent_seq, + uint16_t tcp_hl, + uint16_t tcp_dl) +{ + struct rte_mbuf *pkt = item->inner_item.firstseg; + int cmp; + uint16_t l2_offset; + + l2_offset = pkt->outer_l2_len + pkt->outer_l3_len; + cmp = check_seq_option_v6(&item->inner_item, tcp_hdr, sent_seq, + tcp_hl, tcp_dl, l2_offset); + if (cmp > 0) + /* Append the new packet. */ + return 1; + else if (cmp < 0) + /* Prepend the new packet. */ + return -1; + + return 0; +} + +static inline int +merge_two_vxlan6_tcp6_packets(struct gro_vxlan6_tcp6_item *item, + struct rte_mbuf *pkt, + int cmp, + uint32_t sent_seq) +{ + if (merge_two_tcp6_packets(&item->inner_item, pkt, cmp, sent_seq, + pkt->outer_l2_len + + pkt->outer_l3_len)) + return 1; + + return 0; +} + +static inline void +update_vxlan6_header(struct gro_vxlan6_tcp6_item *item) +{ + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_mbuf *pkt = item->inner_item.firstseg; + uint16_t len; + + /* Update the outer IPv6 header. */ + len = pkt->pkt_len - pkt->outer_l2_len; + ipv6_hdr = (struct rte_ipv6_hdr *)(rte_pktmbuf_mtod(pkt, char *) + + pkt->outer_l2_len); + ipv6_hdr->payload_len = rte_cpu_to_be_16(len - pkt->outer_l3_len); + + /* Update the outer UDP header. */ + len -= pkt->outer_l3_len; + udp_hdr = (struct rte_udp_hdr *)((char *)ipv6_hdr + pkt->outer_l3_len); + udp_hdr->dgram_len = rte_cpu_to_be_16(len); + + /* Update the inner IPv6 header. */ + len -= pkt->l2_len; + ipv6_hdr = (struct rte_ipv6_hdr *)((char *)udp_hdr + pkt->l2_len); + /* IPv6 payload_len does not include IPv6 header. */ + ipv6_hdr->payload_len = rte_cpu_to_be_16(len - pkt->l3_len); +} + +int32_t +gro_vxlan6_tcp6_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan6_tcp6_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ipv6_hdr *outer_ipv6_hdr; + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_tcp_hdr *tcp_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_vxlan_hdr *vxlan_hdr; + uint32_t sent_seq; + int32_t tcp_dl; + + struct vxlan6_tcp6_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_ipv6_hdr = (struct rte_ipv6_hdr *)((char *)outer_eth_hdr + + pkt->outer_l2_len); + udp_hdr = (struct rte_udp_hdr *)((char *)outer_ipv6_hdr + + pkt->outer_l3_len); + vxlan_hdr = (struct rte_vxlan_hdr *)((char *)udp_hdr + + sizeof(struct rte_udp_hdr)); + eth_hdr = (struct rte_ether_hdr *)((char *)vxlan_hdr + + sizeof(struct rte_vxlan_hdr)); + ipv6_hdr = (struct rte_ipv6_hdr *)((char *)udp_hdr + pkt->l2_len); + tcp_hdr = (struct rte_tcp_hdr *)((char *)ipv6_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. + */ + if (pkt->pkt_len <= hdr_len) + return -1; + tcp_dl = pkt->pkt_len - hdr_len; + + sent_seq = rte_be_to_cpu_32(tcp_hdr->sent_seq); + + rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.inner_key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.inner_key.eth_daddr)); + gro_ipv6_addr_copy(ipv6_hdr->src_addr, key.inner_key.ip_saddr); + gro_ipv6_addr_copy(ipv6_hdr->dst_addr, key.inner_key.ip_daddr); + key.inner_key.recv_ack = tcp_hdr->recv_ack; + key.inner_key.src_port = tcp_hdr->src_port; + key.inner_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; + rte_ether_addr_copy(&(outer_eth_hdr->s_addr), &(key.outer_eth_saddr)); + rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr)); + gro_ipv6_addr_copy(outer_ipv6_hdr->src_addr, key.outer_ip_saddr); + gro_ipv6_addr_copy(outer_ipv6_hdr->dst_addr, key.outer_ip_daddr); + 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_vxlan6_tcp6_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); + 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_vxlan_seq_option_v6(&(tbl->items[cur_idx]), tcp_hdr, + sent_seq, pkt->l4_len, tcp_dl); + if (cmp) { + if (merge_two_vxlan6_tcp6_packets( + &(tbl->items[cur_idx]), + pkt, cmp, sent_seq)) + 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) == + 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 + ) == INVALID_ARRAY_INDEX) + return -1; + + return 0; +} + +uint16_t +gro_vxlan6_tcp6_tbl_timeout_flush(struct gro_vxlan6_tcp6_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_vxlan6_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_vxlan6_tcp6_tbl_pkt_count(void *tbl) +{ + struct gro_vxlan6_tcp6_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/librte_gro/gro_vxlan6_tcp6.h b/lib/librte_gro/gro_vxlan6_tcp6.h new file mode 100644 index 0000000..0659ae4 --- /dev/null +++ b/lib/librte_gro/gro_vxlan6_tcp6.h @@ -0,0 +1,153 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#ifndef _GRO_VXLAN6_TCP6_H_ +#define _GRO_VXLAN6_TCP6_H_ + +#include "gro_tcp6.h" + +#define GRO_VXLAN6_TCP6_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + +/* Header fields representing a IPv6 VxLAN flow */ +struct vxlan6_tcp6_flow_key { + struct tcp6_flow_key inner_key; + struct rte_vxlan_hdr vxlan_hdr; + + struct rte_ether_addr outer_eth_saddr; + struct rte_ether_addr outer_eth_daddr; + + uint8_t outer_ip_saddr[16]; + uint8_t outer_ip_daddr[16]; + + /* Outer UDP ports */ + uint16_t outer_src_port; + uint16_t outer_dst_port; + +}; + +struct gro_vxlan6_tcp6_flow { + struct vxlan6_tcp6_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_vxlan6_tcp6_item { + struct gro_tcp6_item inner_item; +}; + +/* + * IPv6 VxLAN (with an outer IPv6 header and an inner TCP/IPv6 packet) + * reassembly table structure + */ +struct gro_vxlan6_tcp6_tbl { + /* item array */ + struct gro_vxlan6_tcp6_item *items; + /* flow array */ + struct gro_vxlan6_tcp6_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 IPv6 VxLAN reassembly table for IPv6 VxLAN packets + * which have an outer IPv6 header and an inner TCP/IPv6 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_vxlan6_tcp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + +/** + * This function destroys a IPv6 VxLAN reassembly table. + * + * @param tbl + * Pointer pointing to the IPv6 VxLAN reassembly table + */ +void gro_vxlan6_tcp6_tbl_destroy(void *tbl); + +/** + * This function merges a IPv6 VxLAN packet which has an outer IPv6 header and + * an inner TCP/IPv6 packet. It does not process the packet, whose TCP + * header has SYN, FIN, RST, PSH, CWR, ECE or URG bit set, or 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. 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 IPv6 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_vxlan6_tcp6_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan6_tcp6_tbl *tbl, + uint64_t start_time); + +/** + * This function flushes timeout packets in the IPv6 VxLAN reassembly table, + * and without updating checksums. + * + * @param tbl + * Pointer pointing to a IPv6 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_vxlan6_tcp6_tbl_timeout_flush(struct gro_vxlan6_tcp6_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out); + +/** + * This function returns the number of the packets in a IPv6 VxLAN + * reassembly table. + * + * @param tbl + * Pointer pointing to the IPv6 VxLAN reassembly table + * + * @return + * The number of packets in the table + */ +uint32_t gro_vxlan6_tcp6_tbl_pkt_count(void *tbl); +#endif diff --git a/lib/librte_gro/meson.build b/lib/librte_gro/meson.build index 994ee06..3eff89c 100644 --- a/lib/librte_gro/meson.build +++ b/lib/librte_gro/meson.build @@ -1,6 +1,6 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c') +sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c') headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c index 12ed3b2..0c5584e 100644 --- a/lib/librte_gro/rte_gro.c +++ b/lib/librte_gro/rte_gro.c @@ -12,6 +12,7 @@ #include "gro_tcp6.h" #include "gro_udp4.h" #include "gro_vxlan6_tcp4.h" +#include "gro_vxlan6_tcp6.h" #include "gro_vxlan_tcp4.h" #include "gro_vxlan_tcp6.h" #include "gro_vxlan_udp4.h" @@ -26,17 +27,22 @@ gro_tcp4_tbl_create, gro_vxlan_tcp4_tbl_create, gro_udp4_tbl_create, gro_vxlan_udp4_tbl_create, gro_tcp6_tbl_create, gro_vxlan_tcp6_tbl_create, - gro_vxlan6_tcp4_tbl_create, NULL}; + gro_vxlan6_tcp4_tbl_create, gro_vxlan6_tcp6_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, gro_vxlan_tcp6_tbl_destroy, - gro_vxlan6_tcp4_tbl_destroy, NULL}; + gro_vxlan6_tcp4_tbl_destroy, + gro_vxlan6_tcp6_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, gro_vxlan_tcp6_tbl_pkt_count, - gro_vxlan6_tcp4_tbl_pkt_count, NULL}; + gro_vxlan6_tcp4_tbl_pkt_count, + gro_vxlan6_tcp6_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) && \ @@ -102,6 +108,19 @@ ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN))) +#define IS_IPV6_VXLAN_TCP6_PKT(ptype) (RTE_ETH_IS_IPV6_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + ((ptype & RTE_PTYPE_TUNNEL_VXLAN) == \ + RTE_PTYPE_TUNNEL_VXLAN) && \ + ((ptype & RTE_PTYPE_INNER_L4_TCP) == \ + RTE_PTYPE_INNER_L4_TCP) && \ + (((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6_EXT) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN))) + /* * GRO context structure. It keeps the table structures, which are * used to merge packets, for different GRO types. Before using @@ -220,13 +239,20 @@ struct gro_ctx { struct gro_vxlan6_tcp4_item vxlan6_tcp4_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + /* Allocate a reassembly table for IPv6 VXLAN TCP/IPv6 GRO */ + struct gro_vxlan6_tcp6_tbl vxlan6_tcp6_tbl; + struct gro_vxlan6_tcp6_flow + vxlan6_tcp6_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_vxlan6_tcp6_item + vxlan6_tcp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + struct rte_mbuf *unprocess_pkts[nb_pkts]; 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_tcp6_gro = 0, - do_vxlan6_tcp4_gro = 0; + do_vxlan6_tcp4_gro = 0, do_vxlan6_tcp6_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -234,7 +260,8 @@ struct gro_ctx { RTE_GRO_UDP_IPV4 | RTE_GRO_TCP_IPV6 | RTE_GRO_IPV4_VXLAN_TCP_IPV6 | - RTE_GRO_IPV6_VXLAN_TCP_IPV4)) == 0)) + RTE_GRO_IPV6_VXLAN_TCP_IPV4 | + RTE_GRO_IPV6_VXLAN_TCP_IPV6)) == 0)) return nb_pkts; /* Get the maximum number of packets */ @@ -333,6 +360,19 @@ struct gro_ctx { do_vxlan6_tcp4_gro = 1; } + if (param->gro_types & RTE_GRO_IPV6_VXLAN_TCP_IPV6) { + for (i = 0; i < item_num; i++) + vxlan6_tcp6_flows[i].start_index = INVALID_ARRAY_INDEX; + + vxlan6_tcp6_tbl.flows = vxlan6_tcp6_flows; + vxlan6_tcp6_tbl.items = vxlan6_tcp6_items; + vxlan6_tcp6_tbl.flow_num = 0; + vxlan6_tcp6_tbl.item_num = 0; + vxlan6_tcp6_tbl.max_flow_num = item_num; + vxlan6_tcp6_tbl.max_item_num = item_num; + do_vxlan6_tcp6_gro = 1; + } + for (i = 0; i < nb_pkts; i++) { /* * The timestamp is ignored, since all packets @@ -398,6 +438,15 @@ struct gro_ctx { nb_after_gro--; else if (ret < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_VXLAN_TCP6_PKT(pkts[i]->packet_type) && + do_vxlan6_tcp6_gro) { + ret = gro_vxlan6_tcp6_reassemble(pkts[i], + &vxlan6_tcp6_tbl, 0); + if (ret > 0) + /* Merge successfully */ + nb_after_gro--; + else if (ret < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -442,6 +491,11 @@ struct gro_ctx { 0, &pkts[i], nb_pkts - i); } + if (do_vxlan6_tcp6_gro) { + i += gro_vxlan6_tcp6_tbl_timeout_flush(&vxlan6_tcp6_tbl, + 0, &pkts[i], nb_pkts - i); + } + /* Copy unprocessed packets */ if (unprocess_num > 0) { memcpy(&pkts[i], unprocess_pkts, @@ -462,11 +516,12 @@ struct gro_ctx { struct rte_mbuf *unprocess_pkts[nb_pkts]; struct gro_ctx *gro_ctx = ctx; void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_tbl, - *vxlan_tcp6_tbl, *vxlan6_tcp4_tbl; + *vxlan_tcp6_tbl, *vxlan6_tcp4_tbl, *vxlan6_tcp6_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, do_vxlan_tcp6_gro, do_vxlan6_tcp4_gro; + do_tcp6_gro, do_vxlan_tcp6_gro, do_vxlan6_tcp4_gro, + do_vxlan6_tcp6_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -474,7 +529,8 @@ struct gro_ctx { RTE_GRO_UDP_IPV4 | RTE_GRO_TCP_IPV6 | RTE_GRO_IPV4_VXLAN_TCP_IPV6 | - RTE_GRO_IPV6_VXLAN_TCP_IPV4)) == 0)) + RTE_GRO_IPV6_VXLAN_TCP_IPV4 | + RTE_GRO_IPV6_VXLAN_TCP_IPV6)) == 0)) return nb_pkts; tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX]; @@ -484,6 +540,7 @@ struct gro_ctx { tcp6_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV6_INDEX]; vxlan_tcp6_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX]; vxlan6_tcp4_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX]; + vxlan6_tcp6_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == RTE_GRO_TCP_IPV4; @@ -499,6 +556,8 @@ struct gro_ctx { == RTE_GRO_IPV4_VXLAN_TCP_IPV6; do_vxlan6_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_IPV6_VXLAN_TCP_IPV4) == RTE_GRO_IPV6_VXLAN_TCP_IPV4; + do_vxlan6_tcp6_gro = (gro_ctx->gro_types & RTE_GRO_IPV6_VXLAN_TCP_IPV6) + == RTE_GRO_IPV6_VXLAN_TCP_IPV6; current_time = rte_rdtsc(); @@ -538,6 +597,11 @@ struct gro_ctx { if (gro_vxlan6_tcp4_reassemble(pkts[i], vxlan6_tcp4_tbl, current_time) < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_VXLAN_TCP6_PKT(pkts[i]->packet_type) && + do_vxlan6_tcp6_gro) { + if (gro_vxlan6_tcp6_reassemble(pkts[i], vxlan6_tcp6_tbl, + current_time) < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -614,6 +678,13 @@ struct gro_ctx { num += gro_vxlan6_tcp4_tbl_timeout_flush(gro_ctx->tbls[ RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX], flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_IPV6_VXLAN_TCP_IPV6) && left_nb_out > 0) { + num += gro_vxlan6_tcp6_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX], + flush_timestamp, &out[num], left_nb_out); } return num; diff --git a/lib/librte_gro/rte_gro.h b/lib/librte_gro/rte_gro.h index 2949980..cb0895f 100644 --- a/lib/librte_gro/rte_gro.h +++ b/lib/librte_gro/rte_gro.h @@ -47,6 +47,9 @@ #define RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX 6 #define RTE_GRO_IPV6_VXLAN_TCP_IPV4 (1ULL << RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX) /**< IPv6 VxLAN TCP/IPv4 GRO flag. */ +#define RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX 7 +#define RTE_GRO_IPV6_VXLAN_TCP_IPV6 (1ULL << RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX) +/**< IPv6 VxLAN TCP/IPv6 GRO flag. */ /** * Structure used to create GRO context objects or used to pass From patchwork Mon Dec 21 03:50:49 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: yang_y_yi X-Patchwork-Id: 85576 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 1B4E8A09FE; Mon, 21 Dec 2020 04:52:34 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 5E4D1CC75; Mon, 21 Dec 2020 04:51:07 +0100 (CET) Received: from mail-m972.mail.163.com (mail-m972.mail.163.com [123.126.97.2]) by dpdk.org (Postfix) with ESMTP id 67C9DCB6B for ; Mon, 21 Dec 2020 04:50:58 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id:MIME-Version; bh=vjlXp HUzR8iTXdbxTtbws6oZ4WZKAtfF3iWE9R0j7+U=; b=YnM0IVVVLiriFYo+gCWMj V0pUOm5yMfUfHmhzjTGwu8zUxL9cV2WLlNaH5zZZOXaBGvI2eHMsUvcFbZhy0l9Z jkvXwGXRdRjqBBrywyPxMDsuyYWO2YWlzKdK5IFd9PU6QUGONIb0gohXHKvSUfIz isaPtfg/0rJvKzY9ur8T0E= Received: from yangyi0100.home.langchao.com (unknown [111.207.123.53]) by smtp2 (Coremail) with SMTP id GtxpCgD3vb6cG+BfUOf7Fw--.755S7; Mon, 21 Dec 2020 11:50:55 +0800 (CST) From: yang_y_yi@163.com To: dev@dpdk.org Cc: jiayu.hu@intel.com, konstantin.ananyev@intel.com, thomas@monjalon.net, yangyi01@inspur.com, yang_y_yi@163.com Date: Mon, 21 Dec 2020 11:50:49 +0800 Message-Id: <20201221035052.128292-6-yang_y_yi@163.com> X-Mailer: git-send-email 2.19.2.windows.1 In-Reply-To: <20201221035052.128292-1-yang_y_yi@163.com> References: <20201221035052.128292-1-yang_y_yi@163.com> MIME-Version: 1.0 X-CM-TRANSID: GtxpCgD3vb6cG+BfUOf7Fw--.755S7 X-Coremail-Antispam: 1Uf129KBjvAXoWfuF4rKF43Wr1xAw1kXw1fZwb_yoW5CFW5Zo WxZws8Gryv9r1jvr40yF1kWryIgw18Kw47Zws0gr4vgws7ZrWUK393Ww43Aa17XrWaqFZY v397Zay7XF4fAFZxn29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxUO89MUUUUU X-Originating-IP: [111.207.123.53] X-CM-SenderInfo: 51dqwsp1b1xqqrwthudrp/1tbiqB8Ci1c7TJYYwQAAsR Subject: [dpdk-dev] [PATCH v1 5/8] gro: support UDP/IPv6 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Yi Yang UDP/IPv6 GRO can help improve UDP/IPv6 performance. With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP/IPv6 performance, it will merge small adjacent UDP/IPv6 fragments to a big UDP/IPv6 packet immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VLAN use case. Signed-off-by: Yi Yang --- .../prog_guide/generic_receive_offload_lib.rst | 6 +- doc/guides/rel_notes/release_21_02.rst | 5 + lib/librte_gro/gro_udp6.c | 487 +++++++++++++++++++++ lib/librte_gro/gro_udp6.h | 284 ++++++++++++ lib/librte_gro/meson.build | 2 +- lib/librte_gro/rte_gro.c | 72 ++- lib/librte_gro/rte_gro.h | 3 + 7 files changed, 847 insertions(+), 12 deletions(-) create mode 100644 lib/librte_gro/gro_udp6.c create mode 100644 lib/librte_gro/gro_udp6.h diff --git a/doc/guides/prog_guide/generic_receive_offload_lib.rst b/doc/guides/prog_guide/generic_receive_offload_lib.rst index 0efade3..0ea3076 100644 --- a/doc/guides/prog_guide/generic_receive_offload_lib.rst +++ b/doc/guides/prog_guide/generic_receive_offload_lib.rst @@ -31,9 +31,9 @@ fragmentation is possible (i.e., DF==0). Additionally, it complies RFC 6864 to process the IPv4 ID field. Currently, the GRO library provides GRO supports for TCP/IPv4, UDP/IPv4, -and TCP/IPv6 packets as well as VxLAN packets which contain an outer IPv4 -header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 packet or an outer IPv6 -header and an inner TCP/IPv4 or TCP/IPv6 packet. +UDP/IPv6, and TCP/IPv6 packets as well as VxLAN packets which contain an +outer IPv4 header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 packet or +an outer IPv6 header and an inner TCP/IPv4 or TCP/IPv6 packet. Two Sets of API --------------- diff --git a/doc/guides/rel_notes/release_21_02.rst b/doc/guides/rel_notes/release_21_02.rst index a5bc2f1..d8974b7 100644 --- a/doc/guides/rel_notes/release_21_02.rst +++ b/doc/guides/rel_notes/release_21_02.rst @@ -75,6 +75,11 @@ New Features Added TCP/IPv6 GRO support for IPv6 VXLAN packets, this enabled TCP/IPv6 GRO support for IPv6 VXLAN use case. +* **Added UDP/IPv6 GRO support for non-VXLAN packets.** + + Added UDP/IPv6 GRO support for non-VXLAN packets, this enabled UDP/IPv6 + GRO support for IPv6 VLAN use case. + Removed Items ------------- diff --git a/lib/librte_gro/gro_udp6.c b/lib/librte_gro/gro_udp6.c new file mode 100644 index 0000000..193cf2e --- /dev/null +++ b/lib/librte_gro/gro_udp6.c @@ -0,0 +1,487 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#include +#include +#include +#include +#include + +#include "gro_udp6.h" + +void * +gro_udp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_udp6_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_UDP6_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_udp6_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_udp6_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_udp6_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; + } + /* INVALID_ARRAY_INDEX indicates an empty flow */ + 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_udp6_tbl_destroy(void *tbl) +{ + struct gro_udp6_tbl *udp6_tbl = tbl; + + if (udp6_tbl) { + rte_free(udp6_tbl->items); + rte_free(udp6_tbl->flows); + } + rte_free(udp6_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_udp6_tbl *tbl) +{ + uint32_t i; + uint32_t max_item_num = tbl->max_item_num; + + for (i = 0; i < max_item_num; i++) + if (tbl->items[i].firstseg == NULL) + return i; + return INVALID_ARRAY_INDEX; +} + +static inline uint32_t +find_an_empty_flow(struct gro_udp6_tbl *tbl) +{ + uint32_t i; + uint32_t max_flow_num = tbl->max_flow_num; + + 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_udp6_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 (item_idx == INVALID_ARRAY_INDEX) + return INVALID_ARRAY_INDEX; + + tbl->items[item_idx].firstseg = pkt; + tbl->items[item_idx].lastseg = rte_pktmbuf_lastseg(pkt); + tbl->items[item_idx].start_time = start_time; + tbl->items[item_idx].next_pkt_idx = INVALID_ARRAY_INDEX; + tbl->items[item_idx].frag_offset = frag_offset; + tbl->items[item_idx].is_last_frag = is_last_frag; + tbl->items[item_idx].nb_merged = 1; + tbl->item_num++; + + /* if the previous packet exists, chain them together. */ + if (prev_idx != INVALID_ARRAY_INDEX) { + tbl->items[item_idx].next_pkt_idx = + tbl->items[prev_idx].next_pkt_idx; + tbl->items[prev_idx].next_pkt_idx = item_idx; + } + + return item_idx; +} + +static inline uint32_t +delete_item(struct gro_udp6_tbl *tbl, uint32_t item_idx, + uint32_t prev_item_idx) +{ + uint32_t next_idx = tbl->items[item_idx].next_pkt_idx; + + /* NULL indicates an empty item */ + tbl->items[item_idx].firstseg = NULL; + tbl->item_num--; + if (prev_item_idx != INVALID_ARRAY_INDEX) + tbl->items[prev_item_idx].next_pkt_idx = next_idx; + + return next_idx; +} + +/* Copy IPv6 addr */ +static inline void gro_ipv6_addr_copy(const uint8_t *ipv6_from, + uint8_t *ipv6_to) +{ + const uint64_t *from_words = (const uint64_t *)ipv6_from; + uint64_t *to_words = (uint64_t *)ipv6_to; + + to_words[0] = from_words[0]; + to_words[1] = from_words[1]; +} + +static inline uint32_t +insert_new_flow(struct gro_udp6_tbl *tbl, + struct udp6_flow_key *src, + uint32_t item_idx) +{ + struct udp6_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->eth_saddr), &(dst->eth_saddr)); + rte_ether_addr_copy(&(src->eth_daddr), &(dst->eth_daddr)); + gro_ipv6_addr_copy(src->ip_saddr, dst->ip_saddr); + gro_ipv6_addr_copy(src->ip_daddr, dst->ip_daddr); + dst->ip_id = src->ip_id; + + tbl->flows[flow_idx].start_index = item_idx; + tbl->flow_num++; + + return flow_idx; +} + +static inline uint16_t +get_ipv6_frag_offset(struct rte_ipv6_fragment_ext *ipv6_frag_hdr) +{ + return ((rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) >> 3) * 8); +} + +static inline uint8_t +is_last_ipv6_frag(struct rte_ipv6_fragment_ext *ipv6_frag_hdr) +{ + return (rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) & 0x0001); +} + +/* + * update the packet length for the flushed packet. + */ +static inline void +update_header(struct gro_udp6_item *item) +{ + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_mbuf *pkt = item->firstseg; + struct rte_ipv6_fragment_ext *ipv6_frag_hdr; + size_t fh_len = sizeof(*ipv6_frag_hdr); + + ipv6_hdr = (struct rte_ipv6_hdr *)(rte_pktmbuf_mtod(pkt, char *) + + pkt->l2_len); + /* Note: payload_len includes extension headers and upper layers + * data, but l3_len also includes extension headers, so need to + * add length of extension headers if they exist. + */ + ipv6_hdr->payload_len = rte_cpu_to_be_16(pkt->pkt_len - + pkt->l2_len - pkt->l3_len); + + /* Remove fragment extension header or clear MF flag */ + if (item->is_last_frag && (ipv6_hdr->proto == IPPROTO_FRAGMENT)) { + uint16_t ip_ofs; + + ipv6_frag_hdr = (struct rte_ipv6_fragment_ext *)(ipv6_hdr + 1); + ip_ofs = get_ipv6_frag_offset(ipv6_frag_hdr); + if (ip_ofs == 0) { + ipv6_hdr->proto = ipv6_frag_hdr->next_header; + pkt->l3_len -= fh_len; + + /* Remove IPv6 fragment extension header */ + memmove(rte_pktmbuf_mtod_offset(pkt, char *, fh_len), + rte_pktmbuf_mtod(pkt, char*), + pkt->outer_l2_len + pkt->outer_l3_len + + pkt->l2_len + pkt->l3_len); + rte_pktmbuf_adj(pkt, fh_len); + } else { + /* clear MF flag */ + ipv6_frag_hdr->frag_data = rte_cpu_to_be_16( + (rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) & + 0xFFFE)); + ipv6_hdr->payload_len += fh_len; + } + } +} + +int32_t +gro_udp6_reassemble(struct rte_mbuf *pkt, + struct gro_udp6_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *eth_hdr; + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_ipv6_fragment_ext *ipv6_frag_hdr; + uint16_t fh_len = sizeof(*ipv6_frag_hdr); + uint16_t ip_dl; + uint32_t ip_id; + uint16_t hdr_len; + uint16_t frag_offset = 0; + uint8_t is_last_frag; + + struct udp6_flow_key key; + uint32_t cur_idx, prev_idx, item_idx; + uint32_t i, max_flow_num, remaining_flow_num; + int cmp; + uint8_t find; + + /* + * Don't process the packet whose UDP header length is not equal + * to 20. + */ + if (unlikely(pkt->l4_len != UDP_HDRLEN)) + return -1; + + eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *); + ipv6_hdr = (struct rte_ipv6_hdr *)((char *)eth_hdr + pkt->l2_len); + + /* Note: l3_len includes length of extension headers */ + hdr_len = pkt->l2_len + pkt->l3_len; + + /* + * Don't process non-fragment packet. + */ + if (ipv6_hdr->proto != IPPROTO_FRAGMENT) + return -1; + + /* + * Don't process the packet whose payload length is less than or + * equal to 0. + */ + if (pkt->pkt_len <= hdr_len) + return -1; + + ipv6_frag_hdr = (struct rte_ipv6_fragment_ext *)(ipv6_hdr + 1); + ip_dl = rte_be_to_cpu_16(ipv6_hdr->payload_len) - fh_len; + ip_id = rte_be_to_cpu_32(ipv6_frag_hdr->id); + frag_offset = get_ipv6_frag_offset(ipv6_frag_hdr); + is_last_frag = is_last_ipv6_frag(ipv6_frag_hdr); + + rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.eth_daddr)); + gro_ipv6_addr_copy(ipv6_hdr->src_addr, key.ip_saddr); + gro_ipv6_addr_copy(ipv6_hdr->dst_addr, key.ip_daddr); + key.ip_id = ip_id; + + /* 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_udp6_flow(tbl->flows[i].key, key)) { + find = 1; + break; + } + remaining_flow_num--; + } + } + + /* + * Fail to 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 (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 + * stored 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 for + * the input packet. + */ + cur_idx = tbl->flows[i].start_index; + prev_idx = cur_idx; + do { + cmp = udp6_check_neighbor(&(tbl->items[cur_idx]), + frag_offset, ip_dl, 0); + if (cmp) { + if (merge_two_udp6_packets(&(tbl->items[cur_idx]), + pkt, cmp, frag_offset, + is_last_frag, 0)) + return 1; + /* + * Fail to merge the two packets, as the packet + * length is greater than the max value. Store + * 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].frag_offset) { + break; + } + + prev_idx = cur_idx; + cur_idx = tbl->items[cur_idx].next_pkt_idx; + } while (cur_idx != INVALID_ARRAY_INDEX); + + /* Fail to find a neighbor, so store 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 (item_idx == INVALID_ARRAY_INDEX) + return -1; + tbl->items[item_idx].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_udp6_merge_items(struct gro_udp6_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].next_pkt_idx; + while (item_idx != INVALID_ARRAY_INDEX) { + pkt = tbl->items[item_idx].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].frag_offset; + is_last_frag = tbl->items[item_idx].is_last_frag; + cmp = udp6_check_neighbor(&(tbl->items[start_idx]), + frag_offset, ip_dl, 0); + if (cmp) { + if (merge_two_udp6_packets( + &(tbl->items[start_idx]), + pkt, cmp, frag_offset, + is_last_frag, 0)) { + item_idx = delete_item(tbl, item_idx, + INVALID_ARRAY_INDEX); + tbl->items[start_idx].next_pkt_idx + = item_idx; + } else { + return 0; + } + } else { + return 0; + } + } + + return 0; +} + +uint16_t +gro_udp6_tbl_timeout_flush(struct gro_udp6_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].start_time <= flush_timestamp) { + gro_udp6_merge_items(tbl, j); + out[k++] = tbl->items[j].firstseg; + if (tbl->items[j].nb_merged > 1) + update_header(&(tbl->items[j])); + /* + * Delete the packet and get the next + * packet in the flow. + */ + 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 this flow won't be + * timeout. Go to check other flows. + */ + break; + } + } + return k; +} + +uint32_t +gro_udp6_tbl_pkt_count(void *tbl) +{ + struct gro_udp6_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/librte_gro/gro_udp6.h b/lib/librte_gro/gro_udp6.h new file mode 100644 index 0000000..92696e4 --- /dev/null +++ b/lib/librte_gro/gro_udp6.h @@ -0,0 +1,284 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#ifndef _GRO_UDP6_H_ +#define _GRO_UDP6_H_ + +#include +#include +#include + +#define INVALID_ARRAY_INDEX 0xffffffffUL +#define GRO_UDP6_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + +/* + * The max length of a IPv6 packet, which includes the length of the L3 + * header, the L4 header and the data payload. + */ +#define MAX_IPV6_PKT_LENGTH UINT16_MAX + +#define UDP_HDRLEN 8 + +/* Header fields representing a UDP/IPv6 flow */ +struct udp6_flow_key { + struct rte_ether_addr eth_saddr; + struct rte_ether_addr eth_daddr; + uint8_t ip_saddr[16]; + uint8_t ip_daddr[16]; + + /* IP fragment for UDP does not contain UDP header + * except the first one. But IP ID must be same. + * ip_id of fragment is 32 bit for IPv6 + */ + uint32_t ip_id; +}; + +struct gro_udp6_flow { + struct udp6_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_udp6_item { + /* + * The first MBUF segment of the packet. If the value + * is NULL, it means the item is empty. + */ + struct rte_mbuf *firstseg; + /* The last MBUF segment of the packet */ + struct rte_mbuf *lastseg; + /* + * The time when the first packet is inserted into the table. + * This value won't be updated, even if the packet is merged + * with other packets. + */ + uint64_t start_time; + /* + * next_pkt_idx is used to chain the packets that + * are in the same flow but can't be merged together + * (e.g. caused by packet reordering). + */ + uint32_t next_pkt_idx; + /* offset of IP fragment packet */ + uint16_t frag_offset; + /* is last IP fragment? */ + uint8_t is_last_frag; + /* the number of merged packets */ + uint16_t nb_merged; +}; + +/* + * UDP/IPv6 reassembly table structure. + */ +struct gro_udp6_tbl { + /* item array */ + struct gro_udp6_item *items; + /* flow array */ + struct gro_udp6_flow *flows; + /* current item number */ + uint32_t item_num; + /* current flow num */ + uint32_t flow_num; + /* item array size */ + uint32_t max_item_num; + /* flow array size */ + uint32_t max_flow_num; +}; + +/** + * This function creates a UDP/IPv6 reassembly table. + * + * @param socket_id + * Socket index for allocating the UDP/IPv6 reassemble table + * @param max_flow_num + * The maximum number of flows in the UDP/IPv6 GRO 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_udp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + +/** + * This function destroys a UDP/IPv6 reassembly table. + * + * @param tbl + * Pointer pointing to the UDP/IPv6 reassembly table. + */ +void gro_udp6_tbl_destroy(void *tbl); + +/** + * This function merges a UDP/IPv6 packet. + * + * 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 it isn't UDP fragment or there is no available space in + * the table. + * + * @param pkt + * Packet to reassemble + * @param tbl + * Pointer pointing to the UDP/IPv6 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_udp6_reassemble(struct rte_mbuf *pkt, + struct gro_udp6_tbl *tbl, + uint64_t start_time); + +/** + * This function flushes timeout packets in a UDP/IPv6 reassembly table, + * and without updating checksums. + * + * @param tbl + * UDP/IPv6 reassembly table pointer + * @param flush_timestamp + * Flush 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_udp6_tbl_timeout_flush(struct gro_udp6_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out); + +/** + * This function returns the number of the packets in a UDP/IPv6 + * reassembly table. + * + * @param tbl + * UDP/IPv6 reassembly table pointer + * + * @return + * The number of packets in the table + */ +uint32_t gro_udp6_tbl_pkt_count(void *tbl); + +#ifndef _GRO_TCP6_H_ +static inline int rte_is_same_ipv6_addr(const uint8_t *ipv6_a1, + const uint8_t *ipv6_a2) +{ + const uint64_t *w1 = (const uint64_t *)ipv6_a1; + const uint64_t *w2 = (const uint64_t *)ipv6_a2; + + return ((w1[0] ^ w2[0]) | (w1[1] ^ w2[1])) == 0; +} +#endif + +/* + * Check if two UDP/IPv6 packets belong to the same flow. + */ +static inline int +is_same_udp6_flow(struct udp6_flow_key k1, struct udp6_flow_key k2) +{ + return (rte_is_same_ether_addr(&k1.eth_saddr, &k2.eth_saddr) && + rte_is_same_ether_addr(&k1.eth_daddr, &k2.eth_daddr) && + rte_is_same_ipv6_addr(k1.ip_saddr, k2.ip_saddr) && + rte_is_same_ipv6_addr(k1.ip_daddr, k2.ip_daddr) && + (k1.ip_id == k2.ip_id)); +} + +/* + * Merge two UDP/IPv6 packets without updating checksums. + * If cmp is larger than 0, append the new packet to the + * original packet. Otherwise, pre-pend the new packet to + * the original packet. + */ +static inline int +merge_two_udp6_packets(struct gro_udp6_item *item, + struct rte_mbuf *pkt, + int cmp, + uint16_t frag_offset, + uint8_t is_last_frag, + uint16_t l2_offset) +{ + struct rte_mbuf *pkt_head, *pkt_tail, *lastseg; + uint16_t hdr_len, l2_len; + uint32_t ip_len; + + if (cmp > 0) { + pkt_head = item->firstseg; + pkt_tail = pkt; + } else { + pkt_head = pkt; + pkt_tail = item->firstseg; + } + + /* check if the IPv6 packet length is greater than the max value */ + hdr_len = l2_offset + pkt_head->l2_len + pkt_head->l3_len; + l2_len = l2_offset > 0 ? pkt_head->outer_l2_len : pkt_head->l2_len; + ip_len = pkt_head->pkt_len - l2_len + + pkt_tail->pkt_len - hdr_len; + if (unlikely(ip_len > MAX_IPV6_PKT_LENGTH)) + return 0; + + /* remove the packet header for the tail packet */ + rte_pktmbuf_adj(pkt_tail, hdr_len); + + /* chain two packets together */ + if (cmp > 0) { + item->lastseg->next = pkt; + item->lastseg = rte_pktmbuf_lastseg(pkt); + } else { + lastseg = rte_pktmbuf_lastseg(pkt); + lastseg->next = item->firstseg; + item->firstseg = pkt; + item->frag_offset = frag_offset; + } + item->nb_merged++; + if (is_last_frag) + item->is_last_frag = is_last_frag; + + /* update MBUF metadata for the merged packet */ + pkt_head->nb_segs += pkt_tail->nb_segs; + pkt_head->pkt_len += pkt_tail->pkt_len; + + return 1; +} + +/* + * Check if two UDP/IPv6 packets are neighbors. + */ +static inline int +udp6_check_neighbor(struct gro_udp6_item *item, + uint16_t frag_offset, + uint16_t ip_dl, + uint16_t l2_offset) +{ + struct rte_mbuf *pkt_orig = item->firstseg; + uint16_t len; + + /* check if the two packets are neighbors */ + len = pkt_orig->pkt_len - l2_offset - pkt_orig->l2_len - + pkt_orig->l3_len; + if (frag_offset == item->frag_offset + len) + /* append the new packet */ + return 1; + else if (frag_offset + ip_dl == item->frag_offset) + /* pre-pend the new packet */ + return -1; + + return 0; +} +#endif diff --git a/lib/librte_gro/meson.build b/lib/librte_gro/meson.build index 3eff89c..7939081 100644 --- a/lib/librte_gro/meson.build +++ b/lib/librte_gro/meson.build @@ -1,6 +1,6 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c') +sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c', 'gro_udp6.c') headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c index 0c5584e..13b38cc 100644 --- a/lib/librte_gro/rte_gro.c +++ b/lib/librte_gro/rte_gro.c @@ -11,6 +11,7 @@ #include "gro_tcp4.h" #include "gro_tcp6.h" #include "gro_udp4.h" +#include "gro_udp6.h" #include "gro_vxlan6_tcp4.h" #include "gro_vxlan6_tcp6.h" #include "gro_vxlan_tcp4.h" @@ -28,21 +29,21 @@ gro_udp4_tbl_create, gro_vxlan_udp4_tbl_create, gro_tcp6_tbl_create, gro_vxlan_tcp6_tbl_create, gro_vxlan6_tcp4_tbl_create, gro_vxlan6_tcp6_tbl_create, - NULL}; + gro_udp6_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, gro_vxlan_tcp6_tbl_destroy, gro_vxlan6_tcp4_tbl_destroy, gro_vxlan6_tcp6_tbl_destroy, - NULL}; + gro_udp6_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, gro_vxlan_tcp6_tbl_pkt_count, gro_vxlan6_tcp4_tbl_pkt_count, gro_vxlan6_tcp6_tbl_pkt_count, - NULL}; + gro_udp6_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) && \ @@ -121,6 +122,10 @@ ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN))) +#define IS_IPV6_UDP_PKT(ptype) (RTE_ETH_IS_IPV6_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + (RTE_ETH_IS_TUNNEL_PKT(ptype) == 0)) + /* * GRO context structure. It keeps the table structures, which are * used to merge packets, for different GRO types. Before using @@ -246,13 +251,19 @@ struct gro_ctx { struct gro_vxlan6_tcp6_item vxlan6_tcp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + /* allocate a reassembly table for UDP/IPv6 GRO */ + struct gro_udp6_tbl udp6_tbl; + struct gro_udp6_flow udp6_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_udp6_item udp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} }; + struct rte_mbuf *unprocess_pkts[nb_pkts]; 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_tcp6_gro = 0, - do_vxlan6_tcp4_gro = 0, do_vxlan6_tcp6_gro = 0; + do_vxlan6_tcp4_gro = 0, do_vxlan6_tcp6_gro = 0, + do_udp6_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -261,7 +272,8 @@ struct gro_ctx { RTE_GRO_TCP_IPV6 | RTE_GRO_IPV4_VXLAN_TCP_IPV6 | RTE_GRO_IPV6_VXLAN_TCP_IPV4 | - RTE_GRO_IPV6_VXLAN_TCP_IPV6)) == 0)) + RTE_GRO_IPV6_VXLAN_TCP_IPV6 | + RTE_GRO_UDP_IPV6)) == 0)) return nb_pkts; /* Get the maximum number of packets */ @@ -373,6 +385,19 @@ struct gro_ctx { do_vxlan6_tcp6_gro = 1; } + if (param->gro_types & RTE_GRO_UDP_IPV6) { + for (i = 0; i < item_num; i++) + udp6_flows[i].start_index = INVALID_ARRAY_INDEX; + + udp6_tbl.flows = udp6_flows; + udp6_tbl.items = udp6_items; + udp6_tbl.flow_num = 0; + udp6_tbl.item_num = 0; + udp6_tbl.max_flow_num = item_num; + udp6_tbl.max_item_num = item_num; + do_udp6_gro = 1; + } + for (i = 0; i < nb_pkts; i++) { /* * The timestamp is ignored, since all packets @@ -447,6 +472,14 @@ struct gro_ctx { nb_after_gro--; else if (ret < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_UDP_PKT(pkts[i]->packet_type) && + do_udp6_gro) { + ret = gro_udp6_reassemble(pkts[i], &udp6_tbl, 0); + if (ret > 0) + /* merge successfully */ + nb_after_gro--; + else if (ret < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -496,6 +529,11 @@ struct gro_ctx { 0, &pkts[i], nb_pkts - i); } + if (do_udp6_gro) { + i += gro_udp6_tbl_timeout_flush(&udp6_tbl, 0, + &pkts[i], nb_pkts - i); + } + /* Copy unprocessed packets */ if (unprocess_num > 0) { memcpy(&pkts[i], unprocess_pkts, @@ -516,12 +554,13 @@ struct gro_ctx { struct rte_mbuf *unprocess_pkts[nb_pkts]; struct gro_ctx *gro_ctx = ctx; void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_tbl, - *vxlan_tcp6_tbl, *vxlan6_tcp4_tbl, *vxlan6_tcp6_tbl; + *vxlan_tcp6_tbl, *vxlan6_tcp4_tbl, *vxlan6_tcp6_tbl, + *udp6_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, do_vxlan_tcp6_gro, do_vxlan6_tcp4_gro, - do_vxlan6_tcp6_gro; + do_vxlan6_tcp6_gro, do_udp6_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -530,7 +569,8 @@ struct gro_ctx { RTE_GRO_TCP_IPV6 | RTE_GRO_IPV4_VXLAN_TCP_IPV6 | RTE_GRO_IPV6_VXLAN_TCP_IPV4 | - RTE_GRO_IPV6_VXLAN_TCP_IPV6)) == 0)) + RTE_GRO_IPV6_VXLAN_TCP_IPV6 | + RTE_GRO_UDP_IPV6)) == 0)) return nb_pkts; tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX]; @@ -541,6 +581,7 @@ struct gro_ctx { vxlan_tcp6_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV6_INDEX]; vxlan6_tcp4_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX]; vxlan6_tcp6_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX]; + udp6_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV6_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == RTE_GRO_TCP_IPV4; @@ -558,6 +599,8 @@ struct gro_ctx { == RTE_GRO_IPV6_VXLAN_TCP_IPV4; do_vxlan6_tcp6_gro = (gro_ctx->gro_types & RTE_GRO_IPV6_VXLAN_TCP_IPV6) == RTE_GRO_IPV6_VXLAN_TCP_IPV6; + do_udp6_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV6) == + RTE_GRO_UDP_IPV6; current_time = rte_rdtsc(); @@ -602,6 +645,11 @@ struct gro_ctx { if (gro_vxlan6_tcp6_reassemble(pkts[i], vxlan6_tcp6_tbl, current_time) < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_UDP_PKT(pkts[i]->packet_type) && + do_udp6_gro) { + if (gro_udp6_reassemble(pkts[i], udp6_tbl, + current_time) < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -685,6 +733,14 @@ struct gro_ctx { num += gro_vxlan6_tcp6_tbl_timeout_flush(gro_ctx->tbls[ RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX], flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_UDP_IPV6) && left_nb_out > 0) { + num += gro_udp6_tbl_timeout_flush( + gro_ctx->tbls[RTE_GRO_UDP_IPV6_INDEX], + flush_timestamp, + &out[num], left_nb_out); } return num; diff --git a/lib/librte_gro/rte_gro.h b/lib/librte_gro/rte_gro.h index cb0895f..94ed3d3 100644 --- a/lib/librte_gro/rte_gro.h +++ b/lib/librte_gro/rte_gro.h @@ -50,6 +50,9 @@ #define RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX 7 #define RTE_GRO_IPV6_VXLAN_TCP_IPV6 (1ULL << RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX) /**< IPv6 VxLAN TCP/IPv6 GRO flag. */ +#define RTE_GRO_UDP_IPV6_INDEX 8 +#define RTE_GRO_UDP_IPV6 (1ULL << RTE_GRO_UDP_IPV6_INDEX) +/**< UDP/IPv6 GRO flag */ /** * Structure used to create GRO context objects or used to pass From patchwork Mon Dec 21 03:50:50 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: yang_y_yi X-Patchwork-Id: 85577 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 8B4CFA09FE; Mon, 21 Dec 2020 04:52:52 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 08755CCA4; Mon, 21 Dec 2020 04:51:09 +0100 (CET) Received: from mail-m972.mail.163.com (mail-m972.mail.163.com [123.126.97.2]) by dpdk.org (Postfix) with ESMTP id 7C2A3CB76 for ; Mon, 21 Dec 2020 04:50:58 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id:MIME-Version; bh=+cXSi GgkrPb0xTGg1X3LV5kESqVMgMyHvjZBMflmfCs=; b=T2YpyigFQtnwzI8kKQ8bk 9dFhLUVVsa/zEO2QQgCCe5+9UiObeQvj7IafCEvL9BgWLZ822mnNZF2DXES0RGlb peg5mtRa1x0URytGZ7R/2N7AOTXAyJt1/lXzhqSNKX+q7d96MzzAU2S3OEhtc1Mm ywtXa8h7BZM91RKbZUgn3c= Received: from yangyi0100.home.langchao.com (unknown [111.207.123.53]) by smtp2 (Coremail) with SMTP id GtxpCgD3vb6cG+BfUOf7Fw--.755S8; Mon, 21 Dec 2020 11:50:55 +0800 (CST) From: yang_y_yi@163.com To: dev@dpdk.org Cc: jiayu.hu@intel.com, konstantin.ananyev@intel.com, thomas@monjalon.net, yangyi01@inspur.com, yang_y_yi@163.com Date: Mon, 21 Dec 2020 11:50:50 +0800 Message-Id: <20201221035052.128292-7-yang_y_yi@163.com> X-Mailer: git-send-email 2.19.2.windows.1 In-Reply-To: <20201221035052.128292-1-yang_y_yi@163.com> References: <20201221035052.128292-1-yang_y_yi@163.com> MIME-Version: 1.0 X-CM-TRANSID: GtxpCgD3vb6cG+BfUOf7Fw--.755S8 X-Coremail-Antispam: 1Uf129KBjvAXoWfuF45GFWxJFWruF1kAry7ZFb_yoW5uw47Ko WxXws8Wr1kurn0yr4jyr1xuryjgw1xKw47Aws0grs5Wwn2yrWDGrZ3Ww4fAa17Xr45ZFyv vwn3ua17XF4IyFs7n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxUO89MUUUUU X-Originating-IP: [111.207.123.53] X-CM-SenderInfo: 51dqwsp1b1xqqrwthudrp/xtbBEh8Ci16iadMbBQAAsc Subject: [dpdk-dev] [PATCH v1 6/8] gro: support IPv4 VXLAN UDP/IPv6 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Yi Yang IPv4 VXLAN UDP/IPv6 GRO can help improve UDP/IPv6 performance in IPv4 VXLAN use case. With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP/IPv6 performance, it will merge small adjacent IPv4 VXLAN UDP/IPv6 fragments to a big IPv4 VXLAN UDP/IPv6 packet immediate after they are received from a physical NIC. It is very helpful in OVS DPDK IPv4 VXLAN use case. Signed-off-by: Yi Yang --- .../prog_guide/generic_receive_offload_lib.rst | 4 +- doc/guides/rel_notes/release_21_02.rst | 5 + lib/librte_gro/gro_vxlan_udp6.c | 607 +++++++++++++++++++++ lib/librte_gro/gro_vxlan_udp6.h | 152 ++++++ lib/librte_gro/meson.build | 2 +- lib/librte_gro/rte_gro.c | 83 ++- lib/librte_gro/rte_gro.h | 3 + 7 files changed, 845 insertions(+), 11 deletions(-) create mode 100644 lib/librte_gro/gro_vxlan_udp6.c create mode 100644 lib/librte_gro/gro_vxlan_udp6.h diff --git a/doc/guides/prog_guide/generic_receive_offload_lib.rst b/doc/guides/prog_guide/generic_receive_offload_lib.rst index 0ea3076..906e85f 100644 --- a/doc/guides/prog_guide/generic_receive_offload_lib.rst +++ b/doc/guides/prog_guide/generic_receive_offload_lib.rst @@ -32,8 +32,8 @@ fragmentation is possible (i.e., DF==0). Additionally, it complies RFC Currently, the GRO library provides GRO supports for TCP/IPv4, UDP/IPv4, UDP/IPv6, and TCP/IPv6 packets as well as VxLAN packets which contain an -outer IPv4 header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 packet or -an outer IPv6 header and an inner TCP/IPv4 or TCP/IPv6 packet. +outer IPv4 header and an inner TCP/IPv4, UDP/IPv4, TCP/IPv6 or UDP/IPv6 +packet or an outer IPv6 header and an inner TCP/IPv4 or TCP/IPv6 packet. Two Sets of API --------------- diff --git a/doc/guides/rel_notes/release_21_02.rst b/doc/guides/rel_notes/release_21_02.rst index d8974b7..4758cea 100644 --- a/doc/guides/rel_notes/release_21_02.rst +++ b/doc/guides/rel_notes/release_21_02.rst @@ -80,6 +80,11 @@ New Features Added UDP/IPv6 GRO support for non-VXLAN packets, this enabled UDP/IPv6 GRO support for IPv6 VLAN use case. +* **Added UDP/IPv6 GRO support for IPv4 VXLAN packets.** + + Added UDP/IPv6 GRO support for IPv4 VXLAN packets, this enabled UDP/IPv6 + GRO support for IPv4 VXLAN use case. + Removed Items ------------- diff --git a/lib/librte_gro/gro_vxlan_udp6.c b/lib/librte_gro/gro_vxlan_udp6.c new file mode 100644 index 0000000..8c76b41 --- /dev/null +++ b/lib/librte_gro/gro_vxlan_udp6.c @@ -0,0 +1,607 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#include +#include +#include +#include +#include +#include + +#include "gro_vxlan_udp6.h" + +void * +gro_vxlan_udp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_vxlan_udp6_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_VXLAN_UDP6_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_vxlan_udp6_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_vxlan_udp6_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_vxlan_udp6_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_vxlan_udp6_tbl_destroy(void *tbl) +{ + struct gro_vxlan_udp6_tbl *vxlan_tbl = tbl; + + if (vxlan_tbl) { + rte_free(vxlan_tbl->items); + rte_free(vxlan_tbl->flows); + } + rte_free(vxlan_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_vxlan_udp6_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_vxlan_udp6_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_vxlan_udp6_tbl *tbl, + struct rte_mbuf *pkt, + uint64_t start_time, + uint32_t prev_idx, + uint16_t frag_offset, + uint8_t is_last_frag, + uint16_t outer_ip_id, + uint8_t outer_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.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->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_vxlan_udp6_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; +} + +/* Copy IPv6 addr */ +static inline void gro_ipv6_addr_copy(const uint8_t *ipv6_from, + uint8_t *ipv6_to) +{ + const uint64_t *from_words = (const uint64_t *)ipv6_from; + uint64_t *to_words = (uint64_t *)ipv6_to; + + to_words[0] = from_words[0]; + to_words[1] = from_words[1]; +} + + +static inline uint32_t +insert_new_flow(struct gro_vxlan_udp6_tbl *tbl, + struct vxlan_udp6_flow_key *src, + uint32_t item_idx) +{ + struct vxlan_udp6_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)); + gro_ipv6_addr_copy(src->inner_key.ip_saddr, dst->inner_key.ip_saddr); + gro_ipv6_addr_copy(src->inner_key.ip_daddr, dst->inner_key.ip_daddr); + 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; + 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_vxlan_udp6_flow(struct vxlan_udp6_flow_key k1, + struct vxlan_udp6_flow_key k2) +{ + /* For VxLAN 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) && + is_same_udp6_flow(k1.inner_key, k2.inner_key)); +} + +static inline int +udp6_check_vxlan_neighbor(struct gro_vxlan_udp6_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; + + l2_offset = pkt->outer_l2_len + pkt->outer_l3_len; + cmp = udp6_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_vxlan_udp6_packets(struct gro_vxlan_udp6_item *item, + struct rte_mbuf *pkt, + int cmp, + uint16_t frag_offset, + uint8_t is_last_frag) +{ + if (merge_two_udp6_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 uint16_t +get_ipv6_frag_offset(struct rte_ipv6_fragment_ext *ipv6_frag_hdr) +{ + return ((rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) >> 3) * 8); +} + +static inline uint8_t +is_last_ipv6_frag(struct rte_ipv6_fragment_ext *ipv6_frag_hdr) +{ + return (rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) & 0x0001); +} + +static inline void +update_vxlan_header(struct gro_vxlan_udp6_item *item) +{ + struct rte_ipv4_hdr *outer_ipv4_hdr; + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_ipv6_fragment_ext *ipv6_frag_hdr; + size_t fh_len = sizeof(*ipv6_frag_hdr); + struct rte_mbuf *pkt = item->inner_item.firstseg; + uint16_t len; + + /* Position to inner IPv6 header first */ + ipv6_hdr = (struct rte_ipv6_hdr *)rte_pktmbuf_mtod_offset(pkt, char *, + pkt->outer_l2_len + pkt->outer_l3_len + pkt->l2_len); + len = pkt->pkt_len - pkt->outer_l2_len - pkt->outer_l3_len + - pkt->l2_len; + ipv6_hdr->payload_len = rte_cpu_to_be_16(len - pkt->l3_len); + + /* Remove fragment extension header or clear MF flag */ + if (item->inner_item.is_last_frag + && (ipv6_hdr->proto == IPPROTO_FRAGMENT)) { + uint16_t ip_ofs; + + ipv6_frag_hdr = (struct rte_ipv6_fragment_ext *)(ipv6_hdr + 1); + ip_ofs = get_ipv6_frag_offset(ipv6_frag_hdr); + if (ip_ofs == 0) { + ipv6_hdr->proto = ipv6_frag_hdr->next_header; + pkt->l3_len -= fh_len; + + /* Remove IPv6 fragment extension header */ + memmove(rte_pktmbuf_mtod_offset(pkt, char *, fh_len), + rte_pktmbuf_mtod(pkt, char*), + pkt->outer_l2_len + pkt->outer_l3_len + + pkt->l2_len + pkt->l3_len); + rte_pktmbuf_adj(pkt, fh_len); + } else { + /* clear MF flag */ + ipv6_frag_hdr->frag_data = rte_cpu_to_be_16( + (rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) & + 0xFFFE)); + ipv6_hdr->payload_len += fh_len; + } + } + + /* Must adjust outer header after inner IPv6 is handled. */ + /* Update the outer IPv4 header. */ + len = pkt->pkt_len - pkt->outer_l2_len; + outer_ipv4_hdr = (struct rte_ipv4_hdr *)(rte_pktmbuf_mtod(pkt, char *) + + pkt->outer_l2_len); + outer_ipv4_hdr->total_length = rte_cpu_to_be_16(len); + + /* Point to the outer UDP header. */ + len -= pkt->outer_l3_len; + udp_hdr = (struct rte_udp_hdr *)((char *)outer_ipv4_hdr + + pkt->outer_l3_len); + udp_hdr->dgram_len = rte_cpu_to_be_16(len); +} + +int32_t +gro_vxlan_udp6_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan_udp6_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ipv4_hdr *outer_ipv4_hdr; + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_ipv6_fragment_ext *ipv6_frag_hdr; + uint16_t fh_len = sizeof(*ipv6_frag_hdr); + struct rte_udp_hdr *udp_hdr; + struct rte_vxlan_hdr *vxlan_hdr; + uint16_t frag_offset; + uint8_t is_last_frag; + int16_t ip_dl; + uint32_t ip_id; + uint16_t outer_ip_id; + uint8_t outer_is_atomic; + + struct vxlan_udp6_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); + vxlan_hdr = (struct rte_vxlan_hdr *)((char *)udp_hdr + + sizeof(struct rte_udp_hdr)); + eth_hdr = (struct rte_ether_hdr *)((char *)vxlan_hdr + + sizeof(struct rte_vxlan_hdr)); + /* l2_len = outer udp hdr len + vxlan hdr len + inner l2 len */ + ipv6_hdr = (struct rte_ipv6_hdr *)((char *)udp_hdr + pkt->l2_len); + + /* + * Don't process the packet which has non-fragment inner IP. + */ + if (ipv6_hdr->proto != IPPROTO_FRAGMENT) + return -1; + + /* Note: l3_len includes length of extension headers */ + 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; + + /* + * Save IPv4 ID for the packet whose DF bit is 0. For the packet + * whose DF bit is 1, IPv4 ID is ignored. + */ + frag_offset = rte_be_to_cpu_16(outer_ipv4_hdr->fragment_offset); + outer_is_atomic = + ((frag_offset & 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); + ipv6_frag_hdr = (struct rte_ipv6_fragment_ext *)(ipv6_hdr + 1); + ip_dl = rte_be_to_cpu_16(ipv6_hdr->payload_len) - fh_len; + ip_id = rte_be_to_cpu_32(ipv6_frag_hdr->id); + frag_offset = get_ipv6_frag_offset(ipv6_frag_hdr); + is_last_frag = is_last_ipv6_frag(ipv6_frag_hdr); + + rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.inner_key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.inner_key.eth_daddr)); + gro_ipv6_addr_copy(ipv6_hdr->src_addr, key.inner_key.ip_saddr); + gro_ipv6_addr_copy(ipv6_hdr->dst_addr, key.inner_key.ip_daddr); + 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; + rte_ether_addr_copy(&(outer_eth_hdr->s_addr), &(key.outer_eth_saddr)); + rte_ether_addr_copy(&(outer_eth_hdr->d_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_vxlan_udp6_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, outer_ip_id, + outer_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 = udp6_check_vxlan_neighbor(&(tbl->items[cur_idx]), + frag_offset, ip_dl); + if (cmp) { + if (merge_two_vxlan_udp6_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, + outer_ip_id, + outer_is_atomic) + == 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, outer_ip_id, + outer_is_atomic); + if (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, outer_ip_id, + outer_is_atomic) == INVALID_ARRAY_INDEX) + return -1; + } + + return 0; +} + +static int +gro_vxlan_udp6_merge_items(struct gro_vxlan_udp6_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 = udp6_check_vxlan_neighbor(&(tbl->items[start_idx]), + frag_offset, ip_dl); + if (cmp) { + if (merge_two_vxlan_udp6_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_vxlan_udp6_tbl_timeout_flush(struct gro_vxlan_udp6_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_vxlan_udp6_merge_items(tbl, j); + out[k++] = tbl->items[j].inner_item.firstseg; + if (tbl->items[j].inner_item.nb_merged > 1) + update_vxlan_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_vxlan_udp6_tbl_pkt_count(void *tbl) +{ + struct gro_vxlan_udp6_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/librte_gro/gro_vxlan_udp6.h b/lib/librte_gro/gro_vxlan_udp6.h new file mode 100644 index 0000000..648733d --- /dev/null +++ b/lib/librte_gro/gro_vxlan_udp6.h @@ -0,0 +1,152 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#ifndef _GRO_VXLAN_UDP6_H_ +#define _GRO_VXLAN_UDP6_H_ + +#include "gro_udp6.h" + +#define GRO_VXLAN_UDP6_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + +/* Header fields representing a VxLAN flow */ +struct vxlan_udp6_flow_key { + struct udp6_flow_key inner_key; + struct rte_vxlan_hdr vxlan_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_vxlan_udp6_flow { + struct vxlan_udp6_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_vxlan_udp6_item { + struct gro_udp6_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 UDP/IPv6 packet) + * reassembly table structure + */ +struct gro_vxlan_udp6_tbl { + /* item array */ + struct gro_vxlan_udp6_item *items; + /* flow array */ + struct gro_vxlan_udp6_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 IPv4 VxLAN reassembly table for IPv4 VxLAN packets + * which have an outer IPv4 header and an inner UDP/IPv6 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_vxlan_udp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + +/** + * This function destroys a IPv4 VxLAN reassembly table. + * + * @param tbl + * Pointer pointing to the IPv4 VxLAN reassembly table + */ +void gro_vxlan_udp6_tbl_destroy(void *tbl); + +/** + * This function merges a IPv4 VxLAN packet which has an outer IPv4 header and + * an inner UDP/IPv6 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 IPv4 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_vxlan_udp6_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan_udp6_tbl *tbl, + uint64_t start_time); + +/** + * This function flushes timeout packets in the IPv4 VxLAN reassembly table, + * and without updating checksums. + * + * @param tbl + * Pointer pointing to a IPv4 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_vxlan_udp6_tbl_timeout_flush(struct gro_vxlan_udp6_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out); + +/** + * This function returns the number of the packets in a IPv4 VxLAN + * reassembly table. + * + * @param tbl + * Pointer pointing to the IPv4 VxLAN reassembly table + * + * @return + * The number of packets in the table + */ +uint32_t gro_vxlan_udp6_tbl_pkt_count(void *tbl); +#endif diff --git a/lib/librte_gro/meson.build b/lib/librte_gro/meson.build index 7939081..14b6b64 100644 --- a/lib/librte_gro/meson.build +++ b/lib/librte_gro/meson.build @@ -1,6 +1,6 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c', 'gro_udp6.c') +sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c', 'gro_udp6.c', 'gro_vxlan_udp6.c') headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c index 13b38cc..3bb7ea1 100644 --- a/lib/librte_gro/rte_gro.c +++ b/lib/librte_gro/rte_gro.c @@ -17,6 +17,7 @@ #include "gro_vxlan_tcp4.h" #include "gro_vxlan_tcp6.h" #include "gro_vxlan_udp4.h" +#include "gro_vxlan_udp6.h" typedef void *(*gro_tbl_create_fn)(uint16_t socket_id, uint16_t max_flow_num, @@ -29,21 +30,24 @@ gro_udp4_tbl_create, gro_vxlan_udp4_tbl_create, gro_tcp6_tbl_create, gro_vxlan_tcp6_tbl_create, gro_vxlan6_tcp4_tbl_create, gro_vxlan6_tcp6_tbl_create, - gro_udp6_tbl_create, NULL}; + gro_udp6_tbl_create, gro_vxlan_udp6_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, gro_vxlan_tcp6_tbl_destroy, gro_vxlan6_tcp4_tbl_destroy, gro_vxlan6_tcp6_tbl_destroy, - gro_udp6_tbl_destroy, NULL}; + gro_udp6_tbl_destroy, gro_vxlan_udp6_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, gro_vxlan_tcp6_tbl_pkt_count, gro_vxlan6_tcp4_tbl_pkt_count, gro_vxlan6_tcp6_tbl_pkt_count, - gro_udp6_tbl_pkt_count, NULL}; + gro_udp6_tbl_pkt_count, gro_vxlan_udp6_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) && \ @@ -126,6 +130,19 @@ ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ (RTE_ETH_IS_TUNNEL_PKT(ptype) == 0)) +#define IS_IPV4_VXLAN_UDP6_PKT(ptype) (RTE_ETH_IS_IPV4_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + ((ptype & RTE_PTYPE_TUNNEL_VXLAN) == \ + RTE_PTYPE_TUNNEL_VXLAN) && \ + ((ptype & RTE_PTYPE_INNER_L4_UDP) == \ + RTE_PTYPE_INNER_L4_UDP) && \ + (((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6_EXT) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN))) + /* * GRO context structure. It keeps the table structures, which are * used to merge packets, for different GRO types. Before using @@ -256,6 +273,12 @@ struct gro_ctx { struct gro_udp6_flow udp6_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; struct gro_udp6_item udp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} }; + /* Allocate a reassembly table for IPv4 VXLAN UDP/IPv6 GRO */ + struct gro_vxlan_udp6_tbl vxlan_udp6_tbl; + struct gro_vxlan_udp6_flow vxlan_udp6_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_vxlan_udp6_item vxlan_udp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] + = {{{0}, 0, 0} }; + struct rte_mbuf *unprocess_pkts[nb_pkts]; uint32_t item_num; int32_t ret; @@ -263,7 +286,7 @@ struct gro_ctx { 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_tcp6_gro = 0, do_vxlan6_tcp4_gro = 0, do_vxlan6_tcp6_gro = 0, - do_udp6_gro = 0; + do_udp6_gro = 0, do_vxlan_udp6_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -273,7 +296,8 @@ struct gro_ctx { RTE_GRO_IPV4_VXLAN_TCP_IPV6 | RTE_GRO_IPV6_VXLAN_TCP_IPV4 | RTE_GRO_IPV6_VXLAN_TCP_IPV6 | - RTE_GRO_UDP_IPV6)) == 0)) + RTE_GRO_UDP_IPV6 | + RTE_GRO_IPV4_VXLAN_UDP_IPV6)) == 0)) return nb_pkts; /* Get the maximum number of packets */ @@ -398,6 +422,19 @@ struct gro_ctx { do_udp6_gro = 1; } + if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV6) { + for (i = 0; i < item_num; i++) + vxlan_udp6_flows[i].start_index = INVALID_ARRAY_INDEX; + + vxlan_udp6_tbl.flows = vxlan_udp6_flows; + vxlan_udp6_tbl.items = vxlan_udp6_items; + vxlan_udp6_tbl.flow_num = 0; + vxlan_udp6_tbl.item_num = 0; + vxlan_udp6_tbl.max_flow_num = item_num; + vxlan_udp6_tbl.max_item_num = item_num; + do_vxlan_udp6_gro = 1; + } + for (i = 0; i < nb_pkts; i++) { /* * The timestamp is ignored, since all packets @@ -480,6 +517,15 @@ struct gro_ctx { nb_after_gro--; else if (ret < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV4_VXLAN_UDP6_PKT(pkts[i]->packet_type) && + do_vxlan_udp6_gro) { + ret = gro_vxlan_udp6_reassemble(pkts[i], + &vxlan_udp6_tbl, 0); + if (ret > 0) + /* Merge successfully */ + nb_after_gro--; + else if (ret < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -534,6 +580,11 @@ struct gro_ctx { &pkts[i], nb_pkts - i); } + if (do_vxlan_udp6_gro) { + i += gro_vxlan_udp6_tbl_timeout_flush(&vxlan_udp6_tbl, + 0, &pkts[i], nb_pkts - i); + } + /* Copy unprocessed packets */ if (unprocess_num > 0) { memcpy(&pkts[i], unprocess_pkts, @@ -555,12 +606,12 @@ struct gro_ctx { struct gro_ctx *gro_ctx = ctx; void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_tbl, *vxlan_tcp6_tbl, *vxlan6_tcp4_tbl, *vxlan6_tcp6_tbl, - *udp6_tbl; + *udp6_tbl, *vxlan_udp6_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, do_vxlan_tcp6_gro, do_vxlan6_tcp4_gro, - do_vxlan6_tcp6_gro, do_udp6_gro; + do_vxlan6_tcp6_gro, do_udp6_gro, do_vxlan_udp6_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -570,7 +621,8 @@ struct gro_ctx { RTE_GRO_IPV4_VXLAN_TCP_IPV6 | RTE_GRO_IPV6_VXLAN_TCP_IPV4 | RTE_GRO_IPV6_VXLAN_TCP_IPV6 | - RTE_GRO_UDP_IPV6)) == 0)) + RTE_GRO_UDP_IPV6 | + RTE_GRO_IPV4_VXLAN_UDP_IPV6)) == 0)) return nb_pkts; tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX]; @@ -582,6 +634,7 @@ struct gro_ctx { vxlan6_tcp4_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_TCP_IPV4_INDEX]; vxlan6_tcp6_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX]; udp6_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV6_INDEX]; + vxlan_udp6_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == RTE_GRO_TCP_IPV4; @@ -601,6 +654,8 @@ struct gro_ctx { == RTE_GRO_IPV6_VXLAN_TCP_IPV6; do_udp6_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV6) == RTE_GRO_UDP_IPV6; + do_vxlan_udp6_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV6) + == RTE_GRO_IPV4_VXLAN_UDP_IPV6; current_time = rte_rdtsc(); @@ -650,6 +705,11 @@ struct gro_ctx { if (gro_udp6_reassemble(pkts[i], udp6_tbl, current_time) < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV4_VXLAN_UDP6_PKT(pkts[i]->packet_type) && + do_vxlan_udp6_gro) { + if (gro_vxlan_udp6_reassemble(pkts[i], vxlan_udp6_tbl, + current_time) < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -741,6 +801,13 @@ struct gro_ctx { gro_ctx->tbls[RTE_GRO_UDP_IPV6_INDEX], flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV6) && left_nb_out > 0) { + num += gro_vxlan_udp6_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX], + flush_timestamp, &out[num], left_nb_out); } return num; diff --git a/lib/librte_gro/rte_gro.h b/lib/librte_gro/rte_gro.h index 94ed3d3..1824ce3 100644 --- a/lib/librte_gro/rte_gro.h +++ b/lib/librte_gro/rte_gro.h @@ -53,6 +53,9 @@ #define RTE_GRO_UDP_IPV6_INDEX 8 #define RTE_GRO_UDP_IPV6 (1ULL << RTE_GRO_UDP_IPV6_INDEX) /**< UDP/IPv6 GRO flag */ +#define RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX 9 +#define RTE_GRO_IPV4_VXLAN_UDP_IPV6 (1ULL << RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX) +/**< IPv4 VxLAN UDP/IPv6 GRO flag. */ /** * Structure used to create GRO context objects or used to pass From patchwork Mon Dec 21 03:50:51 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: yang_y_yi X-Patchwork-Id: 85579 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 53BDEA09FE; Mon, 21 Dec 2020 04:53:30 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 9AA4FCCBD; Mon, 21 Dec 2020 04:51:11 +0100 (CET) Received: from mail-m972.mail.163.com (mail-m972.mail.163.com [123.126.97.2]) by dpdk.org (Postfix) with ESMTP id C4828CB79 for ; Mon, 21 Dec 2020 04:50:58 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id:MIME-Version; bh=bdVff lUwCCNrhnEecWCnpE8Ekzxs6cOSGsFKghPNiWY=; b=VtZ7zWzxi6Zj44IQwhfHr DUUiQzfAaQMuDR0iEpbl0XBlE04cxW/GwX2zvr50m28d6go3SFUFoLg/Q1t2UP/I LaIiv90i0WWs9y3mzY7xf1r5zM384fSUNrQvcUNIbLyeCe5bhHBCSe9ZwUJNcX7F SsoU5tIp9NLGxO1nZzH+ro= Received: from yangyi0100.home.langchao.com (unknown [111.207.123.53]) by smtp2 (Coremail) with SMTP id GtxpCgD3vb6cG+BfUOf7Fw--.755S9; Mon, 21 Dec 2020 11:50:55 +0800 (CST) From: yang_y_yi@163.com To: dev@dpdk.org Cc: jiayu.hu@intel.com, konstantin.ananyev@intel.com, thomas@monjalon.net, yangyi01@inspur.com, yang_y_yi@163.com Date: Mon, 21 Dec 2020 11:50:51 +0800 Message-Id: <20201221035052.128292-8-yang_y_yi@163.com> X-Mailer: git-send-email 2.19.2.windows.1 In-Reply-To: <20201221035052.128292-1-yang_y_yi@163.com> References: <20201221035052.128292-1-yang_y_yi@163.com> MIME-Version: 1.0 X-CM-TRANSID: GtxpCgD3vb6cG+BfUOf7Fw--.755S9 X-Coremail-Antispam: 1Uf129KBjvAXoWftFW7Kw1kCrW5ZrW8Jr43KFg_yoW5ZF4rXo WxXan09rykur1Yyr40yr1xuryjgw48KrnrCrs0gw4fW3Z2yrWUG393Ww43Aa17X3yavF9Y 9w1xWa17XF42yrZ7n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxUO89MUUUUU X-Originating-IP: [111.207.123.53] X-CM-SenderInfo: 51dqwsp1b1xqqrwthudrp/1tbiEAACi18YEc33VAAAsh Subject: [dpdk-dev] [PATCH v1 7/8] gro: support IPv6 VXLAN UDP/IPv4 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Yi Yang IPv6 VXLAN UDP/IPv4 GRO can help improve UDP/IPv4 performance in IPv6 VXLAN use case. With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP/IPv4 performance, it will merge small adjacent IPv6 VXLAN UDP/IPv4 fragments to a big IPv6 VXLAN UDP/IPv4 packet immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VXLAN use case. Signed-off-by: Yi Yang --- .../prog_guide/generic_receive_offload_lib.rst | 3 +- doc/guides/rel_notes/release_21_02.rst | 5 + lib/librte_gro/gro_vxlan6_udp4.c | 559 +++++++++++++++++++++ lib/librte_gro/gro_vxlan6_udp4.h | 148 ++++++ lib/librte_gro/meson.build | 2 +- lib/librte_gro/rte_gro.c | 84 +++- lib/librte_gro/rte_gro.h | 3 + 7 files changed, 794 insertions(+), 10 deletions(-) create mode 100644 lib/librte_gro/gro_vxlan6_udp4.c create mode 100644 lib/librte_gro/gro_vxlan6_udp4.h diff --git a/doc/guides/prog_guide/generic_receive_offload_lib.rst b/doc/guides/prog_guide/generic_receive_offload_lib.rst index 906e85f..8f48809 100644 --- a/doc/guides/prog_guide/generic_receive_offload_lib.rst +++ b/doc/guides/prog_guide/generic_receive_offload_lib.rst @@ -33,7 +33,8 @@ fragmentation is possible (i.e., DF==0). Additionally, it complies RFC Currently, the GRO library provides GRO supports for TCP/IPv4, UDP/IPv4, UDP/IPv6, and TCP/IPv6 packets as well as VxLAN packets which contain an outer IPv4 header and an inner TCP/IPv4, UDP/IPv4, TCP/IPv6 or UDP/IPv6 -packet or an outer IPv6 header and an inner TCP/IPv4 or TCP/IPv6 packet. +packet or an outer IPv6 header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 +packet. Two Sets of API --------------- diff --git a/doc/guides/rel_notes/release_21_02.rst b/doc/guides/rel_notes/release_21_02.rst index 4758cea..5e3d10b 100644 --- a/doc/guides/rel_notes/release_21_02.rst +++ b/doc/guides/rel_notes/release_21_02.rst @@ -85,6 +85,11 @@ New Features Added UDP/IPv6 GRO support for IPv4 VXLAN packets, this enabled UDP/IPv6 GRO support for IPv4 VXLAN use case. +* **Added UDP/IPv4 GRO support for IPv6 VXLAN packets.** + + Added UDP/IPv4 GRO support for IPv6 VXLAN packets, this enabled UDP/IPv4 + GRO support for IPv6 VXLAN use case. + Removed Items ------------- diff --git a/lib/librte_gro/gro_vxlan6_udp4.c b/lib/librte_gro/gro_vxlan6_udp4.c new file mode 100644 index 0000000..c9e7af4 --- /dev/null +++ b/lib/librte_gro/gro_vxlan6_udp4.c @@ -0,0 +1,559 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#include +#include +#include +#include +#include +#include + +#include "gro_vxlan6_udp4.h" + +void * +gro_vxlan6_udp4_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_vxlan6_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_VXLAN6_UDP4_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_vxlan6_udp4_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_vxlan6_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_vxlan6_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_vxlan6_udp4_tbl_destroy(void *tbl) +{ + struct gro_vxlan6_udp4_tbl *vxlan6_tbl = tbl; + + if (vxlan6_tbl) { + rte_free(vxlan6_tbl->items); + rte_free(vxlan6_tbl->flows); + } + rte_free(vxlan6_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_vxlan6_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_vxlan6_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_vxlan6_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_vxlan6_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; +} + +/* Copy IPv6 addr */ +static inline void gro_ipv6_addr_copy(const uint8_t *ipv6_from, + uint8_t *ipv6_to) +{ + const uint64_t *from_words = (const uint64_t *)ipv6_from; + uint64_t *to_words = (uint64_t *)ipv6_to; + + to_words[0] = from_words[0]; + to_words[1] = from_words[1]; +} + +static inline int rte_is_same_ipv6_addr(const uint8_t *ipv6_a1, + const uint8_t *ipv6_a2) +{ + const uint64_t *w1 = (const uint64_t *)ipv6_a1; + const uint64_t *w2 = (const uint64_t *)ipv6_a2; + + return ((w1[0] ^ w2[0]) | (w1[1] ^ w2[1])) == 0; +} + +static inline uint32_t +insert_new_flow(struct gro_vxlan6_udp4_tbl *tbl, + struct vxlan6_udp4_flow_key *src, + uint32_t item_idx) +{ + struct vxlan6_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; + rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr)); + rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr)); + gro_ipv6_addr_copy(src->outer_ip_saddr, dst->outer_ip_saddr); + gro_ipv6_addr_copy(src->outer_ip_daddr, dst->outer_ip_daddr); + 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_vxlan6_udp4_flow(struct vxlan6_udp4_flow_key k1, + struct vxlan6_udp4_flow_key k2) +{ + /* For VxLAN 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) && + rte_is_same_ipv6_addr(k1.outer_ip_saddr, + k2.outer_ip_saddr) && + rte_is_same_ipv6_addr(k1.outer_ip_daddr, + k2.outer_ip_daddr) && + (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) && + is_same_udp4_flow(k1.inner_key, k2.inner_key)); +} + +static inline int +udp_check_vxlan6_neighbor(struct gro_vxlan6_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; + + 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_vxlan6_udp4_packets(struct gro_vxlan6_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_vxlan6_header(struct gro_vxlan6_udp4_item *item) +{ + struct rte_ipv6_hdr *ipv6_hdr; + 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 IPv6 header. */ + len = pkt->pkt_len - pkt->outer_l2_len; + ipv6_hdr = (struct rte_ipv6_hdr *)(rte_pktmbuf_mtod(pkt, char *) + + pkt->outer_l2_len); + ipv6_hdr->payload_len = rte_cpu_to_be_16(len - pkt->outer_l3_len); + + /* Update the outer UDP header. */ + len -= pkt->outer_l3_len; + udp_hdr = (struct rte_udp_hdr *)((char *)ipv6_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_vxlan6_udp4_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan6_udp4_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ipv6_hdr *outer_ipv6_hdr; + struct rte_ipv4_hdr *ipv4_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_vxlan_hdr *vxlan_hdr; + uint16_t frag_offset; + uint8_t is_last_frag; + int16_t ip_dl; + uint16_t ip_id; + + struct vxlan6_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_ipv6_hdr = (struct rte_ipv6_hdr *)((char *)outer_eth_hdr + + pkt->outer_l2_len); + + udp_hdr = (struct rte_udp_hdr *)((char *)outer_ipv6_hdr + + pkt->outer_l3_len); + vxlan_hdr = (struct rte_vxlan_hdr *)((char *)udp_hdr + + sizeof(struct rte_udp_hdr)); + eth_hdr = (struct rte_ether_hdr *)((char *)vxlan_hdr + + sizeof(struct rte_vxlan_hdr)); + /* l2_len = outer udp hdr len + vxlan 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->s_addr), &(key.inner_key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->d_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; + rte_ether_addr_copy(&(outer_eth_hdr->s_addr), &(key.outer_eth_saddr)); + rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr)); + gro_ipv6_addr_copy(outer_ipv6_hdr->src_addr, key.outer_ip_saddr); + gro_ipv6_addr_copy(outer_ipv6_hdr->dst_addr, key.outer_ip_daddr); + 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_vxlan6_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 (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 = udp_check_vxlan6_neighbor(&(tbl->items[cur_idx]), + frag_offset, ip_dl); + if (cmp) { + if (merge_two_vxlan6_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 (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_vxlan6_udp4_merge_items(struct gro_vxlan6_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 = udp_check_vxlan6_neighbor(&(tbl->items[start_idx]), + frag_offset, ip_dl); + if (cmp) { + if (merge_two_vxlan6_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_vxlan6_udp4_tbl_timeout_flush(struct gro_vxlan6_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_vxlan6_udp4_merge_items(tbl, j); + out[k++] = tbl->items[j].inner_item.firstseg; + if (tbl->items[j].inner_item.nb_merged > 1) + update_vxlan6_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_vxlan6_udp4_tbl_pkt_count(void *tbl) +{ + struct gro_vxlan6_udp4_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/librte_gro/gro_vxlan6_udp4.h b/lib/librte_gro/gro_vxlan6_udp4.h new file mode 100644 index 0000000..14dc2b6 --- /dev/null +++ b/lib/librte_gro/gro_vxlan6_udp4.h @@ -0,0 +1,148 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#ifndef _GRO_VXLAN6_UDP4_H_ +#define _GRO_VXLAN6_UDP4_H_ + +#include "gro_udp4.h" + +#define GRO_VXLAN6_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + +/* Header fields representing a IPv6 VxLAN flow */ +struct vxlan6_udp4_flow_key { + struct udp4_flow_key inner_key; + struct rte_vxlan_hdr vxlan_hdr; + + struct rte_ether_addr outer_eth_saddr; + struct rte_ether_addr outer_eth_daddr; + + uint8_t outer_ip_saddr[16]; + uint8_t outer_ip_daddr[16]; + + /* Outer UDP ports */ + uint16_t outer_src_port; + uint16_t outer_dst_port; + +}; + +struct gro_vxlan6_udp4_flow { + struct vxlan6_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_vxlan6_udp4_item { + struct gro_udp4_item inner_item; +}; + +/* + * IPv6 VxLAN (with an outer IPv6 header and an inner UDP/IPv4 packet) + * reassembly table structure + */ +struct gro_vxlan6_udp4_tbl { + /* item array */ + struct gro_vxlan6_udp4_item *items; + /* flow array */ + struct gro_vxlan6_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 IPv6 VxLAN reassembly table for IPv6 VxLAN packets + * which have an outer IPv6 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_vxlan6_udp4_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + +/** + * This function destroys a IPv6 VxLAN reassembly table. + * + * @param tbl + * Pointer pointing to the IPv6 VxLAN reassembly table + */ +void gro_vxlan6_udp4_tbl_destroy(void *tbl); + +/** + * This function merges a IPv6 VxLAN packet which has an outer IPv6 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 IPv6 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_vxlan6_udp4_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan6_udp4_tbl *tbl, + uint64_t start_time); + +/** + * This function flushes timeout packets in the IPv6 VxLAN reassembly table, + * and without updating checksums. + * + * @param tbl + * Pointer pointing to a IPv6 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_vxlan6_udp4_tbl_timeout_flush(struct gro_vxlan6_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 IPv6 VxLAN + * reassembly table. + * + * @param tbl + * Pointer pointing to the IPv6 VxLAN reassembly table + * + * @return + * The number of packets in the table + */ +uint32_t gro_vxlan6_udp4_tbl_pkt_count(void *tbl); +#endif diff --git a/lib/librte_gro/meson.build b/lib/librte_gro/meson.build index 14b6b64..e23197d 100644 --- a/lib/librte_gro/meson.build +++ b/lib/librte_gro/meson.build @@ -1,6 +1,6 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c', 'gro_udp6.c', 'gro_vxlan_udp6.c') +sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c', 'gro_udp6.c', 'gro_vxlan_udp6.c', 'gro_vxlan6_udp4.c') headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c index 3bb7ea1..021a49e 100644 --- a/lib/librte_gro/rte_gro.c +++ b/lib/librte_gro/rte_gro.c @@ -14,6 +14,7 @@ #include "gro_udp6.h" #include "gro_vxlan6_tcp4.h" #include "gro_vxlan6_tcp6.h" +#include "gro_vxlan6_udp4.h" #include "gro_vxlan_tcp4.h" #include "gro_vxlan_tcp6.h" #include "gro_vxlan_udp4.h" @@ -31,7 +32,7 @@ gro_tcp6_tbl_create, gro_vxlan_tcp6_tbl_create, gro_vxlan6_tcp4_tbl_create, gro_vxlan6_tcp6_tbl_create, gro_udp6_tbl_create, gro_vxlan_udp6_tbl_create, - NULL}; + gro_vxlan6_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, @@ -39,7 +40,7 @@ gro_vxlan6_tcp4_tbl_destroy, gro_vxlan6_tcp6_tbl_destroy, gro_udp6_tbl_destroy, gro_vxlan_udp6_tbl_destroy, - NULL}; + gro_vxlan6_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, @@ -47,7 +48,7 @@ gro_vxlan6_tcp4_tbl_pkt_count, gro_vxlan6_tcp6_tbl_pkt_count, gro_udp6_tbl_pkt_count, gro_vxlan_udp6_tbl_pkt_count, - NULL}; + gro_vxlan6_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) && \ @@ -143,6 +144,19 @@ ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN))) +#define IS_IPV6_VXLAN_UDP4_PKT(ptype) (RTE_ETH_IS_IPV6_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + ((ptype & RTE_PTYPE_TUNNEL_VXLAN) == \ + RTE_PTYPE_TUNNEL_VXLAN) && \ + ((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))) + /* * GRO context structure. It keeps the table structures, which are * used to merge packets, for different GRO types. Before using @@ -279,6 +293,13 @@ struct gro_ctx { struct gro_vxlan_udp6_item vxlan_udp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}, 0, 0} }; + /* Allocate a reassembly table for IPv6 VXLAN UDP/IPv4 GRO */ + struct gro_vxlan6_udp4_tbl vxlan6_udp4_tbl; + struct gro_vxlan6_udp4_flow + vxlan6_udp4_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_vxlan6_udp4_item + vxlan6_udp4_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + struct rte_mbuf *unprocess_pkts[nb_pkts]; uint32_t item_num; int32_t ret; @@ -286,7 +307,8 @@ struct gro_ctx { 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_tcp6_gro = 0, do_vxlan6_tcp4_gro = 0, do_vxlan6_tcp6_gro = 0, - do_udp6_gro = 0, do_vxlan_udp6_gro = 0; + do_udp6_gro = 0, do_vxlan_udp6_gro = 0, + do_vxlan6_udp4_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -297,7 +319,8 @@ struct gro_ctx { RTE_GRO_IPV6_VXLAN_TCP_IPV4 | RTE_GRO_IPV6_VXLAN_TCP_IPV6 | RTE_GRO_UDP_IPV6 | - RTE_GRO_IPV4_VXLAN_UDP_IPV6)) == 0)) + RTE_GRO_IPV4_VXLAN_UDP_IPV6 | + RTE_GRO_IPV6_VXLAN_UDP_IPV4)) == 0)) return nb_pkts; /* Get the maximum number of packets */ @@ -435,6 +458,19 @@ struct gro_ctx { do_vxlan_udp6_gro = 1; } + if (param->gro_types & RTE_GRO_IPV6_VXLAN_UDP_IPV4) { + for (i = 0; i < item_num; i++) + vxlan6_udp4_flows[i].start_index = INVALID_ARRAY_INDEX; + + vxlan6_udp4_tbl.flows = vxlan6_udp4_flows; + vxlan6_udp4_tbl.items = vxlan6_udp4_items; + vxlan6_udp4_tbl.flow_num = 0; + vxlan6_udp4_tbl.item_num = 0; + vxlan6_udp4_tbl.max_flow_num = item_num; + vxlan6_udp4_tbl.max_item_num = item_num; + do_vxlan6_udp4_gro = 1; + } + for (i = 0; i < nb_pkts; i++) { /* * The timestamp is ignored, since all packets @@ -526,6 +562,15 @@ struct gro_ctx { nb_after_gro--; else if (ret < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_VXLAN_UDP4_PKT(pkts[i]->packet_type) && + do_vxlan6_udp4_gro) { + ret = gro_vxlan6_udp4_reassemble(pkts[i], + &vxlan6_udp4_tbl, 0); + if (ret > 0) + /* Merge successfully */ + nb_after_gro--; + else if (ret < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -585,6 +630,12 @@ struct gro_ctx { 0, &pkts[i], nb_pkts - i); } + if (do_vxlan6_udp4_gro) { + i += gro_vxlan6_udp4_tbl_timeout_flush(&vxlan6_udp4_tbl, + 0, &pkts[i], nb_pkts - i); + + } + /* Copy unprocessed packets */ if (unprocess_num > 0) { memcpy(&pkts[i], unprocess_pkts, @@ -606,12 +657,13 @@ struct gro_ctx { struct gro_ctx *gro_ctx = ctx; void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_tbl, *vxlan_tcp6_tbl, *vxlan6_tcp4_tbl, *vxlan6_tcp6_tbl, - *udp6_tbl, *vxlan_udp6_tbl; + *udp6_tbl, *vxlan_udp6_tbl, *vxlan6_udp4_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, do_vxlan_tcp6_gro, do_vxlan6_tcp4_gro, - do_vxlan6_tcp6_gro, do_udp6_gro, do_vxlan_udp6_gro; + do_vxlan6_tcp6_gro, do_udp6_gro, do_vxlan_udp6_gro, + do_vxlan6_udp4_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -622,7 +674,8 @@ struct gro_ctx { RTE_GRO_IPV6_VXLAN_TCP_IPV4 | RTE_GRO_IPV6_VXLAN_TCP_IPV6 | RTE_GRO_UDP_IPV6 | - RTE_GRO_IPV4_VXLAN_UDP_IPV6)) == 0)) + RTE_GRO_IPV4_VXLAN_UDP_IPV6 | + RTE_GRO_IPV6_VXLAN_UDP_IPV4)) == 0)) return nb_pkts; tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX]; @@ -635,6 +688,7 @@ struct gro_ctx { vxlan6_tcp6_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_TCP_IPV6_INDEX]; udp6_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV6_INDEX]; vxlan_udp6_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX]; + vxlan6_udp4_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_UDP_IPV4_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == RTE_GRO_TCP_IPV4; @@ -656,6 +710,8 @@ struct gro_ctx { RTE_GRO_UDP_IPV6; do_vxlan_udp6_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV6) == RTE_GRO_IPV4_VXLAN_UDP_IPV6; + do_vxlan6_udp4_gro = (gro_ctx->gro_types & RTE_GRO_IPV6_VXLAN_UDP_IPV4) + == RTE_GRO_IPV6_VXLAN_UDP_IPV4; current_time = rte_rdtsc(); @@ -710,6 +766,11 @@ struct gro_ctx { if (gro_vxlan_udp6_reassemble(pkts[i], vxlan_udp6_tbl, current_time) < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_VXLAN_UDP4_PKT(pkts[i]->packet_type) && + do_vxlan6_udp4_gro) { + if (gro_vxlan6_udp4_reassemble(pkts[i], vxlan6_udp4_tbl, + current_time) < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -808,6 +869,13 @@ struct gro_ctx { num += gro_vxlan_udp6_tbl_timeout_flush(gro_ctx->tbls[ RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX], flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_IPV6_VXLAN_UDP_IPV4) && left_nb_out > 0) { + num += gro_vxlan6_udp4_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_IPV6_VXLAN_UDP_IPV4_INDEX], + flush_timestamp, &out[num], left_nb_out); } return num; diff --git a/lib/librte_gro/rte_gro.h b/lib/librte_gro/rte_gro.h index 1824ce3..ddcded6 100644 --- a/lib/librte_gro/rte_gro.h +++ b/lib/librte_gro/rte_gro.h @@ -56,6 +56,9 @@ #define RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX 9 #define RTE_GRO_IPV4_VXLAN_UDP_IPV6 (1ULL << RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX) /**< IPv4 VxLAN UDP/IPv6 GRO flag. */ +#define RTE_GRO_IPV6_VXLAN_UDP_IPV4_INDEX 10 +#define RTE_GRO_IPV6_VXLAN_UDP_IPV4 (1ULL << RTE_GRO_IPV6_VXLAN_UDP_IPV4_INDEX) +/**< IPv6 VxLAN UDP/IPv4 GRO flag. */ /** * Structure used to create GRO context objects or used to pass From patchwork Mon Dec 21 03:50:52 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: yang_y_yi X-Patchwork-Id: 85580 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 3BAEFA09FE; Mon, 21 Dec 2020 04:53:49 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id EE8BCCCE0; Mon, 21 Dec 2020 04:51:12 +0100 (CET) Received: from mail-m972.mail.163.com (mail-m972.mail.163.com [123.126.97.2]) by dpdk.org (Postfix) with ESMTP id 14D61CACA for ; Mon, 21 Dec 2020 04:50:58 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=163.com; s=s110527; h=From:Subject:Date:Message-Id:MIME-Version; bh=ZTEEC Ac7LQ8ony9GqOQ+YxaJEL3kBLTjS95nqKmZ3z8=; b=Ryyv3tca9dEV4KYX15pqn xUGYz0FoG4ohr/2q4zun8FWZ15740NPrCbBFg/Lj1uHMR/si7z7MobyKIJpm6PY5 myep4hf/HYqh7JIo2rHQKt/VcCeGDPpa8kpnuuIS1XWCWf+p8NxIew7O1FO1+sF8 5PuesG2NTqX+y/fWdMPo2U= Received: from yangyi0100.home.langchao.com (unknown [111.207.123.53]) by smtp2 (Coremail) with SMTP id GtxpCgD3vb6cG+BfUOf7Fw--.755S10; Mon, 21 Dec 2020 11:50:56 +0800 (CST) From: yang_y_yi@163.com To: dev@dpdk.org Cc: jiayu.hu@intel.com, konstantin.ananyev@intel.com, thomas@monjalon.net, yangyi01@inspur.com, yang_y_yi@163.com Date: Mon, 21 Dec 2020 11:50:52 +0800 Message-Id: <20201221035052.128292-9-yang_y_yi@163.com> X-Mailer: git-send-email 2.19.2.windows.1 In-Reply-To: <20201221035052.128292-1-yang_y_yi@163.com> References: <20201221035052.128292-1-yang_y_yi@163.com> MIME-Version: 1.0 X-CM-TRANSID: GtxpCgD3vb6cG+BfUOf7Fw--.755S10 X-Coremail-Antispam: 1Uf129KBjvAXoWfCFWxKrWfZrW5JryDKryxAFb_yoW5uFWkAo WxXan8Xr1kur1Yyr1YyF1xur1jgw18Kr47Crs0gws5W3Z2vrWUWrZ3Ww43Aa17X3yYya4v 9wn3Wa17XF4Iyrs7n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxUO1v3DUUUU X-Originating-IP: [111.207.123.53] X-CM-SenderInfo: 51dqwsp1b1xqqrwthudrp/xtbBEgACi16iadMbDgAAsI Subject: [dpdk-dev] [PATCH v1 8/8] gro: support IPv6 VXLAN UDP/IPv6 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Yi Yang IPv6 VXLAN UDP/IPv6 GRO can help improve UDP/IPv6 performance in IPv6 VXLAN use case. With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP/IPv6 performance, it will merge small adjacent IPv6 VXLAN UDP/IPv6 fragments to a big IPv6 VXLAN UDP/IPv6 packet immediate after they are received from a physical NIC. It is very helpful in OVS DPDK IPv6 VXLAN use case. Signed-off-by: Yi Yang --- .../prog_guide/generic_receive_offload_lib.rst | 4 +- doc/guides/rel_notes/release_21_02.rst | 5 + lib/librte_gro/gro_vxlan6_udp6.c | 589 +++++++++++++++++++++ lib/librte_gro/gro_vxlan6_udp6.h | 148 ++++++ lib/librte_gro/meson.build | 2 +- lib/librte_gro/rte_gro.c | 84 ++- lib/librte_gro/rte_gro.h | 3 + 7 files changed, 824 insertions(+), 11 deletions(-) create mode 100644 lib/librte_gro/gro_vxlan6_udp6.c create mode 100644 lib/librte_gro/gro_vxlan6_udp6.h diff --git a/doc/guides/prog_guide/generic_receive_offload_lib.rst b/doc/guides/prog_guide/generic_receive_offload_lib.rst index 8f48809..971323d 100644 --- a/doc/guides/prog_guide/generic_receive_offload_lib.rst +++ b/doc/guides/prog_guide/generic_receive_offload_lib.rst @@ -33,8 +33,8 @@ fragmentation is possible (i.e., DF==0). Additionally, it complies RFC Currently, the GRO library provides GRO supports for TCP/IPv4, UDP/IPv4, UDP/IPv6, and TCP/IPv6 packets as well as VxLAN packets which contain an outer IPv4 header and an inner TCP/IPv4, UDP/IPv4, TCP/IPv6 or UDP/IPv6 -packet or an outer IPv6 header and an inner TCP/IPv4, UDP/IPv4 or TCP/IPv6 -packet. +packet or an outer IPv6 header and an inner TCP/IPv4, UDP/IPv4, TCP/IPv6 +or UDP/IPv6 packet. Two Sets of API --------------- diff --git a/doc/guides/rel_notes/release_21_02.rst b/doc/guides/rel_notes/release_21_02.rst index 5e3d10b..991aa51 100644 --- a/doc/guides/rel_notes/release_21_02.rst +++ b/doc/guides/rel_notes/release_21_02.rst @@ -90,6 +90,11 @@ New Features Added UDP/IPv4 GRO support for IPv6 VXLAN packets, this enabled UDP/IPv4 GRO support for IPv6 VXLAN use case. +* **Added UDP/IPv6 GRO support for IPv6 VXLAN packets.** + + Added UDP/IPv6 GRO support for IPv6 VXLAN packets, this enabled UDP/IPv6 + GRO support for IPv6 VXLAN use case. + Removed Items ------------- diff --git a/lib/librte_gro/gro_vxlan6_udp6.c b/lib/librte_gro/gro_vxlan6_udp6.c new file mode 100644 index 0000000..c038e13 --- /dev/null +++ b/lib/librte_gro/gro_vxlan6_udp6.c @@ -0,0 +1,589 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#include +#include +#include +#include +#include +#include + +#include "gro_vxlan6_udp6.h" + +void * +gro_vxlan6_udp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow) +{ + struct gro_vxlan6_udp6_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_VXLAN6_UDP6_TBL_MAX_ITEM_NUM); + + if (entries_num == 0) + return NULL; + + tbl = rte_zmalloc_socket(__func__, + sizeof(struct gro_vxlan6_udp6_tbl), + RTE_CACHE_LINE_SIZE, + socket_id); + if (tbl == NULL) + return NULL; + + size = sizeof(struct gro_vxlan6_udp6_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_vxlan6_udp6_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_vxlan6_udp6_tbl_destroy(void *tbl) +{ + struct gro_vxlan6_udp6_tbl *vxlan6_tbl = tbl; + + if (vxlan6_tbl) { + rte_free(vxlan6_tbl->items); + rte_free(vxlan6_tbl->flows); + } + rte_free(vxlan6_tbl); +} + +static inline uint32_t +find_an_empty_item(struct gro_vxlan6_udp6_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_vxlan6_udp6_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_vxlan6_udp6_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_vxlan6_udp6_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; +} + +/* Copy IPv6 addr */ +static inline void gro_ipv6_addr_copy(const uint8_t *ipv6_from, + uint8_t *ipv6_to) +{ + const uint64_t *from_words = (const uint64_t *)ipv6_from; + uint64_t *to_words = (uint64_t *)ipv6_to; + + to_words[0] = from_words[0]; + to_words[1] = from_words[1]; +} + +static inline uint32_t +insert_new_flow(struct gro_vxlan6_udp6_tbl *tbl, + struct vxlan6_udp6_flow_key *src, + uint32_t item_idx) +{ + struct vxlan6_udp6_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)); + gro_ipv6_addr_copy(src->inner_key.ip_saddr, dst->inner_key.ip_saddr); + gro_ipv6_addr_copy(src->inner_key.ip_daddr, dst->inner_key.ip_daddr); + 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; + rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr)); + rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr)); + gro_ipv6_addr_copy(src->outer_ip_saddr, dst->outer_ip_saddr); + gro_ipv6_addr_copy(src->outer_ip_daddr, dst->outer_ip_daddr); + 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_vxlan6_udp6_flow(struct vxlan6_udp6_flow_key k1, + struct vxlan6_udp6_flow_key k2) +{ + /* For VxLAN 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) && + rte_is_same_ipv6_addr(k1.outer_ip_saddr, + k2.outer_ip_saddr) && + rte_is_same_ipv6_addr(k1.outer_ip_daddr, + k2.outer_ip_daddr) && + (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) && + is_same_udp6_flow(k1.inner_key, k2.inner_key)); +} + +static inline int +udp6_check_vxlan6_neighbor(struct gro_vxlan6_udp6_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; + + l2_offset = pkt->outer_l2_len + pkt->outer_l3_len; + cmp = udp6_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_vxlan6_udp6_packets(struct gro_vxlan6_udp6_item *item, + struct rte_mbuf *pkt, + int cmp, + uint16_t frag_offset, + uint8_t is_last_frag) +{ + if (merge_two_udp6_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 uint16_t +get_ipv6_frag_offset(struct rte_ipv6_fragment_ext *ipv6_frag_hdr) +{ + return ((rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) >> 3) * 8); +} + +static inline uint8_t +is_last_ipv6_frag(struct rte_ipv6_fragment_ext *ipv6_frag_hdr) +{ + return (rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) & 0x0001); +} + +static inline void +update_vxlan6_header(struct gro_vxlan6_udp6_item *item) +{ + struct rte_ipv6_hdr *outer_ipv6_hdr, *ipv6_hdr; + struct rte_udp_hdr *udp_hdr; + struct rte_ipv6_fragment_ext *ipv6_frag_hdr; + size_t fh_len = sizeof(*ipv6_frag_hdr); + struct rte_mbuf *pkt = item->inner_item.firstseg; + uint16_t len; + + /* Position to inner IPv6 header first */ + ipv6_hdr = (struct rte_ipv6_hdr *)rte_pktmbuf_mtod_offset(pkt, char *, + pkt->outer_l2_len + pkt->outer_l3_len + pkt->l2_len); + len = pkt->pkt_len - pkt->outer_l2_len - pkt->outer_l3_len + - pkt->l2_len; + ipv6_hdr->payload_len = rte_cpu_to_be_16(len - pkt->l3_len); + + /* Remove fragment extension header or clear MF flag */ + if (item->inner_item.is_last_frag + && (ipv6_hdr->proto == IPPROTO_FRAGMENT)) { + uint16_t ip_ofs; + + ipv6_frag_hdr = (struct rte_ipv6_fragment_ext *)(ipv6_hdr + 1); + ip_ofs = get_ipv6_frag_offset(ipv6_frag_hdr); + if (ip_ofs == 0) { + ipv6_hdr->proto = ipv6_frag_hdr->next_header; + pkt->l3_len -= fh_len; + + /* Remove IPv6 fragment extension header */ + memmove(rte_pktmbuf_mtod_offset(pkt, char *, fh_len), + rte_pktmbuf_mtod(pkt, char*), + pkt->outer_l2_len + pkt->outer_l3_len + + pkt->l2_len + pkt->l3_len); + rte_pktmbuf_adj(pkt, fh_len); + } else { + /* clear MF flag */ + ipv6_frag_hdr->frag_data = rte_cpu_to_be_16( + (rte_be_to_cpu_16(ipv6_frag_hdr->frag_data) & + 0xFFFE)); + ipv6_hdr->payload_len += fh_len; + } + } + + /* Must adjust outer payload_len after inner IPv6 is handled. */ + /* Update the outer IPv6 header. */ + len = pkt->pkt_len - pkt->outer_l2_len; + outer_ipv6_hdr = (struct rte_ipv6_hdr *)(rte_pktmbuf_mtod(pkt, char *) + + pkt->outer_l2_len); + outer_ipv6_hdr->payload_len = rte_cpu_to_be_16(len + - pkt->outer_l3_len); + + /* Point to the outer UDP header. */ + len -= pkt->outer_l3_len; + udp_hdr = (struct rte_udp_hdr *)((char *)outer_ipv6_hdr + + pkt->outer_l3_len); + udp_hdr->dgram_len = rte_cpu_to_be_16(len); +} + +int32_t +gro_vxlan6_udp6_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan6_udp6_tbl *tbl, + uint64_t start_time) +{ + struct rte_ether_hdr *outer_eth_hdr, *eth_hdr; + struct rte_ipv6_hdr *outer_ipv6_hdr; + struct rte_ipv6_hdr *ipv6_hdr; + struct rte_ipv6_fragment_ext *ipv6_frag_hdr; + uint16_t fh_len = sizeof(*ipv6_frag_hdr); + struct rte_udp_hdr *udp_hdr; + struct rte_vxlan_hdr *vxlan_hdr; + uint16_t frag_offset; + uint8_t is_last_frag; + int16_t ip_dl; + uint32_t ip_id; + + struct vxlan6_udp6_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_ipv6_hdr = (struct rte_ipv6_hdr *)((char *)outer_eth_hdr + + pkt->outer_l2_len); + + udp_hdr = (struct rte_udp_hdr *)((char *)outer_ipv6_hdr + + pkt->outer_l3_len); + vxlan_hdr = (struct rte_vxlan_hdr *)((char *)udp_hdr + + sizeof(struct rte_udp_hdr)); + eth_hdr = (struct rte_ether_hdr *)((char *)vxlan_hdr + + sizeof(struct rte_vxlan_hdr)); + /* l2_len = outer udp hdr len + vxlan hdr len + inner l2 len */ + ipv6_hdr = (struct rte_ipv6_hdr *)((char *)udp_hdr + pkt->l2_len); + + /* + * Don't process the packet which has non-fragment inner IP. + */ + if (ipv6_hdr->proto != IPPROTO_FRAGMENT) + return -1; + + /* Note: l3_len includes length of extension headers */ + 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; + + ipv6_frag_hdr = (struct rte_ipv6_fragment_ext *)(ipv6_hdr + 1); + ip_dl = rte_be_to_cpu_16(ipv6_hdr->payload_len) - fh_len; + ip_id = rte_be_to_cpu_32(ipv6_frag_hdr->id); + frag_offset = get_ipv6_frag_offset(ipv6_frag_hdr); + is_last_frag = is_last_ipv6_frag(ipv6_frag_hdr); + + rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.inner_key.eth_saddr)); + rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.inner_key.eth_daddr)); + gro_ipv6_addr_copy(ipv6_hdr->src_addr, key.inner_key.ip_saddr); + gro_ipv6_addr_copy(ipv6_hdr->dst_addr, key.inner_key.ip_daddr); + 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; + rte_ether_addr_copy(&(outer_eth_hdr->s_addr), &(key.outer_eth_saddr)); + rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr)); + gro_ipv6_addr_copy(outer_ipv6_hdr->src_addr, key.outer_ip_saddr); + gro_ipv6_addr_copy(outer_ipv6_hdr->dst_addr, key.outer_ip_daddr); + 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_vxlan6_udp6_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 (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 = udp6_check_vxlan6_neighbor(&(tbl->items[cur_idx]), + frag_offset, ip_dl); + if (cmp) { + if (merge_two_vxlan6_udp6_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 (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_vxlan6_udp6_merge_items(struct gro_vxlan6_udp6_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 = udp6_check_vxlan6_neighbor(&(tbl->items[start_idx]), + frag_offset, ip_dl); + if (cmp) { + if (merge_two_vxlan6_udp6_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_vxlan6_udp6_tbl_timeout_flush(struct gro_vxlan6_udp6_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_vxlan6_udp6_merge_items(tbl, j); + out[k++] = tbl->items[j].inner_item.firstseg; + if (tbl->items[j].inner_item.nb_merged > 1) + update_vxlan6_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_vxlan6_udp6_tbl_pkt_count(void *tbl) +{ + struct gro_vxlan6_udp6_tbl *gro_tbl = tbl; + + if (gro_tbl) + return gro_tbl->item_num; + + return 0; +} diff --git a/lib/librte_gro/gro_vxlan6_udp6.h b/lib/librte_gro/gro_vxlan6_udp6.h new file mode 100644 index 0000000..7f3a8e8 --- /dev/null +++ b/lib/librte_gro/gro_vxlan6_udp6.h @@ -0,0 +1,148 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Inspur Corporation + */ + +#ifndef _GRO_VXLAN6_UDP6_H_ +#define _GRO_VXLAN6_UDP6_H_ + +#include "gro_udp6.h" + +#define GRO_VXLAN6_UDP6_TBL_MAX_ITEM_NUM (1024UL * 1024UL) + +/* Header fields representing a IPv6 VxLAN flow */ +struct vxlan6_udp6_flow_key { + struct udp6_flow_key inner_key; + struct rte_vxlan_hdr vxlan_hdr; + + struct rte_ether_addr outer_eth_saddr; + struct rte_ether_addr outer_eth_daddr; + + uint8_t outer_ip_saddr[16]; + uint8_t outer_ip_daddr[16]; + + /* Outer UDP ports */ + uint16_t outer_src_port; + uint16_t outer_dst_port; + +}; + +struct gro_vxlan6_udp6_flow { + struct vxlan6_udp6_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_vxlan6_udp6_item { + struct gro_udp6_item inner_item; +}; + +/* + * IPv6 VxLAN (with an outer IPv6 header and an inner UDP/IPv6 packet) + * reassembly table structure + */ +struct gro_vxlan6_udp6_tbl { + /* item array */ + struct gro_vxlan6_udp6_item *items; + /* flow array */ + struct gro_vxlan6_udp6_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 IPv6 VxLAN reassembly table for IPv6 VxLAN packets + * which have an outer IPv6 header and an inner UDP/IPv6 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_vxlan6_udp6_tbl_create(uint16_t socket_id, + uint16_t max_flow_num, + uint16_t max_item_per_flow); + +/** + * This function destroys a IPv6 VxLAN reassembly table. + * + * @param tbl + * Pointer pointing to the IPv6 VxLAN reassembly table + */ +void gro_vxlan6_udp6_tbl_destroy(void *tbl); + +/** + * This function merges a IPv6 VxLAN packet which has an outer IPv6 header and + * an inner UDP/IPv6 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 IPv6 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_vxlan6_udp6_reassemble(struct rte_mbuf *pkt, + struct gro_vxlan6_udp6_tbl *tbl, + uint64_t start_time); + +/** + * This function flushes timeout packets in the IPv6 VxLAN reassembly table, + * and without updating checksums. + * + * @param tbl + * Pointer pointing to a IPv6 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_vxlan6_udp6_tbl_timeout_flush(struct gro_vxlan6_udp6_tbl *tbl, + uint64_t flush_timestamp, + struct rte_mbuf **out, + uint16_t nb_out); + +/** + * This function returns the number of the packets in a IPv6 VxLAN + * reassembly table. + * + * @param tbl + * Pointer pointing to the IPv6 VxLAN reassembly table + * + * @return + * The number of packets in the table + */ +uint32_t gro_vxlan6_udp6_tbl_pkt_count(void *tbl); +#endif diff --git a/lib/librte_gro/meson.build b/lib/librte_gro/meson.build index e23197d..56d015a 100644 --- a/lib/librte_gro/meson.build +++ b/lib/librte_gro/meson.build @@ -1,6 +1,6 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c', 'gro_udp6.c', 'gro_vxlan_udp6.c', 'gro_vxlan6_udp4.c') +sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c', 'gro_tcp6.c', 'gro_vxlan_tcp6.c', 'gro_vxlan6_tcp4.c', 'gro_vxlan6_tcp6.c', 'gro_udp6.c', 'gro_vxlan_udp6.c', 'gro_vxlan6_udp4.c', 'gro_vxlan6_udp6.c') headers = files('rte_gro.h') deps += ['ethdev'] diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c index 021a49e..abe3911 100644 --- a/lib/librte_gro/rte_gro.c +++ b/lib/librte_gro/rte_gro.c @@ -15,6 +15,7 @@ #include "gro_vxlan6_tcp4.h" #include "gro_vxlan6_tcp6.h" #include "gro_vxlan6_udp4.h" +#include "gro_vxlan6_udp6.h" #include "gro_vxlan_tcp4.h" #include "gro_vxlan_tcp6.h" #include "gro_vxlan_udp4.h" @@ -32,7 +33,8 @@ gro_tcp6_tbl_create, gro_vxlan_tcp6_tbl_create, gro_vxlan6_tcp4_tbl_create, gro_vxlan6_tcp6_tbl_create, gro_udp6_tbl_create, gro_vxlan_udp6_tbl_create, - gro_vxlan6_udp4_tbl_create, NULL}; + gro_vxlan6_udp4_tbl_create, gro_vxlan6_udp6_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, @@ -40,7 +42,8 @@ gro_vxlan6_tcp4_tbl_destroy, gro_vxlan6_tcp6_tbl_destroy, gro_udp6_tbl_destroy, gro_vxlan_udp6_tbl_destroy, - gro_vxlan6_udp4_tbl_destroy, NULL}; + gro_vxlan6_udp4_tbl_destroy, + gro_vxlan6_udp6_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, @@ -48,7 +51,8 @@ gro_vxlan6_tcp4_tbl_pkt_count, gro_vxlan6_tcp6_tbl_pkt_count, gro_udp6_tbl_pkt_count, gro_vxlan_udp6_tbl_pkt_count, - gro_vxlan6_udp4_tbl_pkt_count, NULL}; + gro_vxlan6_udp4_tbl_pkt_count, + gro_vxlan6_udp6_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) && \ @@ -157,6 +161,19 @@ ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN))) +#define IS_IPV6_VXLAN_UDP6_PKT(ptype) (RTE_ETH_IS_IPV6_HDR(ptype) && \ + ((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \ + ((ptype & RTE_PTYPE_TUNNEL_VXLAN) == \ + RTE_PTYPE_TUNNEL_VXLAN) && \ + ((ptype & RTE_PTYPE_INNER_L4_UDP) == \ + RTE_PTYPE_INNER_L4_UDP) && \ + (((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6_EXT) || \ + ((ptype & RTE_PTYPE_INNER_L3_MASK) == \ + RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN))) + /* * GRO context structure. It keeps the table structures, which are * used to merge packets, for different GRO types. Before using @@ -300,6 +317,13 @@ struct gro_ctx { struct gro_vxlan6_udp4_item vxlan6_udp4_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + /* Allocate a reassembly table for IPv6 VXLAN UDP/IPv6 GRO */ + struct gro_vxlan6_udp6_tbl vxlan6_udp6_tbl; + struct gro_vxlan6_udp6_flow + vxlan6_udp6_flows[RTE_GRO_MAX_BURST_ITEM_NUM]; + struct gro_vxlan6_udp6_item + vxlan6_udp6_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{{0}} }; + struct rte_mbuf *unprocess_pkts[nb_pkts]; uint32_t item_num; int32_t ret; @@ -308,7 +332,7 @@ struct gro_ctx { do_vxlan_udp_gro = 0, do_tcp6_gro = 0, do_vxlan_tcp6_gro = 0, do_vxlan6_tcp4_gro = 0, do_vxlan6_tcp6_gro = 0, do_udp6_gro = 0, do_vxlan_udp6_gro = 0, - do_vxlan6_udp4_gro = 0; + do_vxlan6_udp4_gro = 0, do_vxlan6_udp6_gro = 0; if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -320,7 +344,8 @@ struct gro_ctx { RTE_GRO_IPV6_VXLAN_TCP_IPV6 | RTE_GRO_UDP_IPV6 | RTE_GRO_IPV4_VXLAN_UDP_IPV6 | - RTE_GRO_IPV6_VXLAN_UDP_IPV4)) == 0)) + RTE_GRO_IPV6_VXLAN_UDP_IPV4 | + RTE_GRO_IPV6_VXLAN_UDP_IPV6)) == 0)) return nb_pkts; /* Get the maximum number of packets */ @@ -471,6 +496,19 @@ struct gro_ctx { do_vxlan6_udp4_gro = 1; } + if (param->gro_types & RTE_GRO_IPV6_VXLAN_UDP_IPV6) { + for (i = 0; i < item_num; i++) + vxlan6_udp6_flows[i].start_index = INVALID_ARRAY_INDEX; + + vxlan6_udp6_tbl.flows = vxlan6_udp6_flows; + vxlan6_udp6_tbl.items = vxlan6_udp6_items; + vxlan6_udp6_tbl.flow_num = 0; + vxlan6_udp6_tbl.item_num = 0; + vxlan6_udp6_tbl.max_flow_num = item_num; + vxlan6_udp6_tbl.max_item_num = item_num; + do_vxlan6_udp6_gro = 1; + } + for (i = 0; i < nb_pkts; i++) { /* * The timestamp is ignored, since all packets @@ -571,6 +609,15 @@ struct gro_ctx { nb_after_gro--; else if (ret < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_VXLAN_UDP6_PKT(pkts[i]->packet_type) && + do_vxlan6_udp6_gro) { + ret = gro_vxlan6_udp6_reassemble(pkts[i], + &vxlan6_udp6_tbl, 0); + if (ret > 0) + /* Merge successfully */ + nb_after_gro--; + else if (ret < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -633,7 +680,11 @@ struct gro_ctx { if (do_vxlan6_udp4_gro) { i += gro_vxlan6_udp4_tbl_timeout_flush(&vxlan6_udp4_tbl, 0, &pkts[i], nb_pkts - i); + } + if (do_vxlan6_udp6_gro) { + i += gro_vxlan6_udp6_tbl_timeout_flush(&vxlan6_udp6_tbl, + 0, &pkts[i], nb_pkts - i); } /* Copy unprocessed packets */ @@ -657,13 +708,14 @@ struct gro_ctx { struct gro_ctx *gro_ctx = ctx; void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl, *tcp6_tbl, *vxlan_tcp6_tbl, *vxlan6_tcp4_tbl, *vxlan6_tcp6_tbl, - *udp6_tbl, *vxlan_udp6_tbl, *vxlan6_udp4_tbl; + *udp6_tbl, *vxlan_udp6_tbl, *vxlan6_udp4_tbl, + *vxlan6_udp6_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, do_vxlan_tcp6_gro, do_vxlan6_tcp4_gro, do_vxlan6_tcp6_gro, do_udp6_gro, do_vxlan_udp6_gro, - do_vxlan6_udp4_gro; + do_vxlan6_udp4_gro, do_vxlan6_udp6_gro; if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 | RTE_GRO_TCP_IPV4 | @@ -675,7 +727,8 @@ struct gro_ctx { RTE_GRO_IPV6_VXLAN_TCP_IPV6 | RTE_GRO_UDP_IPV6 | RTE_GRO_IPV4_VXLAN_UDP_IPV6 | - RTE_GRO_IPV6_VXLAN_UDP_IPV4)) == 0)) + RTE_GRO_IPV6_VXLAN_UDP_IPV4 | + RTE_GRO_IPV6_VXLAN_UDP_IPV6)) == 0)) return nb_pkts; tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX]; @@ -689,6 +742,7 @@ struct gro_ctx { udp6_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV6_INDEX]; vxlan_udp6_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV6_INDEX]; vxlan6_udp4_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_UDP_IPV4_INDEX]; + vxlan6_udp6_tbl = gro_ctx->tbls[RTE_GRO_IPV6_VXLAN_UDP_IPV6_INDEX]; do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == RTE_GRO_TCP_IPV4; @@ -712,6 +766,8 @@ struct gro_ctx { == RTE_GRO_IPV4_VXLAN_UDP_IPV6; do_vxlan6_udp4_gro = (gro_ctx->gro_types & RTE_GRO_IPV6_VXLAN_UDP_IPV4) == RTE_GRO_IPV6_VXLAN_UDP_IPV4; + do_vxlan6_udp6_gro = (gro_ctx->gro_types & RTE_GRO_IPV6_VXLAN_UDP_IPV6) + == RTE_GRO_IPV6_VXLAN_UDP_IPV6; current_time = rte_rdtsc(); @@ -771,6 +827,11 @@ struct gro_ctx { if (gro_vxlan6_udp4_reassemble(pkts[i], vxlan6_udp4_tbl, current_time) < 0) unprocess_pkts[unprocess_num++] = pkts[i]; + } else if (IS_IPV6_VXLAN_UDP6_PKT(pkts[i]->packet_type) && + do_vxlan6_udp6_gro) { + if (gro_vxlan6_udp6_reassemble(pkts[i], vxlan6_udp6_tbl, + current_time) < 0) + unprocess_pkts[unprocess_num++] = pkts[i]; } else unprocess_pkts[unprocess_num++] = pkts[i]; } @@ -876,6 +937,13 @@ struct gro_ctx { num += gro_vxlan6_udp4_tbl_timeout_flush(gro_ctx->tbls[ RTE_GRO_IPV6_VXLAN_UDP_IPV4_INDEX], flush_timestamp, &out[num], left_nb_out); + left_nb_out = max_nb_out - num; + } + + if ((gro_types & RTE_GRO_IPV6_VXLAN_UDP_IPV6) && left_nb_out > 0) { + num += gro_vxlan6_udp6_tbl_timeout_flush(gro_ctx->tbls[ + RTE_GRO_IPV6_VXLAN_UDP_IPV6_INDEX], + flush_timestamp, &out[num], left_nb_out); } return num; diff --git a/lib/librte_gro/rte_gro.h b/lib/librte_gro/rte_gro.h index ddcded6..fefa2e9 100644 --- a/lib/librte_gro/rte_gro.h +++ b/lib/librte_gro/rte_gro.h @@ -59,6 +59,9 @@ #define RTE_GRO_IPV6_VXLAN_UDP_IPV4_INDEX 10 #define RTE_GRO_IPV6_VXLAN_UDP_IPV4 (1ULL << RTE_GRO_IPV6_VXLAN_UDP_IPV4_INDEX) /**< IPv6 VxLAN UDP/IPv4 GRO flag. */ +#define RTE_GRO_IPV6_VXLAN_UDP_IPV6_INDEX 11 +#define RTE_GRO_IPV6_VXLAN_UDP_IPV6 (1ULL << RTE_GRO_IPV6_VXLAN_UDP_IPV6_INDEX) +/**< IPv6 VxLAN UDP/IPv6 GRO flag. */ /** * Structure used to create GRO context objects or used to pass