From patchwork Mon Oct 5 17:54:45 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adrien Mazarguil X-Patchwork-Id: 7450 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 185F393EA; Mon, 5 Oct 2015 19:55:37 +0200 (CEST) Received: from mail-wi0-f179.google.com (mail-wi0-f179.google.com [209.85.212.179]) by dpdk.org (Postfix) with ESMTP id 695689251 for ; Mon, 5 Oct 2015 19:55:35 +0200 (CEST) Received: by wiclk2 with SMTP id lk2so132479525wic.0 for ; Mon, 05 Oct 2015 10:55:35 -0700 (PDT) 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=DiBO12hOzDekyFvRpUZWREUUTAgcZyMrejrMdlFFMK0=; b=fTkaRsawcWKhnR+XnN/2F9OscdGmvFRWeZ20U454uoQ7vcqjfNcnKN84iLyqtmNojN +KMp1/qhUO99+iQnLopsadHx5pacru+/2pP69APkBsiwJpkc8X32yyyDCVyXp3vgWEIK VruU8CUGxryOuyUj5zKiRUic5Wf8zZM+DD0SadO7h0gLd4mnBvyWOzsQLDqx4VYQW12a G41vzrtLioq6qxVl3qJdE5yOIGXzuAArO3mESQWsnuBPB+7+5NrD2OzRMTwe0Ddxl+w3 9pduglpu1k5zDTTR7rs5VFspmew0FucalMW9dUjJ8GqG4Cx2akRk8l4rn11um7rZB4Qw Py8g== X-Gm-Message-State: ALoCoQmL7HUA+IEeWsZwJrdDACpNFp72Fmu+KKyVlFaLXQHmBlWs/PNOtXciqK1U4L7Pkar1pyaf X-Received: by 10.180.102.226 with SMTP id fr2mr14078476wib.3.1444067735264; Mon, 05 Oct 2015 10:55:35 -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 jd7sm6261804wjb.19.2015.10.05.10.55.34 (version=TLSv1.2 cipher=RC4-SHA bits=128/128); Mon, 05 Oct 2015 10:55:34 -0700 (PDT) From: Adrien Mazarguil To: dev@dpdk.org Date: Mon, 5 Oct 2015 19:54:45 +0200 Message-Id: <1444067692-29645-11-git-send-email-adrien.mazarguil@6wind.com> X-Mailer: git-send-email 2.1.0 In-Reply-To: <1444067692-29645-1-git-send-email-adrien.mazarguil@6wind.com> References: <1444067692-29645-1-git-send-email-adrien.mazarguil@6wind.com> Subject: [dpdk-dev] [PATCH 10/17] 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 bc2a19b..fb9d594 100644 --- a/drivers/net/mlx5/mlx5.c +++ b/drivers/net/mlx5/mlx5.c @@ -129,7 +129,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)); } @@ -379,10 +383,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 fc042e8..de72f94 100644 --- a/drivers/net/mlx5/mlx5.h +++ b/drivers/net/mlx5/mlx5.h @@ -118,7 +118,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. */ }; @@ -177,7 +178,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 2bd1277..283e56b 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[] = { @@ -260,16 +265,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. */ @@ -330,7 +337,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); @@ -413,10 +419,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 94e5f04..0db4393 100644 --- a/drivers/net/mlx5/mlx5_rxtx.h +++ b/drivers/net/mlx5/mlx5_rxtx.h @@ -148,6 +148,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. */ @@ -216,6 +217,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;