drivers/net/mlx5/mlx5_mp.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2019 6WIND S.A.
   3  * Copyright 2019 Mellanox Technologies, Ltd
   4  */
   5
   6 #include <stdio.h>
   7 #include <time.h>
   8
   9 #include <rte_eal.h>
  10 #include <rte_ethdev_driver.h>
  11 #include <rte_string_fns.h>
  12
  13 #include <mlx5_common_mp.h>
  14 #include <mlx5_common_mr.h>
  15
  16 #include "mlx5.h"
  17 #include "mlx5_rxtx.h"
  18 #include "mlx5_utils.h"
  19
  20 int
  21 mlx5_mp_primary_handle(const struct rte_mp_msg *mp_msg, const void *peer)
  22 {
  23         struct rte_mp_msg mp_res;
  24         struct mlx5_mp_param *res = (struct mlx5_mp_param *)mp_res.param;
  25         const struct mlx5_mp_param *param =
  26                 (const struct mlx5_mp_param *)mp_msg->param;
  27         struct rte_eth_dev *dev;
  28         struct mlx5_priv *priv;
  29         struct mr_cache_entry entry;
  30         uint32_t lkey;
  31         int ret;
  32
  33         MLX5_ASSERT(rte_eal_process_type() == RTE_PROC_PRIMARY);
  34         if (!rte_eth_dev_is_valid_port(param->port_id)) {
  35                 rte_errno = ENODEV;
  36                 DRV_LOG(ERR, "port %u invalid port ID", param->port_id);
  37                 return -rte_errno;
  38         }
  39         dev = &rte_eth_devices[param->port_id];
  40         priv = dev->data->dev_private;
  41         switch (param->type) {
  42         case MLX5_MP_REQ_CREATE_MR:
  43                 mp_init_msg(&priv->mp_id, &mp_res, param->type);
  44                 lkey = mlx5_mr_create_primary(priv->sh->pd,
  45                                               &priv->sh->share_cache,
  46                                               &entry, param->args.addr,
  47                                               priv->config.mr_ext_memseg_en);
  48                 if (lkey == UINT32_MAX)
  49                         res->result = -rte_errno;
  50                 ret = rte_mp_reply(&mp_res, peer);
  51                 break;
  52         case MLX5_MP_REQ_VERBS_CMD_FD:
  53                 mp_init_msg(&priv->mp_id, &mp_res, param->type);
  54                 mp_res.num_fds = 1;
  55                 mp_res.fds[0] = priv->sh->ctx->cmd_fd;
  56                 res->result = 0;
  57                 ret = rte_mp_reply(&mp_res, peer);
  58                 break;
  59         case MLX5_MP_REQ_QUEUE_STATE_MODIFY:
  60                 mp_init_msg(&priv->mp_id, &mp_res, param->type);
  61                 res->result = mlx5_queue_state_modify_primary
  62                                         (dev, &param->args.state_modify);
  63                 ret = rte_mp_reply(&mp_res, peer);
  64                 break;
  65         default:
  66                 rte_errno = EINVAL;
  67                 DRV_LOG(ERR, "port %u invalid mp request type",
  68                         dev->data->port_id);
  69                 return -rte_errno;
  70         }
  71         return ret;
  72 }
  73
  74 /**
  75  * IPC message handler of a secondary process.
  76  *
  77  * @param[in] dev
  78  *   Pointer to Ethernet structure.
  79  * @param[in] peer
  80  *   Pointer to the peer socket path.
  81  *
  82  * @return
  83  *   0 on success, a negative errno value otherwise and rte_errno is set.
  84  */
  85 int
  86 mlx5_mp_secondary_handle(const struct rte_mp_msg *mp_msg, const void *peer)
  87 {
  88         struct rte_mp_msg mp_res;
  89         struct mlx5_mp_param *res = (struct mlx5_mp_param *)mp_res.param;
  90         const struct mlx5_mp_param *param =
  91                 (const struct mlx5_mp_param *)mp_msg->param;
  92         struct rte_eth_dev *dev;
  93         struct mlx5_priv *priv;
  94         int ret;
  95
  96         MLX5_ASSERT(rte_eal_process_type() == RTE_PROC_SECONDARY);
  97         if (!rte_eth_dev_is_valid_port(param->port_id)) {
  98                 rte_errno = ENODEV;
  99                 DRV_LOG(ERR, "port %u invalid port ID", param->port_id);
 100                 return -rte_errno;
 101         }
 102         dev = &rte_eth_devices[param->port_id];
 103         priv = dev->data->dev_private;
 104         switch (param->type) {
 105         case MLX5_MP_REQ_START_RXTX:
 106                 DRV_LOG(INFO, "port %u starting datapath", dev->data->port_id);
 107                 rte_mb();
 108                 dev->rx_pkt_burst = mlx5_select_rx_function(dev);
 109                 dev->tx_pkt_burst = mlx5_select_tx_function(dev);
 110                 mp_init_msg(&priv->mp_id, &mp_res, param->type);
 111                 res->result = 0;
 112                 ret = rte_mp_reply(&mp_res, peer);
 113                 break;
 114         case MLX5_MP_REQ_STOP_RXTX:
 115                 DRV_LOG(INFO, "port %u stopping datapath", dev->data->port_id);
 116                 dev->rx_pkt_burst = removed_rx_burst;
 117                 dev->tx_pkt_burst = removed_tx_burst;
 118                 rte_mb();
 119                 mp_init_msg(&priv->mp_id, &mp_res, param->type);
 120                 res->result = 0;
 121                 ret = rte_mp_reply(&mp_res, peer);
 122                 break;
 123         default:
 124                 rte_errno = EINVAL;
 125                 DRV_LOG(ERR, "port %u invalid mp request type",
 126                         dev->data->port_id);
 127                 return -rte_errno;
 128         }
 129         return ret;
 130 }
 131
 132 /**
 133  * Broadcast request of stopping/starting data-path to secondary processes.
 134  *
 135  * @param[in] dev
 136  *   Pointer to Ethernet structure.
 137  * @param[in] type
 138  *   Request type.
 139  */
 140 static void
 141 mp_req_on_rxtx(struct rte_eth_dev *dev, enum mlx5_mp_req_type type)
 142 {
 143         struct rte_mp_msg mp_req;
 144         struct rte_mp_msg *mp_res;
 145         struct rte_mp_reply mp_rep;
 146         struct mlx5_mp_param *res;
 147         struct timespec ts = {.tv_sec = MLX5_MP_REQ_TIMEOUT_SEC, .tv_nsec = 0};
 148         struct mlx5_priv *priv = dev->data->dev_private;
 149         int ret;
 150         int i;
 151
 152         MLX5_ASSERT(rte_eal_process_type() == RTE_PROC_PRIMARY);
 153         if (!mlx5_shared_data->secondary_cnt)
 154                 return;
 155         if (type != MLX5_MP_REQ_START_RXTX && type != MLX5_MP_REQ_STOP_RXTX) {
 156                 DRV_LOG(ERR, "port %u unknown request (req_type %d)",
 157                         dev->data->port_id, type);
 158                 return;
 159         }
 160         mp_init_msg(&priv->mp_id, &mp_req, type);
 161         ret = rte_mp_request_sync(&mp_req, &mp_rep, &ts);
 162         if (ret) {
 163                 if (rte_errno != ENOTSUP)
 164                         DRV_LOG(ERR, "port %u failed to request stop/start Rx/Tx (%d)",
 165                                 dev->data->port_id, type);
 166                 goto exit;
 167         }
 168         if (mp_rep.nb_sent != mp_rep.nb_received) {
 169                 DRV_LOG(ERR,
 170                         "port %u not all secondaries responded (req_type %d)",
 171                         dev->data->port_id, type);
 172                 goto exit;
 173         }
 174         for (i = 0; i < mp_rep.nb_received; i++) {
 175                 mp_res = &mp_rep.msgs[i];
 176                 res = (struct mlx5_mp_param *)mp_res->param;
 177                 if (res->result) {
 178                         DRV_LOG(ERR, "port %u request failed on secondary #%d",
 179                                 dev->data->port_id, i);
 180                         goto exit;
 181                 }
 182         }
 183 exit:
 184         free(mp_rep.msgs);
 185 }
 186
 187 /**
 188  * Broadcast request of starting data-path to secondary processes. The request
 189  * is synchronous.
 190  *
 191  * @param[in] dev
 192  *   Pointer to Ethernet structure.
 193  */
 194 void
 195 mlx5_mp_req_start_rxtx(struct rte_eth_dev *dev)
 196 {
 197         mp_req_on_rxtx(dev, MLX5_MP_REQ_START_RXTX);
 198 }
 199
 200 /**
 201  * Broadcast request of stopping data-path to secondary processes. The request
 202  * is synchronous.
 203  *
 204  * @param[in] dev
 205  *   Pointer to Ethernet structure.
 206  */
 207 void
 208 mlx5_mp_req_stop_rxtx(struct rte_eth_dev *dev)
 209 {
 210         mp_req_on_rxtx(dev, MLX5_MP_REQ_STOP_RXTX);
 211 }