[dpdk-dev] [PATCH 10/17] mlx5: use one RSS hash key per flow type

[Adrien Mazarguil <adrien.mazarguil@6wind.com>]

From: Nelio Laranjeiro <nelio.laranjeiro@6wind.com>

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 <nelio.laranjeiro@6wind.com>
Signed-off-by: Adrien Mazarguil <adrien.mazarguil@6wind.com>
---
 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;
 
-- 
2.1.0