From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by dpdk.org (Postfix) with ESMTP id 4F6347D5E for ; Thu, 24 Aug 2017 16:13:46 +0200 (CEST) Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga102.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 24 Aug 2017 07:13:45 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.41,421,1498546800"; d="scan'208";a="141575689" Received: from dpdk15.sh.intel.com ([10.67.111.77]) by orsmga005.jf.intel.com with ESMTP; 24 Aug 2017 07:13:44 -0700 From: Jiayu Hu To: dev@dpdk.org Cc: mark.b.kavanagh@intel.com, konstantin.ananyev@intel.com, jianfeng.tan@intel.com, Jiayu Hu Date: Thu, 24 Aug 2017 22:15:44 +0800 Message-Id: <1503584144-63181-6-git-send-email-jiayu.hu@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1503584144-63181-1-git-send-email-jiayu.hu@intel.com> References: <1503584144-63181-1-git-send-email-jiayu.hu@intel.com> Subject: [dpdk-dev] [PATCH 5/5] app/testpmd: enable TCP/IPv4, VxLAN and GRE GSO 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: , X-List-Received-Date: Thu, 24 Aug 2017 14:13:47 -0000 This patch adds GSO support to the csum forwarding engine. Oversized packets transmitted over a GSO-enabled port will undergo segmentation (with the exception of packet-types unsupported by the GSO library). GSO support is disabled by default. GSO support may be toggled on a per-port basis, using the command "set port gso on|off". The maximum packet length for GSO segments may be set with the command "set port gso_segsz " Signed-off-by: Jiayu Hu Signed-off-by: Mark Kavanagh --- app/test-pmd/cmdline.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++ app/test-pmd/config.c | 25 ++++++++++ app/test-pmd/csumonly.c | 68 +++++++++++++++++++++++++-- app/test-pmd/testpmd.c | 9 ++++ app/test-pmd/testpmd.h | 10 ++++ 5 files changed, 228 insertions(+), 5 deletions(-) diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index cd8c358..754e249 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -431,6 +431,13 @@ static void cmd_help_long_parsed(void *parsed_result, " Set max flow number and max packet number per-flow" " for GRO.\n\n" + "set port (port_id) gso (on|off)" + " Enable or disable Generic Segmentation Offload in" + " csum forwarding engine.\n\n" + + "set port gso_segsz \n" + " Set max packet length for GSO segment.\n\n" + "set fwd (%s)\n" " Set packet forwarding mode.\n\n" @@ -3963,6 +3970,118 @@ cmdline_parse_inst_t cmd_gro_set = { }, }; +/* *** ENABLE/DISABLE GSO FOR PORTS *** */ +struct cmd_gso_enable_result { + cmdline_fixed_string_t cmd_set; + cmdline_fixed_string_t cmd_port; + cmdline_fixed_string_t cmd_keyword; + cmdline_fixed_string_t cmd_mode; + uint8_t cmd_pid; +}; + +static void +cmd_gso_enable_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_gso_enable_result *res; + + res = parsed_result; + setup_gso(res->cmd_mode, res->cmd_pid); +} + +cmdline_parse_token_string_t cmd_gso_enable_set = + TOKEN_STRING_INITIALIZER(struct cmd_gso_enable_result, + cmd_set, "set"); +cmdline_parse_token_string_t cmd_gso_enable_port = + TOKEN_STRING_INITIALIZER(struct cmd_gso_enable_result, + cmd_port, "port"); +cmdline_parse_token_string_t cmd_gso_enable_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_gso_enable_result, + cmd_keyword, "gso"); +cmdline_parse_token_string_t cmd_gso_enable_mode = + TOKEN_STRING_INITIALIZER(struct cmd_gso_enable_result, + cmd_mode, "on#off"); +cmdline_parse_token_num_t cmd_gso_enable_pid = + TOKEN_NUM_INITIALIZER(struct cmd_gso_enable_result, + cmd_pid, UINT8); + +cmdline_parse_inst_t cmd_gso_enable = { + .f = cmd_gso_enable_parsed, + .data = NULL, + .help_str = "set port gso on|off", + .tokens = { + (void *)&cmd_gso_enable_set, + (void *)&cmd_gso_enable_port, + (void *)&cmd_gso_enable_pid, + (void *)&cmd_gso_enable_keyword, + (void *)&cmd_gso_enable_mode, + NULL, + }, +}; + +/* *** SET MAX PACKET LENGTH FOR GSO SEGMENT *** */ +struct cmd_gso_size_result { + cmdline_fixed_string_t cmd_set; + cmdline_fixed_string_t cmd_port; + cmdline_fixed_string_t cmd_keyword; + uint16_t cmd_segsz; + uint8_t cmd_pid; +}; + +static void +cmd_gso_size_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_gso_size_result *res = parsed_result; + + if (port_id_is_invalid(res->cmd_pid, ENABLED_WARN)) + return; + + if (!strcmp(res->cmd_keyword, "gso_segsz")) { + if (res->cmd_segsz == 0) { + gso_ports[res->cmd_pid].enable = 0; + gso_ports[res->cmd_pid].gso_segsz = 0; + printf("Input gso_segsz is 0. Disable GSO for" + " port %u\n", res->cmd_pid); + } else + gso_ports[res->cmd_pid].gso_segsz = res->cmd_segsz; + + } +} + +cmdline_parse_token_string_t cmd_gso_size_set = + TOKEN_STRING_INITIALIZER(struct cmd_gso_size_result, + cmd_set, "set"); +cmdline_parse_token_string_t cmd_gso_size_port = + TOKEN_STRING_INITIALIZER(struct cmd_gso_size_result, + cmd_port, "port"); +cmdline_parse_token_string_t cmd_gso_size_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_gso_size_result, + cmd_keyword, "gso_segsz"); +cmdline_parse_token_num_t cmd_gso_size_segsz = + TOKEN_NUM_INITIALIZER(struct cmd_gso_size_result, + cmd_segsz, UINT16); +cmdline_parse_token_num_t cmd_gso_size_pid = + TOKEN_NUM_INITIALIZER(struct cmd_gso_size_result, + cmd_pid, UINT8); + +cmdline_parse_inst_t cmd_gso_size = { + .f = cmd_gso_size_parsed, + .data = NULL, + .help_str = "set port gso_segsz : set max " + "packet length for GSO segment (0 to disable GSO)", + .tokens = { + (void *)&cmd_gso_size_set, + (void *)&cmd_gso_size_port, + (void *)&cmd_gso_size_pid, + (void *)&cmd_gso_size_keyword, + (void *)&cmd_gso_size_segsz, + NULL, + }, +}; + /* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */ struct cmd_set_flush_rx { cmdline_fixed_string_t set; @@ -14251,6 +14370,8 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_tunnel_tso_show, (cmdline_parse_inst_t *)&cmd_enable_gro, (cmdline_parse_inst_t *)&cmd_gro_set, + (cmdline_parse_inst_t *)&cmd_gso_enable, + (cmdline_parse_inst_t *)&cmd_gso_size, (cmdline_parse_inst_t *)&cmd_link_flow_control_set, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_rx, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_tx, diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c index 3ae3e1c..1837fb1 100644 --- a/app/test-pmd/config.c +++ b/app/test-pmd/config.c @@ -2454,6 +2454,31 @@ setup_gro(const char *mode, uint8_t port_id) } } +void +setup_gso(const char *mode, uint8_t port_id) +{ + if (!rte_eth_dev_is_valid_port(port_id)) { + printf("invalid port id %u\n", port_id); + return; + } + if (strcmp(mode, "on") == 0) { + if (test_done == 0) { + printf("before enable GSO," + " please stop forwarding first\n"); + return; + } + gso_ports[port_id].enable = 1; + gso_ports[port_id].gso_segsz = ETHER_MAX_LEN; + } else if (strcmp(mode, "off") == 0) { + if (test_done == 0) { + printf("before disable GSO," + " please stop forwarding first\n"); + return; + } + gso_ports[port_id].enable = 0; + } +} + char* list_pkt_forwarding_modes(void) { diff --git a/app/test-pmd/csumonly.c b/app/test-pmd/csumonly.c index 90c8119..f55bb0f 100644 --- a/app/test-pmd/csumonly.c +++ b/app/test-pmd/csumonly.c @@ -70,6 +70,7 @@ #include #include #include +#include #include "testpmd.h" #define IP_DEFTTL 64 /* from RFC 1340. */ @@ -627,6 +628,9 @@ static void pkt_burst_checksum_forward(struct fwd_stream *fs) { struct rte_mbuf *pkts_burst[MAX_PKT_BURST]; + struct rte_mbuf *gso_segments[GSO_MAX_PKT_BURST]; + struct rte_gso_ctx *gso_ctx; + struct rte_mbuf **tx_pkts_burst; struct rte_port *txp; struct rte_mbuf *m, *p; struct ether_hdr *eth_hdr; @@ -641,6 +645,9 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) uint32_t rx_bad_ip_csum; uint32_t rx_bad_l4_csum; struct testpmd_offload_info info; + uint8_t no_gso[GSO_MAX_PKT_BURST] = {0}; + uint16_t nb_segments = 0; + int ret; #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES uint64_t start_tsc; @@ -851,13 +858,54 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) } } + if (unlikely(gso_ports[fs->tx_port].enable)) { + gso_ctx = &(current_fwd_lcore()->gso_ctx); + gso_ctx->gso_size = gso_ports[fs->tx_port].gso_segsz > 0 ? + gso_ports[fs->tx_port].gso_segsz : gso_ctx->gso_size; + for (i = 0; i < nb_rx; i++) { + ret = rte_gso_segment(pkts_burst[i], *gso_ctx, + &gso_segments[nb_segments], + GSO_MAX_PKT_BURST - nb_segments); + if (ret > 1) + nb_segments += ret; + else if (ret == 1) { + gso_segments[nb_segments] = pkts_burst[i]; + no_gso[nb_segments++] = 1; + } else { + /* insufficient MBUFs, stop GSO */ + memcpy(&gso_segments[nb_segments], + &pkts_burst[i], + sizeof(struct rte_mbuf *) * + (nb_rx - i)); + nb_segments += (nb_rx - i); + break; + } + if (unlikely(nb_rx - i >= GSO_MAX_PKT_BURST - + nb_segments)) { + /* + * insufficient space in gso_segments, + * stop GSO. + */ + memcpy(&gso_segments[nb_segments], + &pkts_burst[i], + sizeof(struct rte_mbuf *) * + (nb_rx - i)); + nb_segments += (nb_rx - i); + break; + } + } + tx_pkts_burst = gso_segments; + nb_rx = nb_segments; + } else + tx_pkts_burst = pkts_burst; + nb_prep = rte_eth_tx_prepare(fs->tx_port, fs->tx_queue, - pkts_burst, nb_rx); + tx_pkts_burst, nb_rx); if (nb_prep != nb_rx) printf("Preparing packet burst to transmit failed: %s\n", rte_strerror(rte_errno)); - nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, + nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, tx_pkts_burst, nb_prep); /* @@ -868,7 +916,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) { rte_delay_us(burst_tx_delay_time); nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue, - &pkts_burst[nb_tx], nb_rx - nb_tx); + &tx_pkts_burst[nb_tx], nb_rx - nb_tx); } } fs->tx_packets += nb_tx; @@ -878,12 +926,22 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) #ifdef RTE_TEST_PMD_RECORD_BURST_STATS fs->tx_burst_stats.pkt_burst_spread[nb_tx]++; #endif - if (unlikely(nb_tx < nb_rx)) { + + if (unlikely(nb_tx < nb_rx) && + unlikely(gso_ports[fs->tx_port].enable)) { fs->fwd_dropped += (nb_rx - nb_tx); do { - rte_pktmbuf_free(pkts_burst[nb_tx]); + if (no_gso[nb_tx] == 0) + rte_pktmbuf_detach(tx_pkts_burst[nb_tx]->next); + rte_pktmbuf_free(tx_pkts_burst[nb_tx]); + } while (++nb_tx < nb_rx); + } else if (unlikely(nb_tx < nb_rx)) { + fs->fwd_dropped += (nb_rx - nb_tx); + do { + rte_pktmbuf_free(tx_pkts_burst[nb_tx]); } while (++nb_tx < nb_rx); } + #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES end_tsc = rte_rdtsc(); core_cycles = (end_tsc - start_tsc); diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c index 7d40139..16c60f0 100644 --- a/app/test-pmd/testpmd.c +++ b/app/test-pmd/testpmd.c @@ -400,6 +400,8 @@ static int eth_event_callback(uint8_t port_id, */ static int all_ports_started(void); +struct gso_status gso_ports[RTE_MAX_ETHPORTS]; + /* * Helper function to check if socket is already discovered. * If yes, return positive value. If not, return zero. @@ -664,6 +666,13 @@ init_config(void) if (mbp == NULL) mbp = mbuf_pool_find(0); fwd_lcores[lc_id]->mbp = mbp; + /* initialize GSO context */ + fwd_lcores[lc_id]->gso_ctx.direct_pool = mbp; + fwd_lcores[lc_id]->gso_ctx.indirect_pool = mbp; + fwd_lcores[lc_id]->gso_ctx.gso_types = RTE_GSO_TCP_IPV4 | + RTE_GSO_IPV4_VXLAN_TCP_IPV4 | + RTE_GSO_IPV4_GRE_TCP_IPV4; + fwd_lcores[lc_id]->gso_ctx.gso_size = ETHER_MAX_LEN; } /* Configuration of packet forwarding streams. */ diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h index c9d7739..3697d3f 100644 --- a/app/test-pmd/testpmd.h +++ b/app/test-pmd/testpmd.h @@ -36,6 +36,7 @@ #include #include +#include #define RTE_PORT_ALL (~(portid_t)0x0) @@ -205,6 +206,7 @@ struct rte_port { * CPU id. configuration table. */ struct fwd_lcore { + struct rte_gso_ctx gso_ctx; /**< GSO context */ struct rte_mempool *mbp; /**< The mbuf pool to use by this core */ streamid_t stream_idx; /**< index of 1st stream in "fwd_streams" */ streamid_t stream_nb; /**< number of streams in "fwd_streams" */ @@ -442,6 +444,13 @@ struct gro_status { }; extern struct gro_status gro_ports[RTE_MAX_ETHPORTS]; +#define GSO_MAX_PKT_BURST 2048 +struct gso_status { + uint16_t gso_segsz; + uint8_t enable; +}; +extern struct gso_status gso_ports[RTE_MAX_ETHPORTS]; + static inline unsigned int lcore_num(void) { @@ -641,6 +650,7 @@ void get_5tuple_filter(uint8_t port_id, uint16_t index); int rx_queue_id_is_invalid(queueid_t rxq_id); int tx_queue_id_is_invalid(queueid_t txq_id); void setup_gro(const char *mode, uint8_t port_id); +void setup_gso(const char *mode, uint8_t port_id); /* Functions to manage the set of filtered Multicast MAC addresses */ void mcast_addr_add(uint8_t port_id, struct ether_addr *mc_addr); -- 2.7.4