From patchwork Wed Feb 4 09:25:16 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Olivier Matz X-Patchwork-Id: 2955 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id 020BBADF5; Wed, 4 Feb 2015 10:25:58 +0100 (CET) Received: from mail-wi0-f173.google.com (mail-wi0-f173.google.com [209.85.212.173]) by dpdk.org (Postfix) with ESMTP id EE86DAE03 for ; Wed, 4 Feb 2015 10:25:56 +0100 (CET) Received: by mail-wi0-f173.google.com with SMTP id r20so30291138wiv.0 for ; Wed, 04 Feb 2015 01:25:56 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=ClgeT8QaY/vuyhOoTTLAKbS4KBwpz0jRcNFu9mmH0fE=; b=T7glOAYP2z7a9FXA8lij+AwJcTD3hR4JApPDsEMeCDbyM4Ciqnm9FG5M9abM6yTx9X lGO9O3BXLemiC0wKTaP5lnjYBDcBmb0bc5OAaG2bdCHlaVcITymDbLGDJrRj5l1l/k/K WOnGMWw4weZtogyyYLs3KVhPUUQR57/poPu7SRQ5X79K8B2uNeiV+axOPe8p4B4gq3hD 5e+BwBS57HumW2przphXkV2q+u55Cce/Dw5mdbj9+IdjCO1w8YRZ9TNk2/RZeYhzyQVO H4hvV+ANVJdG+0DgsYsuKPuRJW+ohxeMpe4zJbvDsRRInMoMzT+Cys3A423RDNSjxrYg wInQ== X-Gm-Message-State: ALoCoQnpo5FTvGUoUVGKKyqSQLXnNBOm7WTbeq+Y2E+yXseQva6DMSkrA8AHnnX+bnOxCSI0qwbQ X-Received: by 10.180.212.113 with SMTP id nj17mr44045924wic.54.1423041956820; Wed, 04 Feb 2015 01:25:56 -0800 (PST) Received: from glumotte.dev.6wind.com (6wind.net2.nerim.net. [213.41.180.237]) by mx.google.com with ESMTPSA id a13sm2346491wic.3.2015.02.04.01.25.55 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 04 Feb 2015 01:25:56 -0800 (PST) From: Olivier Matz To: dev@dpdk.org Date: Wed, 4 Feb 2015 10:25:16 +0100 Message-Id: <1423041925-26956-12-git-send-email-olivier.matz@6wind.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1423041925-26956-1-git-send-email-olivier.matz@6wind.com> References: <1422623775-8050-1-git-send-email-olivier.matz@6wind.com> <1423041925-26956-1-git-send-email-olivier.matz@6wind.com> Subject: [dpdk-dev] [PATCH v2 11/20] testpmd: use a structure to store offload info in csum fwd engine X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" To simplify the API of parse_* functions, store all the offload information for the current packet in a structure. No functional change. Signed-off-by: Olivier Matz --- app/test-pmd/csumonly.c | 222 +++++++++++++++++++++++++----------------------- 1 file changed, 115 insertions(+), 107 deletions(-) diff --git a/app/test-pmd/csumonly.c b/app/test-pmd/csumonly.c index b023f12..0b89d89 100644 --- a/app/test-pmd/csumonly.c +++ b/app/test-pmd/csumonly.c @@ -86,6 +86,21 @@ #define _htons(x) (x) #endif +/* structure that caches offload info for the current packet */ +struct testpmd_offload_info { + uint16_t ethertype; + uint16_t l2_len; + uint16_t l3_len; + uint16_t l4_len; + uint8_t l4_proto; + uint8_t l4_tun_len; + uint8_t is_tunnel; + uint16_t outer_ethertype; + uint16_t outer_l2_len; + uint16_t outer_l3_len; + uint16_t tso_segsz; +}; + static uint16_t get_psd_sum(void *l3_hdr, uint16_t ethertype, uint64_t ol_flags) { @@ -106,38 +121,36 @@ get_udptcp_checksum(void *l3_hdr, void *l4_hdr, uint16_t ethertype) /* Parse an IPv4 header to fill l3_len, l4_len, and l4_proto */ static void -parse_ipv4(struct ipv4_hdr *ipv4_hdr, uint16_t *l3_len, uint8_t *l4_proto, - uint16_t *l4_len) +parse_ipv4(struct ipv4_hdr *ipv4_hdr, struct testpmd_offload_info *info) { struct tcp_hdr *tcp_hdr; - *l3_len = (ipv4_hdr->version_ihl & 0x0f) * 4; - *l4_proto = ipv4_hdr->next_proto_id; + info->l3_len = (ipv4_hdr->version_ihl & 0x0f) * 4; + info->l4_proto = ipv4_hdr->next_proto_id; /* only fill l4_len for TCP, it's useful for TSO */ - if (*l4_proto == IPPROTO_TCP) { - tcp_hdr = (struct tcp_hdr *)((char *)ipv4_hdr + *l3_len); - *l4_len = (tcp_hdr->data_off & 0xf0) >> 2; + if (info->l4_proto == IPPROTO_TCP) { + tcp_hdr = (struct tcp_hdr *)((char *)ipv4_hdr + info->l3_len); + info->l4_len = (tcp_hdr->data_off & 0xf0) >> 2; } else - *l4_len = 0; + info->l4_len = 0; } /* Parse an IPv6 header to fill l3_len, l4_len, and l4_proto */ static void -parse_ipv6(struct ipv6_hdr *ipv6_hdr, uint16_t *l3_len, uint8_t *l4_proto, - uint16_t *l4_len) +parse_ipv6(struct ipv6_hdr *ipv6_hdr, struct testpmd_offload_info *info) { struct tcp_hdr *tcp_hdr; - *l3_len = sizeof(struct ipv6_hdr); - *l4_proto = ipv6_hdr->proto; + info->l3_len = sizeof(struct ipv6_hdr); + info->l4_proto = ipv6_hdr->proto; /* only fill l4_len for TCP, it's useful for TSO */ - if (*l4_proto == IPPROTO_TCP) { - tcp_hdr = (struct tcp_hdr *)((char *)ipv6_hdr + *l3_len); - *l4_len = (tcp_hdr->data_off & 0xf0) >> 2; + if (info->l4_proto == IPPROTO_TCP) { + tcp_hdr = (struct tcp_hdr *)((char *)ipv6_hdr + info->l3_len); + info->l4_len = (tcp_hdr->data_off & 0xf0) >> 2; } else - *l4_len = 0; + info->l4_len = 0; } /* @@ -146,35 +159,34 @@ parse_ipv6(struct ipv6_hdr *ipv6_hdr, uint16_t *l3_len, uint8_t *l4_proto, * header. The l4_len argument is only set in case of TCP (useful for TSO). */ static void -parse_ethernet(struct ether_hdr *eth_hdr, uint16_t *ethertype, uint16_t *l2_len, - uint16_t *l3_len, uint8_t *l4_proto, uint16_t *l4_len) +parse_ethernet(struct ether_hdr *eth_hdr, struct testpmd_offload_info *info) { struct ipv4_hdr *ipv4_hdr; struct ipv6_hdr *ipv6_hdr; - *l2_len = sizeof(struct ether_hdr); - *ethertype = eth_hdr->ether_type; + info->l2_len = sizeof(struct ether_hdr); + info->ethertype = eth_hdr->ether_type; - if (*ethertype == _htons(ETHER_TYPE_VLAN)) { + if (info->ethertype == _htons(ETHER_TYPE_VLAN)) { struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1); - *l2_len += sizeof(struct vlan_hdr); - *ethertype = vlan_hdr->eth_proto; + info->l2_len += sizeof(struct vlan_hdr); + info->ethertype = vlan_hdr->eth_proto; } - switch (*ethertype) { + switch (info->ethertype) { case _htons(ETHER_TYPE_IPv4): - ipv4_hdr = (struct ipv4_hdr *) ((char *)eth_hdr + *l2_len); - parse_ipv4(ipv4_hdr, l3_len, l4_proto, l4_len); + ipv4_hdr = (struct ipv4_hdr *) ((char *)eth_hdr + info->l2_len); + parse_ipv4(ipv4_hdr, info); break; case _htons(ETHER_TYPE_IPv6): - ipv6_hdr = (struct ipv6_hdr *) ((char *)eth_hdr + *l2_len); - parse_ipv6(ipv6_hdr, l3_len, l4_proto, l4_len); + ipv6_hdr = (struct ipv6_hdr *) ((char *)eth_hdr + info->l2_len); + parse_ipv6(ipv6_hdr, info); break; default: - *l4_len = 0; - *l3_len = 0; - *l4_proto = 0; + info->l4_len = 0; + info->l3_len = 0; + info->l4_proto = 0; break; } } @@ -197,8 +209,8 @@ change_ip_addresses(void *l3_hdr, uint16_t ethertype) /* if possible, calculate the checksum of a packet in hw or sw, * depending on the testpmd command line configuration */ static uint64_t -process_inner_cksums(void *l3_hdr, uint16_t ethertype, uint16_t l3_len, - uint8_t l4_proto, uint16_t tso_segsz, uint16_t testpmd_ol_flags) +process_inner_cksums(void *l3_hdr, const struct testpmd_offload_info *info, + uint16_t testpmd_ol_flags) { struct ipv4_hdr *ipv4_hdr = l3_hdr; struct udp_hdr *udp_hdr; @@ -206,12 +218,12 @@ process_inner_cksums(void *l3_hdr, uint16_t ethertype, uint16_t l3_len, struct sctp_hdr *sctp_hdr; uint64_t ol_flags = 0; - if (ethertype == _htons(ETHER_TYPE_IPv4)) { + if (info->ethertype == _htons(ETHER_TYPE_IPv4)) { ipv4_hdr = l3_hdr; ipv4_hdr->hdr_checksum = 0; ol_flags |= PKT_TX_IPV4; - if (tso_segsz != 0 && l4_proto == IPPROTO_TCP) { + if (info->tso_segsz != 0 && info->l4_proto == IPPROTO_TCP) { ol_flags |= PKT_TX_IP_CKSUM; } else { if (testpmd_ol_flags & TESTPMD_TX_OFFLOAD_IP_CKSUM) @@ -220,41 +232,44 @@ process_inner_cksums(void *l3_hdr, uint16_t ethertype, uint16_t l3_len, ipv4_hdr->hdr_checksum = rte_ipv4_cksum(ipv4_hdr); } - } else if (ethertype == _htons(ETHER_TYPE_IPv6)) + } else if (info->ethertype == _htons(ETHER_TYPE_IPv6)) ol_flags |= PKT_TX_IPV6; else return 0; /* packet type not supported, nothing to do */ - if (l4_proto == IPPROTO_UDP) { - udp_hdr = (struct udp_hdr *)((char *)l3_hdr + l3_len); + if (info->l4_proto == IPPROTO_UDP) { + udp_hdr = (struct udp_hdr *)((char *)l3_hdr + info->l3_len); /* do not recalculate udp cksum if it was 0 */ if (udp_hdr->dgram_cksum != 0) { udp_hdr->dgram_cksum = 0; if (testpmd_ol_flags & TESTPMD_TX_OFFLOAD_UDP_CKSUM) { ol_flags |= PKT_TX_UDP_CKSUM; udp_hdr->dgram_cksum = get_psd_sum(l3_hdr, - ethertype, ol_flags); + info->ethertype, ol_flags); } else { udp_hdr->dgram_cksum = get_udptcp_checksum(l3_hdr, udp_hdr, - ethertype); + info->ethertype); } } - } else if (l4_proto == IPPROTO_TCP) { - tcp_hdr = (struct tcp_hdr *)((char *)l3_hdr + l3_len); + } else if (info->l4_proto == IPPROTO_TCP) { + tcp_hdr = (struct tcp_hdr *)((char *)l3_hdr + info->l3_len); tcp_hdr->cksum = 0; - if (tso_segsz != 0) { + if (info->tso_segsz != 0) { ol_flags |= PKT_TX_TCP_SEG; - tcp_hdr->cksum = get_psd_sum(l3_hdr, ethertype, ol_flags); + tcp_hdr->cksum = get_psd_sum(l3_hdr, info->ethertype, + ol_flags); } else if (testpmd_ol_flags & TESTPMD_TX_OFFLOAD_TCP_CKSUM) { ol_flags |= PKT_TX_TCP_CKSUM; - tcp_hdr->cksum = get_psd_sum(l3_hdr, ethertype, ol_flags); + tcp_hdr->cksum = get_psd_sum(l3_hdr, info->ethertype, + ol_flags); } else { tcp_hdr->cksum = - get_udptcp_checksum(l3_hdr, tcp_hdr, ethertype); + get_udptcp_checksum(l3_hdr, tcp_hdr, + info->ethertype); } - } else if (l4_proto == IPPROTO_SCTP) { - sctp_hdr = (struct sctp_hdr *)((char *)l3_hdr + l3_len); + } else if (info->l4_proto == IPPROTO_SCTP) { + sctp_hdr = (struct sctp_hdr *)((char *)l3_hdr + info->l3_len); sctp_hdr->cksum = 0; /* sctp payload must be a multiple of 4 to be * offloaded */ @@ -274,15 +289,15 @@ process_inner_cksums(void *l3_hdr, uint16_t ethertype, uint16_t l3_len, * meaning IP + UDP). The caller already checked that it's a vxlan * packet */ static uint64_t -process_outer_cksums(void *outer_l3_hdr, uint16_t outer_ethertype, - uint16_t outer_l3_len, uint16_t testpmd_ol_flags) +process_outer_cksums(void *outer_l3_hdr, struct testpmd_offload_info *info, +uint16_t testpmd_ol_flags) { struct ipv4_hdr *ipv4_hdr = outer_l3_hdr; struct ipv6_hdr *ipv6_hdr = outer_l3_hdr; struct udp_hdr *udp_hdr; uint64_t ol_flags = 0; - if (outer_ethertype == _htons(ETHER_TYPE_IPv4)) { + if (info->outer_ethertype == _htons(ETHER_TYPE_IPv4)) { ipv4_hdr->hdr_checksum = 0; ol_flags |= PKT_TX_OUTER_IPV4; @@ -296,11 +311,11 @@ process_outer_cksums(void *outer_l3_hdr, uint16_t outer_ethertype, /* outer UDP checksum is always done in software as we have no * hardware supporting it today, and no API for it. */ - udp_hdr = (struct udp_hdr *)((char *)outer_l3_hdr + outer_l3_len); + udp_hdr = (struct udp_hdr *)((char *)outer_l3_hdr + info->outer_l3_len); /* do not recalculate udp cksum if it was 0 */ if (udp_hdr->dgram_cksum != 0) { udp_hdr->dgram_cksum = 0; - if (outer_ethertype == _htons(ETHER_TYPE_IPv4)) + if (info->outer_ethertype == _htons(ETHER_TYPE_IPv4)) udp_hdr->dgram_cksum = rte_ipv4_udptcp_cksum(ipv4_hdr, udp_hdr); else @@ -347,14 +362,9 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) uint16_t i; uint64_t ol_flags; uint16_t testpmd_ol_flags; - uint8_t l4_proto, l4_tun_len = 0; - uint16_t ethertype = 0, outer_ethertype = 0; - uint16_t l2_len = 0, l3_len = 0, l4_len = 0; - uint16_t outer_l2_len = 0, outer_l3_len = 0; - uint16_t tso_segsz; - int tunnel = 0; uint32_t rx_bad_ip_csum; uint32_t rx_bad_l4_csum; + struct testpmd_offload_info info; #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES uint64_t start_tsc; @@ -381,13 +391,13 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) txp = &ports[fs->tx_port]; testpmd_ol_flags = txp->tx_ol_flags; - tso_segsz = txp->tso_segsz; + memset(&info, 0, sizeof(info)); + info.tso_segsz = txp->tso_segsz; for (i = 0; i < nb_rx; i++) { ol_flags = 0; - tunnel = 0; - l4_tun_len = 0; + info.is_tunnel = 0; m = pkts_burst[i]; /* Update the L3/L4 checksum error packet statistics */ @@ -398,49 +408,47 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) * and inner headers */ eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *); - parse_ethernet(eth_hdr, ðertype, &l2_len, &l3_len, - &l4_proto, &l4_len); - l3_hdr = (char *)eth_hdr + l2_len; + parse_ethernet(eth_hdr, &info); + l3_hdr = (char *)eth_hdr + info.l2_len; /* check if it's a supported tunnel (only vxlan for now) */ if ((testpmd_ol_flags & TESTPMD_TX_OFFLOAD_PARSE_TUNNEL) && - l4_proto == IPPROTO_UDP) { - udp_hdr = (struct udp_hdr *)((char *)l3_hdr + l3_len); + info.l4_proto == IPPROTO_UDP) { + udp_hdr = (struct udp_hdr *)((char *)l3_hdr + info.l3_len); /* check udp destination port, 4789 is the default * vxlan port (rfc7348) */ if (udp_hdr->dst_port == _htons(4789)) { - l4_tun_len = ETHER_VXLAN_HLEN; - tunnel = 1; + info.l4_tun_len = ETHER_VXLAN_HLEN; + info.is_tunnel = 1; /* currently, this flag is set by i40e only if the * packet is vxlan */ } else if (m->ol_flags & (PKT_RX_TUNNEL_IPV4_HDR | PKT_RX_TUNNEL_IPV6_HDR)) - tunnel = 1; + info.is_tunnel = 1; - if (tunnel == 1) { - outer_ethertype = ethertype; - outer_l2_len = l2_len; - outer_l3_len = l3_len; + if (info.is_tunnel == 1) { + info.outer_ethertype = info.ethertype; + info.outer_l2_len = info.l2_len; + info.outer_l3_len = info.l3_len; outer_l3_hdr = l3_hdr; eth_hdr = (struct ether_hdr *)((char *)udp_hdr + sizeof(struct udp_hdr) + sizeof(struct vxlan_hdr)); - parse_ethernet(eth_hdr, ðertype, &l2_len, - &l3_len, &l4_proto, &l4_len); - l3_hdr = (char *)eth_hdr + l2_len; + parse_ethernet(eth_hdr, &info); + l3_hdr = (char *)eth_hdr + info.l2_len; } } /* step 2: change all source IPs (v4 or v6) so we need * to recompute the chksums even if they were correct */ - change_ip_addresses(l3_hdr, ethertype); - if (tunnel == 1) - change_ip_addresses(outer_l3_hdr, outer_ethertype); + change_ip_addresses(l3_hdr, info.ethertype); + if (info.is_tunnel == 1) + change_ip_addresses(outer_l3_hdr, info.outer_ethertype); /* step 3: depending on user command line configuration, * recompute checksum either in software or flag the @@ -448,25 +456,24 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) * is configured, prepare the mbuf for TCP segmentation. */ /* process checksums of inner headers first */ - ol_flags |= process_inner_cksums(l3_hdr, ethertype, - l3_len, l4_proto, tso_segsz, testpmd_ol_flags); + ol_flags |= process_inner_cksums(l3_hdr, &info, testpmd_ol_flags); /* Then process outer headers if any. Note that the software * checksum will be wrong if one of the inner checksums is * processed in hardware. */ - if (tunnel == 1) { - ol_flags |= process_outer_cksums(outer_l3_hdr, - outer_ethertype, outer_l3_len, testpmd_ol_flags); + if (info.is_tunnel == 1) { + ol_flags |= process_outer_cksums(outer_l3_hdr, &info, + testpmd_ol_flags); } /* step 4: fill the mbuf meta data (flags and header lengths) */ - if (tunnel == 1) { + if (info.is_tunnel == 1) { if (testpmd_ol_flags & TESTPMD_TX_OFFLOAD_OUTER_IP_CKSUM) { - m->outer_l2_len = outer_l2_len; - m->outer_l3_len = outer_l3_len; - m->l2_len = l4_tun_len + l2_len; - m->l3_len = l3_len; + m->outer_l2_len = info.outer_l2_len; + m->outer_l3_len = info.outer_l3_len; + m->l2_len = info.l4_tun_len + info.l2_len; + m->l3_len = info.l3_len; } else { /* if there is a outer UDP cksum @@ -474,21 +481,22 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) the outer checksum will be wrong as the payload will be modified by the hardware */ - m->l2_len = outer_l2_len + outer_l3_len + + m->l2_len = info.outer_l2_len + + info.outer_l3_len + sizeof(struct udp_hdr) + - sizeof(struct vxlan_hdr) + l2_len; - m->l3_len = l3_len; - m->l4_len = l4_len; + sizeof(struct vxlan_hdr) + info.l2_len; + m->l3_len = info.l3_len; + m->l4_len = info.l4_len; } } else { /* this is only useful if an offload flag is * set, but it does not hurt to fill it in any * case */ - m->l2_len = l2_len; - m->l3_len = l3_len; - m->l4_len = l4_len; + m->l2_len = info.l2_len; + m->l3_len = info.l3_len; + m->l4_len = info.l4_len; } - m->tso_segsz = tso_segsz; + m->tso_segsz = info.tso_segsz; m->ol_flags = ol_flags; /* if verbose mode is enabled, dump debug info */ @@ -515,27 +523,27 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) /* dump rx parsed packet info */ printf("rx: l2_len=%d ethertype=%x l3_len=%d " "l4_proto=%d l4_len=%d\n", - l2_len, rte_be_to_cpu_16(ethertype), - l3_len, l4_proto, l4_len); - if (tunnel == 1) + info.l2_len, rte_be_to_cpu_16(info.ethertype), + info.l3_len, info.l4_proto, info.l4_len); + if (info.is_tunnel == 1) printf("rx: outer_l2_len=%d outer_ethertype=%x " - "outer_l3_len=%d\n", outer_l2_len, - rte_be_to_cpu_16(outer_ethertype), - outer_l3_len); + "outer_l3_len=%d\n", info.outer_l2_len, + rte_be_to_cpu_16(info.outer_ethertype), + info.outer_l3_len); /* dump tx packet info */ if ((testpmd_ol_flags & (TESTPMD_TX_OFFLOAD_IP_CKSUM | TESTPMD_TX_OFFLOAD_UDP_CKSUM | TESTPMD_TX_OFFLOAD_TCP_CKSUM | TESTPMD_TX_OFFLOAD_SCTP_CKSUM)) || - tso_segsz != 0) + info.tso_segsz != 0) printf("tx: m->l2_len=%d m->l3_len=%d " "m->l4_len=%d\n", m->l2_len, m->l3_len, m->l4_len); - if ((tunnel == 1) && + if ((info.is_tunnel == 1) && (testpmd_ol_flags & TESTPMD_TX_OFFLOAD_OUTER_IP_CKSUM)) printf("tx: m->outer_l2_len=%d m->outer_l3_len=%d\n", m->outer_l2_len, m->outer_l3_len); - if (tso_segsz != 0) + if (info.tso_segsz != 0) printf("tx: m->tso_segsz=%d\n", m->tso_segsz); printf("tx: flags="); for (j = 0; j < sizeof(tx_flags)/sizeof(*tx_flags); j++) {