From patchwork Mon Jan 13 09:29:35 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ori Kam X-Patchwork-Id: 64542 X-Patchwork-Delegate: ferruh.yigit@amd.com 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 59D99A04F0; Mon, 13 Jan 2020 10:30:14 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 8A7011D5DB; Mon, 13 Jan 2020 10:30:12 +0100 (CET) Received: from mellanox.co.il (mail-il-dmz.mellanox.com [193.47.165.129]) by dpdk.org (Postfix) with ESMTP id 2C3211D5DA for ; Mon, 13 Jan 2020 10:30:10 +0100 (CET) Received: from Internal Mail-Server by MTLPINE1 (envelope-from orika@mellanox.com) with ESMTPS (AES256-SHA encrypted); 13 Jan 2020 11:30:08 +0200 Received: from pegasus03.mtr.labs.mlnx (pegasus03.mtr.labs.mlnx [10.210.16.124]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id 00D9U3M3000700; Mon, 13 Jan 2020 11:30:08 +0200 From: Ori Kam To: Wenzhuo Lu , Jingjing Wu , Bernard Iremonger , John McNamara , Marko Kovacevic Cc: dev@dpdk.org, orika@mellanox.com, ferruh.yigit@intel.com, viacheslavo@mellanox.com, matan@mellanox.com Date: Mon, 13 Jan 2020 09:29:35 +0000 Message-Id: <1578907777-194921-2-git-send-email-orika@mellanox.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1578907777-194921-1-git-send-email-orika@mellanox.com> References: <1578907777-194921-1-git-send-email-orika@mellanox.com> Subject: [dpdk-dev] [PATCH 1/2] app/testpmd: add dynamic flag support 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" DPDK now supports registration of dynamic flags (dynf) to the mbuf. dynf can be given any name, and can be used with a supporting PMD or supporting application. Due to the generic concept of the dynf, it is impossible and meaningless, to define register set/get function for each flag. This commit introduce a generic way to register and set/clear such flags. The basic syntax: port config dynf The first step the new flag is registered. Regardless if the action is set or clear. There is no way to unregister the flag, after registring it. The second step, if the action is set then we set the requested flag. If this is the first flag that is enabled we also register a call back for the Tx. In this call back we set the flag. If the action is clear the requested flag is cleared, and if there are no more flags that are set, the call back is removed. The reason that the set is only applied in Tx is that in case of Rx it is assumed that the value comes from the PMD. If log is enabled the name of the flag, and value will be printed in the packet info. In order for the log to work correcly the registration of the flag must be done before setting verbose. Signed-off-by: Ori Kam Acked-by: Viacheslav Ovsiienko --- app/test-pmd/cmdline.c | 88 +++++++++++++++++++++++++++++ app/test-pmd/testpmd.h | 16 ++++++ app/test-pmd/util.c | 63 +++++++++++++++++++++ doc/guides/testpmd_app_ug/testpmd_funcs.rst | 10 ++++ 4 files changed, 177 insertions(+) diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index 2d74df8..46c9291 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -40,6 +40,7 @@ #include #include #include +#include #include #include @@ -70,6 +71,8 @@ #include "cmdline_tm.h" #include "bpf_cmd.h" +char dynf_names[64][RTE_MBUF_DYN_NAMESIZE]; + static struct cmdline *testpmd_cl; static void cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue); @@ -901,6 +904,11 @@ static void cmd_help_long_parsed(void *parsed_result, "port config (port_id) tx_metadata (value)\n" " Set Tx metadata value per port. Testpmd will add this value" " to any Tx packet sent from this port\n\n" + + "port config (port_id) dynf (name) set|clear\n" + " Register a dynf and Set/clear this flag on Tx. " + "Testpmd will set this value to any Tx packet " + "sent from this port\n\n" ); } @@ -18837,6 +18845,85 @@ struct cmd_config_tx_metadata_specific_result { }, }; +/* *** set dynf *** */ +struct cmd_config_tx_dynf_specific_result { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + uint16_t port_id; + cmdline_fixed_string_t item; + cmdline_fixed_string_t name; + cmdline_fixed_string_t value; +}; + +static void +cmd_config_dynf_specific_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_config_tx_dynf_specific_result *res = parsed_result; + struct rte_mbuf_dynflag desc_flag; + int flag; + uint64_t old_port_flags; + + if (port_id_is_invalid(res->port_id, ENABLED_WARN)) + return; + flag = rte_mbuf_dynflag_lookup(res->name, NULL); + if (flag <= 0) { + strcpy(desc_flag.name, res->name); + desc_flag.flags = 0; + flag = rte_mbuf_dynflag_register(&desc_flag); + if (flag < 0) { + printf("Can't register flag"); + return; + } + strcpy(dynf_names[flag], res->name); + } + old_port_flags = ports[res->port_id].dynf; + if (!strcmp(res->value, "set")) { + ports[res->port_id].dynf |= 1UL << flag; + if (old_port_flags == 0) + add_tx_dynf_callback(res->port_id); + } else { + ports[res->port_id].dynf &= ~(1UL << flag); + if (ports[res->port_id].dynf == 0) + remove_tx_dynf_callback(res->port_id); + } +} + +cmdline_parse_token_string_t cmd_config_tx_dynf_specific_port = + TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result, + keyword, "port"); +cmdline_parse_token_string_t cmd_config_tx_dynf_specific_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result, + keyword, "config"); +cmdline_parse_token_num_t cmd_config_tx_dynf_specific_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_config_tx_dynf_specific_result, + port_id, UINT16); +cmdline_parse_token_string_t cmd_config_tx_dynf_specific_item = + TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result, + item, "dynf"); +cmdline_parse_token_string_t cmd_config_tx_dynf_specific_name = + TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result, + name, NULL); +cmdline_parse_token_string_t cmd_config_tx_dynf_specific_value = + TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result, + value, "set#clear"); + +cmdline_parse_inst_t cmd_config_tx_dynf_specific = { + .f = cmd_config_dynf_specific_parsed, + .data = NULL, + .help_str = "port config dynf set|clear", + .tokens = { + (void *)&cmd_config_tx_dynf_specific_port, + (void *)&cmd_config_tx_dynf_specific_keyword, + (void *)&cmd_config_tx_dynf_specific_port_id, + (void *)&cmd_config_tx_dynf_specific_item, + (void *)&cmd_config_tx_dynf_specific_name, + (void *)&cmd_config_tx_dynf_specific_value, + NULL, + }, +}; + /* *** display tx_metadata per port configuration *** */ struct cmd_show_tx_metadata_result { cmdline_fixed_string_t cmd_show; @@ -19520,6 +19607,7 @@ struct cmd_showport_macs_result { (cmdline_parse_inst_t *)&cmd_set_raw, (cmdline_parse_inst_t *)&cmd_show_set_raw, (cmdline_parse_inst_t *)&cmd_show_set_raw_all, + (cmdline_parse_inst_t *)&cmd_config_tx_dynf_specific, NULL, }; diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h index 857a11f..49f3e43 100644 --- a/app/test-pmd/testpmd.h +++ b/app/test-pmd/testpmd.h @@ -104,6 +104,13 @@ struct rss_type_info { extern const struct rss_type_info rss_type_table[]; /** + * Dynf name array. + * + * Array that holds the name for each dynf. + */ +extern char dynf_names[64][RTE_MBUF_DYN_NAMESIZE]; + +/** * The data structure associated with a forwarding stream between a receive * port/queue and a transmit port/queue. */ @@ -193,6 +200,9 @@ struct rte_port { /**< metadata value to insert in Tx packets. */ uint32_t tx_metadata; const struct rte_eth_rxtx_callback *tx_set_md_cb[RTE_MAX_QUEUES_PER_PORT+1]; + /**< dynamic flags. */ + uint64_t dynf; + const struct rte_eth_rxtx_callback *tx_set_dynf_cb[RTE_MAX_QUEUES_PER_PORT+1]; }; /** @@ -884,6 +894,12 @@ uint16_t tx_pkt_set_md(uint16_t port_id, __rte_unused uint16_t queue, void add_tx_md_callback(portid_t portid); void remove_tx_md_callback(portid_t portid); +uint16_t tx_pkt_set_dynf(uint16_t port_id, __rte_unused uint16_t queue, + struct rte_mbuf *pkts[], uint16_t nb_pkts, + __rte_unused void *user_param); +void add_tx_dynf_callback(portid_t portid); +void remove_tx_dynf_callback(portid_t portid); + /* * Work-around of a compilation error with ICC on invocations of the * rte_be_to_cpu_16() function. diff --git a/app/test-pmd/util.c b/app/test-pmd/util.c index b514be5..5af3d07 100644 --- a/app/test-pmd/util.c +++ b/app/test-pmd/util.c @@ -39,6 +39,7 @@ uint16_t udp_port; uint32_t vx_vni; const char *reason; + int dynf_index; if (!nb_pkts) return; @@ -88,6 +89,12 @@ if (is_rx && (ol_flags & PKT_RX_DYNF_METADATA)) printf(" - Rx metadata: 0x%x", *RTE_FLOW_DYNF_METADATA(mb)); + for (dynf_index = 0; dynf_index < 64; dynf_index++) { + if (dynf_names[dynf_index][0] != '\0') + printf(" - dynf %s: %d", + dynf_names[dynf_index], + !!(ol_flags & (1UL << dynf_index))); + } if (mb->packet_type) { rte_get_ptype_name(mb->packet_type, buf, sizeof(buf)); printf(" - hw ptype: %s", buf); @@ -241,6 +248,62 @@ } } +uint16_t +tx_pkt_set_dynf(uint16_t port_id, __rte_unused uint16_t queue, + struct rte_mbuf *pkts[], uint16_t nb_pkts, + __rte_unused void *user_param) +{ + uint16_t i = 0; + + if (ports[port_id].dynf) + for (i = 0; i < nb_pkts; i++) + pkts[i]->ol_flags |= ports[port_id].dynf; + return nb_pkts; +} + +void +add_tx_dynf_callback(portid_t portid) +{ + struct rte_eth_dev_info dev_info; + uint16_t queue; + int ret; + + if (port_id_is_invalid(portid, ENABLED_WARN)) + return; + + ret = eth_dev_info_get_print_err(portid, &dev_info); + if (ret != 0) + return; + + for (queue = 0; queue < dev_info.nb_tx_queues; queue++) + if (!ports[portid].tx_set_dynf_cb[queue]) + ports[portid].tx_set_dynf_cb[queue] = + rte_eth_add_tx_callback(portid, queue, + tx_pkt_set_dynf, NULL); +} + +void +remove_tx_dynf_callback(portid_t portid) +{ + struct rte_eth_dev_info dev_info; + uint16_t queue; + int ret; + + if (port_id_is_invalid(portid, ENABLED_WARN)) + return; + + ret = eth_dev_info_get_print_err(portid, &dev_info); + if (ret != 0) + return; + + for (queue = 0; queue < dev_info.nb_tx_queues; queue++) + if (ports[portid].tx_set_dynf_cb[queue]) { + rte_eth_remove_tx_callback(portid, queue, + ports[portid].tx_set_dynf_cb[queue]); + ports[portid].tx_set_dynf_cb[queue] = NULL; + } +} + int eth_dev_info_get_print_err(uint16_t port_id, struct rte_eth_dev_info *dev_info) diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst b/doc/guides/testpmd_app_ug/testpmd_funcs.rst index 10aabf5..94327e1 100644 --- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst +++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst @@ -2317,6 +2317,16 @@ testpmd will add this value to any Tx packet sent from this port:: testpmd> port config (port_id) tx_metadata (value) +port config dynf +~~~~~~~~~~~~~~~~ + +Set/clear dynamic flag per port. +testpmd will register this flag in the mbuf (same registration +for both Tx and Rx). Then set/clear this flag for each Tx +packet sent from this port. The set bit only works for Tx packet:: + + testpmd> port config (port_id) dynf (name) (set|clear) + port config mtu ~~~~~~~~~~~~~~~ From patchwork Mon Jan 13 09:29:36 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ori Kam X-Patchwork-Id: 64543 X-Patchwork-Delegate: ferruh.yigit@amd.com 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 28148A04F0; Mon, 13 Jan 2020 10:30:23 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 40C861D5E7; Mon, 13 Jan 2020 10:30:14 +0100 (CET) Received: from mellanox.co.il (mail-il-dmz.mellanox.com [193.47.165.129]) by dpdk.org (Postfix) with ESMTP id 4FE231D5DB for ; Mon, 13 Jan 2020 10:30:10 +0100 (CET) Received: from Internal Mail-Server by MTLPINE1 (envelope-from orika@mellanox.com) with ESMTPS (AES256-SHA encrypted); 13 Jan 2020 11:30:09 +0200 Received: from pegasus03.mtr.labs.mlnx (pegasus03.mtr.labs.mlnx [10.210.16.124]) by labmailer.mlnx (8.13.8/8.13.8) with ESMTP id 00D9U3M4000700; Mon, 13 Jan 2020 11:30:09 +0200 From: Ori Kam To: Matan Azrad , Shahaf Shuler , Viacheslav Ovsiienko Cc: dev@dpdk.org, orika@mellanox.com, ferruh.yigit@intel.com Date: Mon, 13 Jan 2020 09:29:36 +0000 Message-Id: <1578907777-194921-3-git-send-email-orika@mellanox.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1578907777-194921-1-git-send-email-orika@mellanox.com> References: <1578907777-194921-1-git-send-email-orika@mellanox.com> Subject: [dpdk-dev] [PATCH 2/2] net/mlx5: add fine grain dynamic flag support 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" The inline feature is designed to save PCI bandwidth by copying some of the data to the wqe. This feature if enabled works for all packets. In some cases when using external memory, the PCI bandwidth is not relevant since the memory can be accessed by other means. This commit introduce the ability to control the inline with mbuf granularity. In order to use this feature the application should register the field name, and restart the port. Signed-off-by: Ori Kam Acked-by: Viacheslav Ovsiienko --- drivers/net/mlx5/mlx5.c | 15 +++++++++++++++ drivers/net/mlx5/mlx5_rxtx.c | 2 ++ drivers/net/mlx5/mlx5_rxtx.h | 3 +++ drivers/net/mlx5/mlx5_trigger.c | 8 ++++++++ drivers/net/mlx5/rte_pmd_mlx5.h | 32 +++++++++++++++++++++++++++++++ drivers/net/mlx5/rte_pmd_mlx5_version.map | 7 +++++++ 6 files changed, 67 insertions(+) create mode 100644 drivers/net/mlx5/rte_pmd_mlx5.h diff --git a/drivers/net/mlx5/mlx5.c b/drivers/net/mlx5/mlx5.c index 50960c9..27dbe27 100644 --- a/drivers/net/mlx5/mlx5.c +++ b/drivers/net/mlx5/mlx5.c @@ -46,6 +46,7 @@ #include "mlx5_glue.h" #include "mlx5_mr.h" #include "mlx5_flow.h" +#include "rte_pmd_mlx5.h" /* Device parameter to enable RX completion queue compression. */ #define MLX5_RXQ_CQE_COMP_EN "rxq_cqe_comp_en" @@ -1988,6 +1989,20 @@ struct mlx5_flow_id_pool * return ret; } +int +rte_pmd_mlx5_get_dyn_flag_names(char *names[], uint16_t n) +{ + static const char *const dynf_names[] = { + RTE_PMD_MLX5_FINE_GRANULARITY_INLINE, + }; + int num = RTE_MIN(n, RTE_DIM(dynf_names)); + int i; + + for (i = 0; i < num; i++) + strcpy(names[i], dynf_names[i]); + return num; +} + /** * Check sibling device configurations. * diff --git a/drivers/net/mlx5/mlx5_rxtx.c b/drivers/net/mlx5/mlx5_rxtx.c index 67cafd1..aa6aa22 100644 --- a/drivers/net/mlx5/mlx5_rxtx.c +++ b/drivers/net/mlx5/mlx5_rxtx.c @@ -126,6 +126,8 @@ enum mlx5_txcmp_code { uint8_t mlx5_cksum_table[1 << 10] __rte_cache_aligned; uint8_t mlx5_swp_types_table[1 << 10] __rte_cache_aligned; +uint64_t rte_net_mlx5_dynf_inline_mask; + /** * Build a table to translate Rx completion flags to packet type. * diff --git a/drivers/net/mlx5/mlx5_rxtx.h b/drivers/net/mlx5/mlx5_rxtx.h index e362b4a..7c38c57 100644 --- a/drivers/net/mlx5/mlx5_rxtx.h +++ b/drivers/net/mlx5/mlx5_rxtx.h @@ -42,6 +42,9 @@ /* Support tunnel matching. */ #define MLX5_FLOW_TUNNEL 9 +/* Mbuf dynamic flag offset for inline. */ +extern uint64_t rte_net_mlx5_dynf_inline_mask; + struct mlx5_rxq_stats { #ifdef MLX5_PMD_SOFT_COUNTERS uint64_t ipackets; /**< Total of successfully received packets. */ diff --git a/drivers/net/mlx5/mlx5_trigger.c b/drivers/net/mlx5/mlx5_trigger.c index ab6937a..ab253b2 100644 --- a/drivers/net/mlx5/mlx5_trigger.c +++ b/drivers/net/mlx5/mlx5_trigger.c @@ -13,6 +13,7 @@ #include "mlx5.h" #include "mlx5_rxtx.h" #include "mlx5_utils.h" +#include "rte_pmd_mlx5.h" /** * Stop traffic on Tx queues. @@ -270,8 +271,15 @@ { struct mlx5_priv *priv = dev->data->dev_private; int ret; + int fine_inline; DRV_LOG(DEBUG, "port %u starting device", dev->data->port_id); + fine_inline = rte_mbuf_dynflag_lookup + (RTE_PMD_MLX5_FINE_GRANULARITY_INLINE, NULL); + if (fine_inline > 0) + rte_net_mlx5_dynf_inline_mask = 1UL << fine_inline; + else + rte_net_mlx5_dynf_inline_mask = 0; ret = mlx5_dev_configure_rss_reta(dev); if (ret) { DRV_LOG(ERR, "port %u reta config failed: %s", diff --git a/drivers/net/mlx5/rte_pmd_mlx5.h b/drivers/net/mlx5/rte_pmd_mlx5.h new file mode 100644 index 0000000..12e18ca --- /dev/null +++ b/drivers/net/mlx5/rte_pmd_mlx5.h @@ -0,0 +1,32 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2020 Mellanox Technologies, Ltd + */ + +#ifndef RTE_PMD_PRIVATE_MLX5_H_ +#define RTE_PMD_PRIVATE_MLX5_H_ + +/** + * @file + * MLX5 public header. + * + * This interface provides the ability to support private PMD + * dynamic flags. + */ + +#define RTE_PMD_MLX5_FINE_GRANULARITY_INLINE "mlx5_fine_granularity_inline" + +/** + * Returns the dynamic flags name, that are supported. + * + * @param[out] names + * Array that is used to return the supported dynamic flags names. + * @param[in] n + * The number of elements in the names array. + * + * @return + * The number of dynamic flags that were copied. + */ +__rte_experimental +int rte_pmd_mlx5_get_dyn_flag_names(char *names[], uint16_t n); + +#endif diff --git a/drivers/net/mlx5/rte_pmd_mlx5_version.map b/drivers/net/mlx5/rte_pmd_mlx5_version.map index f9f17e4..c8b1031 100644 --- a/drivers/net/mlx5/rte_pmd_mlx5_version.map +++ b/drivers/net/mlx5/rte_pmd_mlx5_version.map @@ -1,3 +1,10 @@ DPDK_20.0 { local: *; }; + +EXPERIMENTAL { + global: + + # added in 20.02 + rte_pmd_mlx5_get_dyn_flag_names; +};