d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

mlx5: use one RSS hash key per flow type

Browse Source 
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>
This commit is contained in:
Nelio Laranjeiro 2015-10-30 19:55:12 +01:00 committed by Thomas Monjalon
parent 2f97422e77
commit 0573873d5b
5 changed files with 104 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
drivers/net/mlx5/mlx5.c
View File

@ -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. */

6
drivers/net/mlx5/mlx5.h
View File

@ -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 *);

83
drivers/net/mlx5/mlx5_rss.c
View File

@ -60,6 +60,33 @@
#include "mlx5.h"
#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.
*
@ -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;
unsigned int i;
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;
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;

24
drivers/net/mlx5/mlx5_rxq.c
View File

@ -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],
};

4
drivers/net/mlx5/mlx5_rxtx.h
View File

@ -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;