From patchwork Fri Oct 15 16:26:55 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michal Krawczyk X-Patchwork-Id: 101804 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id D4436A034F; Fri, 15 Oct 2021 18:27:50 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 3C4E341134; Fri, 15 Oct 2021 18:27:48 +0200 (CEST) Received: from mail-lf1-f45.google.com (mail-lf1-f45.google.com [209.85.167.45]) by mails.dpdk.org (Postfix) with ESMTP id 714B741120 for ; Fri, 15 Oct 2021 18:27:46 +0200 (CEST) Received: by mail-lf1-f45.google.com with SMTP id p16so44201467lfa.2 for ; Fri, 15 Oct 2021 09:27:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=semihalf-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Dd+bIJIzUVqtDRbftzYI+kTlFKSyIFldpnpajTFBBto=; b=KFR+zFVEnNlGzPmICn+RdGYkmYicM5OknUYvOHINp6m3utbCa35SihxKRTdK+rXzfg hDcPurmyEjKe2O11go+r7A7qz4dUMRsLblH+oCqNR2aiz9vuRMfuhnQ8BIym3aQPJacB YH7MLNIefkH/OkgXnONTlAf8uqIf1cwr5JSEOWhjyQFWIQjizNJxrAG1Mu0ga/xVcU13 lx53wCOdJ80+COXV1Qekt4GW2hpKuuQb0/zopfS2G6YS8uc0s8XVingcPukX/MQLAKvz G1xA8NjaO8MCYiuPqJgjqdw5R1ZCAQRMjYd8nm8dy5cnEp5OK1pVjZaormByehpMOmfU 3DqQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Dd+bIJIzUVqtDRbftzYI+kTlFKSyIFldpnpajTFBBto=; b=SR4Rjfbr48+WAKbljiUOCfP7jp0Wr+g6kBR5s5yQe7sHvCwRs22WQ718QlC5eK3tc1 9CfDcdwWoqD8lx8TXAJl3ryRmixjJl0rID3fBxV++wqW/90XJelEtcWGkjhH4Acm78HX mMQL6Y99Lrqowz4WQu+m7PRFPln2Qh9kHFD35/nnHw4DLg3ZOF4lqUJvo8+n5GQ1Q58y jLIo1445+RfHvZFtuUUYKUa8fI36bYl3affn9J0+wyTDUL6rn5ugdT+wZCt/GBQ5/WHx SGVuqDek5IFHQruEY1Nrchmzf7CYdXEE0qeEpRUpdxwSRi3RTnT0XeKpodwuAzC44Hno hPTQ== X-Gm-Message-State: AOAM533yymqr8dhgPv6cmTcJ9LJ49kgjnWbaAn8ABmnyk6MfEsw/5ijI 8voPxHHg+2+NNJUtJ98CGIufDA== X-Google-Smtp-Source: ABdhPJyGtOZ2c3dq9DOPnIrQ4ZOgWQWduUpZPvSnWnh4u2MRjI0SQbaAuY+4G1BsaR9N3/dRTs/YPw== X-Received: by 2002:a2e:7f0f:: with SMTP id a15mr14396200ljd.251.1634315265859; Fri, 15 Oct 2021 09:27:45 -0700 (PDT) Received: from DESKTOP-U5LNN3J.localdomain (89-79-181-52.dynamic.chello.pl. [89.79.181.52]) by smtp.gmail.com with ESMTPSA id b3sm559219lfe.58.2021.10.15.09.27.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Oct 2021 09:27:45 -0700 (PDT) From: Michal Krawczyk To: ferruh.yigit@intel.com Cc: dev@dpdk.org, upstream@semihalf.com, shaibran@amazon.com, ndagan@amazon.com, igorch@amazon.com, Michal Krawczyk , stable@dpdk.org Date: Fri, 15 Oct 2021 18:26:55 +0200 Message-Id: <20211015162701.16324-2-mk@semihalf.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211015162701.16324-1-mk@semihalf.com> References: <20211014201858.9571-1-mk@semihalf.com> <20211015162701.16324-1-mk@semihalf.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 1/7] net/ena: fix verification of the offload capabilities X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 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" ENA PMD has multiple checksum offload flags, which are more discrete than the DPDK offload capabilities flags. As the driver wasn't storing it's internal checksum offload capabilities and was relying only on the DPDK capabilities, not all scenarios could be properly covered (like when to prepare pseudo header checksum and when not). Moreover, the user could request offload capability, which isn't supported by the HW and the PMD would quietly ignore the issue. This commit reworks eth_ena_prep_pkts() function to perform additional checks and to properly reflect the HW requirements. With the RTE_LIBRTE_ETHDEV_DEBUG enabled, the function will do even more verifications, to help the user find any issues with the mbuf configuration. Fixes: b3fc5a1ae10d ("net/ena: add Tx preparation") Cc: stable@dpdk.org Signed-off-by: Michal Krawczyk Reviewed-by: Igor Chauskin Reviewed-by: Shai Brandes --- drivers/net/ena/ena_ethdev.c | 235 +++++++++++++++++++++++++++-------- drivers/net/ena/ena_ethdev.h | 6 +- 2 files changed, 184 insertions(+), 57 deletions(-) diff --git a/drivers/net/ena/ena_ethdev.c b/drivers/net/ena/ena_ethdev.c index a82d4b6287..227831a98c 100644 --- a/drivers/net/ena/ena_ethdev.c +++ b/drivers/net/ena/ena_ethdev.c @@ -140,6 +140,23 @@ static const struct ena_stats ena_stats_rx_strings[] = { #define ENA_TX_OFFLOAD_NOTSUP_MASK \ (PKT_TX_OFFLOAD_MASK ^ ENA_TX_OFFLOAD_MASK) +/** HW specific offloads capabilities. */ +/* IPv4 checksum offload. */ +#define ENA_L3_IPV4_CSUM 0x0001 +/* TCP/UDP checksum offload for IPv4 packets. */ +#define ENA_L4_IPV4_CSUM 0x0002 +/* TCP/UDP checksum offload for IPv4 packets with pseudo header checksum. */ +#define ENA_L4_IPV4_CSUM_PARTIAL 0x0004 +/* TCP/UDP checksum offload for IPv6 packets. */ +#define ENA_L4_IPV6_CSUM 0x0008 +/* TCP/UDP checksum offload for IPv6 packets with pseudo header checksum. */ +#define ENA_L4_IPV6_CSUM_PARTIAL 0x0010 +/* TSO support for IPv4 packets. */ +#define ENA_IPV4_TSO 0x0020 + +/* Device supports setting RSS hash. */ +#define ENA_RX_RSS_HASH 0x0040 + static const struct rte_pci_id pci_id_ena_map[] = { { RTE_PCI_DEVICE(PCI_VENDOR_ID_AMAZON, PCI_DEVICE_ID_ENA_VF) }, { RTE_PCI_DEVICE(PCI_VENDOR_ID_AMAZON, PCI_DEVICE_ID_ENA_VF_RSERV0) }, @@ -1624,6 +1641,50 @@ static uint32_t ena_calc_max_io_queue_num(struct ena_com_dev *ena_dev, return max_num_io_queues; } +static void +ena_set_offloads(struct ena_offloads *offloads, + struct ena_admin_feature_offload_desc *offload_desc) +{ + if (offload_desc->tx & ENA_ADMIN_FEATURE_OFFLOAD_DESC_TSO_IPV4_MASK) + offloads->tx_offloads |= ENA_IPV4_TSO; + + /* Tx IPv4 checksum offloads */ + if (offload_desc->tx & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_TX_L3_CSUM_IPV4_MASK) + offloads->tx_offloads |= ENA_L3_IPV4_CSUM; + if (offload_desc->tx & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_TX_L4_IPV4_CSUM_FULL_MASK) + offloads->tx_offloads |= ENA_L4_IPV4_CSUM; + if (offload_desc->tx & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_TX_L4_IPV4_CSUM_PART_MASK) + offloads->tx_offloads |= ENA_L4_IPV4_CSUM_PARTIAL; + + /* Tx IPv6 checksum offloads */ + if (offload_desc->tx & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_TX_L4_IPV6_CSUM_FULL_MASK) + offloads->tx_offloads |= ENA_L4_IPV6_CSUM; + if (offload_desc->tx & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_TX_L4_IPV6_CSUM_PART_MASK) + offloads->tx_offloads |= ENA_L4_IPV6_CSUM_PARTIAL; + + /* Rx IPv4 checksum offloads */ + if (offload_desc->rx_supported & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_RX_L3_CSUM_IPV4_MASK) + offloads->rx_offloads |= ENA_L3_IPV4_CSUM; + if (offload_desc->rx_supported & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_RX_L4_IPV4_CSUM_MASK) + offloads->rx_offloads |= ENA_L4_IPV4_CSUM; + + /* Rx IPv6 checksum offloads */ + if (offload_desc->rx_supported & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_RX_L4_IPV6_CSUM_MASK) + offloads->rx_offloads |= ENA_L4_IPV6_CSUM; + + if (offload_desc->rx_supported & + ENA_ADMIN_FEATURE_OFFLOAD_DESC_RX_HASH_MASK) + offloads->rx_offloads |= ENA_RX_RSS_HASH; +} + static int eth_ena_dev_init(struct rte_eth_dev *eth_dev) { struct ena_calc_queue_size_ctx calc_queue_ctx = { 0 }; @@ -1745,17 +1806,7 @@ static int eth_ena_dev_init(struct rte_eth_dev *eth_dev) /* Set max MTU for this device */ adapter->max_mtu = get_feat_ctx.dev_attr.max_mtu; - /* set device support for offloads */ - adapter->offloads.tso4_supported = (get_feat_ctx.offload.tx & - ENA_ADMIN_FEATURE_OFFLOAD_DESC_TSO_IPV4_MASK) != 0; - adapter->offloads.tx_csum_supported = (get_feat_ctx.offload.tx & - ENA_ADMIN_FEATURE_OFFLOAD_DESC_TX_L4_IPV4_CSUM_PART_MASK) != 0; - adapter->offloads.rx_csum_supported = - (get_feat_ctx.offload.rx_supported & - ENA_ADMIN_FEATURE_OFFLOAD_DESC_RX_L4_IPV4_CSUM_MASK) != 0; - adapter->offloads.rss_hash_supported = - (get_feat_ctx.offload.rx_supported & - ENA_ADMIN_FEATURE_OFFLOAD_DESC_RX_HASH_MASK) != 0; + ena_set_offloads(&adapter->offloads, &get_feat_ctx.offload); /* Copy MAC address and point DPDK to it */ eth_dev->data->mac_addrs = (struct rte_ether_addr *)adapter->mac_addr; @@ -1915,25 +1966,28 @@ static int ena_infos_get(struct rte_eth_dev *dev, ETH_LINK_SPEED_100G; /* Set Tx & Rx features available for device */ - if (adapter->offloads.tso4_supported) + if (adapter->offloads.tx_offloads & ENA_IPV4_TSO) tx_feat |= DEV_TX_OFFLOAD_TCP_TSO; - if (adapter->offloads.tx_csum_supported) - tx_feat |= DEV_TX_OFFLOAD_IPV4_CKSUM | - DEV_TX_OFFLOAD_UDP_CKSUM | - DEV_TX_OFFLOAD_TCP_CKSUM; + if (adapter->offloads.tx_offloads & ENA_L3_IPV4_CSUM) + tx_feat |= DEV_TX_OFFLOAD_IPV4_CKSUM; + if (adapter->offloads.tx_offloads & + (ENA_L4_IPV4_CSUM_PARTIAL | ENA_L4_IPV4_CSUM | + ENA_L4_IPV6_CSUM | ENA_L4_IPV6_CSUM_PARTIAL)) + tx_feat |= DEV_TX_OFFLOAD_UDP_CKSUM | DEV_TX_OFFLOAD_TCP_CKSUM; - if (adapter->offloads.rx_csum_supported) - rx_feat |= DEV_RX_OFFLOAD_IPV4_CKSUM | - DEV_RX_OFFLOAD_UDP_CKSUM | - DEV_RX_OFFLOAD_TCP_CKSUM; + if (adapter->offloads.rx_offloads & ENA_L3_IPV4_CSUM) + rx_feat |= DEV_RX_OFFLOAD_IPV4_CKSUM; + if (adapter->offloads.rx_offloads & + (ENA_L4_IPV4_CSUM | ENA_L4_IPV6_CSUM)) + rx_feat |= DEV_RX_OFFLOAD_UDP_CKSUM | DEV_RX_OFFLOAD_TCP_CKSUM; rx_feat |= DEV_RX_OFFLOAD_JUMBO_FRAME; tx_feat |= DEV_TX_OFFLOAD_MULTI_SEGS; /* Inform framework about available features */ dev_info->rx_offload_capa = rx_feat; - if (adapter->offloads.rss_hash_supported) + if (adapter->offloads.rx_offloads & ENA_RX_RSS_HASH) dev_info->rx_offload_capa |= DEV_RX_OFFLOAD_RSS_HASH; dev_info->rx_queue_offload_capa = rx_feat; dev_info->tx_offload_capa = tx_feat; @@ -2183,45 +2237,60 @@ eth_ena_prep_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint32_t i; struct rte_mbuf *m; struct ena_ring *tx_ring = (struct ena_ring *)(tx_queue); + struct ena_adapter *adapter = tx_ring->adapter; struct rte_ipv4_hdr *ip_hdr; uint64_t ol_flags; + uint64_t l4_csum_flag; + uint64_t dev_offload_capa; uint16_t frag_field; + bool need_pseudo_csum; + dev_offload_capa = adapter->offloads.tx_offloads; for (i = 0; i != nb_pkts; i++) { m = tx_pkts[i]; ol_flags = m->ol_flags; - if (!(ol_flags & PKT_TX_IPV4)) + /* Check if any offload flag was set */ + if (ol_flags == 0) continue; - /* If there was not L2 header length specified, assume it is - * length of the ethernet header. - */ - if (unlikely(m->l2_len == 0)) - m->l2_len = sizeof(struct rte_ether_hdr); - - ip_hdr = rte_pktmbuf_mtod_offset(m, struct rte_ipv4_hdr *, - m->l2_len); - frag_field = rte_be_to_cpu_16(ip_hdr->fragment_offset); - - if ((frag_field & RTE_IPV4_HDR_DF_FLAG) != 0) { - m->packet_type |= RTE_PTYPE_L4_NONFRAG; - - /* If IPv4 header has DF flag enabled and TSO support is - * disabled, partial chcecksum should not be calculated. - */ - if (!tx_ring->adapter->offloads.tso4_supported) - continue; - } - - if ((ol_flags & ENA_TX_OFFLOAD_NOTSUP_MASK) != 0 || - (ol_flags & PKT_TX_L4_MASK) == - PKT_TX_SCTP_CKSUM) { + l4_csum_flag = ol_flags & PKT_TX_L4_MASK; + /* SCTP checksum offload is not supported by the ENA. */ + if ((ol_flags & ENA_TX_OFFLOAD_NOTSUP_MASK) || + l4_csum_flag == PKT_TX_SCTP_CKSUM) { + PMD_TX_LOG(DEBUG, + "mbuf[%" PRIu32 "] has unsupported offloads flags set: 0x%" PRIu64 "\n", + i, ol_flags); rte_errno = ENOTSUP; return i; } #ifdef RTE_LIBRTE_ETHDEV_DEBUG + /* Check if requested offload is also enabled for the queue */ + if ((ol_flags & PKT_TX_IP_CKSUM && + !(tx_ring->offloads & DEV_TX_OFFLOAD_IPV4_CKSUM)) || + (l4_csum_flag == PKT_TX_TCP_CKSUM && + !(tx_ring->offloads & DEV_TX_OFFLOAD_TCP_CKSUM)) || + (l4_csum_flag == PKT_TX_UDP_CKSUM && + !(tx_ring->offloads & DEV_TX_OFFLOAD_UDP_CKSUM))) { + PMD_TX_LOG(DEBUG, + "mbuf[%" PRIu32 "]: requested offloads: %" PRIu16 " are not enabled for the queue[%u]\n", + i, m->nb_segs, tx_ring->id); + rte_errno = EINVAL; + return i; + } + + /* The caller is obligated to set l2 and l3 len if any cksum + * offload is enabled. + */ + if (unlikely(ol_flags & (PKT_TX_IP_CKSUM | PKT_TX_L4_MASK) && + (m->l2_len == 0 || m->l3_len == 0))) { + PMD_TX_LOG(DEBUG, + "mbuf[%" PRIu32 "]: l2_len or l3_len values are 0 while the offload was requested\n", + i); + rte_errno = EINVAL; + return i; + } ret = rte_validate_tx_offload(m); if (ret != 0) { rte_errno = -ret; @@ -2229,16 +2298,76 @@ eth_ena_prep_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, } #endif - /* In case we are supposed to TSO and have DF not set (DF=0) - * hardware must be provided with partial checksum, otherwise - * it will take care of necessary calculations. + /* Verify HW support for requested offloads and determine if + * pseudo header checksum is needed. */ + need_pseudo_csum = false; + if (ol_flags & PKT_TX_IPV4) { + if (ol_flags & PKT_TX_IP_CKSUM && + !(dev_offload_capa & ENA_L3_IPV4_CSUM)) { + rte_errno = ENOTSUP; + return i; + } - ret = rte_net_intel_cksum_flags_prepare(m, - ol_flags & ~PKT_TX_TCP_SEG); - if (ret != 0) { - rte_errno = -ret; - return i; + if (ol_flags & PKT_TX_TCP_SEG && + !(dev_offload_capa & ENA_IPV4_TSO)) { + rte_errno = ENOTSUP; + return i; + } + + /* Check HW capabilities and if pseudo csum is needed + * for L4 offloads. + */ + if (l4_csum_flag != PKT_TX_L4_NO_CKSUM && + !(dev_offload_capa & ENA_L4_IPV4_CSUM)) { + if (dev_offload_capa & + ENA_L4_IPV4_CSUM_PARTIAL) { + need_pseudo_csum = true; + } else { + rte_errno = ENOTSUP; + return i; + } + } + + /* Parse the DF flag */ + ip_hdr = rte_pktmbuf_mtod_offset(m, + struct rte_ipv4_hdr *, m->l2_len); + frag_field = rte_be_to_cpu_16(ip_hdr->fragment_offset); + if (frag_field & RTE_IPV4_HDR_DF_FLAG) { + m->packet_type |= RTE_PTYPE_L4_NONFRAG; + } else if (ol_flags & PKT_TX_TCP_SEG) { + /* In case we are supposed to TSO and have DF + * not set (DF=0) hardware must be provided with + * partial checksum. + */ + need_pseudo_csum = true; + } + } else if (ol_flags & PKT_TX_IPV6) { + /* There is no support for IPv6 TSO as for now. */ + if (ol_flags & PKT_TX_TCP_SEG) { + rte_errno = ENOTSUP; + return i; + } + + /* Check HW capabilities and if pseudo csum is needed */ + if (l4_csum_flag != PKT_TX_L4_NO_CKSUM && + !(dev_offload_capa & ENA_L4_IPV6_CSUM)) { + if (dev_offload_capa & + ENA_L4_IPV6_CSUM_PARTIAL) { + need_pseudo_csum = true; + } else { + rte_errno = ENOTSUP; + return i; + } + } + } + + if (need_pseudo_csum) { + ret = rte_net_intel_cksum_flags_prepare(m, ol_flags); + if (ret != 0) { + rte_errno = -ret; + return i; + } } } diff --git a/drivers/net/ena/ena_ethdev.h b/drivers/net/ena/ena_ethdev.h index 06ac8b06b5..26d425a893 100644 --- a/drivers/net/ena/ena_ethdev.h +++ b/drivers/net/ena/ena_ethdev.h @@ -223,10 +223,8 @@ struct ena_stats_eni { }; struct ena_offloads { - bool tso4_supported; - bool tx_csum_supported; - bool rx_csum_supported; - bool rss_hash_supported; + uint32_t tx_offloads; + uint32_t rx_offloads; }; /* board specific private data structure */ From patchwork Fri Oct 15 16:26:56 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michal Krawczyk X-Patchwork-Id: 101805 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id E0C9AA034F; Fri, 15 Oct 2021 18:27:59 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C6D684118B; Fri, 15 Oct 2021 18:27:49 +0200 (CEST) Received: from mail-lf1-f48.google.com (mail-lf1-f48.google.com [209.85.167.48]) by mails.dpdk.org (Postfix) with ESMTP id 8262941134 for ; Fri, 15 Oct 2021 18:27:47 +0200 (CEST) Received: by mail-lf1-f48.google.com with SMTP id g36so27265579lfv.3 for ; Fri, 15 Oct 2021 09:27:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=semihalf-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=VtaB/wVkvcJ6VS1ByXDez9oL2ce0uNoYrXOwYleCjjU=; b=XcAdpPApM1AFyabzP83gqRXDU9je20+UCY5Re943PKe/YD10tGEyXXPYt/r2Ilvqym 4YOExoURKfimOoiOupwzEWbx11WlCyhv0JfNaXOHqE2QQKXQF6r+WZni9BnCruGDSvBV 6KRexVEG/OtnSvT11nrK12Cok+yVQbhYmxat/4sbBvblhnsmFHE+BaQM4dXzpO+kJZOn qGgHMEjbIXJfr1bzwK5rCOyli6UFGtpsOWPhNdP5nMYgc7PaQmv6+PtSSyRhpfsHq5Vb MakHd6v2RgAQIGx4mvz3zMeY7KeSY0RNQHldIrwRT+Ct6DYss4yrTeTr06PkIRKZGqgX fa0Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=VtaB/wVkvcJ6VS1ByXDez9oL2ce0uNoYrXOwYleCjjU=; b=luI/wb8GS6MYA34G1/EHEWnCFHUmqehdpll5K2f/XUQZNsEyAs+mpjSJq1/Vy9geXU CkW+9aod3LUgsjxhGOxJHyhtPC6itmDvcwySqIwGk1MiubYcSBDmgAvGSYdb/JEN18Tk YeuibonR6R+X8fKJWlA2urQgMrxEsZoeWFG6IGHfCYnb4N1vOOIq2H3i788J/yKYczv0 1aKUr/O/XI2loKjtvCYTZB1FUc12okpvmGmGElJCiwG8MpsCiNcXEScbtXAPL+cMzxaf gL7nPk/kcBz1f5BRON/NgT0HPJL2WW4fTcEHhqO1yL1NUNEYeEekrKRGFtKltcxVYZTa hkOg== X-Gm-Message-State: AOAM531osqtFKQGETzU+OBzmeprP1bsErpoGZy7q7UEv2s5uKrnNCqcu ZiKAEj6+iqK4xU1rzXqM1hrzQQ== X-Google-Smtp-Source: ABdhPJydeFlg4AKMfZVoU7Y1h354EFGymiLv1GALOZxOxFnM4/vmn1gshaS8WCLMXK+drJBvRMZQQA== X-Received: by 2002:a05:6512:2347:: with SMTP id p7mr12297147lfu.558.1634315267101; Fri, 15 Oct 2021 09:27:47 -0700 (PDT) Received: from DESKTOP-U5LNN3J.localdomain (89-79-181-52.dynamic.chello.pl. [89.79.181.52]) by smtp.gmail.com with ESMTPSA id b3sm559219lfe.58.2021.10.15.09.27.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Oct 2021 09:27:46 -0700 (PDT) From: Michal Krawczyk To: ferruh.yigit@intel.com Cc: dev@dpdk.org, upstream@semihalf.com, shaibran@amazon.com, ndagan@amazon.com, igorch@amazon.com, Michal Krawczyk Date: Fri, 15 Oct 2021 18:26:56 +0200 Message-Id: <20211015162701.16324-3-mk@semihalf.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211015162701.16324-1-mk@semihalf.com> References: <20211014201858.9571-1-mk@semihalf.com> <20211015162701.16324-1-mk@semihalf.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 2/7] net/ena: support Tx/Rx free thresholds X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 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 caller can pass Tx or Rx free threshold value to the configuration structure for each ring. It determines when the Tx/Rx function should start cleaning up/refilling the descriptors. ENA was ignoring this value and doing it's own calulcations. Now the user can configure ENA's behavior using this parameter and if this variable won't be set, the ENA will continue with the old behavior and will use it's own threshold value. The default value is not provided by the ENA in the ena_infos_get(), as it's being determined dynamically, depending on the requested ring size. Note that NULL check for Tx conf was removed from the function ena_tx_queue_setup(), as at this place the configuration will be either provided by the user or the default config will be used and it's handled by the upper (rte_ethdev) layer. Tx threshold shouldn't be used for the Tx cleanup budget as it can be inadequate to the used burst. Now the PMD tries to release mbufs for the ring until it will be depleted. Signed-off-by: Michal Krawczyk Reviewed-by: Igor Chauskin Reviewed-by: Shai Brandes --- v2: * Fix calculations of the default tx_free_thresh if it wasn't provided by the user. RTE_MIN was replaced with RTE_MAX. doc/guides/rel_notes/release_21_11.rst | 7 ++++ drivers/net/ena/ena_ethdev.c | 44 ++++++++++++++++++-------- drivers/net/ena/ena_ethdev.h | 5 +++ 3 files changed, 42 insertions(+), 14 deletions(-) diff --git a/doc/guides/rel_notes/release_21_11.rst b/doc/guides/rel_notes/release_21_11.rst index 1f033cf80c..45d5cbdc78 100644 --- a/doc/guides/rel_notes/release_21_11.rst +++ b/doc/guides/rel_notes/release_21_11.rst @@ -93,6 +93,13 @@ New Features * Disabled secondary process support. +* **Updated Amazon ENA PMD.** + + Updated the Amazon ENA PMD. The new driver version (v2.5.0) introduced + bug fixes and improvements, including: + + * Support for the tx_free_thresh and rx_free_thresh configuration parameters. + * **Updated Broadcom bnxt PMD.** * Added flow offload support for Thor. diff --git a/drivers/net/ena/ena_ethdev.c b/drivers/net/ena/ena_ethdev.c index 227831a98c..87216f75a9 100644 --- a/drivers/net/ena/ena_ethdev.c +++ b/drivers/net/ena/ena_ethdev.c @@ -1140,6 +1140,7 @@ static int ena_tx_queue_setup(struct rte_eth_dev *dev, struct ena_ring *txq = NULL; struct ena_adapter *adapter = dev->data->dev_private; unsigned int i; + uint16_t dyn_thresh; txq = &adapter->tx_ring[queue_idx]; @@ -1206,10 +1207,18 @@ static int ena_tx_queue_setup(struct rte_eth_dev *dev, for (i = 0; i < txq->ring_size; i++) txq->empty_tx_reqs[i] = i; - if (tx_conf != NULL) { - txq->offloads = - tx_conf->offloads | dev->data->dev_conf.txmode.offloads; + txq->offloads = tx_conf->offloads | dev->data->dev_conf.txmode.offloads; + + /* Check if caller provided the Tx cleanup threshold value. */ + if (tx_conf->tx_free_thresh != 0) { + txq->tx_free_thresh = tx_conf->tx_free_thresh; + } else { + dyn_thresh = txq->ring_size - + txq->ring_size / ENA_REFILL_THRESH_DIVIDER; + txq->tx_free_thresh = RTE_MAX(dyn_thresh, + txq->ring_size - ENA_REFILL_THRESH_PACKET); } + /* Store pointer to this queue in upper layer */ txq->configured = 1; dev->data->tx_queues[queue_idx] = txq; @@ -1228,6 +1237,7 @@ static int ena_rx_queue_setup(struct rte_eth_dev *dev, struct ena_ring *rxq = NULL; size_t buffer_size; int i; + uint16_t dyn_thresh; rxq = &adapter->rx_ring[queue_idx]; if (rxq->configured) { @@ -1307,6 +1317,14 @@ static int ena_rx_queue_setup(struct rte_eth_dev *dev, rxq->offloads = rx_conf->offloads | dev->data->dev_conf.rxmode.offloads; + if (rx_conf->rx_free_thresh != 0) { + rxq->rx_free_thresh = rx_conf->rx_free_thresh; + } else { + dyn_thresh = rxq->ring_size / ENA_REFILL_THRESH_DIVIDER; + rxq->rx_free_thresh = RTE_MIN(dyn_thresh, + (uint16_t)(ENA_REFILL_THRESH_PACKET)); + } + /* Store pointer to this queue in upper layer */ rxq->configured = 1; dev->data->rx_queues[queue_idx] = rxq; @@ -2134,7 +2152,6 @@ static uint16_t eth_ena_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, { struct ena_ring *rx_ring = (struct ena_ring *)(rx_queue); unsigned int free_queue_entries; - unsigned int refill_threshold; uint16_t next_to_clean = rx_ring->next_to_clean; uint16_t descs_in_use; struct rte_mbuf *mbuf; @@ -2216,12 +2233,9 @@ static uint16_t eth_ena_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, rx_ring->next_to_clean = next_to_clean; free_queue_entries = ena_com_free_q_entries(rx_ring->ena_com_io_sq); - refill_threshold = - RTE_MIN(rx_ring->ring_size / ENA_REFILL_THRESH_DIVIDER, - (unsigned int)ENA_REFILL_THRESH_PACKET); /* Burst refill to save doorbells, memory barriers, const interval */ - if (free_queue_entries > refill_threshold) { + if (free_queue_entries >= rx_ring->rx_free_thresh) { ena_com_update_dev_comp_head(rx_ring->ena_com_io_cq); ena_populate_rx_queue(rx_ring, free_queue_entries); } @@ -2588,12 +2602,12 @@ static int ena_xmit_mbuf(struct ena_ring *tx_ring, struct rte_mbuf *mbuf) static void ena_tx_cleanup(struct ena_ring *tx_ring) { - unsigned int cleanup_budget; unsigned int total_tx_descs = 0; + uint16_t cleanup_budget; uint16_t next_to_clean = tx_ring->next_to_clean; - cleanup_budget = RTE_MIN(tx_ring->ring_size / ENA_REFILL_THRESH_DIVIDER, - (unsigned int)ENA_REFILL_THRESH_PACKET); + /* Attempt to release all Tx descriptors (ring_size - 1 -> size_mask) */ + cleanup_budget = tx_ring->size_mask; while (likely(total_tx_descs < cleanup_budget)) { struct rte_mbuf *mbuf; @@ -2634,6 +2648,7 @@ static uint16_t eth_ena_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts) { struct ena_ring *tx_ring = (struct ena_ring *)(tx_queue); + int available_desc; uint16_t sent_idx = 0; #ifdef RTE_ETHDEV_DEBUG_TX @@ -2653,8 +2668,8 @@ static uint16_t eth_ena_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, tx_ring->size_mask)]); } - tx_ring->tx_stats.available_desc = - ena_com_free_q_entries(tx_ring->ena_com_io_sq); + available_desc = ena_com_free_q_entries(tx_ring->ena_com_io_sq); + tx_ring->tx_stats.available_desc = available_desc; /* If there are ready packets to be xmitted... */ if (likely(tx_ring->pkts_without_db)) { @@ -2664,7 +2679,8 @@ static uint16_t eth_ena_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, tx_ring->pkts_without_db = false; } - ena_tx_cleanup(tx_ring); + if (available_desc < tx_ring->tx_free_thresh) + ena_tx_cleanup(tx_ring); tx_ring->tx_stats.available_desc = ena_com_free_q_entries(tx_ring->ena_com_io_sq); diff --git a/drivers/net/ena/ena_ethdev.h b/drivers/net/ena/ena_ethdev.h index 26d425a893..176d713dff 100644 --- a/drivers/net/ena/ena_ethdev.h +++ b/drivers/net/ena/ena_ethdev.h @@ -142,6 +142,11 @@ struct ena_ring { struct ena_com_io_cq *ena_com_io_cq; struct ena_com_io_sq *ena_com_io_sq; + union { + uint16_t tx_free_thresh; + uint16_t rx_free_thresh; + }; + struct ena_com_rx_buf_info ena_bufs[ENA_PKT_MAX_BUFS] __rte_cache_aligned; From patchwork Fri Oct 15 16:26:57 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michal Krawczyk X-Patchwork-Id: 101806 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 0F6BFA034F; Fri, 15 Oct 2021 18:28:07 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 06880411B6; Fri, 15 Oct 2021 18:27:51 +0200 (CEST) Received: from mail-lf1-f53.google.com (mail-lf1-f53.google.com [209.85.167.53]) by mails.dpdk.org (Postfix) with ESMTP id 9657641147 for ; Fri, 15 Oct 2021 18:27:48 +0200 (CEST) Received: by mail-lf1-f53.google.com with SMTP id x27so44301347lfu.5 for ; Fri, 15 Oct 2021 09:27:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=semihalf-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=xpEKrR/ELZ5c3ce9pfZ9iajIFAVVntMOxjAjnVHUr2w=; b=k4o4WkpoQ8Rum/1C5485HS2+1YVHg1/aHMGqOzQ18g1imFdj6pQUQ9GTwVb2Nf/qMF c38VGWbwEIC0jjJisKdL1vGxxClQytRYkBlRxw0c1RyYLgruURT63EY8e2BFvX7LyjxE do7OA2XunTl5LhElf8+Gj242b2LHZIhnOfIZ2hefRjAYCtQHCxjyaFBV2Mxrqln183Ks wXqFOtZ7LJ6Sz9pl5jf0gccqg8pYNo6VVqDoXwVG/lSvDvVzoOSXD358rEoz9D8Iz+9K R0oJ5CKm4ipPBo6Cuq5urQDA/ePN1ixisYPs+lCN/U6bxepuc3NdgFFdsKR41dppdXzj 5fOA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=xpEKrR/ELZ5c3ce9pfZ9iajIFAVVntMOxjAjnVHUr2w=; b=HS1h7MaI54Yq4avIRl6utYCVE/1vQy92aDXCTNNE8u3oUQ8ExLp632lxWcxPq6jTDW 9CPOZjVpWlqpSo4ljqIBN19+rZkQ33xYSImXTPyxCOJkudSe0Hx3P5Os7FRgzb0Yn5X0 WXHhDL48H9GFVegjVZPvFT00RmTgyaqbonKuzsfV9wzI00wfaeehve80kdicKyqk4yGA 2MRKNwukO+gvc9dE+O3YCTrzTpPNsSOQt8hX1aShnL4OvyzVqu4wEG26f89a4eRkxy9c IEqiZz28+yq+bF+Ww1BzVHAgI10CAxP6yekCLf/IFgX2nZXP8ChvkmZfHVDlqjvnrrYk pmFQ== X-Gm-Message-State: AOAM530/0sd+A9HKXWUfSyyS/PBC7fWVtJuPwyoIzhB/43wCj8MMUPNr IVJQhDgQ56FNJnieVfoSKpybcQ== X-Google-Smtp-Source: ABdhPJymRaqKfPgq4iZoqF92SJodalZMbV0hJL4pR+xip8XMvx13rC7/Gp2c/4cd8j0/b2blB+QK/Q== X-Received: by 2002:a2e:611a:: with SMTP id v26mr13286520ljb.122.1634315268251; Fri, 15 Oct 2021 09:27:48 -0700 (PDT) Received: from DESKTOP-U5LNN3J.localdomain (89-79-181-52.dynamic.chello.pl. [89.79.181.52]) by smtp.gmail.com with ESMTPSA id b3sm559219lfe.58.2021.10.15.09.27.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Oct 2021 09:27:47 -0700 (PDT) From: Michal Krawczyk To: ferruh.yigit@intel.com Cc: dev@dpdk.org, upstream@semihalf.com, shaibran@amazon.com, ndagan@amazon.com, igorch@amazon.com, Michal Krawczyk , stable@dpdk.org Date: Fri, 15 Oct 2021 18:26:57 +0200 Message-Id: <20211015162701.16324-4-mk@semihalf.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211015162701.16324-1-mk@semihalf.com> References: <20211014201858.9571-1-mk@semihalf.com> <20211015162701.16324-1-mk@semihalf.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 3/7] net/ena: fix per-queue offload capabilities X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 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" PMD shouldn't advertise the same offloads as both per-queue and per-port [1]. Each offload capability should go either to the [rt]x_queue_offload_capa or [rt]x_offload_capa. As ENA currently doesn't support offloads which could be configured per-queue, only per-port flags should be set. In addition, to make the code cleaner, parsing appropriate offload flags is encapsulated into helper functions, in a similar matter it's done by the other PMDs. [1] https://doc.dpdk.org/guides/prog_guide/ poll_mode_drv.html?highlight=offloads#hardware-offload Fixes: 7369f88f88c0 ("net/ena: convert to new Rx offloads API") Fixes: 56b8b9b7e5d2 ("net/ena: convert to new Tx offloads API") Cc: stable@dpdk.org Signed-off-by: Michal Krawczyk Reviewed-by: Igor Chauskin Reviewed-by: Shai Brandes --- drivers/net/ena/ena_ethdev.c | 90 ++++++++++++++++++++++++------------ 1 file changed, 60 insertions(+), 30 deletions(-) diff --git a/drivers/net/ena/ena_ethdev.c b/drivers/net/ena/ena_ethdev.c index 87216f75a9..c2bd2f12af 100644 --- a/drivers/net/ena/ena_ethdev.c +++ b/drivers/net/ena/ena_ethdev.c @@ -223,6 +223,10 @@ static int ena_queue_start(struct rte_eth_dev *dev, struct ena_ring *ring); static int ena_queue_start_all(struct rte_eth_dev *dev, enum ena_ring_type ring_type); static void ena_stats_restart(struct rte_eth_dev *dev); +static uint64_t ena_get_rx_port_offloads(struct ena_adapter *adapter); +static uint64_t ena_get_tx_port_offloads(struct ena_adapter *adapter); +static uint64_t ena_get_rx_queue_offloads(struct ena_adapter *adapter); +static uint64_t ena_get_tx_queue_offloads(struct ena_adapter *adapter); static int ena_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info); static void ena_interrupt_handler_rte(void *cb_arg); @@ -1959,12 +1963,63 @@ static void ena_init_rings(struct ena_adapter *adapter, } } +static uint64_t ena_get_rx_port_offloads(struct ena_adapter *adapter) +{ + uint64_t port_offloads = 0; + + if (adapter->offloads.rx_offloads & ENA_L3_IPV4_CSUM) + port_offloads |= DEV_RX_OFFLOAD_IPV4_CKSUM; + + if (adapter->offloads.rx_offloads & + (ENA_L4_IPV4_CSUM | ENA_L4_IPV6_CSUM)) + port_offloads |= + DEV_RX_OFFLOAD_UDP_CKSUM | DEV_RX_OFFLOAD_TCP_CKSUM; + + if (adapter->offloads.rx_offloads & ENA_RX_RSS_HASH) + port_offloads |= DEV_RX_OFFLOAD_RSS_HASH; + + port_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME; + + return port_offloads; +} + +static uint64_t ena_get_tx_port_offloads(struct ena_adapter *adapter) +{ + uint64_t port_offloads = 0; + + if (adapter->offloads.tx_offloads & ENA_IPV4_TSO) + port_offloads |= DEV_TX_OFFLOAD_TCP_TSO; + + if (adapter->offloads.tx_offloads & ENA_L3_IPV4_CSUM) + port_offloads |= DEV_TX_OFFLOAD_IPV4_CKSUM; + if (adapter->offloads.tx_offloads & + (ENA_L4_IPV4_CSUM_PARTIAL | ENA_L4_IPV4_CSUM | + ENA_L4_IPV6_CSUM | ENA_L4_IPV6_CSUM_PARTIAL)) + port_offloads |= + DEV_TX_OFFLOAD_UDP_CKSUM | DEV_TX_OFFLOAD_TCP_CKSUM; + + return port_offloads; +} + +static uint64_t ena_get_rx_queue_offloads(struct ena_adapter *adapter) +{ + RTE_SET_USED(adapter); + + return 0; +} + +static uint64_t ena_get_tx_queue_offloads(struct ena_adapter *adapter) +{ + RTE_SET_USED(adapter); + + return 0; +} + static int ena_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info) { struct ena_adapter *adapter; struct ena_com_dev *ena_dev; - uint64_t rx_feat = 0, tx_feat = 0; ena_assert_msg(dev->data != NULL, "Uninitialized device\n"); ena_assert_msg(dev->data->dev_private != NULL, "Uninitialized device\n"); @@ -1983,33 +2038,11 @@ static int ena_infos_get(struct rte_eth_dev *dev, ETH_LINK_SPEED_50G | ETH_LINK_SPEED_100G; - /* Set Tx & Rx features available for device */ - if (adapter->offloads.tx_offloads & ENA_IPV4_TSO) - tx_feat |= DEV_TX_OFFLOAD_TCP_TSO; - - if (adapter->offloads.tx_offloads & ENA_L3_IPV4_CSUM) - tx_feat |= DEV_TX_OFFLOAD_IPV4_CKSUM; - if (adapter->offloads.tx_offloads & - (ENA_L4_IPV4_CSUM_PARTIAL | ENA_L4_IPV4_CSUM | - ENA_L4_IPV6_CSUM | ENA_L4_IPV6_CSUM_PARTIAL)) - tx_feat |= DEV_TX_OFFLOAD_UDP_CKSUM | DEV_TX_OFFLOAD_TCP_CKSUM; - - if (adapter->offloads.rx_offloads & ENA_L3_IPV4_CSUM) - rx_feat |= DEV_RX_OFFLOAD_IPV4_CKSUM; - if (adapter->offloads.rx_offloads & - (ENA_L4_IPV4_CSUM | ENA_L4_IPV6_CSUM)) - rx_feat |= DEV_RX_OFFLOAD_UDP_CKSUM | DEV_RX_OFFLOAD_TCP_CKSUM; - - rx_feat |= DEV_RX_OFFLOAD_JUMBO_FRAME; - tx_feat |= DEV_TX_OFFLOAD_MULTI_SEGS; - /* Inform framework about available features */ - dev_info->rx_offload_capa = rx_feat; - if (adapter->offloads.rx_offloads & ENA_RX_RSS_HASH) - dev_info->rx_offload_capa |= DEV_RX_OFFLOAD_RSS_HASH; - dev_info->rx_queue_offload_capa = rx_feat; - dev_info->tx_offload_capa = tx_feat; - dev_info->tx_queue_offload_capa = tx_feat; + dev_info->rx_offload_capa = ena_get_rx_port_offloads(adapter); + dev_info->tx_offload_capa = ena_get_tx_port_offloads(adapter); + dev_info->rx_queue_offload_capa = ena_get_rx_queue_offloads(adapter); + dev_info->tx_queue_offload_capa = ena_get_tx_queue_offloads(adapter); dev_info->flow_type_rss_offloads = ENA_ALL_RSS_HF; dev_info->hash_key_size = ENA_HASH_KEY_SIZE; @@ -2022,9 +2055,6 @@ static int ena_infos_get(struct rte_eth_dev *dev, dev_info->max_tx_queues = adapter->max_num_io_queues; dev_info->reta_size = ENA_RX_RSS_TABLE_SIZE; - adapter->tx_supported_offloads = tx_feat; - adapter->rx_supported_offloads = rx_feat; - dev_info->rx_desc_lim.nb_max = adapter->max_rx_ring_size; dev_info->rx_desc_lim.nb_min = ENA_MIN_RING_DESC; dev_info->rx_desc_lim.nb_seg_max = RTE_MIN(ENA_PKT_MAX_BUFS, From patchwork Fri Oct 15 16:26:58 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michal Krawczyk X-Patchwork-Id: 101807 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 2B4FEA034F; Fri, 15 Oct 2021 18:28:14 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 38B5D411AD; Fri, 15 Oct 2021 18:27:53 +0200 (CEST) Received: from mail-lf1-f47.google.com (mail-lf1-f47.google.com [209.85.167.47]) by mails.dpdk.org (Postfix) with ESMTP id B58A94117C for ; Fri, 15 Oct 2021 18:27:49 +0200 (CEST) Received: by mail-lf1-f47.google.com with SMTP id r19so42856939lfe.10 for ; Fri, 15 Oct 2021 09:27:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=semihalf-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=rp1Bb1XJSHXd9hdUDhS9BrMlzFrVcOXUFD5VzFUGerI=; b=Iu3ROXJoFmFd+3s1nVFfz8vkqHuSrSwEvCFZicYQDQQ91nBzpXAytycT2WxxbsrjII RgUb0REhbzfra9n63jWeAbevyvEVi+CHRIwUDnU5cQ+s6PqJeBPN+bCGBmCd2iIkMi6v 3LEczoWinVCssokHz/xr5o15yDhgikevUVNdcG/jUbd6PHXX/tj4w+XtzUZr3lCeqpYc Cs+LkJan1jUFOsM2YFaeCCP+Uf+g+h4to1V7gBWGIw35NYsh/j3d0BSDtV00addGTEyh xLvgkWUxEBIrpLvCTMHYbXZHkJmlWQu28gu00YqOv3H6+eaxXwRdqOtacB00cObLDHUF 0idw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=rp1Bb1XJSHXd9hdUDhS9BrMlzFrVcOXUFD5VzFUGerI=; b=LcnrucgavDwOcqw9BzhVSzwXpEG8a8BBe/xzGH3Es+abL8WkpVWbL2jEehPIMi14QG 0yxqD+5W/wKaGrqiRctgSq5yYFZsPqG5SxG1nTfKYKw4hsVc78Twd+RoFmhuWr5S/yVN x1d/4LUM4D4406rpHdnn5Tf50zJYCifAAQU+iXQvBRVZNYMOIbZzPoUpIjwa8BkVYRSZ eR+GTQW2NtMicTm55QWZGMAlb9SZt8z7Afl9eeyq+ns7rUl1YjoGg1Y2cEpj8ZJASKdy T0v1Bj55a/lrqUn1pkJ5cPEqX3Au7qZXaxF4C3ycYILLelRh7fRSJ3MO8jW5o8pSewYm /o/g== X-Gm-Message-State: AOAM532OWPXvK7x+cws6dYm2XxnldUngal2/iWW3R1sz827qED0l5QnK OrviG1ozXP08dmR5CaENfVzE2Q== X-Google-Smtp-Source: ABdhPJz74lO8jkMi6HrMzNpA+mKhDe4kRsWaMI+D3s6c8xEMV3myGX6RcWOYsYEz/4k0DyV58/knHg== X-Received: by 2002:a2e:90b:: with SMTP id 11mr14084734ljj.186.1634315269393; Fri, 15 Oct 2021 09:27:49 -0700 (PDT) Received: from DESKTOP-U5LNN3J.localdomain (89-79-181-52.dynamic.chello.pl. [89.79.181.52]) by smtp.gmail.com with ESMTPSA id b3sm559219lfe.58.2021.10.15.09.27.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Oct 2021 09:27:48 -0700 (PDT) From: Michal Krawczyk To: ferruh.yigit@intel.com Cc: dev@dpdk.org, upstream@semihalf.com, shaibran@amazon.com, ndagan@amazon.com, igorch@amazon.com, Michal Krawczyk , stable@dpdk.org Date: Fri, 15 Oct 2021 18:26:58 +0200 Message-Id: <20211015162701.16324-5-mk@semihalf.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211015162701.16324-1-mk@semihalf.com> References: <20211014201858.9571-1-mk@semihalf.com> <20211015162701.16324-1-mk@semihalf.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 4/7] net/ena: indicate missing scattered Rx capability X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 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" ENA can't be forced to always pass single descriptor for the Rx packet. Even if the passed buffer size is big enough to hold the data, we can't make assumption that the HW won't use extra descriptor because of internal optimizations. This assumption may be true, but only for some of the FW revisions, which may differ depending on the used AWS instance type. As the scattered Rx support on the Rx path already exists, the driver just needs to announce DEV_RX_OFFLOAD_SCATTER capability by turning on the rte_eth_dev_data::scattered_rx option. Fixes: 1173fca25af9 ("ena: add polling-mode driver") Cc: stable@dpdk.org Signed-off-by: Michal Krawczyk Reviewed-by: Igor Chauskin Reviewed-by: Shai Brandes --- drivers/net/ena/ena_ethdev.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/drivers/net/ena/ena_ethdev.c b/drivers/net/ena/ena_ethdev.c index c2bd2f12af..35db2e8356 100644 --- a/drivers/net/ena/ena_ethdev.c +++ b/drivers/net/ena/ena_ethdev.c @@ -1929,8 +1929,14 @@ static int ena_dev_configure(struct rte_eth_dev *dev) dev->data->dev_conf.rxmode.offloads |= DEV_RX_OFFLOAD_RSS_HASH; dev->data->dev_conf.txmode.offloads |= DEV_TX_OFFLOAD_MULTI_SEGS; + /* Scattered Rx cannot be turned off in the HW, so this capability must + * be forced. + */ + dev->data->scattered_rx = 1; + adapter->tx_selected_offloads = dev->data->dev_conf.txmode.offloads; adapter->rx_selected_offloads = dev->data->dev_conf.rxmode.offloads; + return 0; } @@ -1978,7 +1984,7 @@ static uint64_t ena_get_rx_port_offloads(struct ena_adapter *adapter) if (adapter->offloads.rx_offloads & ENA_RX_RSS_HASH) port_offloads |= DEV_RX_OFFLOAD_RSS_HASH; - port_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME; + port_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME | DEV_RX_OFFLOAD_SCATTER; return port_offloads; } From patchwork Fri Oct 15 16:26:59 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michal Krawczyk X-Patchwork-Id: 101808 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id D98DBA034F; Fri, 15 Oct 2021 18:28:20 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 3DBE4411CE; Fri, 15 Oct 2021 18:27:54 +0200 (CEST) Received: from mail-lf1-f52.google.com (mail-lf1-f52.google.com [209.85.167.52]) by mails.dpdk.org (Postfix) with ESMTP id 51F944115F for ; Fri, 15 Oct 2021 18:27:51 +0200 (CEST) Received: by mail-lf1-f52.google.com with SMTP id x27so43649999lfa.9 for ; Fri, 15 Oct 2021 09:27:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=semihalf-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=3iwXqWQPuyX9OMz0Cy/i37RGmE9RJZ10GdeOHpa+074=; b=kgPNfxXNoj2l4XdrJVyGu6wOp/1xjI2d15dr8Jqj+NorWTe5aaU1hcwMgD4J8UFRcW xJ6q5znqSNxgM3lf0e3mL3iioK0z3mr2INa+Ny/brJM7BdSJ7yipOynFd/XkC/FCak8G wez391F2JHLaBWRa1P/AqYmk5zRV3CqIvbru1fiV8w/AR808nP/tGW1d8ntojGtVvW33 7ZN3bGs0bBQy8a+81KUD486r7v50wz5hkR28mjXU2UrcgN7SOZ+9GE48EJsO6cWdHJj6 CazzcOKP37H5GPx3a6pwSG4fZ3SGW/mu823mPhsY4RVER7XI+vRP+7+PfRHxJZu5NNsu NyVw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=3iwXqWQPuyX9OMz0Cy/i37RGmE9RJZ10GdeOHpa+074=; b=zC/wFrDVKAi7RLajjXCQwa21QZQ+XcIzlRByOTvOnJgoLjeJcgna3bAlhJSWOywQjO 01RGQ1ZjyAoFrmq6cmvhPZjYfiaAyM2XBFFLSoqnetjIul5GQvCLh1X43ok6BMsJbRgO poK+ui+6MplDc01Uq788DxuHMgeupA+OJZyH2Fb4NS4iXPWb7QGejM41/X1n5yR4WWsN AiNRwJtMbCFwUQcKQhJ5crMsLazOjzzTtgnrL9PHQbVo8l6rxOE7LCww+gp+rBDi7Vuy 91PyPEcCYOcWglJycEyPu9jQwSxRgMv2Yi2Goh83Wl8vxMY9t4S3Ip7WgIorGholHdLQ /scg== X-Gm-Message-State: AOAM530aujkGpqZ5ylfrQqiwI2CwmTR8P+fEo2L7Fql8yCmCg/VfgaQy UG2dXqfLhdS71JvdG3+i2k+hag== X-Google-Smtp-Source: ABdhPJx+u1112J0Tzczfhi0oXjH5TEODE9lLHRjrMkpqn+GabupbAQr74jN6wB7PtgnuEF9jkXYHCg== X-Received: by 2002:a05:6512:984:: with SMTP id w4mr12117413lft.141.1634315270626; Fri, 15 Oct 2021 09:27:50 -0700 (PDT) Received: from DESKTOP-U5LNN3J.localdomain (89-79-181-52.dynamic.chello.pl. [89.79.181.52]) by smtp.gmail.com with ESMTPSA id b3sm559219lfe.58.2021.10.15.09.27.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Oct 2021 09:27:50 -0700 (PDT) From: Michal Krawczyk To: ferruh.yigit@intel.com Cc: dev@dpdk.org, upstream@semihalf.com, shaibran@amazon.com, ndagan@amazon.com, igorch@amazon.com, Michal Krawczyk Date: Fri, 15 Oct 2021 18:26:59 +0200 Message-Id: <20211015162701.16324-6-mk@semihalf.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211015162701.16324-1-mk@semihalf.com> References: <20211014201858.9571-1-mk@semihalf.com> <20211015162701.16324-1-mk@semihalf.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 5/7] net/ena: add NUMA aware allocations X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 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" Only the IO rings memory was allocated with taking the socket ID into the respect, while the other structures was allocated using the regular rte_zmalloc() API. Ring specific structures are now being allocated using the ring's socket ID. Signed-off-by: Michal Krawczyk Reviewed-by: Igor Chauskin Reviewed-by: Shai Brandes --- doc/guides/rel_notes/release_21_11.rst | 1 + drivers/net/ena/ena_ethdev.c | 42 ++++++++++++++------------ 2 files changed, 24 insertions(+), 19 deletions(-) diff --git a/doc/guides/rel_notes/release_21_11.rst b/doc/guides/rel_notes/release_21_11.rst index 45d5cbdc78..c87862e713 100644 --- a/doc/guides/rel_notes/release_21_11.rst +++ b/doc/guides/rel_notes/release_21_11.rst @@ -99,6 +99,7 @@ New Features bug fixes and improvements, including: * Support for the tx_free_thresh and rx_free_thresh configuration parameters. + * NUMA aware allocations for the queue helper structures. * **Updated Broadcom bnxt PMD.** diff --git a/drivers/net/ena/ena_ethdev.c b/drivers/net/ena/ena_ethdev.c index 35db2e8356..e31cb0b65c 100644 --- a/drivers/net/ena/ena_ethdev.c +++ b/drivers/net/ena/ena_ethdev.c @@ -1177,19 +1177,20 @@ static int ena_tx_queue_setup(struct rte_eth_dev *dev, txq->numa_socket_id = socket_id; txq->pkts_without_db = false; - txq->tx_buffer_info = rte_zmalloc("txq->tx_buffer_info", - sizeof(struct ena_tx_buffer) * - txq->ring_size, - RTE_CACHE_LINE_SIZE); + txq->tx_buffer_info = rte_zmalloc_socket("txq->tx_buffer_info", + sizeof(struct ena_tx_buffer) * txq->ring_size, + RTE_CACHE_LINE_SIZE, + socket_id); if (!txq->tx_buffer_info) { PMD_DRV_LOG(ERR, "Failed to allocate memory for Tx buffer info\n"); return -ENOMEM; } - txq->empty_tx_reqs = rte_zmalloc("txq->empty_tx_reqs", - sizeof(u16) * txq->ring_size, - RTE_CACHE_LINE_SIZE); + txq->empty_tx_reqs = rte_zmalloc_socket("txq->empty_tx_reqs", + sizeof(uint16_t) * txq->ring_size, + RTE_CACHE_LINE_SIZE, + socket_id); if (!txq->empty_tx_reqs) { PMD_DRV_LOG(ERR, "Failed to allocate memory for empty Tx requests\n"); @@ -1198,9 +1199,10 @@ static int ena_tx_queue_setup(struct rte_eth_dev *dev, } txq->push_buf_intermediate_buf = - rte_zmalloc("txq->push_buf_intermediate_buf", - txq->tx_max_header_size, - RTE_CACHE_LINE_SIZE); + rte_zmalloc_socket("txq->push_buf_intermediate_buf", + txq->tx_max_header_size, + RTE_CACHE_LINE_SIZE, + socket_id); if (!txq->push_buf_intermediate_buf) { PMD_DRV_LOG(ERR, "Failed to alloc push buffer for LLQ\n"); rte_free(txq->tx_buffer_info); @@ -1282,19 +1284,20 @@ static int ena_rx_queue_setup(struct rte_eth_dev *dev, rxq->numa_socket_id = socket_id; rxq->mb_pool = mp; - rxq->rx_buffer_info = rte_zmalloc("rxq->buffer_info", + rxq->rx_buffer_info = rte_zmalloc_socket("rxq->buffer_info", sizeof(struct ena_rx_buffer) * nb_desc, - RTE_CACHE_LINE_SIZE); + RTE_CACHE_LINE_SIZE, + socket_id); if (!rxq->rx_buffer_info) { PMD_DRV_LOG(ERR, "Failed to allocate memory for Rx buffer info\n"); return -ENOMEM; } - rxq->rx_refill_buffer = rte_zmalloc("rxq->rx_refill_buffer", - sizeof(struct rte_mbuf *) * nb_desc, - RTE_CACHE_LINE_SIZE); - + rxq->rx_refill_buffer = rte_zmalloc_socket("rxq->rx_refill_buffer", + sizeof(struct rte_mbuf *) * nb_desc, + RTE_CACHE_LINE_SIZE, + socket_id); if (!rxq->rx_refill_buffer) { PMD_DRV_LOG(ERR, "Failed to allocate memory for Rx refill buffer\n"); @@ -1303,9 +1306,10 @@ static int ena_rx_queue_setup(struct rte_eth_dev *dev, return -ENOMEM; } - rxq->empty_rx_reqs = rte_zmalloc("rxq->empty_rx_reqs", - sizeof(uint16_t) * nb_desc, - RTE_CACHE_LINE_SIZE); + rxq->empty_rx_reqs = rte_zmalloc_socket("rxq->empty_rx_reqs", + sizeof(uint16_t) * nb_desc, + RTE_CACHE_LINE_SIZE, + socket_id); if (!rxq->empty_rx_reqs) { PMD_DRV_LOG(ERR, "Failed to allocate memory for empty Rx requests\n"); From patchwork Fri Oct 15 16:27:00 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michal Krawczyk X-Patchwork-Id: 101809 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 62D0BA034F; Fri, 15 Oct 2021 18:28:26 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 467F8411D8; Fri, 15 Oct 2021 18:27:55 +0200 (CEST) Received: from mail-lf1-f51.google.com (mail-lf1-f51.google.com [209.85.167.51]) by mails.dpdk.org (Postfix) with ESMTP id 2D2C5411CD for ; Fri, 15 Oct 2021 18:27:52 +0200 (CEST) Received: by mail-lf1-f51.google.com with SMTP id x27so44301969lfu.5 for ; Fri, 15 Oct 2021 09:27:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=semihalf-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=lr4nRWZlzta4nz29M3v3RISFtFDcck1yTb+edl+pwcU=; b=Lf4GOXuYhjp6JsJMnWLYuxwWKgM5leCmJ5wRRJ9Oy/0fskW4VhICSIaEe3Xbe6OimW xhmxZtv7vKV4QUqwCNLpXAsowPs7/pBCXDDlZRr5JQ1G5cZhpqLdvpm1Ceih/WiWJd6W umehnGJn8/t47LbBFNej8H++j8BUjnMVfSK4+ducqOIRxJkBezYiBrpuN0zpkcMdCChn S8VoHqmHFxZfejIMsJ0KtzmUp7PEBet13HfhYKNp0G5hvcu9V5ubX7S3g7FMaTblNjGp 5aSZGYkk0k5FuzXiC/9tv94OBrsPJ7rhUZOYH4AXOZ/1Ns8agYFo4UZEg0fw2e0jo2Rd aVMQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=lr4nRWZlzta4nz29M3v3RISFtFDcck1yTb+edl+pwcU=; b=c8kb4HVX70rvubcZ5NQDbwpq27GU9HpZQGegRmQxt+vl4FwvEheyIEez9zDLcBkKQ8 Qoz27S5aFkfhOCiZkcMIhGrN0iTFpgP1xL06HZ9QtODsbh/lUEBviway17ugZCHjT3SI cdpEqiYaI8lKur/G9+GrecaQGCJzPi8qVoBtpt3EWEoc5XPtXBFKvk1eRsTkod3fp38H s0mBOQusSk9ZXUO87ys/+tEVfx4szzIfpwhdhoON9gfyaIeFTfyXtTCwHU4eIKI8MPHs 9JOxfdoyVgTZJMjQbrnkr7DqvsPQtPecxMBcgjKb6ywypPsjOopQZi3iuDiRBe6LU+n7 Ngtg== X-Gm-Message-State: AOAM5312Fu7Dp7yAJ3w2vn2ZPocZrmova/UIilak+QyztpzjC9M8jWEm SWGPhEy7UzNFiUk+0kUeVrFMaQ== X-Google-Smtp-Source: ABdhPJxI5+T6sgE74/+ZdlsSqyCw0cj12FOgP85ayUKtUVVvoXlxTIjFGjd4VM+V+R2CSsHqeiwI+Q== X-Received: by 2002:a05:6512:3089:: with SMTP id z9mr11217364lfd.690.1634315271753; Fri, 15 Oct 2021 09:27:51 -0700 (PDT) Received: from DESKTOP-U5LNN3J.localdomain (89-79-181-52.dynamic.chello.pl. [89.79.181.52]) by smtp.gmail.com with ESMTPSA id b3sm559219lfe.58.2021.10.15.09.27.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Oct 2021 09:27:51 -0700 (PDT) From: Michal Krawczyk To: ferruh.yigit@intel.com Cc: dev@dpdk.org, upstream@semihalf.com, shaibran@amazon.com, ndagan@amazon.com, igorch@amazon.com, Michal Krawczyk Date: Fri, 15 Oct 2021 18:27:00 +0200 Message-Id: <20211015162701.16324-7-mk@semihalf.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211015162701.16324-1-mk@semihalf.com> References: <20211014201858.9571-1-mk@semihalf.com> <20211015162701.16324-1-mk@semihalf.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 6/7] net/ena: add check for missing Tx completions X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 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" In some cases Tx descriptors may be uncompleted by the HW and as a result they will never be released. This patch adds checking for the missing Tx completions to the ENA timer service, so in order to use this feature, the application must call the function rte_timer_manage(). Missing Tx completion reset threshold is determined dynamically, by taking into consideration ring size and the default value. Tx cleanup is associated with the Tx burst function. As DPDK applications can call Tx burst function dynamically, time when last cleanup was called must be traced to avoid false detection of the missing Tx completion. Signed-off-by: Michal Krawczyk Reviewed-by: Igor Chauskin Reviewed-by: Shai Brandes --- doc/guides/rel_notes/release_21_11.rst | 1 + drivers/net/ena/ena_ethdev.c | 118 +++++++++++++++++++++++++ drivers/net/ena/ena_ethdev.h | 15 ++++ 3 files changed, 134 insertions(+) diff --git a/doc/guides/rel_notes/release_21_11.rst b/doc/guides/rel_notes/release_21_11.rst index c87862e713..198f56a694 100644 --- a/doc/guides/rel_notes/release_21_11.rst +++ b/doc/guides/rel_notes/release_21_11.rst @@ -100,6 +100,7 @@ New Features * Support for the tx_free_thresh and rx_free_thresh configuration parameters. * NUMA aware allocations for the queue helper structures. + * Watchdog's feature which is checking for missing Tx completions. * **Updated Broadcom bnxt PMD.** diff --git a/drivers/net/ena/ena_ethdev.c b/drivers/net/ena/ena_ethdev.c index e31cb0b65c..5554057ed3 100644 --- a/drivers/net/ena/ena_ethdev.c +++ b/drivers/net/ena/ena_ethdev.c @@ -99,6 +99,7 @@ static const struct ena_stats ena_stats_tx_strings[] = { ENA_STAT_TX_ENTRY(doorbells), ENA_STAT_TX_ENTRY(bad_req_id), ENA_STAT_TX_ENTRY(available_desc), + ENA_STAT_TX_ENTRY(missed_tx), }; static const struct ena_stats ena_stats_rx_strings[] = { @@ -1176,6 +1177,7 @@ static int ena_tx_queue_setup(struct rte_eth_dev *dev, txq->size_mask = nb_desc - 1; txq->numa_socket_id = socket_id; txq->pkts_without_db = false; + txq->last_cleanup_ticks = 0; txq->tx_buffer_info = rte_zmalloc_socket("txq->tx_buffer_info", sizeof(struct ena_tx_buffer) * txq->ring_size, @@ -1225,6 +1227,9 @@ static int ena_tx_queue_setup(struct rte_eth_dev *dev, txq->ring_size - ENA_REFILL_THRESH_PACKET); } + txq->missing_tx_completion_threshold = + RTE_MIN(txq->ring_size / 2, ENA_DEFAULT_MISSING_COMP); + /* Store pointer to this queue in upper layer */ txq->configured = 1; dev->data->tx_queues[queue_idx] = txq; @@ -1551,6 +1556,85 @@ static void check_for_admin_com_state(struct ena_adapter *adapter) } } +static int check_for_tx_completion_in_queue(struct ena_adapter *adapter, + struct ena_ring *tx_ring) +{ + struct ena_tx_buffer *tx_buf; + uint64_t timestamp; + uint64_t completion_delay; + uint32_t missed_tx = 0; + unsigned int i; + int rc = 0; + + for (i = 0; i < tx_ring->ring_size; ++i) { + tx_buf = &tx_ring->tx_buffer_info[i]; + timestamp = tx_buf->timestamp; + + if (timestamp == 0) + continue; + + completion_delay = rte_get_timer_cycles() - timestamp; + if (completion_delay > adapter->missing_tx_completion_to) { + if (unlikely(!tx_buf->print_once)) { + PMD_TX_LOG(WARNING, + "Found a Tx that wasn't completed on time, qid %d, index %d. Missing Tx outstanding for %" PRIu64 " msecs.\n", + tx_ring->id, i, completion_delay / + rte_get_timer_hz() * 1000); + tx_buf->print_once = true; + } + ++missed_tx; + } + } + + if (unlikely(missed_tx > tx_ring->missing_tx_completion_threshold)) { + PMD_DRV_LOG(ERR, + "The number of lost Tx completions is above the threshold (%d > %d). Trigger the device reset.\n", + missed_tx, + tx_ring->missing_tx_completion_threshold); + adapter->reset_reason = ENA_REGS_RESET_MISS_TX_CMPL; + adapter->trigger_reset = true; + rc = -EIO; + } + + tx_ring->tx_stats.missed_tx += missed_tx; + + return rc; +} + +static void check_for_tx_completions(struct ena_adapter *adapter) +{ + struct ena_ring *tx_ring; + uint64_t tx_cleanup_delay; + size_t qid; + int budget; + uint16_t nb_tx_queues = adapter->edev_data->nb_tx_queues; + + if (adapter->missing_tx_completion_to == ENA_HW_HINTS_NO_TIMEOUT) + return; + + nb_tx_queues = adapter->edev_data->nb_tx_queues; + budget = adapter->missing_tx_completion_budget; + + qid = adapter->last_tx_comp_qid; + while (budget-- > 0) { + tx_ring = &adapter->tx_ring[qid]; + + /* Tx cleanup is called only by the burst function and can be + * called dynamically by the application. Also cleanup is + * limited by the threshold. To avoid false detection of the + * missing HW Tx completion, get the delay since last cleanup + * function was called. + */ + tx_cleanup_delay = rte_get_timer_cycles() - + tx_ring->last_cleanup_ticks; + if (tx_cleanup_delay < adapter->tx_cleanup_stall_delay) + check_for_tx_completion_in_queue(adapter, tx_ring); + qid = (qid + 1) % nb_tx_queues; + } + + adapter->last_tx_comp_qid = qid; +} + static void ena_timer_wd_callback(__rte_unused struct rte_timer *timer, void *arg) { @@ -1559,6 +1643,7 @@ static void ena_timer_wd_callback(__rte_unused struct rte_timer *timer, check_for_missing_keep_alive(adapter); check_for_admin_com_state(adapter); + check_for_tx_completions(adapter); if (unlikely(adapter->trigger_reset)) { PMD_DRV_LOG(ERR, "Trigger reset is on\n"); @@ -1938,6 +2023,20 @@ static int ena_dev_configure(struct rte_eth_dev *dev) */ dev->data->scattered_rx = 1; + adapter->last_tx_comp_qid = 0; + + adapter->missing_tx_completion_budget = + RTE_MIN(ENA_MONITORED_TX_QUEUES, dev->data->nb_tx_queues); + + adapter->missing_tx_completion_to = ENA_TX_TIMEOUT; + /* To avoid detection of the spurious Tx completion timeout due to + * application not calling the Tx cleanup function, set timeout for the + * Tx queue which should be half of the missing completion timeout for a + * safety. If there will be a lot of missing Tx completions in the + * queue, they will be detected sooner or later. + */ + adapter->tx_cleanup_stall_delay = adapter->missing_tx_completion_to / 2; + adapter->tx_selected_offloads = dev->data->dev_conf.txmode.offloads; adapter->rx_selected_offloads = dev->data->dev_conf.rxmode.offloads; @@ -2440,6 +2539,20 @@ static void ena_update_hints(struct ena_adapter *adapter, adapter->ena_dev.mmio_read.reg_read_to = hints->mmio_read_timeout * 1000; + if (hints->missing_tx_completion_timeout) { + if (hints->missing_tx_completion_timeout == + ENA_HW_HINTS_NO_TIMEOUT) { + adapter->missing_tx_completion_to = + ENA_HW_HINTS_NO_TIMEOUT; + } else { + /* Convert from msecs to ticks */ + adapter->missing_tx_completion_to = rte_get_timer_hz() * + hints->missing_tx_completion_timeout / 1000; + adapter->tx_cleanup_stall_delay = + adapter->missing_tx_completion_to / 2; + } + } + if (hints->driver_watchdog_timeout) { if (hints->driver_watchdog_timeout == ENA_HW_HINTS_NO_TIMEOUT) adapter->keep_alive_timeout = ENA_HW_HINTS_NO_TIMEOUT; @@ -2630,6 +2743,7 @@ static int ena_xmit_mbuf(struct ena_ring *tx_ring, struct rte_mbuf *mbuf) } tx_info->tx_descs = nb_hw_desc; + tx_info->timestamp = rte_get_timer_cycles(); tx_ring->tx_stats.cnt++; tx_ring->tx_stats.bytes += mbuf->pkt_len; @@ -2662,6 +2776,7 @@ static void ena_tx_cleanup(struct ena_ring *tx_ring) /* Get Tx info & store how many descs were processed */ tx_info = &tx_ring->tx_buffer_info[req_id]; + tx_info->timestamp = 0; mbuf = tx_info->mbuf; rte_pktmbuf_free(mbuf); @@ -2682,6 +2797,9 @@ static void ena_tx_cleanup(struct ena_ring *tx_ring) ena_com_comp_ack(tx_ring->ena_com_io_sq, total_tx_descs); ena_com_update_dev_comp_head(tx_ring->ena_com_io_cq); } + + /* Notify completion handler that the cleanup was just called */ + tx_ring->last_cleanup_ticks = rte_get_timer_cycles(); } static uint16_t eth_ena_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, diff --git a/drivers/net/ena/ena_ethdev.h b/drivers/net/ena/ena_ethdev.h index 176d713dff..4f4142ed12 100644 --- a/drivers/net/ena/ena_ethdev.h +++ b/drivers/net/ena/ena_ethdev.h @@ -36,6 +36,10 @@ #define ENA_WD_TIMEOUT_SEC 3 #define ENA_DEVICE_KALIVE_TIMEOUT (ENA_WD_TIMEOUT_SEC * rte_get_timer_hz()) +#define ENA_TX_TIMEOUT (5 * rte_get_timer_hz()) +#define ENA_MONITORED_TX_QUEUES 3 +#define ENA_DEFAULT_MISSING_COMP 256U + /* While processing submitted and completed descriptors (rx and tx path * respectively) in a loop it is desired to: * - perform batch submissions while populating sumbissmion queue @@ -75,6 +79,8 @@ struct ena_tx_buffer { struct rte_mbuf *mbuf; unsigned int tx_descs; unsigned int num_of_bufs; + uint64_t timestamp; + bool print_once; struct ena_com_buf bufs[ENA_PKT_MAX_BUFS]; }; @@ -103,6 +109,7 @@ struct ena_stats_tx { u64 doorbells; u64 bad_req_id; u64 available_desc; + u64 missed_tx; }; struct ena_stats_rx { @@ -118,6 +125,7 @@ struct ena_stats_rx { struct ena_ring { u16 next_to_use; u16 next_to_clean; + uint64_t last_cleanup_ticks; enum ena_ring_type type; enum ena_admin_placement_policy_type tx_mem_queue_type; @@ -171,6 +179,8 @@ struct ena_ring { }; unsigned int numa_socket_id; + + uint32_t missing_tx_completion_threshold; } __rte_cache_aligned; enum ena_adapter_state { @@ -291,6 +301,11 @@ struct ena_adapter { bool wd_state; bool use_large_llq_hdr; + + uint32_t last_tx_comp_qid; + uint64_t missing_tx_completion_to; + uint64_t missing_tx_completion_budget; + uint64_t tx_cleanup_stall_delay; }; int ena_rss_reta_update(struct rte_eth_dev *dev, From patchwork Fri Oct 15 16:27:01 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michal Krawczyk X-Patchwork-Id: 101810 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 20973A034F; Fri, 15 Oct 2021 18:28:34 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id A39FA41205; Fri, 15 Oct 2021 18:27:56 +0200 (CEST) Received: from mail-lf1-f42.google.com (mail-lf1-f42.google.com [209.85.167.42]) by mails.dpdk.org (Postfix) with ESMTP id 4EBFC411CE for ; Fri, 15 Oct 2021 18:27:53 +0200 (CEST) Received: by mail-lf1-f42.google.com with SMTP id x27so43650401lfa.9 for ; Fri, 15 Oct 2021 09:27:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=semihalf-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=mZWrq45JDIdRE40q500yPtdN76zzmASQgkW/wzjJ3kY=; b=VRHN14qKl6U7TkLxQeyqG1mXUrNyvlMVg2V63EDhgCFLAopElzMNtnGNrlAneCXP4J YdkCFck3WyG1tAmzXz2UegzJ/LnWpFo39zqqAbayY3BotvUqOIVj7ahOB3BME1Rh6zKU AKXZiw3mEviFDStEPzEaETRk/nOEiKF0In5FRkLljht3mr92p5fG2tSfLbukYzAa8DnZ ey8BPBS+iVAgpK1jzs2zBJ55EseGF8w9VlBba3gAdFoAG8/BO4vlA9VBjeSm3/ccwnbv UvTLr9GVUZSvnuMxblbivDj5TOAYO5Du4RR6MFEh7lmcq6My06+WBmM2QhBspVHyOArU x4WA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=mZWrq45JDIdRE40q500yPtdN76zzmASQgkW/wzjJ3kY=; b=Rr3+t5gdO1q5jjHuamlFkhoxSNT5p0UQnKfM+rvQSQMdTaSMmMEA9goQVZbtO9XQeF xP8ZUh4hKxSD/cza+TSQ+RYLtqWEzW8IbDDPTQ8J+hj/IyIWJLgpRsQ2VbfsjdMw6aWA u7rPErSms5qNYu+eAGqjt/7bw4LgsOHfhGUtA6kZQBoLT0bwHUWJIvZteACof7c8Xx6E KVrhe07DWovb6vA3hoZ7PNJ+sy0q7zzbf7bI/Yop4c3oMsPbat04Q+yFoHt7op96+UtK MxvfRVAUn+LCewZWwqOax12o+hu1l9t4Qs+h+CsXj9SyCA6h5Sa/O7k9oWjaEaJ4YYZB tAFg== X-Gm-Message-State: AOAM531OszlxEsGNNuN0lB/mE9h8gzZDyvsugic3HFxbgO6oOFWzRUiJ 5MqCuxj4oLieUkGjjMa6vjoBNQ== X-Google-Smtp-Source: ABdhPJyB9g9liLC6W5AdEPdA6f4NZtTJD1jsNU/4j7wZC2WdE3bMjTbfhdcXX08TNLz+mczReojzjg== X-Received: by 2002:a05:6512:1112:: with SMTP id l18mr11608872lfg.649.1634315272958; Fri, 15 Oct 2021 09:27:52 -0700 (PDT) Received: from DESKTOP-U5LNN3J.localdomain (89-79-181-52.dynamic.chello.pl. [89.79.181.52]) by smtp.gmail.com with ESMTPSA id b3sm559219lfe.58.2021.10.15.09.27.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Oct 2021 09:27:52 -0700 (PDT) From: Michal Krawczyk To: ferruh.yigit@intel.com Cc: dev@dpdk.org, upstream@semihalf.com, shaibran@amazon.com, ndagan@amazon.com, igorch@amazon.com, Michal Krawczyk Date: Fri, 15 Oct 2021 18:27:01 +0200 Message-Id: <20211015162701.16324-8-mk@semihalf.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20211015162701.16324-1-mk@semihalf.com> References: <20211014201858.9571-1-mk@semihalf.com> <20211015162701.16324-1-mk@semihalf.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH v2 7/7] net/ena: update version to 2.5.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 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" This version update contains: * Fix for verification of the offload capabilities (especially for IPv6 packets). * Support for Tx and Rx free threshold values. * Fixes for per-queue offload capabilities. * Announce support of the scattered Rx offload. * NUMA aware allocations. * Check for the missing Tx completions. Signed-off-by: Michal Krawczyk --- drivers/net/ena/ena_ethdev.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/net/ena/ena_ethdev.c b/drivers/net/ena/ena_ethdev.c index 5554057ed3..cad9d46198 100644 --- a/drivers/net/ena/ena_ethdev.c +++ b/drivers/net/ena/ena_ethdev.c @@ -21,7 +21,7 @@ #include #define DRV_MODULE_VER_MAJOR 2 -#define DRV_MODULE_VER_MINOR 4 +#define DRV_MODULE_VER_MINOR 5 #define DRV_MODULE_VER_SUBMINOR 0 #define __MERGE_64B_H_L(h, l) (((uint64_t)h << 32) | l)