From patchwork Fri Oct 30 18:55:12 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adrien Mazarguil X-Patchwork-Id: 8473 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id 9A5E193A0; Fri, 30 Oct 2015 19:56:19 +0100 (CET) Received: from mail-wi0-f179.google.com (mail-wi0-f179.google.com [209.85.212.179]) by dpdk.org (Postfix) with ESMTP id 163139370 for ; Fri, 30 Oct 2015 19:56:09 +0100 (CET) Received: by wicfx6 with SMTP id fx6so16472928wic.1 for ; Fri, 30 Oct 2015 11:56:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=6wind_com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=mgy5x6iKH0JBDf+1GxVvJqK2d/XizzSghF3fyNo88Tg=; b=HhZCF3f4cfvcigAyPhip8G87hyzDdzXc+OJOlhNdRoQgrYmD0c7YYhAFh3fHiKOVTI O9SynMxT9Mfp3cOeU+bIuq/wzsS+pp+rA/INPze0tKzPnBAokK+KeG2+AhqU2UMUQGFm dB+esvmkwfW3RwYdxfOv7EHj5Grfv0ua2Cgfd5+MZnaL3vnLLiaTF38Ec7EfZOVsvnl3 qQoYe2GUZprHkSm5Y6FTeUaDJZ/GuDb97JSgD/PDEnCwHUX4+TF4cH1SGwPiao1GkiND fxAzmro5Ec8L+jESmtZNaKhQafWC9R4tha/cl+MPD4V7UsOn6qDOkUW+mmxedWfy7m6L VHCw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=mgy5x6iKH0JBDf+1GxVvJqK2d/XizzSghF3fyNo88Tg=; b=FwbGr0OVC4ULno9Mf7mBio8Z3TIEv07BmVbZR9JvBrx/Y9DjaVRcIXgs6IMsDC2hzj 8nvdF0DyzWOQRd8X6hUSy47jlsuo4DDK8PLAlwWjx1+wCydJPrZZX7VqvetAd//mfvvz 3Lb/JdajnSm47wUEDlHP+owgFFSfdS8j9rvTbGnv7eD4z5/eVuHySfrCZLkZhrmgTSdW bEWz51mRNvRp0U6JW+uHEVVoeD8mGnZ65pNVZ8kZPPktpwrjTgh/vFK4dog87B5gbxZh 3jeXg7cpwGMP+2qJ88am1VBoaliDbs4nkBWbG7dpWL0t5lXg8i1Ejes7rvjG0mfcOVGj cdsQ== X-Gm-Message-State: ALoCoQm6o1bHssH8LgudTKxodG/hypTfNnHTdFWLVbv9QSYIYTogN8QG2jVcEplP/BjZWzY1vcpW X-Received: by 10.194.189.133 with SMTP id gi5mr10360228wjc.13.1446231368916; Fri, 30 Oct 2015 11:56:08 -0700 (PDT) Received: from 6wind.com (guy78-3-82-239-227-177.fbx.proxad.net. [82.239.227.177]) by smtp.gmail.com with ESMTPSA id l81sm4251347wmb.2.2015.10.30.11.56.07 (version=TLSv1.2 cipher=RC4-SHA bits=128/128); Fri, 30 Oct 2015 11:56:08 -0700 (PDT) From: Adrien Mazarguil To: dev@dpdk.org Date: Fri, 30 Oct 2015 19:55:12 +0100 Message-Id: <1446231319-8185-10-git-send-email-adrien.mazarguil@6wind.com> X-Mailer: git-send-email 2.1.0 In-Reply-To: <1446231319-8185-1-git-send-email-adrien.mazarguil@6wind.com> References: <1444067692-29645-1-git-send-email-adrien.mazarguil@6wind.com> <1446231319-8185-1-git-send-email-adrien.mazarguil@6wind.com> Subject: [dpdk-dev] [PATCH v2 09/16] mlx5: use one RSS hash key per flow type X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Nelio Laranjeiro DPDK expects to have an RSS hash key per flow type (IPv4, IPv6, UDPv4, etc.), to handle this the PMD must keep a table of hash keys to be able to reconfigure the queues at each start/stop call. Signed-off-by: Nelio Laranjeiro Signed-off-by: Adrien Mazarguil --- drivers/net/mlx5/mlx5.c | 17 +++++++-- drivers/net/mlx5/mlx5.h | 6 ++-- drivers/net/mlx5/mlx5_rss.c | 85 +++++++++++++++++++++++++++++++++----------- drivers/net/mlx5/mlx5_rxq.c | 24 +++++++++---- drivers/net/mlx5/mlx5_rxtx.h | 4 +++ 5 files changed, 105 insertions(+), 31 deletions(-) diff --git a/drivers/net/mlx5/mlx5.c b/drivers/net/mlx5/mlx5.c index 5a3d198..97ce902 100644 --- a/drivers/net/mlx5/mlx5.c +++ b/drivers/net/mlx5/mlx5.c @@ -127,7 +127,11 @@ mlx5_dev_close(struct rte_eth_dev *dev) claim_zero(ibv_close_device(priv->ctx)); } else assert(priv->ctx == NULL); - rte_free(priv->rss_conf); + if (priv->rss_conf != NULL) { + for (i = 0; (i != hash_rxq_init_n); ++i) + rte_free((*priv->rss_conf)[i]); + rte_free(priv->rss_conf); + } priv_unlock(priv); memset(priv, 0, sizeof(*priv)); } @@ -377,10 +381,17 @@ mlx5_pci_devinit(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev) #endif /* HAVE_EXP_QUERY_DEVICE */ priv->vf = vf; - /* Register default RSS hash key. */ + /* Allocate and register default RSS hash keys. */ + priv->rss_conf = rte_calloc(__func__, hash_rxq_init_n, + sizeof((*priv->rss_conf)[0]), 0); + if (priv->rss_conf == NULL) { + err = ENOMEM; + goto port_error; + } err = rss_hash_rss_conf_new_key(priv, rss_hash_default_key, - rss_hash_default_key_len); + rss_hash_default_key_len, + ETH_RSS_PROTO_MASK); if (err) goto port_error; /* Configure the first MAC address by default. */ diff --git a/drivers/net/mlx5/mlx5.h b/drivers/net/mlx5/mlx5.h index 70bacf5..03e33d6 100644 --- a/drivers/net/mlx5/mlx5.h +++ b/drivers/net/mlx5/mlx5.h @@ -113,7 +113,8 @@ struct priv { /* Hash RX QPs feeding the indirection table. */ struct hash_rxq (*hash_rxqs)[]; unsigned int hash_rxqs_n; /* Hash RX QPs array size. */ - struct rte_eth_rss_conf *rss_conf; /* RSS configuration. */ + /* RSS configuration array indexed by hash RX queue type. */ + struct rte_eth_rss_conf *(*rss_conf)[]; rte_spinlock_t lock; /* Lock for control functions. */ }; @@ -172,7 +173,8 @@ void mlx5_mac_addr_add(struct rte_eth_dev *, struct ether_addr *, uint32_t, /* mlx5_rss.c */ -int rss_hash_rss_conf_new_key(struct priv *, const uint8_t *, unsigned int); +int rss_hash_rss_conf_new_key(struct priv *, const uint8_t *, unsigned int, + uint64_t); int mlx5_rss_hash_update(struct rte_eth_dev *, struct rte_eth_rss_conf *); int mlx5_rss_hash_conf_get(struct rte_eth_dev *, struct rte_eth_rss_conf *); diff --git a/drivers/net/mlx5/mlx5_rss.c b/drivers/net/mlx5/mlx5_rss.c index 2dc58e5..bf19aca 100644 --- a/drivers/net/mlx5/mlx5_rss.c +++ b/drivers/net/mlx5/mlx5_rss.c @@ -61,6 +61,33 @@ #include "mlx5_rxtx.h" /** + * Get a RSS configuration hash key. + * + * @param priv + * Pointer to private structure. + * @param rss_hf + * RSS hash functions configuration must be retrieved for. + * + * @return + * Pointer to a RSS configuration structure or NULL if rss_hf cannot + * be matched. + */ +static struct rte_eth_rss_conf * +rss_hash_get(struct priv *priv, uint64_t rss_hf) +{ + unsigned int i; + + for (i = 0; (i != hash_rxq_init_n); ++i) { + uint64_t dpdk_rss_hf = hash_rxq_init[i].dpdk_rss_hf; + + if (!(dpdk_rss_hf & rss_hf)) + continue; + return (*priv->rss_conf)[i]; + } + return NULL; +} + +/** * Register a RSS key. * * @param priv @@ -69,25 +96,35 @@ * Hash key to register. * @param key_len * Hash key length in bytes. + * @param rss_hf + * RSS hash functions the provided key applies to. * * @return * 0 on success, errno value on failure. */ int rss_hash_rss_conf_new_key(struct priv *priv, const uint8_t *key, - unsigned int key_len) + unsigned int key_len, uint64_t rss_hf) { - struct rte_eth_rss_conf *rss_conf; - - rss_conf = rte_realloc(priv->rss_conf, - (sizeof(*rss_conf) + key_len), - 0); - if (!rss_conf) - return ENOMEM; - rss_conf->rss_key = (void *)(rss_conf + 1); - rss_conf->rss_key_len = key_len; - memcpy(rss_conf->rss_key, key, key_len); - priv->rss_conf = rss_conf; + unsigned int i; + + for (i = 0; (i != hash_rxq_init_n); ++i) { + struct rte_eth_rss_conf *rss_conf; + uint64_t dpdk_rss_hf = hash_rxq_init[i].dpdk_rss_hf; + + if (!(dpdk_rss_hf & rss_hf)) + continue; + rss_conf = rte_realloc((*priv->rss_conf)[i], + (sizeof(*rss_conf) + key_len), + 0); + if (!rss_conf) + return ENOMEM; + rss_conf->rss_key = (void *)(rss_conf + 1); + rss_conf->rss_key_len = key_len; + rss_conf->rss_hf = dpdk_rss_hf; + memcpy(rss_conf->rss_key, key, key_len); + (*priv->rss_conf)[i] = rss_conf; + } return 0; } @@ -117,11 +154,13 @@ mlx5_rss_hash_update(struct rte_eth_dev *dev, if (rss_conf->rss_key) err = rss_hash_rss_conf_new_key(priv, rss_conf->rss_key, - rss_conf->rss_key_len); + rss_conf->rss_key_len, + rss_conf->rss_hf); else err = rss_hash_rss_conf_new_key(priv, rss_hash_default_key, - rss_hash_default_key_len); + rss_hash_default_key_len, + ETH_RSS_PROTO_MASK); /* Store the configuration set into port configure. * This will enable/disable hash RX queues associated to the protocols @@ -149,19 +188,25 @@ mlx5_rss_hash_conf_get(struct rte_eth_dev *dev, struct rte_eth_rss_conf *rss_conf) { struct priv *priv = dev->data->dev_private; + struct rte_eth_rss_conf *priv_rss_conf; priv_lock(priv); assert(priv->rss_conf != NULL); + priv_rss_conf = rss_hash_get(priv, rss_conf->rss_hf); + if (!priv_rss_conf) { + rss_conf->rss_hf = 0; + priv_unlock(priv); + return -EINVAL; + } if (rss_conf->rss_key && - rss_conf->rss_key_len >= priv->rss_conf->rss_key_len) + rss_conf->rss_key_len >= priv_rss_conf->rss_key_len) memcpy(rss_conf->rss_key, - priv->rss_conf->rss_key, - priv->rss_conf->rss_key_len); - rss_conf->rss_key_len = priv->rss_conf->rss_key_len; - /* FIXME: rss_hf should be more specific. */ - rss_conf->rss_hf = ETH_RSS_PROTO_MASK; + priv_rss_conf->rss_key, + priv_rss_conf->rss_key_len); + rss_conf->rss_key_len = priv_rss_conf->rss_key_len; + rss_conf->rss_hf = priv_rss_conf->rss_hf; priv_unlock(priv); return 0; diff --git a/drivers/net/mlx5/mlx5_rxq.c b/drivers/net/mlx5/mlx5_rxq.c index 79c2346..d46fc13 100644 --- a/drivers/net/mlx5/mlx5_rxq.c +++ b/drivers/net/mlx5/mlx5_rxq.c @@ -65,12 +65,13 @@ #include "mlx5_defs.h" /* Initialization data for hash RX queues. */ -static const struct hash_rxq_init hash_rxq_init[] = { +const struct hash_rxq_init hash_rxq_init[] = { [HASH_RXQ_TCPV4] = { .hash_fields = (IBV_EXP_RX_HASH_SRC_IPV4 | IBV_EXP_RX_HASH_DST_IPV4 | IBV_EXP_RX_HASH_SRC_PORT_TCP | IBV_EXP_RX_HASH_DST_PORT_TCP), + .dpdk_rss_hf = ETH_RSS_NONFRAG_IPV4_TCP, .flow_priority = 0, .flow_spec.tcp_udp = { .type = IBV_FLOW_SPEC_TCP, @@ -83,6 +84,7 @@ static const struct hash_rxq_init hash_rxq_init[] = { IBV_EXP_RX_HASH_DST_IPV4 | IBV_EXP_RX_HASH_SRC_PORT_UDP | IBV_EXP_RX_HASH_DST_PORT_UDP), + .dpdk_rss_hf = ETH_RSS_NONFRAG_IPV4_UDP, .flow_priority = 0, .flow_spec.tcp_udp = { .type = IBV_FLOW_SPEC_UDP, @@ -93,6 +95,8 @@ static const struct hash_rxq_init hash_rxq_init[] = { [HASH_RXQ_IPV4] = { .hash_fields = (IBV_EXP_RX_HASH_SRC_IPV4 | IBV_EXP_RX_HASH_DST_IPV4), + .dpdk_rss_hf = (ETH_RSS_IPV4 | + ETH_RSS_FRAG_IPV4), .flow_priority = 1, .flow_spec.ipv4 = { .type = IBV_FLOW_SPEC_IPV4, @@ -102,6 +106,7 @@ static const struct hash_rxq_init hash_rxq_init[] = { }, [HASH_RXQ_ETH] = { .hash_fields = 0, + .dpdk_rss_hf = 0, .flow_priority = 2, .flow_spec.eth = { .type = IBV_FLOW_SPEC_ETH, @@ -112,7 +117,7 @@ static const struct hash_rxq_init hash_rxq_init[] = { }; /* Number of entries in hash_rxq_init[]. */ -static const unsigned int hash_rxq_init_n = RTE_DIM(hash_rxq_init); +const unsigned int hash_rxq_init_n = RTE_DIM(hash_rxq_init); /* Initialization data for hash RX queue indirection tables. */ static const struct ind_table_init ind_table_init[] = { @@ -259,16 +264,18 @@ static unsigned int priv_make_ind_table_init(struct priv *priv, struct ind_table_init (*table)[IND_TABLE_INIT_N]) { + uint64_t rss_hf; unsigned int i; unsigned int j; unsigned int table_n = 0; /* Mandatory to receive frames not handled by normal hash RX queues. */ unsigned int hash_types_sup = 1 << HASH_RXQ_ETH; + rss_hf = priv->dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf; /* Process other protocols only if more than one queue. */ if (priv->rxqs_n > 1) for (i = 0; (i != hash_rxq_init_n); ++i) - if (hash_rxq_init[i].hash_fields) + if (rss_hf & hash_rxq_init[i].dpdk_rss_hf) hash_types_sup |= (1 << i); /* Filter out entries whose protocols are not in the set. */ @@ -329,7 +336,6 @@ priv_create_hash_rxqs(struct priv *priv) assert(priv->hash_rxqs_n == 0); assert(priv->pd != NULL); assert(priv->ctx != NULL); - assert(priv->rss_conf != NULL); if (priv->rxqs_n == 0) return EINVAL; assert(priv->rxqs != NULL); @@ -412,10 +418,16 @@ priv_create_hash_rxqs(struct priv *priv) struct hash_rxq *hash_rxq = &(*hash_rxqs)[i]; enum hash_rxq_type type = hash_rxq_type_from_n(&ind_table_init[j], k); + struct rte_eth_rss_conf *priv_rss_conf = + (*priv->rss_conf)[type]; struct ibv_exp_rx_hash_conf hash_conf = { .rx_hash_function = IBV_EXP_RX_HASH_FUNC_TOEPLITZ, - .rx_hash_key_len = priv->rss_conf->rss_key_len, - .rx_hash_key = priv->rss_conf->rss_key, + .rx_hash_key_len = (priv_rss_conf ? + priv_rss_conf->rss_key_len : + rss_hash_default_key_len), + .rx_hash_key = (priv_rss_conf ? + priv_rss_conf->rss_key : + rss_hash_default_key), .rx_hash_fields_mask = hash_rxq_init[type].hash_fields, .rwq_ind_tbl = (*ind_tables)[j], }; diff --git a/drivers/net/mlx5/mlx5_rxtx.h b/drivers/net/mlx5/mlx5_rxtx.h index a1bf11f..651eb95 100644 --- a/drivers/net/mlx5/mlx5_rxtx.h +++ b/drivers/net/mlx5/mlx5_rxtx.h @@ -145,6 +145,7 @@ struct flow_attr_spec_eth { /* Initialization data for hash RX queue. */ struct hash_rxq_init { uint64_t hash_fields; /* Fields that participate in the hash. */ + uint64_t dpdk_rss_hf; /* Matching DPDK RSS hash fields. */ unsigned int flow_priority; /* Flow priority to use. */ struct ibv_flow_spec flow_spec; /* Flow specification template. */ const struct hash_rxq_init *underlayer; /* Pointer to underlayer. */ @@ -212,6 +213,9 @@ struct txq { /* mlx5_rxq.c */ +extern const struct hash_rxq_init hash_rxq_init[]; +extern const unsigned int hash_rxq_init_n; + extern uint8_t rss_hash_default_key[]; extern const size_t rss_hash_default_key_len;