drivers/net/mlx5/mlx5_rss.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2015 6WIND S.A.
   3  * Copyright 2015 Mellanox Technologies, Ltd
   4  */
   5
   6 #include <stddef.h>
   7 #include <stdint.h>
   8 #include <errno.h>
   9 #include <string.h>
  10
  11 #include <rte_malloc.h>
  12 #include <ethdev_driver.h>
  13
  14 #include <mlx5_malloc.h>
  15
  16 #include "mlx5_defs.h"
  17 #include "mlx5.h"
  18 #include "mlx5_rxtx.h"
  19 #include "mlx5_rx.h"
  20
  21 /**
  22  * DPDK callback to update the RSS hash configuration.
  23  *
  24  * @param dev
  25  *   Pointer to Ethernet device structure.
  26  * @param[in] rss_conf
  27  *   RSS configuration data.
  28  *
  29  * @return
  30  *   0 on success, a negative errno value otherwise and rte_errno is set.
  31  */
  32 int
  33 mlx5_rss_hash_update(struct rte_eth_dev *dev,
  34                      struct rte_eth_rss_conf *rss_conf)
  35 {
  36         struct mlx5_priv *priv = dev->data->dev_private;
  37         unsigned int i;
  38         unsigned int idx;
  39
  40         if (rss_conf->rss_hf & MLX5_RSS_HF_MASK) {
  41                 rte_errno = EINVAL;
  42                 return -rte_errno;
  43         }
  44         if (rss_conf->rss_key && rss_conf->rss_key_len) {
  45                 if (rss_conf->rss_key_len != MLX5_RSS_HASH_KEY_LEN) {
  46                         DRV_LOG(ERR,
  47                                 "port %u RSS key len must be %s Bytes long",
  48                                 dev->data->port_id,
  49                                 RTE_STR(MLX5_RSS_HASH_KEY_LEN));
  50                         rte_errno = EINVAL;
  51                         return -rte_errno;
  52                 }
  53                 priv->rss_conf.rss_key = mlx5_realloc(priv->rss_conf.rss_key,
  54                                                       MLX5_MEM_RTE,
  55                                                       rss_conf->rss_key_len,
  56                                                       0, SOCKET_ID_ANY);
  57                 if (!priv->rss_conf.rss_key) {
  58                         rte_errno = ENOMEM;
  59                         return -rte_errno;
  60                 }
  61                 memcpy(priv->rss_conf.rss_key, rss_conf->rss_key,
  62                        rss_conf->rss_key_len);
  63                 priv->rss_conf.rss_key_len = rss_conf->rss_key_len;
  64         }
  65         priv->rss_conf.rss_hf = rss_conf->rss_hf;
  66         /* Enable the RSS hash in all Rx queues. */
  67         for (i = 0, idx = 0; idx != priv->rxqs_n; ++i) {
  68                 struct mlx5_rxq_priv *rxq = mlx5_rxq_get(dev, i);
  69
  70                 if (rxq == NULL || rxq->ctrl == NULL)
  71                         continue;
  72                 rxq->ctrl->rxq.rss_hash = !!rss_conf->rss_hf &&
  73                         !!(dev->data->dev_conf.rxmode.mq_mode & RTE_ETH_MQ_RX_RSS);
  74                 ++idx;
  75         }
  76         return 0;
  77 }
  78
  79 /**
  80  * DPDK callback to get the RSS hash configuration.
  81  *
  82  * @param dev
  83  *   Pointer to Ethernet device structure.
  84  * @param[in, out] rss_conf
  85  *   RSS configuration data.
  86  *
  87  * @return
  88  *   0 on success, a negative errno value otherwise and rte_errno is set.
  89  */
  90 int
  91 mlx5_rss_hash_conf_get(struct rte_eth_dev *dev,
  92                        struct rte_eth_rss_conf *rss_conf)
  93 {
  94         struct mlx5_priv *priv = dev->data->dev_private;
  95
  96         if (!rss_conf) {
  97                 rte_errno = EINVAL;
  98                 return -rte_errno;
  99         }
 100         if (rss_conf->rss_key &&
 101             (rss_conf->rss_key_len >= priv->rss_conf.rss_key_len)) {
 102                 memcpy(rss_conf->rss_key, priv->rss_conf.rss_key,
 103                        priv->rss_conf.rss_key_len);
 104         }
 105         rss_conf->rss_key_len = priv->rss_conf.rss_key_len;
 106         rss_conf->rss_hf = priv->rss_conf.rss_hf;
 107         return 0;
 108 }
 109
 110 /**
 111  * Allocate/reallocate RETA index table.
 112  *
 113  * @param dev
 114  *   Pointer to Ethernet device.
 115  * @praram reta_size
 116  *   The size of the array to allocate.
 117  *
 118  * @return
 119  *   0 on success, a negative errno value otherwise and rte_errno is set.
 120  */
 121 int
 122 mlx5_rss_reta_index_resize(struct rte_eth_dev *dev, unsigned int reta_size)
 123 {
 124         struct mlx5_priv *priv = dev->data->dev_private;
 125         void *mem;
 126         unsigned int old_size = priv->reta_idx_n;
 127
 128         if (priv->reta_idx_n == reta_size)
 129                 return 0;
 130
 131         mem = mlx5_realloc(priv->reta_idx, MLX5_MEM_RTE,
 132                            reta_size * sizeof((*priv->reta_idx)[0]), 0,
 133                            SOCKET_ID_ANY);
 134         if (!mem) {
 135                 rte_errno = ENOMEM;
 136                 return -rte_errno;
 137         }
 138         priv->reta_idx = mem;
 139         priv->reta_idx_n = reta_size;
 140         if (old_size < reta_size)
 141                 memset(&(*priv->reta_idx)[old_size], 0,
 142                        (reta_size - old_size) *
 143                        sizeof((*priv->reta_idx)[0]));
 144         return 0;
 145 }
 146
 147 /**
 148  * DPDK callback to get the RETA indirection table.
 149  *
 150  * @param dev
 151  *   Pointer to Ethernet device structure.
 152  * @param reta_conf
 153  *   Pointer to RETA configuration structure array.
 154  * @param reta_size
 155  *   Size of the RETA table.
 156  *
 157  * @return
 158  *   0 on success, a negative errno value otherwise and rte_errno is set.
 159  */
 160 int
 161 mlx5_dev_rss_reta_query(struct rte_eth_dev *dev,
 162                         struct rte_eth_rss_reta_entry64 *reta_conf,
 163                         uint16_t reta_size)
 164 {
 165         struct mlx5_priv *priv = dev->data->dev_private;
 166         unsigned int idx;
 167         unsigned int i;
 168
 169         if (!reta_size || reta_size > priv->reta_idx_n) {
 170                 rte_errno = EINVAL;
 171                 return -rte_errno;
 172         }
 173         /* Fill each entry of the table even if its bit is not set. */
 174         for (idx = 0, i = 0; (i != reta_size); ++i) {
 175                 idx = i / RTE_ETH_RETA_GROUP_SIZE;
 176                 reta_conf[idx].reta[i % RTE_ETH_RETA_GROUP_SIZE] =
 177                         (*priv->reta_idx)[i];
 178         }
 179         return 0;
 180 }
 181
 182 /**
 183  * DPDK callback to update the RETA indirection table.
 184  *
 185  * @param dev
 186  *   Pointer to Ethernet device structure.
 187  * @param reta_conf
 188  *   Pointer to RETA configuration structure array.
 189  * @param reta_size
 190  *   Size of the RETA table.
 191  *
 192  * @return
 193  *   0 on success, a negative errno value otherwise and rte_errno is set.
 194  */
 195 int
 196 mlx5_dev_rss_reta_update(struct rte_eth_dev *dev,
 197                          struct rte_eth_rss_reta_entry64 *reta_conf,
 198                          uint16_t reta_size)
 199 {
 200         int ret;
 201         struct mlx5_priv *priv = dev->data->dev_private;
 202         unsigned int idx;
 203         unsigned int i;
 204         unsigned int pos;
 205
 206         if (!reta_size) {
 207                 rte_errno = EINVAL;
 208                 return -rte_errno;
 209         }
 210         ret = mlx5_rss_reta_index_resize(dev, reta_size);
 211         if (ret)
 212                 return ret;
 213         for (idx = 0, i = 0; (i != reta_size); ++i) {
 214                 idx = i / RTE_ETH_RETA_GROUP_SIZE;
 215                 pos = i % RTE_ETH_RETA_GROUP_SIZE;
 216                 if (((reta_conf[idx].mask >> pos) & 0x1) == 0)
 217                         continue;
 218                 MLX5_ASSERT(reta_conf[idx].reta[pos] < priv->rxqs_n);
 219                 (*priv->reta_idx)[i] = reta_conf[idx].reta[pos];
 220         }
 221         priv->skip_default_rss_reta = 1;
 222         return mlx5_traffic_restart(dev);
 223 }