2020-06-03 15:05:56 +00:00
|
|
|
/* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
* Copyright 2015 6WIND S.A.
|
|
|
|
* Copyright 2020 Mellanox Technologies, Ltd
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
2020-06-10 09:32:33 +00:00
|
|
|
#include <linux/sockios.h>
|
|
|
|
#include <linux/ethtool.h>
|
2020-06-03 15:05:56 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
|
|
|
|
#include <rte_malloc.h>
|
2021-01-29 16:48:19 +00:00
|
|
|
#include <ethdev_driver.h>
|
|
|
|
#include <ethdev_pci.h>
|
2020-06-03 15:05:56 +00:00
|
|
|
#include <rte_pci.h>
|
2022-07-28 15:26:35 +00:00
|
|
|
#include <bus_driver.h>
|
2022-07-28 15:26:30 +00:00
|
|
|
#include <bus_pci_driver.h>
|
2022-07-28 15:26:25 +00:00
|
|
|
#include <bus_auxiliary_driver.h>
|
2020-06-03 15:05:56 +00:00
|
|
|
#include <rte_common.h>
|
|
|
|
#include <rte_kvargs.h>
|
|
|
|
#include <rte_rwlock.h>
|
|
|
|
#include <rte_spinlock.h>
|
|
|
|
#include <rte_string_fns.h>
|
|
|
|
#include <rte_alarm.h>
|
2020-07-19 10:18:10 +00:00
|
|
|
#include <rte_eal_paging.h>
|
2020-06-03 15:05:56 +00:00
|
|
|
|
|
|
|
#include <mlx5_glue.h>
|
|
|
|
#include <mlx5_devx_cmds.h>
|
|
|
|
#include <mlx5_common.h>
|
2020-06-03 15:06:00 +00:00
|
|
|
#include <mlx5_common_mp.h>
|
2020-06-16 09:44:45 +00:00
|
|
|
#include <mlx5_common_mr.h>
|
net/mlx5: add option to allocate memory from system
Currently, for MLX5 PMD, once millions of flows created, the memory
consumption of the flows are also very huge. For the system with limited
memory, it means the system need to reserve most of the memory as huge
page memory to serve the flows in advance. And other normal applications
will have no chance to use this reserved memory any more. While most of
the time, the system will not have lots of flows, the reserved huge
page memory becomes a bit waste of memory at most of the time.
By the new sys_mem_en devarg, once set it to be true, it allows the PMD
allocate the memory from system by default with the new add mlx5 memory
management functions. Only once the MLX5_MEM_RTE flag is set, the memory
will be allocate from rte, otherwise, it allocates memory from system.
So in this case, the system with limited memory no need to reserve most
of the memory for hugepage. Only some needed memory for datapath objects
will be enough to allocated with explicitly flag. Other memory will be
allocated from system. For system with enough memory, no need to care
about the devarg, the memory will always be from rte hugepage.
One restriction is that for DPDK application with multiple PCI devices,
if the sys_mem_en devargs are different between the devices, the
sys_mem_en only gets the value from the first device devargs, and print
out a message to warn that.
Signed-off-by: Suanming Mou <suanmingm@mellanox.com>
Acked-by: Matan Azrad <matan@mellanox.com>
2020-06-28 03:41:57 +00:00
|
|
|
#include <mlx5_malloc.h>
|
2020-06-03 15:05:56 +00:00
|
|
|
|
|
|
|
#include "mlx5_defs.h"
|
|
|
|
#include "mlx5.h"
|
2020-06-19 07:30:08 +00:00
|
|
|
#include "mlx5_common_os.h"
|
2020-06-03 15:05:56 +00:00
|
|
|
#include "mlx5_utils.h"
|
|
|
|
#include "mlx5_rxtx.h"
|
2021-04-12 06:32:20 +00:00
|
|
|
#include "mlx5_rx.h"
|
2021-04-12 06:32:22 +00:00
|
|
|
#include "mlx5_tx.h"
|
2020-06-03 15:05:56 +00:00
|
|
|
#include "mlx5_autoconf.h"
|
|
|
|
#include "mlx5_flow.h"
|
|
|
|
#include "rte_pmd_mlx5.h"
|
2020-06-16 09:44:46 +00:00
|
|
|
#include "mlx5_verbs.h"
|
2020-08-25 09:31:09 +00:00
|
|
|
#include "mlx5_nl.h"
|
2020-09-03 10:13:36 +00:00
|
|
|
#include "mlx5_devx.h"
|
2020-06-03 15:05:56 +00:00
|
|
|
|
2020-06-03 15:06:00 +00:00
|
|
|
#ifndef HAVE_IBV_MLX5_MOD_MPW
|
|
|
|
#define MLX5DV_CONTEXT_FLAGS_MPW_ALLOWED (1 << 2)
|
|
|
|
#define MLX5DV_CONTEXT_FLAGS_ENHANCED_MPW (1 << 3)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef HAVE_IBV_MLX5_MOD_CQE_128B_COMP
|
|
|
|
#define MLX5DV_CONTEXT_FLAGS_CQE_128B_COMP (1 << 4)
|
|
|
|
#endif
|
|
|
|
|
2020-07-19 10:18:15 +00:00
|
|
|
static const char *MZ_MLX5_PMD_SHARED_DATA = "mlx5_pmd_shared_data";
|
|
|
|
|
|
|
|
/* Spinlock for mlx5_shared_data allocation. */
|
|
|
|
static rte_spinlock_t mlx5_shared_data_lock = RTE_SPINLOCK_INITIALIZER;
|
|
|
|
|
|
|
|
/* Process local data for secondary processes. */
|
|
|
|
static struct mlx5_local_data mlx5_local_data;
|
|
|
|
|
2021-07-13 08:44:39 +00:00
|
|
|
/* rte flow indexed pool configuration. */
|
|
|
|
static struct mlx5_indexed_pool_config icfg[] = {
|
|
|
|
{
|
|
|
|
.size = sizeof(struct rte_flow),
|
|
|
|
.trunk_size = 64,
|
|
|
|
.need_lock = 1,
|
|
|
|
.release_mem_en = 0,
|
|
|
|
.malloc = mlx5_malloc,
|
|
|
|
.free = mlx5_free,
|
|
|
|
.per_core_cache = 0,
|
|
|
|
.type = "ctl_flow_ipool",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.size = sizeof(struct rte_flow),
|
|
|
|
.trunk_size = 64,
|
|
|
|
.grow_trunk = 3,
|
|
|
|
.grow_shift = 2,
|
|
|
|
.need_lock = 1,
|
|
|
|
.release_mem_en = 0,
|
|
|
|
.malloc = mlx5_malloc,
|
|
|
|
.free = mlx5_free,
|
|
|
|
.per_core_cache = 1 << 14,
|
|
|
|
.type = "rte_flow_ipool",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.size = sizeof(struct rte_flow),
|
|
|
|
.trunk_size = 64,
|
|
|
|
.grow_trunk = 3,
|
|
|
|
.grow_shift = 2,
|
|
|
|
.need_lock = 1,
|
|
|
|
.release_mem_en = 0,
|
|
|
|
.malloc = mlx5_malloc,
|
|
|
|
.free = mlx5_free,
|
|
|
|
.per_core_cache = 0,
|
|
|
|
.type = "mcp_flow_ipool",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2020-07-19 11:13:06 +00:00
|
|
|
/**
|
|
|
|
* Set the completion channel file descriptor interrupt as non-blocking.
|
|
|
|
*
|
|
|
|
* @param[in] rxq_obj
|
|
|
|
* Pointer to RQ channel object, which includes the channel fd
|
|
|
|
*
|
|
|
|
* @param[out] fd
|
2021-11-29 16:08:02 +00:00
|
|
|
* The file descriptor (representing the interrupt) used in this channel.
|
2020-07-19 11:13:06 +00:00
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on successfully setting the fd to non-blocking, non-zero otherwise.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
mlx5_os_set_nonblock_channel_fd(int fd)
|
|
|
|
{
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
flags = fcntl(fd, F_GETFL);
|
|
|
|
return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
|
|
|
|
}
|
|
|
|
|
2020-06-03 15:05:58 +00:00
|
|
|
/**
|
|
|
|
* Get mlx5 device attributes. The glue function query_device_ex() is called
|
|
|
|
* with out parameter of type 'struct ibv_device_attr_ex *'. Then fill in mlx5
|
|
|
|
* device attributes from the glue out parameter.
|
|
|
|
*
|
2022-02-14 09:35:05 +00:00
|
|
|
* @param sh
|
|
|
|
* Pointer to shared device context.
|
2020-06-03 15:05:58 +00:00
|
|
|
*
|
|
|
|
* @return
|
2022-02-14 09:34:55 +00:00
|
|
|
* 0 on success, a negative errno value otherwise and rte_errno is set.
|
2020-06-03 15:05:58 +00:00
|
|
|
*/
|
|
|
|
int
|
2022-02-14 09:35:05 +00:00
|
|
|
mlx5_os_capabilities_prepare(struct mlx5_dev_ctx_shared *sh)
|
2020-06-03 15:05:58 +00:00
|
|
|
{
|
|
|
|
int err;
|
2022-02-14 09:35:06 +00:00
|
|
|
struct mlx5_common_device *cdev = sh->cdev;
|
|
|
|
struct mlx5_hca_attr *hca_attr = &cdev->config.hca_attr;
|
2022-02-14 09:35:05 +00:00
|
|
|
struct ibv_device_attr_ex attr_ex = { .comp_mask = 0 };
|
|
|
|
struct mlx5dv_context dv_attr = { .comp_mask = 0 };
|
2021-10-19 20:55:55 +00:00
|
|
|
|
2022-02-14 09:35:06 +00:00
|
|
|
err = mlx5_glue->query_device_ex(cdev->ctx, NULL, &attr_ex);
|
2022-02-14 09:34:55 +00:00
|
|
|
if (err) {
|
|
|
|
rte_errno = errno;
|
|
|
|
return -rte_errno;
|
|
|
|
}
|
2022-02-14 09:35:00 +00:00
|
|
|
#ifdef HAVE_IBV_MLX5_MOD_SWP
|
|
|
|
dv_attr.comp_mask |= MLX5DV_CONTEXT_MASK_SWP;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_IBV_DEVICE_TUNNEL_SUPPORT
|
|
|
|
dv_attr.comp_mask |= MLX5DV_CONTEXT_MASK_TUNNEL_OFFLOADS;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_IBV_DEVICE_STRIDING_RQ_SUPPORT
|
|
|
|
dv_attr.comp_mask |= MLX5DV_CONTEXT_MASK_STRIDING_RQ;
|
|
|
|
#endif
|
2022-02-14 09:35:06 +00:00
|
|
|
err = mlx5_glue->dv_query_device(cdev->ctx, &dv_attr);
|
2022-02-14 09:34:55 +00:00
|
|
|
if (err) {
|
|
|
|
rte_errno = errno;
|
|
|
|
return -rte_errno;
|
|
|
|
}
|
2022-02-14 09:35:05 +00:00
|
|
|
memset(&sh->dev_cap, 0, sizeof(struct mlx5_dev_cap));
|
2022-02-14 09:35:06 +00:00
|
|
|
if (mlx5_dev_is_pci(cdev->dev))
|
|
|
|
sh->dev_cap.vf = mlx5_dev_is_vf_pci(RTE_DEV_TO_PCI(cdev->dev));
|
|
|
|
else
|
|
|
|
sh->dev_cap.sf = 1;
|
2022-02-14 09:35:05 +00:00
|
|
|
sh->dev_cap.max_qp_wr = attr_ex.orig_attr.max_qp_wr;
|
|
|
|
sh->dev_cap.max_sge = attr_ex.orig_attr.max_sge;
|
|
|
|
sh->dev_cap.max_cq = attr_ex.orig_attr.max_cq;
|
|
|
|
sh->dev_cap.max_qp = attr_ex.orig_attr.max_qp;
|
2022-02-14 09:35:06 +00:00
|
|
|
#ifdef HAVE_MLX5DV_DR_ACTION_DEST_DEVX_TIR
|
|
|
|
sh->dev_cap.dest_tir = 1;
|
|
|
|
#endif
|
|
|
|
#if defined(HAVE_IBV_FLOW_DV_SUPPORT) && defined(HAVE_MLX5DV_DR)
|
|
|
|
DRV_LOG(DEBUG, "DV flow is supported.");
|
|
|
|
sh->dev_cap.dv_flow_en = 1;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_MLX5DV_DR_ESWITCH
|
|
|
|
if (hca_attr->eswitch_manager && sh->dev_cap.dv_flow_en && sh->esw_mode)
|
|
|
|
sh->dev_cap.dv_esw_en = 1;
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Multi-packet send is supported by ConnectX-4 Lx PF as well
|
|
|
|
* as all ConnectX-5 devices.
|
|
|
|
*/
|
|
|
|
if (dv_attr.flags & MLX5DV_CONTEXT_FLAGS_MPW_ALLOWED) {
|
|
|
|
if (dv_attr.flags & MLX5DV_CONTEXT_FLAGS_ENHANCED_MPW) {
|
|
|
|
DRV_LOG(DEBUG, "Enhanced MPW is supported.");
|
|
|
|
sh->dev_cap.mps = MLX5_MPW_ENHANCED;
|
|
|
|
} else {
|
|
|
|
DRV_LOG(DEBUG, "MPW is supported.");
|
|
|
|
sh->dev_cap.mps = MLX5_MPW;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
DRV_LOG(DEBUG, "MPW isn't supported.");
|
|
|
|
sh->dev_cap.mps = MLX5_MPW_DISABLED;
|
|
|
|
}
|
|
|
|
#if (RTE_CACHE_LINE_SIZE == 128)
|
|
|
|
if (dv_attr.flags & MLX5DV_CONTEXT_FLAGS_CQE_128B_COMP)
|
|
|
|
sh->dev_cap.cqe_comp = 1;
|
|
|
|
DRV_LOG(DEBUG, "Rx CQE 128B compression is %ssupported.",
|
|
|
|
sh->dev_cap.cqe_comp ? "" : "not ");
|
|
|
|
#else
|
|
|
|
sh->dev_cap.cqe_comp = 1;
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_IBV_DEVICE_MPLS_SUPPORT
|
|
|
|
sh->dev_cap.mpls_en =
|
|
|
|
((dv_attr.tunnel_offloads_caps &
|
|
|
|
MLX5DV_RAW_PACKET_CAP_TUNNELED_OFFLOAD_CW_MPLS_OVER_GRE) &&
|
|
|
|
(dv_attr.tunnel_offloads_caps &
|
|
|
|
MLX5DV_RAW_PACKET_CAP_TUNNELED_OFFLOAD_CW_MPLS_OVER_UDP));
|
|
|
|
DRV_LOG(DEBUG, "MPLS over GRE/UDP tunnel offloading is %ssupported.",
|
|
|
|
sh->dev_cap.mpls_en ? "" : "not ");
|
|
|
|
#else
|
|
|
|
DRV_LOG(WARNING,
|
|
|
|
"MPLS over GRE/UDP tunnel offloading disabled due to old OFED/rdma-core version or firmware configuration");
|
|
|
|
#endif
|
|
|
|
#if defined(HAVE_IBV_WQ_FLAG_RX_END_PADDING)
|
|
|
|
sh->dev_cap.hw_padding = !!attr_ex.rx_pad_end_addr_align;
|
|
|
|
#elif defined(HAVE_IBV_WQ_FLAGS_PCI_WRITE_END_PADDING)
|
|
|
|
sh->dev_cap.hw_padding = !!(attr_ex.device_cap_flags_ex &
|
|
|
|
IBV_DEVICE_PCI_WRITE_END_PADDING);
|
|
|
|
#endif
|
|
|
|
sh->dev_cap.hw_csum =
|
|
|
|
!!(attr_ex.device_cap_flags_ex & IBV_DEVICE_RAW_IP_CSUM);
|
|
|
|
DRV_LOG(DEBUG, "Checksum offloading is %ssupported.",
|
|
|
|
sh->dev_cap.hw_csum ? "" : "not ");
|
|
|
|
sh->dev_cap.hw_vlan_strip = !!(attr_ex.raw_packet_caps &
|
|
|
|
IBV_RAW_PACKET_CAP_CVLAN_STRIPPING);
|
|
|
|
DRV_LOG(DEBUG, "VLAN stripping is %ssupported.",
|
|
|
|
(sh->dev_cap.hw_vlan_strip ? "" : "not "));
|
|
|
|
sh->dev_cap.hw_fcs_strip = !!(attr_ex.raw_packet_caps &
|
|
|
|
IBV_RAW_PACKET_CAP_SCATTER_FCS);
|
|
|
|
#if !defined(HAVE_IBV_DEVICE_COUNTERS_SET_V42) && \
|
|
|
|
!defined(HAVE_IBV_DEVICE_COUNTERS_SET_V45)
|
|
|
|
DRV_LOG(DEBUG, "Counters are not supported.");
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* DPDK doesn't support larger/variable indirection tables.
|
|
|
|
* Once DPDK supports it, take max size from device attr.
|
|
|
|
*/
|
|
|
|
sh->dev_cap.ind_table_max_size =
|
|
|
|
RTE_MIN(attr_ex.rss_caps.max_rwq_indirection_table_size,
|
|
|
|
(unsigned int)RTE_ETH_RSS_RETA_SIZE_512);
|
|
|
|
DRV_LOG(DEBUG, "Maximum Rx indirection table size is %u",
|
|
|
|
sh->dev_cap.ind_table_max_size);
|
|
|
|
sh->dev_cap.tso = (attr_ex.tso_caps.max_tso > 0 &&
|
|
|
|
(attr_ex.tso_caps.supported_qpts &
|
|
|
|
(1 << IBV_QPT_RAW_PACKET)));
|
|
|
|
if (sh->dev_cap.tso)
|
|
|
|
sh->dev_cap.tso_max_payload_sz = attr_ex.tso_caps.max_tso;
|
2022-02-14 09:35:05 +00:00
|
|
|
strlcpy(sh->dev_cap.fw_ver, attr_ex.orig_attr.fw_ver,
|
|
|
|
sizeof(sh->dev_cap.fw_ver));
|
2020-06-03 15:05:58 +00:00
|
|
|
#ifdef HAVE_IBV_MLX5_MOD_SWP
|
2022-02-14 09:35:06 +00:00
|
|
|
if (dv_attr.comp_mask & MLX5DV_CONTEXT_MASK_SWP)
|
|
|
|
sh->dev_cap.swp = dv_attr.sw_parsing_caps.sw_parsing_offloads &
|
|
|
|
(MLX5_SW_PARSING_CAP |
|
|
|
|
MLX5_SW_PARSING_CSUM_CAP |
|
|
|
|
MLX5_SW_PARSING_TSO_CAP);
|
|
|
|
DRV_LOG(DEBUG, "SWP support: %u", sh->dev_cap.swp);
|
2020-06-03 15:05:58 +00:00
|
|
|
#endif
|
2022-02-14 09:35:00 +00:00
|
|
|
#ifdef HAVE_IBV_DEVICE_STRIDING_RQ_SUPPORT
|
2022-02-14 09:35:06 +00:00
|
|
|
if (dv_attr.comp_mask & MLX5DV_CONTEXT_MASK_STRIDING_RQ) {
|
|
|
|
struct mlx5dv_striding_rq_caps *strd_rq_caps =
|
|
|
|
&dv_attr.striding_rq_caps;
|
|
|
|
|
|
|
|
sh->dev_cap.mprq.enabled = 1;
|
|
|
|
sh->dev_cap.mprq.log_min_stride_size =
|
|
|
|
strd_rq_caps->min_single_stride_log_num_of_bytes;
|
|
|
|
sh->dev_cap.mprq.log_max_stride_size =
|
|
|
|
strd_rq_caps->max_single_stride_log_num_of_bytes;
|
|
|
|
sh->dev_cap.mprq.log_min_stride_num =
|
|
|
|
strd_rq_caps->min_single_wqe_log_num_of_strides;
|
|
|
|
sh->dev_cap.mprq.log_max_stride_num =
|
|
|
|
strd_rq_caps->max_single_wqe_log_num_of_strides;
|
|
|
|
sh->dev_cap.mprq.log_min_stride_wqe_size =
|
|
|
|
cdev->config.devx ?
|
|
|
|
hca_attr->log_min_stride_wqe_sz :
|
|
|
|
MLX5_MPRQ_LOG_MIN_STRIDE_WQE_SIZE;
|
|
|
|
DRV_LOG(DEBUG, "\tmin_single_stride_log_num_of_bytes: %u",
|
|
|
|
sh->dev_cap.mprq.log_min_stride_size);
|
|
|
|
DRV_LOG(DEBUG, "\tmax_single_stride_log_num_of_bytes: %u",
|
|
|
|
sh->dev_cap.mprq.log_max_stride_size);
|
|
|
|
DRV_LOG(DEBUG, "\tmin_single_wqe_log_num_of_strides: %u",
|
|
|
|
sh->dev_cap.mprq.log_min_stride_num);
|
|
|
|
DRV_LOG(DEBUG, "\tmax_single_wqe_log_num_of_strides: %u",
|
|
|
|
sh->dev_cap.mprq.log_max_stride_num);
|
|
|
|
DRV_LOG(DEBUG, "\tmin_stride_wqe_log_size: %u",
|
|
|
|
sh->dev_cap.mprq.log_min_stride_wqe_size);
|
|
|
|
DRV_LOG(DEBUG, "\tsupported_qpts: %d",
|
|
|
|
strd_rq_caps->supported_qpts);
|
|
|
|
DRV_LOG(DEBUG, "Device supports Multi-Packet RQ.");
|
|
|
|
}
|
2022-02-14 09:35:00 +00:00
|
|
|
#endif
|
2020-06-03 15:05:58 +00:00
|
|
|
#ifdef HAVE_IBV_DEVICE_TUNNEL_SUPPORT
|
2022-02-14 09:35:06 +00:00
|
|
|
if (dv_attr.comp_mask & MLX5DV_CONTEXT_MASK_TUNNEL_OFFLOADS) {
|
|
|
|
sh->dev_cap.tunnel_en = dv_attr.tunnel_offloads_caps &
|
|
|
|
(MLX5_TUNNELED_OFFLOADS_VXLAN_CAP |
|
|
|
|
MLX5_TUNNELED_OFFLOADS_GRE_CAP |
|
|
|
|
MLX5_TUNNELED_OFFLOADS_GENEVE_CAP);
|
|
|
|
}
|
|
|
|
if (sh->dev_cap.tunnel_en) {
|
|
|
|
DRV_LOG(DEBUG, "Tunnel offloading is supported for %s%s%s",
|
|
|
|
sh->dev_cap.tunnel_en &
|
|
|
|
MLX5_TUNNELED_OFFLOADS_VXLAN_CAP ? "[VXLAN]" : "",
|
|
|
|
sh->dev_cap.tunnel_en &
|
|
|
|
MLX5_TUNNELED_OFFLOADS_GRE_CAP ? "[GRE]" : "",
|
|
|
|
sh->dev_cap.tunnel_en &
|
|
|
|
MLX5_TUNNELED_OFFLOADS_GENEVE_CAP ? "[GENEVE]" : "");
|
|
|
|
} else {
|
|
|
|
DRV_LOG(DEBUG, "Tunnel offloading is not supported.");
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
DRV_LOG(WARNING,
|
|
|
|
"Tunnel offloading disabled due to old OFED/rdma-core version");
|
2020-06-03 15:05:58 +00:00
|
|
|
#endif
|
2022-02-14 09:35:06 +00:00
|
|
|
if (!sh->cdev->config.devx)
|
|
|
|
return 0;
|
|
|
|
/* Check capabilities for Packet Pacing. */
|
|
|
|
DRV_LOG(DEBUG, "Timestamp counter frequency %u kHz.",
|
|
|
|
hca_attr->dev_freq_khz);
|
|
|
|
DRV_LOG(DEBUG, "Packet pacing is %ssupported.",
|
|
|
|
hca_attr->qos.packet_pacing ? "" : "not ");
|
|
|
|
DRV_LOG(DEBUG, "Cross channel ops are %ssupported.",
|
|
|
|
hca_attr->cross_channel ? "" : "not ");
|
|
|
|
DRV_LOG(DEBUG, "WQE index ignore is %ssupported.",
|
|
|
|
hca_attr->wqe_index_ignore ? "" : "not ");
|
|
|
|
DRV_LOG(DEBUG, "Non-wire SQ feature is %ssupported.",
|
|
|
|
hca_attr->non_wire_sq ? "" : "not ");
|
|
|
|
DRV_LOG(DEBUG, "Static WQE SQ feature is %ssupported (%d)",
|
|
|
|
hca_attr->log_max_static_sq_wq ? "" : "not ",
|
|
|
|
hca_attr->log_max_static_sq_wq);
|
|
|
|
DRV_LOG(DEBUG, "WQE rate PP mode is %ssupported.",
|
|
|
|
hca_attr->qos.wqe_rate_pp ? "" : "not ");
|
|
|
|
sh->dev_cap.txpp_en = hca_attr->qos.packet_pacing;
|
|
|
|
if (!hca_attr->cross_channel) {
|
|
|
|
DRV_LOG(DEBUG,
|
|
|
|
"Cross channel operations are required for packet pacing.");
|
|
|
|
sh->dev_cap.txpp_en = 0;
|
|
|
|
}
|
|
|
|
if (!hca_attr->wqe_index_ignore) {
|
|
|
|
DRV_LOG(DEBUG,
|
|
|
|
"WQE index ignore feature is required for packet pacing.");
|
|
|
|
sh->dev_cap.txpp_en = 0;
|
|
|
|
}
|
|
|
|
if (!hca_attr->non_wire_sq) {
|
|
|
|
DRV_LOG(DEBUG,
|
|
|
|
"Non-wire SQ feature is required for packet pacing.");
|
|
|
|
sh->dev_cap.txpp_en = 0;
|
|
|
|
}
|
|
|
|
if (!hca_attr->log_max_static_sq_wq) {
|
|
|
|
DRV_LOG(DEBUG,
|
|
|
|
"Static WQE SQ feature is required for packet pacing.");
|
|
|
|
sh->dev_cap.txpp_en = 0;
|
|
|
|
}
|
|
|
|
if (!hca_attr->qos.wqe_rate_pp) {
|
|
|
|
DRV_LOG(DEBUG,
|
|
|
|
"WQE rate mode is required for packet pacing.");
|
|
|
|
sh->dev_cap.txpp_en = 0;
|
|
|
|
}
|
|
|
|
#ifndef HAVE_MLX5DV_DEVX_UAR_OFFSET
|
|
|
|
DRV_LOG(DEBUG,
|
|
|
|
"DevX does not provide UAR offset, can't create queues for packet pacing.");
|
|
|
|
sh->dev_cap.txpp_en = 0;
|
|
|
|
#endif
|
|
|
|
sh->dev_cap.scatter_fcs_w_decap_disable =
|
|
|
|
hca_attr->scatter_fcs_w_decap_disable;
|
|
|
|
sh->dev_cap.rq_delay_drop_en = hca_attr->rq_delay_drop;
|
|
|
|
mlx5_rt_timestamp_config(sh, hca_attr);
|
2022-02-14 09:34:55 +00:00
|
|
|
return 0;
|
2020-06-03 15:05:58 +00:00
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
|
2021-07-13 12:09:19 +00:00
|
|
|
/**
|
|
|
|
* Detect misc5 support or not
|
|
|
|
*
|
|
|
|
* @param[in] priv
|
|
|
|
* Device private data pointer
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_MLX5DV_DR
|
|
|
|
static void
|
|
|
|
__mlx5_discovery_misc5_cap(struct mlx5_priv *priv)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_IBV_FLOW_DV_SUPPORT
|
|
|
|
/* Dummy VxLAN matcher to detect rdma-core misc5 cap
|
|
|
|
* Case: IPv4--->UDP--->VxLAN--->vni
|
|
|
|
*/
|
|
|
|
void *tbl;
|
|
|
|
struct mlx5_flow_dv_match_params matcher_mask;
|
|
|
|
void *match_m;
|
|
|
|
void *matcher;
|
|
|
|
void *headers_m;
|
|
|
|
void *misc5_m;
|
|
|
|
uint32_t *tunnel_header_m;
|
|
|
|
struct mlx5dv_flow_matcher_attr dv_attr;
|
|
|
|
|
|
|
|
memset(&matcher_mask, 0, sizeof(matcher_mask));
|
|
|
|
matcher_mask.size = sizeof(matcher_mask.buf);
|
|
|
|
match_m = matcher_mask.buf;
|
|
|
|
headers_m = MLX5_ADDR_OF(fte_match_param, match_m, outer_headers);
|
|
|
|
misc5_m = MLX5_ADDR_OF(fte_match_param,
|
|
|
|
match_m, misc_parameters_5);
|
|
|
|
tunnel_header_m = (uint32_t *)
|
|
|
|
MLX5_ADDR_OF(fte_match_set_misc5,
|
|
|
|
misc5_m, tunnel_header_1);
|
|
|
|
MLX5_SET(fte_match_set_lyr_2_4, headers_m, ip_protocol, 0xff);
|
|
|
|
MLX5_SET(fte_match_set_lyr_2_4, headers_m, ip_version, 4);
|
|
|
|
MLX5_SET(fte_match_set_lyr_2_4, headers_m, udp_dport, 0xffff);
|
|
|
|
*tunnel_header_m = 0xffffff;
|
|
|
|
|
|
|
|
tbl = mlx5_glue->dr_create_flow_tbl(priv->sh->rx_domain, 1);
|
|
|
|
if (!tbl) {
|
|
|
|
DRV_LOG(INFO, "No SW steering support");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
dv_attr.type = IBV_FLOW_ATTR_NORMAL,
|
|
|
|
dv_attr.match_mask = (void *)&matcher_mask,
|
|
|
|
dv_attr.match_criteria_enable =
|
|
|
|
(1 << MLX5_MATCH_CRITERIA_ENABLE_OUTER_BIT) |
|
|
|
|
(1 << MLX5_MATCH_CRITERIA_ENABLE_MISC5_BIT);
|
|
|
|
dv_attr.priority = 3;
|
|
|
|
#ifdef HAVE_MLX5DV_DR_ESWITCH
|
|
|
|
void *misc2_m;
|
2022-02-14 09:35:07 +00:00
|
|
|
if (priv->sh->config.dv_esw_en) {
|
2021-07-13 12:09:19 +00:00
|
|
|
/* FDB enabled reg_c_0 */
|
|
|
|
dv_attr.match_criteria_enable |=
|
|
|
|
(1 << MLX5_MATCH_CRITERIA_ENABLE_MISC2_BIT);
|
|
|
|
misc2_m = MLX5_ADDR_OF(fte_match_param,
|
|
|
|
match_m, misc_parameters_2);
|
|
|
|
MLX5_SET(fte_match_set_misc2, misc2_m,
|
|
|
|
metadata_reg_c_0, 0xffff);
|
|
|
|
}
|
|
|
|
#endif
|
2021-10-19 20:55:52 +00:00
|
|
|
matcher = mlx5_glue->dv_create_flow_matcher(priv->sh->cdev->ctx,
|
2021-07-13 12:09:19 +00:00
|
|
|
&dv_attr, tbl);
|
|
|
|
if (matcher) {
|
|
|
|
priv->sh->misc5_cap = 1;
|
|
|
|
mlx5_glue->dv_destroy_flow_matcher(matcher);
|
|
|
|
}
|
|
|
|
mlx5_glue->dr_destroy_flow_tbl(tbl);
|
|
|
|
#else
|
|
|
|
RTE_SET_USED(priv);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-06-03 15:06:00 +00:00
|
|
|
/**
|
|
|
|
* Initialize DR related data within private structure.
|
|
|
|
* Routine checks the reference counter and does actual
|
|
|
|
* resources creation/initialization only if counter is zero.
|
|
|
|
*
|
|
|
|
* @param[in] priv
|
|
|
|
* Pointer to the private device data structure.
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* Zero on success, positive error code otherwise.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
mlx5_alloc_shared_dr(struct mlx5_priv *priv)
|
|
|
|
{
|
|
|
|
struct mlx5_dev_ctx_shared *sh = priv->sh;
|
2021-07-13 08:44:50 +00:00
|
|
|
char s[MLX5_NAME_SIZE] __rte_unused;
|
2020-10-21 11:15:23 +00:00
|
|
|
int err;
|
2020-06-03 15:06:00 +00:00
|
|
|
|
2020-10-21 11:15:23 +00:00
|
|
|
MLX5_ASSERT(sh && sh->refcnt);
|
|
|
|
if (sh->refcnt > 1)
|
|
|
|
return 0;
|
|
|
|
err = mlx5_alloc_table_hash_list(priv);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (err)
|
2020-10-28 09:33:34 +00:00
|
|
|
goto error;
|
2022-02-24 13:40:40 +00:00
|
|
|
if (priv->sh->config.dv_flow_en == 2)
|
|
|
|
return 0;
|
2020-10-28 09:33:34 +00:00
|
|
|
/* The resources below are only valid with DV support. */
|
|
|
|
#ifdef HAVE_IBV_FLOW_DV_SUPPORT
|
2021-07-13 08:44:42 +00:00
|
|
|
/* Init port id action list. */
|
2021-07-13 08:44:41 +00:00
|
|
|
snprintf(s, sizeof(s), "%s_port_id_action_list", sh->ibdev_name);
|
2021-07-13 08:44:48 +00:00
|
|
|
sh->port_id_action_list = mlx5_list_create(s, sh, true,
|
2021-07-13 08:44:46 +00:00
|
|
|
flow_dv_port_id_create_cb,
|
|
|
|
flow_dv_port_id_match_cb,
|
|
|
|
flow_dv_port_id_remove_cb,
|
|
|
|
flow_dv_port_id_clone_cb,
|
|
|
|
flow_dv_port_id_clone_free_cb);
|
|
|
|
if (!sh->port_id_action_list)
|
|
|
|
goto error;
|
2021-07-13 08:44:42 +00:00
|
|
|
/* Init push vlan action list. */
|
2021-07-13 08:44:41 +00:00
|
|
|
snprintf(s, sizeof(s), "%s_push_vlan_action_list", sh->ibdev_name);
|
2021-07-13 08:44:48 +00:00
|
|
|
sh->push_vlan_action_list = mlx5_list_create(s, sh, true,
|
2021-07-13 08:44:46 +00:00
|
|
|
flow_dv_push_vlan_create_cb,
|
|
|
|
flow_dv_push_vlan_match_cb,
|
|
|
|
flow_dv_push_vlan_remove_cb,
|
|
|
|
flow_dv_push_vlan_clone_cb,
|
|
|
|
flow_dv_push_vlan_clone_free_cb);
|
|
|
|
if (!sh->push_vlan_action_list)
|
|
|
|
goto error;
|
2021-07-13 08:44:42 +00:00
|
|
|
/* Init sample action list. */
|
2021-07-13 08:44:41 +00:00
|
|
|
snprintf(s, sizeof(s), "%s_sample_action_list", sh->ibdev_name);
|
2021-07-13 08:44:48 +00:00
|
|
|
sh->sample_action_list = mlx5_list_create(s, sh, true,
|
2021-07-13 08:44:46 +00:00
|
|
|
flow_dv_sample_create_cb,
|
|
|
|
flow_dv_sample_match_cb,
|
|
|
|
flow_dv_sample_remove_cb,
|
|
|
|
flow_dv_sample_clone_cb,
|
|
|
|
flow_dv_sample_clone_free_cb);
|
|
|
|
if (!sh->sample_action_list)
|
|
|
|
goto error;
|
2021-07-13 08:44:42 +00:00
|
|
|
/* Init dest array action list. */
|
2021-07-13 08:44:41 +00:00
|
|
|
snprintf(s, sizeof(s), "%s_dest_array_list", sh->ibdev_name);
|
2021-07-13 08:44:48 +00:00
|
|
|
sh->dest_array_list = mlx5_list_create(s, sh, true,
|
2021-07-13 08:44:46 +00:00
|
|
|
flow_dv_dest_array_create_cb,
|
|
|
|
flow_dv_dest_array_match_cb,
|
|
|
|
flow_dv_dest_array_remove_cb,
|
|
|
|
flow_dv_dest_array_clone_cb,
|
|
|
|
flow_dv_dest_array_clone_free_cb);
|
|
|
|
if (!sh->dest_array_list)
|
|
|
|
goto error;
|
2021-11-02 08:53:43 +00:00
|
|
|
/* Init shared flex parsers list, no need lcore_share */
|
|
|
|
snprintf(s, sizeof(s), "%s_flex_parsers_list", sh->ibdev_name);
|
|
|
|
sh->flex_parsers_dv = mlx5_list_create(s, sh, false,
|
|
|
|
mlx5_flex_parser_create_cb,
|
|
|
|
mlx5_flex_parser_match_cb,
|
|
|
|
mlx5_flex_parser_remove_cb,
|
|
|
|
mlx5_flex_parser_clone_cb,
|
|
|
|
mlx5_flex_parser_clone_free_cb);
|
|
|
|
if (!sh->flex_parsers_dv)
|
|
|
|
goto error;
|
2020-10-28 09:33:34 +00:00
|
|
|
#endif
|
2020-06-03 15:06:00 +00:00
|
|
|
#ifdef HAVE_MLX5DV_DR
|
|
|
|
void *domain;
|
|
|
|
|
|
|
|
/* Reference counter is zero, we should initialize structures. */
|
2021-10-19 20:55:52 +00:00
|
|
|
domain = mlx5_glue->dr_create_domain(sh->cdev->ctx,
|
2020-06-03 15:06:00 +00:00
|
|
|
MLX5DV_DR_DOMAIN_TYPE_NIC_RX);
|
|
|
|
if (!domain) {
|
|
|
|
DRV_LOG(ERR, "ingress mlx5dv_dr_create_domain failed");
|
|
|
|
err = errno;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
sh->rx_domain = domain;
|
2021-10-19 20:55:52 +00:00
|
|
|
domain = mlx5_glue->dr_create_domain(sh->cdev->ctx,
|
2020-06-03 15:06:00 +00:00
|
|
|
MLX5DV_DR_DOMAIN_TYPE_NIC_TX);
|
|
|
|
if (!domain) {
|
|
|
|
DRV_LOG(ERR, "egress mlx5dv_dr_create_domain failed");
|
|
|
|
err = errno;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
sh->tx_domain = domain;
|
|
|
|
#ifdef HAVE_MLX5DV_DR_ESWITCH
|
2022-02-14 09:35:07 +00:00
|
|
|
if (sh->config.dv_esw_en) {
|
2021-10-19 20:55:52 +00:00
|
|
|
domain = mlx5_glue->dr_create_domain(sh->cdev->ctx,
|
|
|
|
MLX5DV_DR_DOMAIN_TYPE_FDB);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!domain) {
|
|
|
|
DRV_LOG(ERR, "FDB mlx5dv_dr_create_domain failed");
|
|
|
|
err = errno;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
sh->fdb_domain = domain;
|
2021-04-05 09:59:01 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* The drop action is just some dummy placeholder in rdma-core. It
|
|
|
|
* does not belong to domains and has no any attributes, and, can be
|
|
|
|
* shared by the entire device.
|
|
|
|
*/
|
|
|
|
sh->dr_drop_action = mlx5_glue->dr_create_flow_action_drop();
|
|
|
|
if (!sh->dr_drop_action) {
|
|
|
|
DRV_LOG(ERR, "FDB mlx5dv_dr_create_flow_action_drop");
|
|
|
|
err = errno;
|
|
|
|
goto error;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
#endif
|
2022-02-14 09:35:07 +00:00
|
|
|
if (!sh->tunnel_hub && sh->config.dv_miss_info)
|
2020-10-25 14:08:09 +00:00
|
|
|
err = mlx5_alloc_tunnel_hub(sh);
|
|
|
|
if (err) {
|
|
|
|
DRV_LOG(ERR, "mlx5_alloc_tunnel_hub failed err=%d", err);
|
|
|
|
goto error;
|
|
|
|
}
|
2022-02-14 09:35:07 +00:00
|
|
|
if (sh->config.reclaim_mode == MLX5_RCM_AGGR) {
|
2020-06-03 15:06:00 +00:00
|
|
|
mlx5_glue->dr_reclaim_domain_memory(sh->rx_domain, 1);
|
|
|
|
mlx5_glue->dr_reclaim_domain_memory(sh->tx_domain, 1);
|
|
|
|
if (sh->fdb_domain)
|
|
|
|
mlx5_glue->dr_reclaim_domain_memory(sh->fdb_domain, 1);
|
|
|
|
}
|
|
|
|
sh->pop_vlan_action = mlx5_glue->dr_create_flow_action_pop_vlan();
|
2022-02-14 09:35:07 +00:00
|
|
|
if (!sh->config.allow_duplicate_pattern) {
|
2021-07-06 08:12:27 +00:00
|
|
|
#ifndef HAVE_MLX5_DR_ALLOW_DUPLICATE
|
|
|
|
DRV_LOG(WARNING, "Disallow duplicate pattern is not supported - maybe old rdma-core version?");
|
|
|
|
#endif
|
|
|
|
mlx5_glue->dr_allow_duplicate_rules(sh->rx_domain, 0);
|
|
|
|
mlx5_glue->dr_allow_duplicate_rules(sh->tx_domain, 0);
|
|
|
|
if (sh->fdb_domain)
|
|
|
|
mlx5_glue->dr_allow_duplicate_rules(sh->fdb_domain, 0);
|
|
|
|
}
|
2021-07-13 12:09:19 +00:00
|
|
|
|
|
|
|
__mlx5_discovery_misc5_cap(priv);
|
2020-06-03 15:06:00 +00:00
|
|
|
#endif /* HAVE_MLX5DV_DR */
|
2020-10-28 09:33:29 +00:00
|
|
|
sh->default_miss_action =
|
|
|
|
mlx5_glue->dr_create_flow_action_default_miss();
|
|
|
|
if (!sh->default_miss_action)
|
|
|
|
DRV_LOG(WARNING, "Default miss action is not supported.");
|
2021-11-04 12:33:19 +00:00
|
|
|
LIST_INIT(&sh->shared_rxqs);
|
2020-06-03 15:06:00 +00:00
|
|
|
return 0;
|
|
|
|
error:
|
|
|
|
/* Rollback the created objects. */
|
|
|
|
if (sh->rx_domain) {
|
|
|
|
mlx5_glue->dr_destroy_domain(sh->rx_domain);
|
|
|
|
sh->rx_domain = NULL;
|
|
|
|
}
|
|
|
|
if (sh->tx_domain) {
|
|
|
|
mlx5_glue->dr_destroy_domain(sh->tx_domain);
|
|
|
|
sh->tx_domain = NULL;
|
|
|
|
}
|
|
|
|
if (sh->fdb_domain) {
|
|
|
|
mlx5_glue->dr_destroy_domain(sh->fdb_domain);
|
|
|
|
sh->fdb_domain = NULL;
|
|
|
|
}
|
2021-04-05 09:59:01 +00:00
|
|
|
if (sh->dr_drop_action) {
|
|
|
|
mlx5_glue->destroy_flow_action(sh->dr_drop_action);
|
|
|
|
sh->dr_drop_action = NULL;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
if (sh->pop_vlan_action) {
|
|
|
|
mlx5_glue->destroy_flow_action(sh->pop_vlan_action);
|
|
|
|
sh->pop_vlan_action = NULL;
|
|
|
|
}
|
2020-09-16 10:19:48 +00:00
|
|
|
if (sh->encaps_decaps) {
|
2020-10-28 09:33:31 +00:00
|
|
|
mlx5_hlist_destroy(sh->encaps_decaps);
|
2020-09-16 10:19:48 +00:00
|
|
|
sh->encaps_decaps = NULL;
|
|
|
|
}
|
2020-07-31 03:34:18 +00:00
|
|
|
if (sh->modify_cmds) {
|
2020-10-28 09:33:31 +00:00
|
|
|
mlx5_hlist_destroy(sh->modify_cmds);
|
2020-07-31 03:34:18 +00:00
|
|
|
sh->modify_cmds = NULL;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
if (sh->tag_table) {
|
|
|
|
/* tags should be destroyed with flow before. */
|
2020-10-28 09:33:31 +00:00
|
|
|
mlx5_hlist_destroy(sh->tag_table);
|
2020-06-03 15:06:00 +00:00
|
|
|
sh->tag_table = NULL;
|
|
|
|
}
|
2020-10-25 14:08:09 +00:00
|
|
|
if (sh->tunnel_hub) {
|
|
|
|
mlx5_release_tunnel_hub(sh, priv->dev_port);
|
|
|
|
sh->tunnel_hub = NULL;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
mlx5_free_table_hash_list(priv);
|
2021-07-13 08:44:46 +00:00
|
|
|
if (sh->port_id_action_list) {
|
|
|
|
mlx5_list_destroy(sh->port_id_action_list);
|
|
|
|
sh->port_id_action_list = NULL;
|
|
|
|
}
|
|
|
|
if (sh->push_vlan_action_list) {
|
|
|
|
mlx5_list_destroy(sh->push_vlan_action_list);
|
|
|
|
sh->push_vlan_action_list = NULL;
|
|
|
|
}
|
|
|
|
if (sh->sample_action_list) {
|
|
|
|
mlx5_list_destroy(sh->sample_action_list);
|
|
|
|
sh->sample_action_list = NULL;
|
|
|
|
}
|
|
|
|
if (sh->dest_array_list) {
|
|
|
|
mlx5_list_destroy(sh->dest_array_list);
|
|
|
|
sh->dest_array_list = NULL;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Destroy DR related data within private structure.
|
|
|
|
*
|
|
|
|
* @param[in] priv
|
|
|
|
* Pointer to the private device data structure.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
mlx5_os_free_shared_dr(struct mlx5_priv *priv)
|
|
|
|
{
|
2020-10-21 11:15:23 +00:00
|
|
|
struct mlx5_dev_ctx_shared *sh = priv->sh;
|
2020-06-03 15:06:00 +00:00
|
|
|
|
2020-10-21 11:15:23 +00:00
|
|
|
MLX5_ASSERT(sh && sh->refcnt);
|
|
|
|
if (sh->refcnt > 1)
|
2020-06-03 15:06:00 +00:00
|
|
|
return;
|
2021-11-04 12:33:19 +00:00
|
|
|
MLX5_ASSERT(LIST_EMPTY(&sh->shared_rxqs));
|
2020-06-03 15:06:00 +00:00
|
|
|
#ifdef HAVE_MLX5DV_DR
|
|
|
|
if (sh->rx_domain) {
|
|
|
|
mlx5_glue->dr_destroy_domain(sh->rx_domain);
|
|
|
|
sh->rx_domain = NULL;
|
|
|
|
}
|
|
|
|
if (sh->tx_domain) {
|
|
|
|
mlx5_glue->dr_destroy_domain(sh->tx_domain);
|
|
|
|
sh->tx_domain = NULL;
|
|
|
|
}
|
|
|
|
#ifdef HAVE_MLX5DV_DR_ESWITCH
|
|
|
|
if (sh->fdb_domain) {
|
|
|
|
mlx5_glue->dr_destroy_domain(sh->fdb_domain);
|
|
|
|
sh->fdb_domain = NULL;
|
|
|
|
}
|
2021-04-05 09:59:01 +00:00
|
|
|
if (sh->dr_drop_action) {
|
|
|
|
mlx5_glue->destroy_flow_action(sh->dr_drop_action);
|
|
|
|
sh->dr_drop_action = NULL;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (sh->pop_vlan_action) {
|
|
|
|
mlx5_glue->destroy_flow_action(sh->pop_vlan_action);
|
|
|
|
sh->pop_vlan_action = NULL;
|
|
|
|
}
|
2022-10-19 18:40:06 +00:00
|
|
|
if (sh->send_to_kernel_action.action) {
|
|
|
|
void *action = sh->send_to_kernel_action.action;
|
|
|
|
|
|
|
|
mlx5_glue->destroy_flow_action(action);
|
|
|
|
sh->send_to_kernel_action.action = NULL;
|
|
|
|
}
|
|
|
|
if (sh->send_to_kernel_action.tbl) {
|
|
|
|
struct mlx5_flow_tbl_resource *tbl =
|
|
|
|
sh->send_to_kernel_action.tbl;
|
|
|
|
|
|
|
|
flow_dv_tbl_resource_release(sh, tbl);
|
|
|
|
sh->send_to_kernel_action.tbl = NULL;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
#endif /* HAVE_MLX5DV_DR */
|
2020-10-28 09:33:29 +00:00
|
|
|
if (sh->default_miss_action)
|
|
|
|
mlx5_glue->destroy_flow_action
|
|
|
|
(sh->default_miss_action);
|
2020-09-16 10:19:48 +00:00
|
|
|
if (sh->encaps_decaps) {
|
2020-10-28 09:33:31 +00:00
|
|
|
mlx5_hlist_destroy(sh->encaps_decaps);
|
2020-09-16 10:19:48 +00:00
|
|
|
sh->encaps_decaps = NULL;
|
|
|
|
}
|
2020-07-31 03:34:18 +00:00
|
|
|
if (sh->modify_cmds) {
|
2020-10-28 09:33:31 +00:00
|
|
|
mlx5_hlist_destroy(sh->modify_cmds);
|
2020-07-31 03:34:18 +00:00
|
|
|
sh->modify_cmds = NULL;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
if (sh->tag_table) {
|
|
|
|
/* tags should be destroyed with flow before. */
|
2020-10-28 09:33:31 +00:00
|
|
|
mlx5_hlist_destroy(sh->tag_table);
|
2020-06-03 15:06:00 +00:00
|
|
|
sh->tag_table = NULL;
|
|
|
|
}
|
2020-10-25 14:08:09 +00:00
|
|
|
if (sh->tunnel_hub) {
|
|
|
|
mlx5_release_tunnel_hub(sh, priv->dev_port);
|
|
|
|
sh->tunnel_hub = NULL;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
mlx5_free_table_hash_list(priv);
|
2021-07-13 08:44:46 +00:00
|
|
|
if (sh->port_id_action_list) {
|
|
|
|
mlx5_list_destroy(sh->port_id_action_list);
|
|
|
|
sh->port_id_action_list = NULL;
|
|
|
|
}
|
|
|
|
if (sh->push_vlan_action_list) {
|
|
|
|
mlx5_list_destroy(sh->push_vlan_action_list);
|
|
|
|
sh->push_vlan_action_list = NULL;
|
|
|
|
}
|
|
|
|
if (sh->sample_action_list) {
|
|
|
|
mlx5_list_destroy(sh->sample_action_list);
|
|
|
|
sh->sample_action_list = NULL;
|
|
|
|
}
|
|
|
|
if (sh->dest_array_list) {
|
|
|
|
mlx5_list_destroy(sh->dest_array_list);
|
|
|
|
sh->dest_array_list = NULL;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
|
2020-07-19 10:18:15 +00:00
|
|
|
/**
|
|
|
|
* Initialize shared data between primary and secondary process.
|
|
|
|
*
|
|
|
|
* A memzone is reserved by primary process and secondary processes attach to
|
|
|
|
* the memzone.
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on success, a negative errno value otherwise and rte_errno is set.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
mlx5_init_shared_data(void)
|
|
|
|
{
|
|
|
|
const struct rte_memzone *mz;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
rte_spinlock_lock(&mlx5_shared_data_lock);
|
|
|
|
if (mlx5_shared_data == NULL) {
|
|
|
|
if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
|
|
|
|
/* Allocate shared memory. */
|
|
|
|
mz = rte_memzone_reserve(MZ_MLX5_PMD_SHARED_DATA,
|
|
|
|
sizeof(*mlx5_shared_data),
|
|
|
|
SOCKET_ID_ANY, 0);
|
|
|
|
if (mz == NULL) {
|
|
|
|
DRV_LOG(ERR,
|
|
|
|
"Cannot allocate mlx5 shared data");
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
mlx5_shared_data = mz->addr;
|
|
|
|
memset(mlx5_shared_data, 0, sizeof(*mlx5_shared_data));
|
|
|
|
rte_spinlock_init(&mlx5_shared_data->lock);
|
|
|
|
} else {
|
|
|
|
/* Lookup allocated shared memory. */
|
|
|
|
mz = rte_memzone_lookup(MZ_MLX5_PMD_SHARED_DATA);
|
|
|
|
if (mz == NULL) {
|
|
|
|
DRV_LOG(ERR,
|
|
|
|
"Cannot attach mlx5 shared data");
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
mlx5_shared_data = mz->addr;
|
|
|
|
memset(&mlx5_local_data, 0, sizeof(mlx5_local_data));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
error:
|
|
|
|
rte_spinlock_unlock(&mlx5_shared_data_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* PMD global initialization.
|
|
|
|
*
|
|
|
|
* Independent from individual device, this function initializes global
|
|
|
|
* per-PMD data structures distinguishing primary and secondary processes.
|
|
|
|
* Hence, each initialization is called once per a process.
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on success, a negative errno value otherwise and rte_errno is set.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
mlx5_init_once(void)
|
|
|
|
{
|
|
|
|
struct mlx5_shared_data *sd;
|
|
|
|
struct mlx5_local_data *ld = &mlx5_local_data;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (mlx5_init_shared_data())
|
|
|
|
return -rte_errno;
|
|
|
|
sd = mlx5_shared_data;
|
|
|
|
MLX5_ASSERT(sd);
|
|
|
|
rte_spinlock_lock(&sd->lock);
|
|
|
|
switch (rte_eal_process_type()) {
|
|
|
|
case RTE_PROC_PRIMARY:
|
|
|
|
if (sd->init_done)
|
|
|
|
break;
|
|
|
|
ret = mlx5_mp_init_primary(MLX5_MP_NAME,
|
|
|
|
mlx5_mp_os_primary_handle);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
sd->init_done = true;
|
|
|
|
break;
|
|
|
|
case RTE_PROC_SECONDARY:
|
|
|
|
if (ld->init_done)
|
|
|
|
break;
|
|
|
|
ret = mlx5_mp_init_secondary(MLX5_MP_NAME,
|
|
|
|
mlx5_mp_os_secondary_handle);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
++sd->secondary_cnt;
|
|
|
|
ld->init_done = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
rte_spinlock_unlock(&sd->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-08-02 14:30:24 +00:00
|
|
|
/**
|
|
|
|
* DR flow drop action support detect.
|
|
|
|
*
|
|
|
|
* @param dev
|
|
|
|
* Pointer to rte_eth_dev structure.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
mlx5_flow_drop_action_config(struct rte_eth_dev *dev __rte_unused)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_MLX5DV_DR
|
|
|
|
struct mlx5_priv *priv = dev->data->dev_private;
|
|
|
|
|
2022-02-14 09:35:07 +00:00
|
|
|
if (!priv->sh->config.dv_flow_en || !priv->sh->dr_drop_action)
|
2021-08-02 14:30:24 +00:00
|
|
|
return;
|
|
|
|
/**
|
|
|
|
* DR supports drop action placeholder when it is supported;
|
|
|
|
* otherwise, use the queue drop action.
|
|
|
|
*/
|
2021-10-27 10:35:10 +00:00
|
|
|
if (!priv->sh->drop_action_check_flag) {
|
|
|
|
if (!mlx5_flow_discover_dr_action_support(dev))
|
|
|
|
priv->sh->dr_drop_action_en = 1;
|
|
|
|
priv->sh->drop_action_check_flag = 1;
|
|
|
|
}
|
|
|
|
if (priv->sh->dr_drop_action_en)
|
2021-08-02 14:30:24 +00:00
|
|
|
priv->root_drop_action = priv->sh->dr_drop_action;
|
2021-10-27 10:35:10 +00:00
|
|
|
else
|
|
|
|
priv->root_drop_action = priv->drop_queue.hrxq->action;
|
2021-08-02 14:30:24 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2021-02-25 10:45:01 +00:00
|
|
|
static void
|
|
|
|
mlx5_queue_counter_id_prepare(struct rte_eth_dev *dev)
|
|
|
|
{
|
|
|
|
struct mlx5_priv *priv = dev->data->dev_private;
|
2021-10-19 20:55:52 +00:00
|
|
|
void *ctx = priv->sh->cdev->ctx;
|
2021-02-25 10:45:01 +00:00
|
|
|
|
|
|
|
priv->q_counters = mlx5_devx_cmd_queue_counter_alloc(ctx);
|
|
|
|
if (!priv->q_counters) {
|
|
|
|
struct ibv_cq *cq = mlx5_glue->create_cq(ctx, 1, NULL, NULL, 0);
|
|
|
|
struct ibv_wq *wq;
|
|
|
|
|
|
|
|
DRV_LOG(DEBUG, "Port %d queue counter object cannot be created "
|
|
|
|
"by DevX - fall-back to use the kernel driver global "
|
|
|
|
"queue counter.", dev->data->port_id);
|
|
|
|
/* Create WQ by kernel and query its queue counter ID. */
|
|
|
|
if (cq) {
|
|
|
|
wq = mlx5_glue->create_wq(ctx,
|
|
|
|
&(struct ibv_wq_init_attr){
|
|
|
|
.wq_type = IBV_WQT_RQ,
|
|
|
|
.max_wr = 1,
|
|
|
|
.max_sge = 1,
|
2021-10-19 20:55:54 +00:00
|
|
|
.pd = priv->sh->cdev->pd,
|
2021-02-25 10:45:01 +00:00
|
|
|
.cq = cq,
|
|
|
|
});
|
|
|
|
if (wq) {
|
|
|
|
/* Counter is assigned only on RDY state. */
|
|
|
|
int ret = mlx5_glue->modify_wq(wq,
|
|
|
|
&(struct ibv_wq_attr){
|
|
|
|
.attr_mask = IBV_WQ_ATTR_STATE,
|
|
|
|
.wq_state = IBV_WQS_RDY,
|
|
|
|
});
|
|
|
|
|
|
|
|
if (ret == 0)
|
|
|
|
mlx5_devx_cmd_wq_query(wq,
|
|
|
|
&priv->counter_set_id);
|
|
|
|
claim_zero(mlx5_glue->destroy_wq(wq));
|
|
|
|
}
|
|
|
|
claim_zero(mlx5_glue->destroy_cq(cq));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
priv->counter_set_id = priv->q_counters->id;
|
|
|
|
}
|
|
|
|
if (priv->counter_set_id == 0)
|
|
|
|
DRV_LOG(INFO, "Part of the port %d statistics will not be "
|
|
|
|
"available.", dev->data->port_id);
|
|
|
|
}
|
|
|
|
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
/**
|
|
|
|
* Check if representor spawn info match devargs.
|
|
|
|
*
|
|
|
|
* @param spawn
|
|
|
|
* Verbs device parameters (name, port, switch_info) to spawn.
|
|
|
|
* @param eth_da
|
|
|
|
* Device devargs to probe.
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* Match result.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
mlx5_representor_match(struct mlx5_dev_spawn_data *spawn,
|
|
|
|
struct rte_eth_devargs *eth_da)
|
|
|
|
{
|
|
|
|
struct mlx5_switch_info *switch_info = &spawn->info;
|
|
|
|
unsigned int p, f;
|
|
|
|
uint16_t id;
|
2021-03-28 13:48:15 +00:00
|
|
|
uint16_t repr_id = mlx5_representor_id_encode(switch_info,
|
|
|
|
eth_da->type);
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
|
|
|
|
switch (eth_da->type) {
|
|
|
|
case RTE_ETH_REPRESENTOR_SF:
|
2021-03-28 13:48:15 +00:00
|
|
|
if (!(spawn->info.port_name == -1 &&
|
|
|
|
switch_info->name_type ==
|
|
|
|
MLX5_PHYS_PORT_NAME_TYPE_PFHPF) &&
|
|
|
|
switch_info->name_type != MLX5_PHYS_PORT_NAME_TYPE_PFSF) {
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
rte_errno = EBUSY;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RTE_ETH_REPRESENTOR_VF:
|
|
|
|
/* Allows HPF representor index -1 as exception. */
|
|
|
|
if (!(spawn->info.port_name == -1 &&
|
|
|
|
switch_info->name_type ==
|
|
|
|
MLX5_PHYS_PORT_NAME_TYPE_PFHPF) &&
|
|
|
|
switch_info->name_type != MLX5_PHYS_PORT_NAME_TYPE_PFVF) {
|
|
|
|
rte_errno = EBUSY;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RTE_ETH_REPRESENTOR_NONE:
|
|
|
|
rte_errno = EBUSY;
|
|
|
|
return false;
|
|
|
|
default:
|
|
|
|
rte_errno = ENOTSUP;
|
|
|
|
DRV_LOG(ERR, "unsupported representor type");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
/* Check representor ID: */
|
|
|
|
for (p = 0; p < eth_da->nb_ports; ++p) {
|
|
|
|
if (spawn->pf_bond < 0) {
|
|
|
|
/* For non-LAG mode, allow and ignore pf. */
|
|
|
|
switch_info->pf_num = eth_da->ports[p];
|
2021-03-28 13:48:15 +00:00
|
|
|
repr_id = mlx5_representor_id_encode(switch_info,
|
|
|
|
eth_da->type);
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
}
|
|
|
|
for (f = 0; f < eth_da->nb_representor_ports; ++f) {
|
|
|
|
id = MLX5_REPRESENTOR_ID
|
|
|
|
(eth_da->ports[p], eth_da->type,
|
|
|
|
eth_da->representor_ports[f]);
|
|
|
|
if (repr_id == id)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rte_errno = EBUSY;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-06-03 15:06:00 +00:00
|
|
|
/**
|
|
|
|
* Spawn an Ethernet device from Verbs information.
|
|
|
|
*
|
|
|
|
* @param dpdk_dev
|
|
|
|
* Backing DPDK device.
|
|
|
|
* @param spawn
|
|
|
|
* Verbs device parameters (name, port, switch_info) to spawn.
|
2021-10-19 20:55:50 +00:00
|
|
|
* @param eth_da
|
2021-03-28 13:48:08 +00:00
|
|
|
* Device arguments.
|
2022-02-14 09:35:11 +00:00
|
|
|
* @param mkvlist
|
|
|
|
* Pointer to mlx5 kvargs control, can be NULL if there is no devargs.
|
2020-06-03 15:06:00 +00:00
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* A valid Ethernet device object on success, NULL otherwise and rte_errno
|
|
|
|
* is set. The following errors are defined:
|
|
|
|
*
|
|
|
|
* EBUSY: device is not supposed to be spawned.
|
|
|
|
* EEXIST: device is already spawned
|
|
|
|
*/
|
|
|
|
static struct rte_eth_dev *
|
|
|
|
mlx5_dev_spawn(struct rte_device *dpdk_dev,
|
|
|
|
struct mlx5_dev_spawn_data *spawn,
|
2022-02-14 09:35:11 +00:00
|
|
|
struct rte_eth_devargs *eth_da,
|
|
|
|
struct mlx5_kvargs_ctrl *mkvlist)
|
2020-06-03 15:06:00 +00:00
|
|
|
{
|
|
|
|
const struct mlx5_switch_info *switch_info = &spawn->info;
|
|
|
|
struct mlx5_dev_ctx_shared *sh = NULL;
|
2021-10-19 10:34:55 +00:00
|
|
|
struct ibv_port_attr port_attr = { .state = IBV_PORT_NOP };
|
2020-06-03 15:06:00 +00:00
|
|
|
struct rte_eth_dev *eth_dev = NULL;
|
|
|
|
struct mlx5_priv *priv = NULL;
|
|
|
|
int err = 0;
|
|
|
|
struct rte_ether_addr mac;
|
|
|
|
char name[RTE_ETH_NAME_MAX_LEN];
|
|
|
|
int own_domain_id = 0;
|
|
|
|
uint16_t port_id;
|
2021-07-07 15:54:27 +00:00
|
|
|
struct mlx5_port_info vport_info = { .query_flags = 0 };
|
2022-02-14 09:35:09 +00:00
|
|
|
int nl_rdma;
|
2021-07-13 08:44:39 +00:00
|
|
|
int i;
|
2020-06-03 15:06:00 +00:00
|
|
|
|
|
|
|
/* Determine if this port representor is supposed to be spawned. */
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
if (switch_info->representor && dpdk_dev->devargs &&
|
|
|
|
!mlx5_representor_match(spawn, eth_da))
|
|
|
|
return NULL;
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Build device name. */
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
if (spawn->pf_bond < 0) {
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Single device. */
|
|
|
|
if (!switch_info->representor)
|
|
|
|
strlcpy(name, dpdk_dev->name, sizeof(name));
|
|
|
|
else
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
err = snprintf(name, sizeof(name), "%s_representor_%s%u",
|
2021-03-28 13:48:08 +00:00
|
|
|
dpdk_dev->name,
|
|
|
|
switch_info->name_type ==
|
|
|
|
MLX5_PHYS_PORT_NAME_TYPE_PFSF ? "sf" : "vf",
|
|
|
|
switch_info->port_name);
|
2020-06-03 15:06:00 +00:00
|
|
|
} else {
|
|
|
|
/* Bonding device. */
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
if (!switch_info->representor) {
|
|
|
|
err = snprintf(name, sizeof(name), "%s_%s",
|
2021-10-19 20:55:50 +00:00
|
|
|
dpdk_dev->name, spawn->phys_dev_name);
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
} else {
|
|
|
|
err = snprintf(name, sizeof(name), "%s_%s_representor_c%dpf%d%s%u",
|
2021-10-19 20:55:50 +00:00
|
|
|
dpdk_dev->name, spawn->phys_dev_name,
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
switch_info->ctrl_num,
|
|
|
|
switch_info->pf_num,
|
|
|
|
switch_info->name_type ==
|
|
|
|
MLX5_PHYS_PORT_NAME_TYPE_PFSF ? "sf" : "vf",
|
|
|
|
switch_info->port_name);
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
if (err >= (int)sizeof(name))
|
|
|
|
DRV_LOG(WARNING, "device name overflow %s", name);
|
2020-06-03 15:06:00 +00:00
|
|
|
/* check if the device is already spawned */
|
|
|
|
if (rte_eth_dev_get_port_by_name(name, &port_id) == 0) {
|
2022-02-14 09:35:11 +00:00
|
|
|
/*
|
|
|
|
* When device is already spawned, its devargs should be set
|
|
|
|
* as used. otherwise, mlx5_kvargs_validate() will fail.
|
|
|
|
*/
|
|
|
|
if (mkvlist)
|
|
|
|
mlx5_port_args_set_used(name, port_id, mkvlist);
|
2020-06-03 15:06:00 +00:00
|
|
|
rte_errno = EEXIST;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
DRV_LOG(DEBUG, "naming Ethernet device \"%s\"", name);
|
|
|
|
if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
|
|
|
|
struct mlx5_mp_id mp_id;
|
2022-07-06 17:48:53 +00:00
|
|
|
int fd;
|
2020-06-03 15:06:00 +00:00
|
|
|
|
|
|
|
eth_dev = rte_eth_dev_attach_secondary(name);
|
|
|
|
if (eth_dev == NULL) {
|
|
|
|
DRV_LOG(ERR, "can not attach rte ethdev");
|
|
|
|
rte_errno = ENOMEM;
|
|
|
|
return NULL;
|
|
|
|
}
|
2021-03-28 13:48:09 +00:00
|
|
|
eth_dev->device = dpdk_dev;
|
2020-12-28 12:32:56 +00:00
|
|
|
eth_dev->dev_ops = &mlx5_dev_sec_ops;
|
2020-09-09 13:01:43 +00:00
|
|
|
eth_dev->rx_descriptor_status = mlx5_rx_descriptor_status;
|
|
|
|
eth_dev->tx_descriptor_status = mlx5_tx_descriptor_status;
|
2020-06-03 15:06:00 +00:00
|
|
|
err = mlx5_proc_priv_init(eth_dev);
|
|
|
|
if (err)
|
|
|
|
return NULL;
|
2021-10-18 22:43:53 +00:00
|
|
|
mlx5_mp_id_init(&mp_id, eth_dev->data->port_id);
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Receive command fd from primary process */
|
2022-07-06 17:48:53 +00:00
|
|
|
fd = mlx5_mp_req_verbs_cmd_fd(&mp_id);
|
|
|
|
if (fd < 0)
|
2020-06-03 15:06:00 +00:00
|
|
|
goto err_secondary;
|
|
|
|
/* Remap UAR for Tx queues. */
|
2022-07-06 17:48:53 +00:00
|
|
|
err = mlx5_tx_uar_init_secondary(eth_dev, fd);
|
|
|
|
close(fd);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (err)
|
|
|
|
goto err_secondary;
|
|
|
|
/*
|
|
|
|
* Ethdev pointer is still required as input since
|
|
|
|
* the primary device is not accessible from the
|
|
|
|
* secondary process.
|
|
|
|
*/
|
|
|
|
eth_dev->rx_pkt_burst = mlx5_select_rx_function(eth_dev);
|
|
|
|
eth_dev->tx_pkt_burst = mlx5_select_tx_function(eth_dev);
|
|
|
|
return eth_dev;
|
|
|
|
err_secondary:
|
|
|
|
mlx5_dev_close(eth_dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
2022-02-14 09:35:11 +00:00
|
|
|
sh = mlx5_alloc_shared_dev_ctx(spawn, mkvlist);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!sh)
|
|
|
|
return NULL;
|
2022-03-01 12:15:12 +00:00
|
|
|
nl_rdma = mlx5_nl_init(NETLINK_RDMA, 0);
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Check port status. */
|
2021-10-19 10:34:55 +00:00
|
|
|
if (spawn->phys_port <= UINT8_MAX) {
|
|
|
|
/* Legacy Verbs api only support u8 port number. */
|
|
|
|
err = mlx5_glue->query_port(sh->cdev->ctx, spawn->phys_port,
|
|
|
|
&port_attr);
|
|
|
|
if (err) {
|
|
|
|
DRV_LOG(ERR, "port query failed: %s", strerror(err));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (port_attr.link_layer != IBV_LINK_LAYER_ETHERNET) {
|
|
|
|
DRV_LOG(ERR, "port is not configured in Ethernet mode");
|
|
|
|
err = EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else if (nl_rdma >= 0) {
|
|
|
|
/* IB doesn't allow more than 255 ports, must be Ethernet. */
|
|
|
|
err = mlx5_nl_port_state(nl_rdma,
|
|
|
|
spawn->phys_dev_name,
|
|
|
|
spawn->phys_port);
|
|
|
|
if (err < 0) {
|
|
|
|
DRV_LOG(INFO, "Failed to get netlink port state: %s",
|
|
|
|
strerror(rte_errno));
|
|
|
|
err = -rte_errno;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
port_attr.state = (enum ibv_port_state)err;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
if (port_attr.state != IBV_PORT_ACTIVE)
|
2021-10-19 10:34:55 +00:00
|
|
|
DRV_LOG(INFO, "port is not active: \"%s\" (%d)",
|
2020-06-03 15:06:00 +00:00
|
|
|
mlx5_glue->port_state_str(port_attr.state),
|
|
|
|
port_attr.state);
|
|
|
|
/* Allocate private eth device data. */
|
2020-06-28 09:02:44 +00:00
|
|
|
priv = mlx5_malloc(MLX5_MEM_ZERO | MLX5_MEM_RTE,
|
2020-06-03 15:06:00 +00:00
|
|
|
sizeof(*priv),
|
2020-06-28 09:02:44 +00:00
|
|
|
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (priv == NULL) {
|
|
|
|
DRV_LOG(ERR, "priv allocation failure");
|
|
|
|
err = ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
2022-02-24 23:25:10 +00:00
|
|
|
/*
|
|
|
|
* When user configures remote PD and CTX and device creates RxQ by
|
|
|
|
* DevX, external RxQ is both supported and requested.
|
|
|
|
*/
|
|
|
|
if (mlx5_imported_pd_and_ctx(sh->cdev) && mlx5_devx_obj_ops_en(sh)) {
|
|
|
|
priv->ext_rxqs = mlx5_malloc(MLX5_MEM_ZERO | MLX5_MEM_RTE,
|
|
|
|
sizeof(struct mlx5_external_rxq) *
|
|
|
|
MLX5_MAX_EXT_RX_QUEUES, 0,
|
|
|
|
SOCKET_ID_ANY);
|
|
|
|
if (priv->ext_rxqs == NULL) {
|
|
|
|
DRV_LOG(ERR, "Fail to allocate external RxQ array.");
|
|
|
|
err = ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
DRV_LOG(DEBUG, "External RxQ is supported.");
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
priv->sh = sh;
|
2020-06-10 09:32:27 +00:00
|
|
|
priv->dev_port = spawn->phys_port;
|
2020-06-03 15:06:00 +00:00
|
|
|
priv->pci_dev = spawn->pci_dev;
|
|
|
|
priv->mtu = RTE_ETHER_MTU;
|
|
|
|
/* Some internal functions rely on Netlink sockets, open them now. */
|
2021-10-19 10:34:55 +00:00
|
|
|
priv->nl_socket_rdma = nl_rdma;
|
2022-03-01 12:15:12 +00:00
|
|
|
priv->nl_socket_route = mlx5_nl_init(NETLINK_ROUTE, 0);
|
2020-06-03 15:06:00 +00:00
|
|
|
priv->representor = !!switch_info->representor;
|
|
|
|
priv->master = !!switch_info->master;
|
|
|
|
priv->domain_id = RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID;
|
|
|
|
priv->vport_meta_tag = 0;
|
|
|
|
priv->vport_meta_mask = 0;
|
|
|
|
priv->pf_bond = spawn->pf_bond;
|
2021-08-02 14:55:24 +00:00
|
|
|
|
|
|
|
DRV_LOG(DEBUG,
|
|
|
|
"dev_port=%u bus=%s pci=%s master=%d representor=%d pf_bond=%d\n",
|
|
|
|
priv->dev_port, dpdk_dev->bus->name,
|
|
|
|
priv->pci_dev ? priv->pci_dev->name : "NONE",
|
|
|
|
priv->master, priv->representor, priv->pf_bond);
|
|
|
|
|
2020-06-03 15:06:00 +00:00
|
|
|
/*
|
2021-07-07 15:54:27 +00:00
|
|
|
* If we have E-Switch we should determine the vport attributes.
|
|
|
|
* E-Switch may use either source vport field or reg_c[0] metadata
|
|
|
|
* register to match on vport index. The engaged part of metadata
|
|
|
|
* register is defined by mask.
|
2020-06-03 15:06:00 +00:00
|
|
|
*/
|
2022-02-14 09:35:04 +00:00
|
|
|
if (sh->esw_mode) {
|
2021-10-19 20:55:52 +00:00
|
|
|
err = mlx5_glue->devx_port_query(sh->cdev->ctx,
|
2021-07-07 15:54:27 +00:00
|
|
|
spawn->phys_port,
|
|
|
|
&vport_info);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (err) {
|
|
|
|
DRV_LOG(WARNING,
|
2021-10-19 20:55:50 +00:00
|
|
|
"Cannot query devx port %d on device %s",
|
|
|
|
spawn->phys_port, spawn->phys_dev_name);
|
2021-07-07 15:54:27 +00:00
|
|
|
vport_info.query_flags = 0;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
}
|
2021-07-07 15:54:27 +00:00
|
|
|
if (vport_info.query_flags & MLX5_PORT_QUERY_REG_C0) {
|
|
|
|
priv->vport_meta_tag = vport_info.vport_meta_tag;
|
|
|
|
priv->vport_meta_mask = vport_info.vport_meta_mask;
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!priv->vport_meta_mask) {
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(ERR,
|
|
|
|
"vport zero mask for port %d on bonding device %s",
|
|
|
|
spawn->phys_port, spawn->phys_dev_name);
|
2020-06-03 15:06:00 +00:00
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (priv->vport_meta_tag & ~priv->vport_meta_mask) {
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(ERR,
|
|
|
|
"Invalid vport tag for port %d on bonding device %s",
|
|
|
|
spawn->phys_port, spawn->phys_dev_name);
|
2020-06-03 15:06:00 +00:00
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
2021-07-07 15:54:27 +00:00
|
|
|
if (vport_info.query_flags & MLX5_PORT_QUERY_VPORT) {
|
|
|
|
priv->vport_id = vport_info.vport_id;
|
2022-02-14 09:35:04 +00:00
|
|
|
} else if (spawn->pf_bond >= 0 && sh->esw_mode) {
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(ERR,
|
|
|
|
"Cannot deduce vport index for port %d on bonding device %s",
|
|
|
|
spawn->phys_port, spawn->phys_dev_name);
|
2020-06-03 15:06:00 +00:00
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
} else {
|
2021-07-07 15:54:27 +00:00
|
|
|
/*
|
|
|
|
* Suppose vport index in compatible way. Kernel/rdma_core
|
|
|
|
* support single E-Switch per PF configurations only and
|
|
|
|
* vport_id field contains the vport index for associated VF,
|
|
|
|
* which is deduced from representor port name.
|
|
|
|
* For example, let's have the IB device port 10, it has
|
|
|
|
* attached network device eth0, which has port name attribute
|
|
|
|
* pf0vf2, we can deduce the VF number as 2, and set vport index
|
|
|
|
* as 3 (2+1). This assigning schema should be changed if the
|
|
|
|
* multiple E-Switch instances per PF configurations or/and PCI
|
|
|
|
* subfunctions are added.
|
|
|
|
*/
|
2020-06-03 15:06:00 +00:00
|
|
|
priv->vport_id = switch_info->representor ?
|
|
|
|
switch_info->port_name + 1 : -1;
|
|
|
|
}
|
2021-03-28 13:48:15 +00:00
|
|
|
priv->representor_id = mlx5_representor_id_encode(switch_info,
|
|
|
|
eth_da->type);
|
2020-06-03 15:06:00 +00:00
|
|
|
/*
|
|
|
|
* Look for sibling devices in order to reuse their switch domain
|
|
|
|
* if any, otherwise allocate one.
|
|
|
|
*/
|
2021-08-02 14:55:24 +00:00
|
|
|
MLX5_ETH_FOREACH_DEV(port_id, dpdk_dev) {
|
2020-06-03 15:06:00 +00:00
|
|
|
const struct mlx5_priv *opriv =
|
|
|
|
rte_eth_devices[port_id].data->dev_private;
|
|
|
|
|
|
|
|
if (!opriv ||
|
|
|
|
opriv->sh != priv->sh ||
|
|
|
|
opriv->domain_id ==
|
|
|
|
RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID)
|
|
|
|
continue;
|
|
|
|
priv->domain_id = opriv->domain_id;
|
2021-08-02 14:55:24 +00:00
|
|
|
DRV_LOG(DEBUG, "dev_port-%u inherit domain_id=%u\n",
|
|
|
|
priv->dev_port, priv->domain_id);
|
2020-06-03 15:06:00 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (priv->domain_id == RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID) {
|
|
|
|
err = rte_eth_switch_domain_alloc(&priv->domain_id);
|
|
|
|
if (err) {
|
|
|
|
err = rte_errno;
|
|
|
|
DRV_LOG(ERR, "unable to allocate switch domain: %s",
|
|
|
|
strerror(rte_errno));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
own_domain_id = 1;
|
2021-08-02 14:55:24 +00:00
|
|
|
DRV_LOG(DEBUG, "dev_port-%u new domain_id=%u\n",
|
|
|
|
priv->dev_port, priv->domain_id);
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
2022-02-14 09:34:59 +00:00
|
|
|
if (sh->cdev->config.devx) {
|
2022-02-14 09:35:09 +00:00
|
|
|
struct mlx5_hca_attr *hca_attr = &sh->cdev->config.hca_attr;
|
|
|
|
|
2022-02-14 09:34:58 +00:00
|
|
|
sh->steering_format_version = hca_attr->steering_format_version;
|
2021-04-20 10:55:19 +00:00
|
|
|
#if defined(HAVE_MLX5DV_DR) && \
|
|
|
|
(defined(HAVE_MLX5_DR_CREATE_ACTION_FLOW_METER) || \
|
|
|
|
defined(HAVE_MLX5_DR_CREATE_ACTION_ASO))
|
2022-02-14 09:34:58 +00:00
|
|
|
if (hca_attr->qos.sup && hca_attr->qos.flow_meter_old &&
|
2022-02-14 09:35:07 +00:00
|
|
|
sh->config.dv_flow_en) {
|
2022-02-14 09:34:58 +00:00
|
|
|
uint8_t reg_c_mask = hca_attr->qos.flow_meter_reg_c_ids;
|
2020-06-03 15:06:00 +00:00
|
|
|
/*
|
|
|
|
* Meter needs two REG_C's for color match and pre-sfx
|
|
|
|
* flow match. Here get the REG_C for color match.
|
|
|
|
* REG_C_0 and REG_C_1 is reserved for metadata feature.
|
|
|
|
*/
|
|
|
|
reg_c_mask &= 0xfc;
|
|
|
|
if (__builtin_popcount(reg_c_mask) < 1) {
|
|
|
|
priv->mtr_en = 0;
|
|
|
|
DRV_LOG(WARNING, "No available register for"
|
|
|
|
" meter.");
|
|
|
|
} else {
|
2020-11-18 08:59:56 +00:00
|
|
|
/*
|
|
|
|
* The meter color register is used by the
|
|
|
|
* flow-hit feature as well.
|
|
|
|
* The flow-hit feature must use REG_C_3
|
|
|
|
* Prefer REG_C_3 if it is available.
|
|
|
|
*/
|
|
|
|
if (reg_c_mask & (1 << (REG_C_3 - REG_C_0)))
|
|
|
|
priv->mtr_color_reg = REG_C_3;
|
|
|
|
else
|
|
|
|
priv->mtr_color_reg = ffs(reg_c_mask)
|
|
|
|
- 1 + REG_C_0;
|
2020-06-03 15:06:00 +00:00
|
|
|
priv->mtr_en = 1;
|
2022-02-14 09:34:58 +00:00
|
|
|
priv->mtr_reg_share = hca_attr->qos.flow_meter;
|
2020-06-03 15:06:00 +00:00
|
|
|
DRV_LOG(DEBUG, "The REG_C meter uses is %d",
|
|
|
|
priv->mtr_color_reg);
|
|
|
|
}
|
2020-10-13 14:11:45 +00:00
|
|
|
}
|
2022-02-14 09:34:58 +00:00
|
|
|
if (hca_attr->qos.sup && hca_attr->qos.flow_meter_aso_sup) {
|
2021-04-20 10:55:17 +00:00
|
|
|
uint32_t log_obj_size =
|
|
|
|
rte_log2_u32(MLX5_ASO_MTRS_PER_POOL >> 1);
|
|
|
|
if (log_obj_size >=
|
2022-02-14 09:34:58 +00:00
|
|
|
hca_attr->qos.log_meter_aso_granularity &&
|
|
|
|
log_obj_size <=
|
|
|
|
hca_attr->qos.log_meter_aso_max_alloc)
|
2021-04-20 10:55:17 +00:00
|
|
|
sh->meter_aso_en = 1;
|
2021-04-27 10:43:52 +00:00
|
|
|
}
|
|
|
|
if (priv->mtr_en) {
|
|
|
|
err = mlx5_aso_flow_mtrs_mng_init(priv->sh);
|
|
|
|
if (err) {
|
|
|
|
err = -err;
|
|
|
|
goto error;
|
2021-04-20 10:55:17 +00:00
|
|
|
}
|
|
|
|
}
|
2022-02-14 09:34:58 +00:00
|
|
|
if (hca_attr->flow.tunnel_header_0_1)
|
2021-07-13 12:09:19 +00:00
|
|
|
sh->tunnel_header_0_1 = 1;
|
2022-02-25 01:14:17 +00:00
|
|
|
if (hca_attr->flow.tunnel_header_2_3)
|
|
|
|
sh->tunnel_header_2_3 = 1;
|
2020-10-13 14:11:45 +00:00
|
|
|
#endif
|
2020-11-18 08:59:57 +00:00
|
|
|
#ifdef HAVE_MLX5_DR_CREATE_ACTION_ASO
|
2022-02-14 09:34:58 +00:00
|
|
|
if (hca_attr->flow_hit_aso && priv->mtr_color_reg == REG_C_3) {
|
2020-11-18 08:59:56 +00:00
|
|
|
sh->flow_hit_aso_en = 1;
|
|
|
|
err = mlx5_flow_aso_age_mng_init(sh);
|
|
|
|
if (err) {
|
|
|
|
err = -err;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
DRV_LOG(DEBUG, "Flow Hit ASO is supported.");
|
|
|
|
}
|
2020-11-18 08:59:57 +00:00
|
|
|
#endif /* HAVE_MLX5_DR_CREATE_ACTION_ASO */
|
2022-10-20 15:41:44 +00:00
|
|
|
#if defined (HAVE_MLX5_DR_CREATE_ACTION_ASO) && \
|
|
|
|
defined (HAVE_MLX5_DR_ACTION_ASO_CT)
|
|
|
|
/* HWS create CT ASO SQ based on HWS configure queue number. */
|
|
|
|
if (sh->config.dv_flow_en != 2 &&
|
|
|
|
hca_attr->ct_offload && priv->mtr_color_reg == REG_C_3) {
|
2021-05-05 12:23:15 +00:00
|
|
|
err = mlx5_flow_aso_ct_mng_init(sh);
|
|
|
|
if (err) {
|
|
|
|
err = -err;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
DRV_LOG(DEBUG, "CT ASO is supported.");
|
|
|
|
sh->ct_aso_en = 1;
|
|
|
|
}
|
|
|
|
#endif /* HAVE_MLX5_DR_CREATE_ACTION_ASO && HAVE_MLX5_DR_ACTION_ASO_CT */
|
2020-10-13 14:11:45 +00:00
|
|
|
#if defined(HAVE_MLX5DV_DR) && defined(HAVE_MLX5_DR_CREATE_ACTION_FLOW_SAMPLE)
|
2022-02-14 09:34:58 +00:00
|
|
|
if (hca_attr->log_max_ft_sampler_num > 0 &&
|
2022-02-14 09:35:07 +00:00
|
|
|
sh->config.dv_flow_en) {
|
2020-10-13 14:11:45 +00:00
|
|
|
priv->sampler_en = 1;
|
2021-03-09 09:48:35 +00:00
|
|
|
DRV_LOG(DEBUG, "Sampler enabled!");
|
2020-10-13 14:11:45 +00:00
|
|
|
} else {
|
|
|
|
priv->sampler_en = 0;
|
2022-02-14 09:34:58 +00:00
|
|
|
if (!hca_attr->log_max_ft_sampler_num)
|
2021-03-09 09:48:35 +00:00
|
|
|
DRV_LOG(WARNING,
|
|
|
|
"No available register for sampler.");
|
2020-10-13 14:11:45 +00:00
|
|
|
else
|
2021-03-09 09:48:35 +00:00
|
|
|
DRV_LOG(DEBUG, "DV flow is not supported!");
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
2020-07-16 08:23:05 +00:00
|
|
|
#endif
|
|
|
|
}
|
2022-02-14 09:35:09 +00:00
|
|
|
/* Process parameters and store port configuration on priv structure. */
|
2022-02-14 09:35:11 +00:00
|
|
|
err = mlx5_port_args_config(priv, mkvlist, &priv->config);
|
2022-02-14 09:35:09 +00:00
|
|
|
if (err) {
|
|
|
|
err = rte_errno;
|
|
|
|
DRV_LOG(ERR, "Failed to process port configure: %s",
|
|
|
|
strerror(rte_errno));
|
|
|
|
goto error;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
eth_dev = rte_eth_dev_allocate(name);
|
|
|
|
if (eth_dev == NULL) {
|
|
|
|
DRV_LOG(ERR, "can not allocate rte ethdev");
|
|
|
|
err = ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (priv->representor) {
|
|
|
|
eth_dev->data->dev_flags |= RTE_ETH_DEV_REPRESENTOR;
|
|
|
|
eth_dev->data->representor_id = priv->representor_id;
|
2021-10-11 12:53:06 +00:00
|
|
|
MLX5_ETH_FOREACH_DEV(port_id, dpdk_dev) {
|
|
|
|
struct mlx5_priv *opriv =
|
|
|
|
rte_eth_devices[port_id].data->dev_private;
|
|
|
|
if (opriv &&
|
|
|
|
opriv->master &&
|
|
|
|
opriv->domain_id == priv->domain_id &&
|
|
|
|
opriv->sh == priv->sh) {
|
|
|
|
eth_dev->data->backer_port_id = port_id;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (port_id >= RTE_MAX_ETHPORTS)
|
|
|
|
eth_dev->data->backer_port_id = eth_dev->data->port_id;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
2021-01-24 11:02:03 +00:00
|
|
|
priv->mp_id.port_id = eth_dev->data->port_id;
|
|
|
|
strlcpy(priv->mp_id.name, MLX5_MP_NAME, RTE_MP_MAX_NAME_LEN);
|
2020-06-03 15:06:00 +00:00
|
|
|
/*
|
|
|
|
* Store associated network device interface index. This index
|
|
|
|
* is permanent throughout the lifetime of device. So, we may store
|
|
|
|
* the ifindex here and use the cached value further.
|
|
|
|
*/
|
|
|
|
MLX5_ASSERT(spawn->ifindex);
|
|
|
|
priv->if_index = spawn->ifindex;
|
2021-10-21 08:56:36 +00:00
|
|
|
priv->lag_affinity_idx = sh->refcnt - 1;
|
2020-06-03 15:06:00 +00:00
|
|
|
eth_dev->data->dev_private = priv;
|
|
|
|
priv->dev_data = eth_dev->data;
|
|
|
|
eth_dev->data->mac_addrs = priv->mac;
|
2021-03-28 13:48:09 +00:00
|
|
|
eth_dev->device = dpdk_dev;
|
2020-10-14 02:26:47 +00:00
|
|
|
eth_dev->data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS;
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Configure the first MAC address by default. */
|
|
|
|
if (mlx5_get_mac(eth_dev, &mac.addr_bytes)) {
|
|
|
|
DRV_LOG(ERR,
|
|
|
|
"port %u cannot get MAC address, is mlx5_en"
|
|
|
|
" loaded? (errno: %s)",
|
|
|
|
eth_dev->data->port_id, strerror(rte_errno));
|
|
|
|
err = ENODEV;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
DRV_LOG(INFO,
|
2021-08-25 17:27:33 +00:00
|
|
|
"port %u MAC address is " RTE_ETHER_ADDR_PRT_FMT,
|
2021-08-25 17:27:34 +00:00
|
|
|
eth_dev->data->port_id, RTE_ETHER_ADDR_BYTES(&mac));
|
2020-06-03 15:06:00 +00:00
|
|
|
#ifdef RTE_LIBRTE_MLX5_DEBUG
|
|
|
|
{
|
2020-12-28 12:32:57 +00:00
|
|
|
char ifname[MLX5_NAMESIZE];
|
2020-06-03 15:06:00 +00:00
|
|
|
|
|
|
|
if (mlx5_get_ifname(eth_dev, &ifname) == 0)
|
|
|
|
DRV_LOG(DEBUG, "port %u ifname is \"%s\"",
|
|
|
|
eth_dev->data->port_id, ifname);
|
|
|
|
else
|
|
|
|
DRV_LOG(DEBUG, "port %u ifname is unknown",
|
|
|
|
eth_dev->data->port_id);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Get actual MTU if possible. */
|
|
|
|
err = mlx5_get_mtu(eth_dev, &priv->mtu);
|
|
|
|
if (err) {
|
|
|
|
err = rte_errno;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
DRV_LOG(DEBUG, "port %u MTU is %u", eth_dev->data->port_id,
|
|
|
|
priv->mtu);
|
|
|
|
/* Initialize burst functions to prevent crashes before link-up. */
|
2022-02-11 19:11:42 +00:00
|
|
|
eth_dev->rx_pkt_burst = rte_eth_pkt_burst_dummy;
|
|
|
|
eth_dev->tx_pkt_burst = rte_eth_pkt_burst_dummy;
|
2020-12-28 12:32:56 +00:00
|
|
|
eth_dev->dev_ops = &mlx5_dev_ops;
|
2020-09-09 13:01:43 +00:00
|
|
|
eth_dev->rx_descriptor_status = mlx5_rx_descriptor_status;
|
|
|
|
eth_dev->tx_descriptor_status = mlx5_tx_descriptor_status;
|
|
|
|
eth_dev->rx_queue_count = mlx5_rx_queue_count;
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Register MAC address. */
|
|
|
|
claim_zero(mlx5_mac_addr_add(eth_dev, &mac, 0, 0));
|
2022-02-14 09:35:07 +00:00
|
|
|
if (sh->dev_cap.vf && sh->config.vf_nl_en)
|
2020-06-03 15:06:00 +00:00
|
|
|
mlx5_nl_mac_addr_sync(priv->nl_socket_route,
|
|
|
|
mlx5_ifindex(eth_dev),
|
|
|
|
eth_dev->data->mac_addrs,
|
|
|
|
MLX5_MAX_MAC_ADDRESSES);
|
|
|
|
priv->ctrl_flows = 0;
|
2020-10-28 09:33:25 +00:00
|
|
|
rte_spinlock_init(&priv->flow_list_lock);
|
2020-06-03 15:06:00 +00:00
|
|
|
TAILQ_INIT(&priv->flow_meters);
|
2021-07-02 09:14:43 +00:00
|
|
|
priv->mtr_profile_tbl = mlx5_l3t_create(MLX5_L3T_TYPE_PTR);
|
|
|
|
if (!priv->mtr_profile_tbl)
|
|
|
|
goto error;
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Bring Ethernet device up. */
|
|
|
|
DRV_LOG(DEBUG, "port %u forcing Ethernet interface up",
|
|
|
|
eth_dev->data->port_id);
|
2022-03-01 12:15:14 +00:00
|
|
|
/* Read link status in case it is up and there will be no event. */
|
2020-06-03 15:06:00 +00:00
|
|
|
mlx5_link_update(eth_dev, 0);
|
2022-03-01 12:15:14 +00:00
|
|
|
/* Watch LSC interrupts between port probe and port start. */
|
|
|
|
priv->sh->port[priv->dev_port - 1].nl_ih_port_id =
|
|
|
|
eth_dev->data->port_id;
|
|
|
|
mlx5_set_link_up(eth_dev);
|
2021-07-13 08:44:39 +00:00
|
|
|
for (i = 0; i < MLX5_FLOW_TYPE_MAXI; i++) {
|
2022-02-14 09:35:07 +00:00
|
|
|
icfg[i].release_mem_en = !!sh->config.reclaim_mode;
|
|
|
|
if (sh->config.reclaim_mode)
|
2021-07-13 08:44:39 +00:00
|
|
|
icfg[i].per_core_cache = 0;
|
|
|
|
priv->flows[i] = mlx5_ipool_create(&icfg[i]);
|
|
|
|
if (!priv->flows[i])
|
|
|
|
goto error;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Create context for virtual machine VLAN workaround. */
|
|
|
|
priv->vmwa_context = mlx5_vlan_vmwa_init(eth_dev, spawn->ifindex);
|
2022-02-14 09:35:07 +00:00
|
|
|
if (sh->config.dv_flow_en) {
|
2020-06-03 15:06:00 +00:00
|
|
|
err = mlx5_alloc_shared_dr(priv);
|
|
|
|
if (err)
|
|
|
|
goto error;
|
2021-11-02 08:53:42 +00:00
|
|
|
if (mlx5_flex_item_port_init(eth_dev) < 0)
|
|
|
|
goto error;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
2022-02-14 09:35:08 +00:00
|
|
|
if (mlx5_devx_obj_ops_en(sh)) {
|
2020-09-03 10:13:48 +00:00
|
|
|
priv->obj_ops = devx_obj_ops;
|
2021-02-25 10:45:01 +00:00
|
|
|
mlx5_queue_counter_id_prepare(eth_dev);
|
2021-05-17 15:18:41 +00:00
|
|
|
priv->obj_ops.lb_dummy_queue_create =
|
|
|
|
mlx5_rxq_ibv_obj_dummy_lb_create;
|
|
|
|
priv->obj_ops.lb_dummy_queue_release =
|
|
|
|
mlx5_rxq_ibv_obj_dummy_lb_release;
|
2021-10-19 10:35:01 +00:00
|
|
|
} else if (spawn->max_port > UINT8_MAX) {
|
|
|
|
/* Verbs can't support ports larger than 255 by design. */
|
|
|
|
DRV_LOG(ERR, "must enable DV and ESW when RDMA link ports > 255");
|
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
2020-09-03 10:13:48 +00:00
|
|
|
} else {
|
|
|
|
priv->obj_ops = ibv_obj_ops;
|
|
|
|
}
|
2022-02-14 09:35:07 +00:00
|
|
|
if (sh->config.tx_pp &&
|
2021-11-10 13:05:52 +00:00
|
|
|
priv->obj_ops.txq_obj_new != mlx5_txq_devx_obj_new) {
|
2021-07-29 12:26:43 +00:00
|
|
|
/*
|
|
|
|
* HAVE_MLX5DV_DEVX_UAR_OFFSET is required to support
|
|
|
|
* packet pacing and already checked above.
|
|
|
|
* Hence, we should only make sure the SQs will be created
|
|
|
|
* with DevX, not with Verbs.
|
|
|
|
* Verbs allocates the SQ UAR on its own and it can't be shared
|
|
|
|
* with Clock Queue UAR as required for Tx scheduling.
|
|
|
|
*/
|
|
|
|
DRV_LOG(ERR, "Verbs SQs, UAR can't be shared as required for packet pacing");
|
|
|
|
err = ENODEV;
|
|
|
|
goto error;
|
|
|
|
}
|
2020-10-28 09:33:30 +00:00
|
|
|
priv->drop_queue.hrxq = mlx5_drop_action_create(eth_dev);
|
|
|
|
if (!priv->drop_queue.hrxq)
|
|
|
|
goto error;
|
2022-02-24 13:40:48 +00:00
|
|
|
priv->hrxqs = mlx5_list_create("hrxq", eth_dev, true,
|
|
|
|
mlx5_hrxq_create_cb,
|
|
|
|
mlx5_hrxq_match_cb,
|
|
|
|
mlx5_hrxq_remove_cb,
|
|
|
|
mlx5_hrxq_clone_cb,
|
|
|
|
mlx5_hrxq_clone_free_cb);
|
|
|
|
if (!priv->hrxqs)
|
|
|
|
goto error;
|
2022-10-20 15:41:38 +00:00
|
|
|
mlx5_set_metadata_mask(eth_dev);
|
|
|
|
if (sh->config.dv_xmeta_en != MLX5_XMETA_MODE_LEGACY &&
|
|
|
|
!priv->sh->dv_regc0_mask) {
|
|
|
|
DRV_LOG(ERR, "metadata mode %u is not supported "
|
|
|
|
"(no metadata reg_c[0] is available)",
|
|
|
|
sh->config.dv_xmeta_en);
|
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
2022-02-24 13:40:48 +00:00
|
|
|
rte_rwlock_init(&priv->ind_tbls_lock);
|
2022-10-20 15:57:34 +00:00
|
|
|
if (priv->sh->config.dv_flow_en == 2) {
|
2022-10-20 15:41:39 +00:00
|
|
|
#ifdef HAVE_MLX5_HWS_SUPPORT
|
2022-10-20 15:41:50 +00:00
|
|
|
if (priv->sh->config.dv_esw_en) {
|
net/mlx5: support device control of representor matching
In some E-Switch use cases, applications want to receive all traffic
on a single port. Since currently, flow API does not provide a way to
match traffic forwarded to any port representor, this patch adds
support for controlling representor matching on ingress flow rules.
Representor matching is controlled through a new device argument
repr_matching_en.
- If representor matching is enabled (default setting),
then each ingress pattern template has an implicit REPRESENTED_PORT
item added. Flow rules based on this pattern template will match
the vport associated with the port on which the rule is created.
- If representor matching is disabled, then there will be no implicit
item added. As a result ingress flow rules will match traffic
coming to any port, not only the port on which the flow rule is
created.
Representor matching is enabled by default, to provide an expected
default behavior.
This patch enables egress flow rules on representors when E-Switch is
enabled in the following configurations:
- repr_matching_en=1 and dv_xmeta_en=4
- repr_matching_en=1 and dv_xmeta_en=0
- repr_matching_en=0 and dv_xmeta_en=0
When representor matching is enabled, the following logic is
implemented:
1. Creating an egress template table in group 0 for each port. These
tables will hold default flow rules defined as follows:
pattern SQ
actions MODIFY_FIELD (set available bits in REG_C_0 to
vport_meta_tag)
MODIFY_FIELD (copy REG_A to REG_C_1, only when
dv_xmeta_en == 4)
JUMP (group 1)
2. Egress pattern templates created by an application have an implicit
MLX5_RTE_FLOW_ITEM_TYPE_TAG item prepended to the pattern, which
matches available bits of REG_C_0.
3. Egress flow rules created by an application have an implicit
MLX5_RTE_FLOW_ITEM_TYPE_TAG item prepended to the pattern, which
matches vport_meta_tag placed in available bits of REG_C_0.
4. Egress template tables created by an application, which are in
group n, are placed in group n + 1.
5. Items and actions related to META are operating on REG_A when
dv_xmeta_en == 0 or REG_C_1 when dv_xmeta_en == 4.
When representor matching is disabled and extended metadata is disabled,
no changes to the current logic are required.
Signed-off-by: Dariusz Sosnowski <dsosnowski@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2022-10-20 15:41:51 +00:00
|
|
|
uint32_t usable_bits;
|
|
|
|
uint32_t required_bits;
|
|
|
|
|
2022-10-20 15:41:50 +00:00
|
|
|
if (priv->sh->dv_regc0_mask == UINT32_MAX) {
|
|
|
|
DRV_LOG(ERR, "E-Switch port metadata is required when using HWS "
|
|
|
|
"but it is disabled (configure it through devlink)");
|
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (priv->sh->dv_regc0_mask == 0) {
|
|
|
|
DRV_LOG(ERR, "E-Switch with HWS is not supported "
|
|
|
|
"(no available bits in reg_c[0])");
|
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
net/mlx5: support device control of representor matching
In some E-Switch use cases, applications want to receive all traffic
on a single port. Since currently, flow API does not provide a way to
match traffic forwarded to any port representor, this patch adds
support for controlling representor matching on ingress flow rules.
Representor matching is controlled through a new device argument
repr_matching_en.
- If representor matching is enabled (default setting),
then each ingress pattern template has an implicit REPRESENTED_PORT
item added. Flow rules based on this pattern template will match
the vport associated with the port on which the rule is created.
- If representor matching is disabled, then there will be no implicit
item added. As a result ingress flow rules will match traffic
coming to any port, not only the port on which the flow rule is
created.
Representor matching is enabled by default, to provide an expected
default behavior.
This patch enables egress flow rules on representors when E-Switch is
enabled in the following configurations:
- repr_matching_en=1 and dv_xmeta_en=4
- repr_matching_en=1 and dv_xmeta_en=0
- repr_matching_en=0 and dv_xmeta_en=0
When representor matching is enabled, the following logic is
implemented:
1. Creating an egress template table in group 0 for each port. These
tables will hold default flow rules defined as follows:
pattern SQ
actions MODIFY_FIELD (set available bits in REG_C_0 to
vport_meta_tag)
MODIFY_FIELD (copy REG_A to REG_C_1, only when
dv_xmeta_en == 4)
JUMP (group 1)
2. Egress pattern templates created by an application have an implicit
MLX5_RTE_FLOW_ITEM_TYPE_TAG item prepended to the pattern, which
matches available bits of REG_C_0.
3. Egress flow rules created by an application have an implicit
MLX5_RTE_FLOW_ITEM_TYPE_TAG item prepended to the pattern, which
matches vport_meta_tag placed in available bits of REG_C_0.
4. Egress template tables created by an application, which are in
group n, are placed in group n + 1.
5. Items and actions related to META are operating on REG_A when
dv_xmeta_en == 0 or REG_C_1 when dv_xmeta_en == 4.
When representor matching is disabled and extended metadata is disabled,
no changes to the current logic are required.
Signed-off-by: Dariusz Sosnowski <dsosnowski@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2022-10-20 15:41:51 +00:00
|
|
|
usable_bits = __builtin_popcount(priv->sh->dv_regc0_mask);
|
|
|
|
required_bits = __builtin_popcount(priv->vport_meta_mask);
|
|
|
|
if (usable_bits < required_bits) {
|
|
|
|
DRV_LOG(ERR, "Not enough bits available in reg_c[0] to provide "
|
|
|
|
"representor matching.");
|
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
2022-10-20 15:41:50 +00:00
|
|
|
}
|
2022-10-20 15:57:34 +00:00
|
|
|
if (priv->vport_meta_mask)
|
|
|
|
flow_hw_set_port_info(eth_dev);
|
2022-10-20 15:41:40 +00:00
|
|
|
if (priv->sh->config.dv_esw_en &&
|
|
|
|
priv->sh->config.dv_xmeta_en != MLX5_XMETA_MODE_LEGACY &&
|
|
|
|
priv->sh->config.dv_xmeta_en != MLX5_XMETA_MODE_META32_HWS) {
|
|
|
|
DRV_LOG(ERR,
|
|
|
|
"metadata mode %u is not supported in HWS eswitch mode",
|
|
|
|
priv->sh->config.dv_xmeta_en);
|
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
2022-10-20 15:57:36 +00:00
|
|
|
/* Only HWS requires this information. */
|
|
|
|
flow_hw_init_tags_set(eth_dev);
|
2022-10-20 15:41:43 +00:00
|
|
|
flow_hw_init_flow_metadata_config(eth_dev);
|
2022-10-20 15:41:39 +00:00
|
|
|
if (priv->sh->config.dv_esw_en &&
|
|
|
|
flow_hw_create_vport_action(eth_dev)) {
|
|
|
|
DRV_LOG(ERR, "port %u failed to create vport action",
|
|
|
|
eth_dev->data->port_id);
|
|
|
|
err = EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2022-02-24 13:40:40 +00:00
|
|
|
return eth_dev;
|
2022-10-20 15:57:34 +00:00
|
|
|
#else
|
|
|
|
DRV_LOG(ERR, "DV support is missing for HWS.");
|
|
|
|
goto error;
|
|
|
|
#endif
|
|
|
|
}
|
2021-10-27 10:35:10 +00:00
|
|
|
if (!priv->sh->flow_priority_check_flag) {
|
|
|
|
/* Supported Verbs flow priority number detection. */
|
|
|
|
err = mlx5_flow_discover_priorities(eth_dev);
|
|
|
|
priv->sh->flow_max_priority = err;
|
|
|
|
priv->sh->flow_priority_check_flag = 1;
|
|
|
|
} else {
|
|
|
|
err = priv->sh->flow_max_priority;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
if (err < 0) {
|
|
|
|
err = -err;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
/* Query availability of metadata reg_c's. */
|
2021-10-27 10:35:10 +00:00
|
|
|
if (!priv->sh->metadata_regc_check_flag) {
|
|
|
|
err = mlx5_flow_discover_mreg_c(eth_dev);
|
|
|
|
if (err < 0) {
|
|
|
|
err = -err;
|
|
|
|
goto error;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
if (!mlx5_flow_ext_mreg_supported(eth_dev)) {
|
|
|
|
DRV_LOG(DEBUG,
|
|
|
|
"port %u extensive metadata register is not supported",
|
|
|
|
eth_dev->data->port_id);
|
2022-02-14 09:35:07 +00:00
|
|
|
if (sh->config.dv_xmeta_en != MLX5_XMETA_MODE_LEGACY) {
|
2020-06-03 15:06:00 +00:00
|
|
|
DRV_LOG(ERR, "metadata mode %u is not supported "
|
|
|
|
"(no metadata registers available)",
|
2022-02-14 09:35:07 +00:00
|
|
|
sh->config.dv_xmeta_en);
|
2020-06-03 15:06:00 +00:00
|
|
|
err = ENOTSUP;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
2022-02-14 09:35:07 +00:00
|
|
|
if (sh->config.dv_flow_en &&
|
|
|
|
sh->config.dv_xmeta_en != MLX5_XMETA_MODE_LEGACY &&
|
2020-06-03 15:06:00 +00:00
|
|
|
mlx5_flow_ext_mreg_supported(eth_dev) &&
|
|
|
|
priv->sh->dv_regc0_mask) {
|
|
|
|
priv->mreg_cp_tbl = mlx5_hlist_create(MLX5_FLOW_MREG_HNAME,
|
2020-10-28 09:33:31 +00:00
|
|
|
MLX5_FLOW_MREG_HTABLE_SZ,
|
2021-07-13 08:44:50 +00:00
|
|
|
false, true, eth_dev,
|
2020-10-28 09:33:38 +00:00
|
|
|
flow_dv_mreg_create_cb,
|
2020-12-03 02:18:52 +00:00
|
|
|
flow_dv_mreg_match_cb,
|
2021-07-13 08:44:50 +00:00
|
|
|
flow_dv_mreg_remove_cb,
|
|
|
|
flow_dv_mreg_clone_cb,
|
|
|
|
flow_dv_mreg_clone_free_cb);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!priv->mreg_cp_tbl) {
|
|
|
|
err = ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
2020-10-28 09:33:52 +00:00
|
|
|
rte_spinlock_init(&priv->shared_act_sl);
|
2020-10-20 03:02:23 +00:00
|
|
|
mlx5_flow_counter_mode_config(eth_dev);
|
2021-08-02 14:30:24 +00:00
|
|
|
mlx5_flow_drop_action_config(eth_dev);
|
2022-02-14 09:35:07 +00:00
|
|
|
if (sh->config.dv_flow_en)
|
2020-10-28 09:33:53 +00:00
|
|
|
eth_dev->data->dev_flags |= RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE;
|
2020-06-03 15:06:00 +00:00
|
|
|
return eth_dev;
|
|
|
|
error:
|
|
|
|
if (priv) {
|
2022-11-09 22:29:38 +00:00
|
|
|
priv->sh->port[priv->dev_port - 1].nl_ih_port_id =
|
|
|
|
RTE_MAX_ETHPORTS;
|
|
|
|
rte_io_wmb();
|
2022-10-20 15:41:39 +00:00
|
|
|
#ifdef HAVE_MLX5_HWS_SUPPORT
|
|
|
|
if (eth_dev &&
|
|
|
|
priv->sh &&
|
|
|
|
priv->sh->config.dv_flow_en == 2 &&
|
|
|
|
priv->sh->config.dv_esw_en)
|
|
|
|
flow_hw_destroy_vport_action(eth_dev);
|
|
|
|
#endif
|
2020-06-03 15:06:00 +00:00
|
|
|
if (priv->mreg_cp_tbl)
|
2020-10-28 09:33:31 +00:00
|
|
|
mlx5_hlist_destroy(priv->mreg_cp_tbl);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (priv->sh)
|
|
|
|
mlx5_os_free_shared_dr(priv);
|
|
|
|
if (priv->nl_socket_route >= 0)
|
|
|
|
close(priv->nl_socket_route);
|
|
|
|
if (priv->vmwa_context)
|
|
|
|
mlx5_vlan_vmwa_exit(priv->vmwa_context);
|
2020-10-28 09:33:30 +00:00
|
|
|
if (eth_dev && priv->drop_queue.hrxq)
|
|
|
|
mlx5_drop_action_destroy(eth_dev);
|
2021-07-02 09:14:43 +00:00
|
|
|
if (priv->mtr_profile_tbl)
|
|
|
|
mlx5_l3t_destroy(priv->mtr_profile_tbl);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (own_domain_id)
|
|
|
|
claim_zero(rte_eth_switch_domain_free(priv->domain_id));
|
2021-07-13 08:44:46 +00:00
|
|
|
if (priv->hrxqs)
|
|
|
|
mlx5_list_destroy(priv->hrxqs);
|
2021-11-02 08:53:42 +00:00
|
|
|
if (eth_dev && priv->flex_item_map)
|
|
|
|
mlx5_flex_item_port_cleanup(eth_dev);
|
2022-02-24 23:25:10 +00:00
|
|
|
mlx5_free(priv->ext_rxqs);
|
2020-06-28 09:02:44 +00:00
|
|
|
mlx5_free(priv);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (eth_dev != NULL)
|
|
|
|
eth_dev->data->dev_private = NULL;
|
|
|
|
}
|
|
|
|
if (eth_dev != NULL) {
|
|
|
|
/* mac_addrs must not be freed alone because part of
|
|
|
|
* dev_private
|
|
|
|
**/
|
|
|
|
eth_dev->data->mac_addrs = NULL;
|
|
|
|
rte_eth_dev_release_port(eth_dev);
|
|
|
|
}
|
|
|
|
if (sh)
|
2020-06-10 09:32:27 +00:00
|
|
|
mlx5_free_shared_dev_ctx(sh);
|
2021-10-19 10:34:55 +00:00
|
|
|
if (nl_rdma >= 0)
|
|
|
|
close(nl_rdma);
|
2020-06-03 15:06:00 +00:00
|
|
|
MLX5_ASSERT(err > 0);
|
|
|
|
rte_errno = err;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Comparison callback to sort device data.
|
|
|
|
*
|
|
|
|
* This is meant to be used with qsort().
|
|
|
|
*
|
|
|
|
* @param a[in]
|
|
|
|
* Pointer to pointer to first data object.
|
|
|
|
* @param b[in]
|
|
|
|
* Pointer to pointer to second data object.
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 if both objects are equal, less than 0 if the first argument is less
|
|
|
|
* than the second, greater than 0 otherwise.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
mlx5_dev_spawn_data_cmp(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const struct mlx5_switch_info *si_a =
|
|
|
|
&((const struct mlx5_dev_spawn_data *)a)->info;
|
|
|
|
const struct mlx5_switch_info *si_b =
|
|
|
|
&((const struct mlx5_dev_spawn_data *)b)->info;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Master device first. */
|
|
|
|
ret = si_b->master - si_a->master;
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
/* Then representor devices. */
|
|
|
|
ret = si_b->representor - si_a->representor;
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
/* Unidentified devices come last in no specific order. */
|
|
|
|
if (!si_a->representor)
|
|
|
|
return 0;
|
|
|
|
/* Order representors by name. */
|
|
|
|
return si_a->port_name - si_b->port_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Match PCI information for possible slaves of bonding device.
|
|
|
|
*
|
2021-10-19 20:55:52 +00:00
|
|
|
* @param[in] ibdev_name
|
|
|
|
* Name of Infiniband device.
|
2020-06-03 15:06:00 +00:00
|
|
|
* @param[in] pci_dev
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
* Pointer to primary PCI address structure to match.
|
2020-06-03 15:06:00 +00:00
|
|
|
* @param[in] nl_rdma
|
|
|
|
* Netlink RDMA group socket handle.
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
* @param[in] owner
|
2021-10-19 20:55:52 +00:00
|
|
|
* Representor owner PF index.
|
2021-03-28 13:48:12 +00:00
|
|
|
* @param[out] bond_info
|
|
|
|
* Pointer to bonding information.
|
2020-06-03 15:06:00 +00:00
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* negative value if no bonding device found, otherwise
|
|
|
|
* positive index of slave PF in bonding.
|
|
|
|
*/
|
|
|
|
static int
|
2021-10-19 20:55:52 +00:00
|
|
|
mlx5_device_bond_pci_match(const char *ibdev_name,
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
const struct rte_pci_addr *pci_dev,
|
2021-03-28 13:48:12 +00:00
|
|
|
int nl_rdma, uint16_t owner,
|
|
|
|
struct mlx5_bond_info *bond_info)
|
2020-06-03 15:06:00 +00:00
|
|
|
{
|
|
|
|
char ifname[IF_NAMESIZE + 1];
|
|
|
|
unsigned int ifindex;
|
|
|
|
unsigned int np, i;
|
2021-03-28 13:48:12 +00:00
|
|
|
FILE *bond_file = NULL, *file;
|
2020-06-03 15:06:00 +00:00
|
|
|
int pf = -1;
|
2021-03-28 13:48:12 +00:00
|
|
|
int ret;
|
2021-10-26 08:48:30 +00:00
|
|
|
uint8_t cur_guid[32] = {0};
|
|
|
|
uint8_t guid[32] = {0};
|
2020-06-03 15:06:00 +00:00
|
|
|
|
|
|
|
/*
|
2021-10-19 20:55:52 +00:00
|
|
|
* Try to get master device name. If something goes wrong suppose
|
|
|
|
* the lack of kernel support and no bonding devices.
|
2020-06-03 15:06:00 +00:00
|
|
|
*/
|
2021-03-28 13:48:12 +00:00
|
|
|
memset(bond_info, 0, sizeof(*bond_info));
|
2020-06-03 15:06:00 +00:00
|
|
|
if (nl_rdma < 0)
|
|
|
|
return -1;
|
2021-10-19 20:55:52 +00:00
|
|
|
if (!strstr(ibdev_name, "bond"))
|
2020-06-03 15:06:00 +00:00
|
|
|
return -1;
|
2021-10-19 20:55:52 +00:00
|
|
|
np = mlx5_nl_portnum(nl_rdma, ibdev_name);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!np)
|
|
|
|
return -1;
|
2021-10-26 08:48:30 +00:00
|
|
|
if (mlx5_get_device_guid(pci_dev, cur_guid, sizeof(cur_guid)) < 0)
|
|
|
|
return -1;
|
2020-06-03 15:06:00 +00:00
|
|
|
/*
|
2021-10-19 20:55:52 +00:00
|
|
|
* The master device might not be on the predefined port(not on port
|
|
|
|
* index 1, it is not guaranteed), we have to scan all Infiniband
|
|
|
|
* device ports and find master.
|
2020-06-03 15:06:00 +00:00
|
|
|
*/
|
|
|
|
for (i = 1; i <= np; ++i) {
|
|
|
|
/* Check whether Infiniband port is populated. */
|
2021-10-19 20:55:52 +00:00
|
|
|
ifindex = mlx5_nl_ifindex(nl_rdma, ibdev_name, i);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!ifindex)
|
|
|
|
continue;
|
|
|
|
if (!if_indextoname(ifindex, ifname))
|
|
|
|
continue;
|
|
|
|
/* Try to read bonding slave names from sysfs. */
|
|
|
|
MKSTR(slaves,
|
|
|
|
"/sys/class/net/%s/master/bonding/slaves", ifname);
|
2021-03-28 13:48:12 +00:00
|
|
|
bond_file = fopen(slaves, "r");
|
|
|
|
if (bond_file)
|
2020-06-03 15:06:00 +00:00
|
|
|
break;
|
|
|
|
}
|
2021-03-28 13:48:12 +00:00
|
|
|
if (!bond_file)
|
2020-06-03 15:06:00 +00:00
|
|
|
return -1;
|
|
|
|
/* Use safe format to check maximal buffer length. */
|
|
|
|
MLX5_ASSERT(atol(RTE_STR(IF_NAMESIZE)) == IF_NAMESIZE);
|
2021-03-28 13:48:12 +00:00
|
|
|
while (fscanf(bond_file, "%" RTE_STR(IF_NAMESIZE) "s", ifname) == 1) {
|
2020-06-03 15:06:00 +00:00
|
|
|
char tmp_str[IF_NAMESIZE + 32];
|
|
|
|
struct rte_pci_addr pci_addr;
|
|
|
|
struct mlx5_switch_info info;
|
2021-10-26 08:48:30 +00:00
|
|
|
int ret;
|
2020-06-03 15:06:00 +00:00
|
|
|
|
|
|
|
/* Process slave interface names in the loop. */
|
|
|
|
snprintf(tmp_str, sizeof(tmp_str),
|
|
|
|
"/sys/class/net/%s", ifname);
|
2021-07-21 14:37:32 +00:00
|
|
|
if (mlx5_get_pci_addr(tmp_str, &pci_addr)) {
|
2021-10-19 20:55:52 +00:00
|
|
|
DRV_LOG(WARNING,
|
|
|
|
"Cannot get PCI address for netdev \"%s\".",
|
|
|
|
ifname);
|
2020-06-03 15:06:00 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* Slave interface PCI address match found. */
|
|
|
|
snprintf(tmp_str, sizeof(tmp_str),
|
|
|
|
"/sys/class/net/%s/phys_port_name", ifname);
|
|
|
|
file = fopen(tmp_str, "rb");
|
|
|
|
if (!file)
|
|
|
|
break;
|
|
|
|
info.name_type = MLX5_PHYS_PORT_NAME_TYPE_NOTSET;
|
|
|
|
if (fscanf(file, "%32s", tmp_str) == 1)
|
|
|
|
mlx5_translate_port_name(tmp_str, &info);
|
2021-03-28 13:48:12 +00:00
|
|
|
fclose(file);
|
|
|
|
/* Only process PF ports. */
|
|
|
|
if (info.name_type != MLX5_PHYS_PORT_NAME_TYPE_LEGACY &&
|
|
|
|
info.name_type != MLX5_PHYS_PORT_NAME_TYPE_UPLINK)
|
|
|
|
continue;
|
|
|
|
/* Check max bonding member. */
|
|
|
|
if (info.port_name >= MLX5_BOND_MAX_PORTS) {
|
|
|
|
DRV_LOG(WARNING, "bonding index out of range, "
|
|
|
|
"please increase MLX5_BOND_MAX_PORTS: %s",
|
|
|
|
tmp_str);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Get ifindex. */
|
|
|
|
snprintf(tmp_str, sizeof(tmp_str),
|
|
|
|
"/sys/class/net/%s/ifindex", ifname);
|
|
|
|
file = fopen(tmp_str, "rb");
|
|
|
|
if (!file)
|
|
|
|
break;
|
|
|
|
ret = fscanf(file, "%u", &ifindex);
|
2020-06-03 15:06:00 +00:00
|
|
|
fclose(file);
|
2021-03-28 13:48:12 +00:00
|
|
|
if (ret != 1)
|
|
|
|
break;
|
|
|
|
/* Save bonding info. */
|
|
|
|
strncpy(bond_info->ports[info.port_name].ifname, ifname,
|
|
|
|
sizeof(bond_info->ports[0].ifname));
|
|
|
|
bond_info->ports[info.port_name].pci_addr = pci_addr;
|
|
|
|
bond_info->ports[info.port_name].ifindex = ifindex;
|
|
|
|
bond_info->n_port++;
|
2021-10-26 08:48:30 +00:00
|
|
|
/*
|
|
|
|
* Under socket direct mode, bonding will use
|
|
|
|
* system_image_guid as identification.
|
|
|
|
* After OFED 5.4, guid is readable (ret >= 0) under sysfs.
|
|
|
|
* All bonding members should have the same guid even if driver
|
|
|
|
* is using PCIe BDF.
|
|
|
|
*/
|
|
|
|
ret = mlx5_get_device_guid(&pci_addr, guid, sizeof(guid));
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
else if (ret > 0) {
|
|
|
|
if (!memcmp(guid, cur_guid, sizeof(guid)) &&
|
|
|
|
owner == info.port_name &&
|
|
|
|
(owner != 0 || (owner == 0 &&
|
|
|
|
!rte_pci_addr_cmp(pci_dev, &pci_addr))))
|
|
|
|
pf = info.port_name;
|
|
|
|
} else if (pci_dev->domain == pci_addr.domain &&
|
|
|
|
pci_dev->bus == pci_addr.bus &&
|
|
|
|
pci_dev->devid == pci_addr.devid &&
|
|
|
|
((pci_dev->function == 0 &&
|
|
|
|
pci_dev->function + owner == pci_addr.function) ||
|
|
|
|
(pci_dev->function == owner &&
|
|
|
|
pci_addr.function == owner)))
|
|
|
|
pf = info.port_name;
|
2021-03-28 13:48:12 +00:00
|
|
|
}
|
|
|
|
if (pf >= 0) {
|
|
|
|
/* Get bond interface info */
|
|
|
|
ret = mlx5_sysfs_bond_info(ifindex, &bond_info->ifindex,
|
|
|
|
bond_info->ifname);
|
|
|
|
if (ret)
|
|
|
|
DRV_LOG(ERR, "unable to get bond info: %s",
|
|
|
|
strerror(rte_errno));
|
|
|
|
else
|
|
|
|
DRV_LOG(INFO, "PF device %u, bond device %u(%s)",
|
|
|
|
ifindex, bond_info->ifindex, bond_info->ifname);
|
|
|
|
}
|
2021-10-26 08:48:30 +00:00
|
|
|
if (owner == 0 && pf != 0) {
|
|
|
|
DRV_LOG(INFO, "PCIe instance %04x:%02x:%02x.%x isn't bonding owner",
|
|
|
|
pci_dev->domain, pci_dev->bus, pci_dev->devid,
|
|
|
|
pci_dev->function);
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
return pf;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2021-03-28 13:48:11 +00:00
|
|
|
* Register a PCI device within bonding.
|
2020-06-03 15:06:00 +00:00
|
|
|
*
|
2021-03-28 13:48:11 +00:00
|
|
|
* This function spawns Ethernet devices out of a given PCI device and
|
|
|
|
* bonding owner PF index.
|
2020-06-03 15:06:00 +00:00
|
|
|
*
|
2021-10-19 20:55:46 +00:00
|
|
|
* @param[in] cdev
|
|
|
|
* Pointer to common mlx5 device structure.
|
2021-03-28 13:48:11 +00:00
|
|
|
* @param[in] req_eth_da
|
|
|
|
* Requested ethdev device argument.
|
|
|
|
* @param[in] owner_id
|
|
|
|
* Requested owner PF port ID within bonding device, default to 0.
|
2022-02-14 09:35:11 +00:00
|
|
|
* @param[in, out] mkvlist
|
|
|
|
* Pointer to mlx5 kvargs control, can be NULL if there is no devargs.
|
2020-06-03 15:06:00 +00:00
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on success, a negative errno value otherwise and rte_errno is set.
|
|
|
|
*/
|
2021-03-28 13:48:11 +00:00
|
|
|
static int
|
2021-10-19 20:55:52 +00:00
|
|
|
mlx5_os_pci_probe_pf(struct mlx5_common_device *cdev,
|
2021-03-28 13:48:11 +00:00
|
|
|
struct rte_eth_devargs *req_eth_da,
|
2022-02-14 09:35:11 +00:00
|
|
|
uint16_t owner_id, struct mlx5_kvargs_ctrl *mkvlist)
|
2020-06-03 15:06:00 +00:00
|
|
|
{
|
|
|
|
struct ibv_device **ibv_list;
|
|
|
|
/*
|
|
|
|
* Number of found IB Devices matching with requested PCI BDF.
|
|
|
|
* nd != 1 means there are multiple IB devices over the same
|
|
|
|
* PCI device and we have representors and master.
|
|
|
|
*/
|
|
|
|
unsigned int nd = 0;
|
|
|
|
/*
|
|
|
|
* Number of found IB device Ports. nd = 1 and np = 1..n means
|
|
|
|
* we have the single multiport IB device, and there may be
|
|
|
|
* representors attached to some of found ports.
|
|
|
|
*/
|
|
|
|
unsigned int np = 0;
|
|
|
|
/*
|
|
|
|
* Number of DPDK ethernet devices to Spawn - either over
|
|
|
|
* multiple IB devices or multiple ports of single IB device.
|
|
|
|
* Actually this is the number of iterations to spawn.
|
|
|
|
*/
|
|
|
|
unsigned int ns = 0;
|
|
|
|
/*
|
|
|
|
* Bonding device
|
|
|
|
* < 0 - no bonding device (single one)
|
|
|
|
* >= 0 - bonding device (value is slave PF index)
|
|
|
|
*/
|
|
|
|
int bd = -1;
|
2021-10-19 20:55:46 +00:00
|
|
|
struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(cdev->dev);
|
2020-06-03 15:06:00 +00:00
|
|
|
struct mlx5_dev_spawn_data *list = NULL;
|
2021-03-28 13:48:11 +00:00
|
|
|
struct rte_eth_devargs eth_da = *req_eth_da;
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
struct rte_pci_addr owner_pci = pci_dev->addr; /* Owner PF. */
|
2021-03-28 13:48:12 +00:00
|
|
|
struct mlx5_bond_info bond_info;
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
int ret = -1;
|
2020-06-03 15:06:00 +00:00
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
ibv_list = mlx5_glue->get_device_list(&ret);
|
|
|
|
if (!ibv_list) {
|
|
|
|
rte_errno = errno ? errno : ENOSYS;
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(ERR, "Cannot list devices, is ib_uverbs loaded?");
|
2020-06-03 15:06:00 +00:00
|
|
|
return -rte_errno;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* First scan the list of all Infiniband devices to find
|
|
|
|
* matching ones, gathering into the list.
|
|
|
|
*/
|
|
|
|
struct ibv_device *ibv_match[ret + 1];
|
2022-03-01 12:15:12 +00:00
|
|
|
int nl_route = mlx5_nl_init(NETLINK_ROUTE, 0);
|
|
|
|
int nl_rdma = mlx5_nl_init(NETLINK_RDMA, 0);
|
2020-06-03 15:06:00 +00:00
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
while (ret-- > 0) {
|
|
|
|
struct rte_pci_addr pci_addr;
|
|
|
|
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(DEBUG, "Checking device \"%s\"", ibv_list[ret]->name);
|
2021-10-19 20:55:52 +00:00
|
|
|
bd = mlx5_device_bond_pci_match(ibv_list[ret]->name, &owner_pci,
|
|
|
|
nl_rdma, owner_id, &bond_info);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (bd >= 0) {
|
|
|
|
/*
|
|
|
|
* Bonding device detected. Only one match is allowed,
|
|
|
|
* the bonding is supported over multi-port IB device,
|
|
|
|
* there should be no matches on representor PCI
|
|
|
|
* functions or non VF LAG bonding devices with
|
|
|
|
* specified address.
|
|
|
|
*/
|
|
|
|
if (nd) {
|
|
|
|
DRV_LOG(ERR,
|
|
|
|
"multiple PCI match on bonding device"
|
|
|
|
"\"%s\" found", ibv_list[ret]->name);
|
|
|
|
rte_errno = ENOENT;
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto exit;
|
|
|
|
}
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
/* Amend owner pci address if owner PF ID specified. */
|
|
|
|
if (eth_da.nb_representor_ports)
|
2021-03-28 13:48:11 +00:00
|
|
|
owner_pci.function += owner_id;
|
2021-10-19 20:55:52 +00:00
|
|
|
DRV_LOG(INFO,
|
|
|
|
"PCI information matches for slave %d bonding device \"%s\"",
|
|
|
|
bd, ibv_list[ret]->name);
|
2020-06-03 15:06:00 +00:00
|
|
|
ibv_match[nd++] = ibv_list[ret];
|
|
|
|
break;
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
} else {
|
|
|
|
/* Bonding device not found. */
|
2021-07-21 14:37:32 +00:00
|
|
|
if (mlx5_get_pci_addr(ibv_list[ret]->ibdev_path,
|
|
|
|
&pci_addr))
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
continue;
|
|
|
|
if (owner_pci.domain != pci_addr.domain ||
|
|
|
|
owner_pci.bus != pci_addr.bus ||
|
|
|
|
owner_pci.devid != pci_addr.devid ||
|
|
|
|
owner_pci.function != pci_addr.function)
|
|
|
|
continue;
|
|
|
|
DRV_LOG(INFO, "PCI information matches for device \"%s\"",
|
|
|
|
ibv_list[ret]->name);
|
|
|
|
ibv_match[nd++] = ibv_list[ret];
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ibv_match[nd] = NULL;
|
|
|
|
if (!nd) {
|
|
|
|
/* No device matches, just complain and bail out. */
|
|
|
|
DRV_LOG(WARNING,
|
2022-04-06 07:12:24 +00:00
|
|
|
"PF %u doesn't have Verbs device matches PCI device " PCI_PRI_FMT ","
|
2020-06-03 15:06:00 +00:00
|
|
|
" are kernel drivers loaded?",
|
2022-04-06 07:12:24 +00:00
|
|
|
owner_id, owner_pci.domain, owner_pci.bus,
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
owner_pci.devid, owner_pci.function);
|
2020-06-03 15:06:00 +00:00
|
|
|
rte_errno = ENOENT;
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
if (nd == 1) {
|
|
|
|
/*
|
|
|
|
* Found single matching device may have multiple ports.
|
|
|
|
* Each port may be representor, we have to check the port
|
|
|
|
* number and check the representors existence.
|
|
|
|
*/
|
|
|
|
if (nl_rdma >= 0)
|
|
|
|
np = mlx5_nl_portnum(nl_rdma, ibv_match[0]->name);
|
|
|
|
if (!np)
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(WARNING,
|
|
|
|
"Cannot get IB device \"%s\" ports number.",
|
|
|
|
ibv_match[0]->name);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (bd >= 0 && !np) {
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(ERR, "Cannot get ports for bonding device.");
|
2020-06-03 15:06:00 +00:00
|
|
|
rte_errno = ENOENT;
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
2021-10-19 20:55:50 +00:00
|
|
|
/* Now we can determine the maximal amount of devices to be spawned. */
|
2020-06-28 09:02:44 +00:00
|
|
|
list = mlx5_malloc(MLX5_MEM_ZERO,
|
2021-10-19 20:55:50 +00:00
|
|
|
sizeof(struct mlx5_dev_spawn_data) * (np ? np : nd),
|
2020-06-28 09:02:44 +00:00
|
|
|
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!list) {
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(ERR, "Spawn data array allocation failure.");
|
2020-06-03 15:06:00 +00:00
|
|
|
rte_errno = ENOMEM;
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
if (bd >= 0 || np > 1) {
|
|
|
|
/*
|
|
|
|
* Single IB device with multiple ports found,
|
|
|
|
* it may be E-Switch master device and representors.
|
|
|
|
* We have to perform identification through the ports.
|
|
|
|
*/
|
|
|
|
MLX5_ASSERT(nl_rdma >= 0);
|
|
|
|
MLX5_ASSERT(ns == 0);
|
|
|
|
MLX5_ASSERT(nd == 1);
|
|
|
|
MLX5_ASSERT(np);
|
|
|
|
for (i = 1; i <= np; ++i) {
|
2021-03-28 13:48:12 +00:00
|
|
|
list[ns].bond_info = &bond_info;
|
2020-06-03 15:06:00 +00:00
|
|
|
list[ns].max_port = np;
|
2020-06-03 15:06:02 +00:00
|
|
|
list[ns].phys_port = i;
|
2021-10-19 20:55:50 +00:00
|
|
|
list[ns].phys_dev_name = ibv_match[0]->name;
|
2020-06-03 15:06:00 +00:00
|
|
|
list[ns].eth_dev = NULL;
|
|
|
|
list[ns].pci_dev = pci_dev;
|
2021-10-19 20:55:46 +00:00
|
|
|
list[ns].cdev = cdev;
|
2020-06-03 15:06:00 +00:00
|
|
|
list[ns].pf_bond = bd;
|
2021-10-19 20:55:50 +00:00
|
|
|
list[ns].ifindex = mlx5_nl_ifindex(nl_rdma,
|
|
|
|
ibv_match[0]->name,
|
|
|
|
i);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!list[ns].ifindex) {
|
|
|
|
/*
|
|
|
|
* No network interface index found for the
|
|
|
|
* specified port, it means there is no
|
|
|
|
* representor on this port. It's OK,
|
|
|
|
* there can be disabled ports, for example
|
|
|
|
* if sriov_numvfs < sriov_totalvfs.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
ret = -1;
|
|
|
|
if (nl_route >= 0)
|
2021-10-19 20:55:50 +00:00
|
|
|
ret = mlx5_nl_switch_info(nl_route,
|
|
|
|
list[ns].ifindex,
|
|
|
|
&list[ns].info);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (ret || (!list[ns].info.representor &&
|
|
|
|
!list[ns].info.master)) {
|
|
|
|
/*
|
|
|
|
* We failed to recognize representors with
|
|
|
|
* Netlink, let's try to perform the task
|
|
|
|
* with sysfs.
|
|
|
|
*/
|
2021-10-19 20:55:50 +00:00
|
|
|
ret = mlx5_sysfs_switch_info(list[ns].ifindex,
|
|
|
|
&list[ns].info);
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
if (!ret && bd >= 0) {
|
|
|
|
switch (list[ns].info.name_type) {
|
|
|
|
case MLX5_PHYS_PORT_NAME_TYPE_UPLINK:
|
2021-07-21 08:31:40 +00:00
|
|
|
if (np == 1) {
|
|
|
|
/*
|
|
|
|
* Force standalone bonding
|
|
|
|
* device for ROCE LAG
|
2021-11-29 16:08:02 +00:00
|
|
|
* configurations.
|
2021-07-21 08:31:40 +00:00
|
|
|
*/
|
|
|
|
list[ns].info.master = 0;
|
|
|
|
list[ns].info.representor = 0;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
if (list[ns].info.port_name == bd)
|
|
|
|
ns++;
|
|
|
|
break;
|
net/mlx5: fix host physical function representor naming
The new kernel adds the names like "pf0" for Host PCI physical
function representor on Bluefield SmartNIC hosts. This patch
provides correct HPF representor recognition over the kernel
versions 5.7 and laters.
The following port naming formats are supported:
- missing physical port name (no sysfs/netlink key) at all,
master is assumed
- decimal digits (for example "12"), representor is
assumed, the value is the index of attached VF
- "p" followed by decimal digits, for example "p2", master
is assumed
- "pf" followed by PF index, for example "pf0", Host PF
representor is assumed on SmartNIC systems.
- "pf" followed by PF index concatenated with "vf" followed by
VF index, for example "pf0vf1", representor is assumed.
If index of VF is "-1" it is a special case of Host PF
representor, this representor must be indexed in devargs
as 65535, for example representor=[0-3,65535] will
allow representors for VF0, VF1, VF2, VF3 and for host PF.
Fixes: 79aa430721b1 ("common/mlx5: split common file under Linux directory")
Cc: stable@dpdk.org
Signed-off-by: Viacheslav Ovsiienko <viacheslavo@mellanox.com>
Acked-by: Matan Azrad <matan@mellanox.com>
2020-06-23 07:48:34 +00:00
|
|
|
case MLX5_PHYS_PORT_NAME_TYPE_PFHPF:
|
|
|
|
/* Fallthrough */
|
2020-06-03 15:06:00 +00:00
|
|
|
case MLX5_PHYS_PORT_NAME_TYPE_PFVF:
|
2021-03-28 13:48:08 +00:00
|
|
|
/* Fallthrough */
|
|
|
|
case MLX5_PHYS_PORT_NAME_TYPE_PFSF:
|
2020-06-03 15:06:00 +00:00
|
|
|
if (list[ns].info.pf_num == bd)
|
|
|
|
ns++;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!ret && (list[ns].info.representor ^
|
|
|
|
list[ns].info.master))
|
|
|
|
ns++;
|
|
|
|
}
|
|
|
|
if (!ns) {
|
|
|
|
DRV_LOG(ERR,
|
2021-10-19 20:55:50 +00:00
|
|
|
"Unable to recognize master/representors on the IB device with multiple ports.");
|
2020-06-03 15:06:00 +00:00
|
|
|
rte_errno = ENOENT;
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The existence of several matching entries (nd > 1) means
|
|
|
|
* port representors have been instantiated. No existing Verbs
|
|
|
|
* call nor sysfs entries can tell them apart, this can only
|
|
|
|
* be done through Netlink calls assuming kernel drivers are
|
|
|
|
* recent enough to support them.
|
|
|
|
*
|
|
|
|
* In the event of identification failure through Netlink,
|
|
|
|
* try again through sysfs, then:
|
|
|
|
*
|
|
|
|
* 1. A single IB device matches (nd == 1) with single
|
|
|
|
* port (np=0/1) and is not a representor, assume
|
|
|
|
* no switch support.
|
|
|
|
*
|
|
|
|
* 2. Otherwise no safe assumptions can be made;
|
|
|
|
* complain louder and bail out.
|
|
|
|
*/
|
|
|
|
for (i = 0; i != nd; ++i) {
|
|
|
|
memset(&list[ns].info, 0, sizeof(list[ns].info));
|
2021-03-28 13:48:12 +00:00
|
|
|
list[ns].bond_info = NULL;
|
2020-06-03 15:06:00 +00:00
|
|
|
list[ns].max_port = 1;
|
2020-06-03 15:06:02 +00:00
|
|
|
list[ns].phys_port = 1;
|
2021-10-19 20:55:50 +00:00
|
|
|
list[ns].phys_dev_name = ibv_match[i]->name;
|
2020-06-03 15:06:00 +00:00
|
|
|
list[ns].eth_dev = NULL;
|
|
|
|
list[ns].pci_dev = pci_dev;
|
2021-10-19 20:55:46 +00:00
|
|
|
list[ns].cdev = cdev;
|
2020-06-03 15:06:00 +00:00
|
|
|
list[ns].pf_bond = -1;
|
|
|
|
list[ns].ifindex = 0;
|
|
|
|
if (nl_rdma >= 0)
|
|
|
|
list[ns].ifindex = mlx5_nl_ifindex
|
2021-10-19 20:55:50 +00:00
|
|
|
(nl_rdma,
|
|
|
|
ibv_match[i]->name,
|
|
|
|
1);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!list[ns].ifindex) {
|
|
|
|
char ifname[IF_NAMESIZE];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Netlink failed, it may happen with old
|
|
|
|
* ib_core kernel driver (before 4.16).
|
|
|
|
* We can assume there is old driver because
|
|
|
|
* here we are processing single ports IB
|
|
|
|
* devices. Let's try sysfs to retrieve
|
|
|
|
* the ifindex. The method works for
|
|
|
|
* master device only.
|
|
|
|
*/
|
|
|
|
if (nd > 1) {
|
|
|
|
/*
|
|
|
|
* Multiple devices found, assume
|
|
|
|
* representors, can not distinguish
|
|
|
|
* master/representor and retrieve
|
|
|
|
* ifindex via sysfs.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
2020-06-18 19:06:02 +00:00
|
|
|
ret = mlx5_get_ifname_sysfs
|
|
|
|
(ibv_match[i]->ibdev_path, ifname);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!ret)
|
|
|
|
list[ns].ifindex =
|
|
|
|
if_nametoindex(ifname);
|
|
|
|
if (!list[ns].ifindex) {
|
|
|
|
/*
|
|
|
|
* No network interface index found
|
|
|
|
* for the specified device, it means
|
|
|
|
* there it is neither representor
|
|
|
|
* nor master.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = -1;
|
|
|
|
if (nl_route >= 0)
|
2021-10-19 20:55:52 +00:00
|
|
|
ret = mlx5_nl_switch_info(nl_route,
|
|
|
|
list[ns].ifindex,
|
|
|
|
&list[ns].info);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (ret || (!list[ns].info.representor &&
|
|
|
|
!list[ns].info.master)) {
|
|
|
|
/*
|
|
|
|
* We failed to recognize representors with
|
|
|
|
* Netlink, let's try to perform the task
|
|
|
|
* with sysfs.
|
|
|
|
*/
|
2021-10-19 20:55:50 +00:00
|
|
|
ret = mlx5_sysfs_switch_info(list[ns].ifindex,
|
|
|
|
&list[ns].info);
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
if (!ret && (list[ns].info.representor ^
|
|
|
|
list[ns].info.master)) {
|
|
|
|
ns++;
|
|
|
|
} else if ((nd == 1) &&
|
|
|
|
!list[ns].info.representor &&
|
|
|
|
!list[ns].info.master) {
|
|
|
|
/*
|
2021-10-19 20:55:50 +00:00
|
|
|
* Single IB device with one physical port and
|
2020-06-03 15:06:00 +00:00
|
|
|
* attached network device.
|
2021-10-19 20:55:50 +00:00
|
|
|
* May be SRIOV is not enabled or there is no
|
|
|
|
* representors.
|
2020-06-03 15:06:00 +00:00
|
|
|
*/
|
2021-10-19 20:55:50 +00:00
|
|
|
DRV_LOG(INFO, "No E-Switch support detected.");
|
2020-06-03 15:06:00 +00:00
|
|
|
ns++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!ns) {
|
|
|
|
DRV_LOG(ERR,
|
2021-10-19 20:55:50 +00:00
|
|
|
"Unable to recognize master/representors on the multiple IB devices.");
|
2020-06-03 15:06:00 +00:00
|
|
|
rte_errno = ENOENT;
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto exit;
|
|
|
|
}
|
2021-06-11 15:37:19 +00:00
|
|
|
/*
|
|
|
|
* New kernels may add the switch_id attribute for the case
|
2021-10-19 20:55:52 +00:00
|
|
|
* there is no E-Switch and we wrongly recognized the only
|
|
|
|
* device as master. Override this if there is the single
|
|
|
|
* device with single port and new device name format present.
|
2021-06-11 15:37:19 +00:00
|
|
|
*/
|
|
|
|
if (nd == 1 &&
|
|
|
|
list[0].info.name_type == MLX5_PHYS_PORT_NAME_TYPE_UPLINK) {
|
|
|
|
list[0].info.master = 0;
|
|
|
|
list[0].info.representor = 0;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
MLX5_ASSERT(ns);
|
|
|
|
/*
|
|
|
|
* Sort list to probe devices in natural order for users convenience
|
|
|
|
* (i.e. master first, then representors from lowest to highest ID).
|
|
|
|
*/
|
|
|
|
qsort(list, ns, sizeof(*list), mlx5_dev_spawn_data_cmp);
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
if (eth_da.type != RTE_ETH_REPRESENTOR_NONE) {
|
|
|
|
/* Set devargs default values. */
|
|
|
|
if (eth_da.nb_mh_controllers == 0) {
|
|
|
|
eth_da.nb_mh_controllers = 1;
|
|
|
|
eth_da.mh_controllers[0] = 0;
|
|
|
|
}
|
|
|
|
if (eth_da.nb_ports == 0 && ns > 0) {
|
|
|
|
if (list[0].pf_bond >= 0 && list[0].info.representor)
|
|
|
|
DRV_LOG(WARNING, "Representor on Bonding device should use pf#vf# syntax: %s",
|
|
|
|
pci_dev->device.devargs->args);
|
|
|
|
eth_da.nb_ports = 1;
|
|
|
|
eth_da.ports[0] = list[0].info.pf_num;
|
|
|
|
}
|
|
|
|
if (eth_da.nb_representor_ports == 0) {
|
|
|
|
eth_da.nb_representor_ports = 1;
|
|
|
|
eth_da.representor_ports[0] = 0;
|
|
|
|
}
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
for (i = 0; i != ns; ++i) {
|
|
|
|
uint32_t restore;
|
|
|
|
|
2022-02-14 09:35:11 +00:00
|
|
|
list[i].eth_dev = mlx5_dev_spawn(cdev->dev, &list[i], ð_da,
|
|
|
|
mkvlist);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (!list[i].eth_dev) {
|
|
|
|
if (rte_errno != EBUSY && rte_errno != EEXIST)
|
|
|
|
break;
|
|
|
|
/* Device is disabled or already spawned. Ignore it. */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
restore = list[i].eth_dev->data->dev_flags;
|
|
|
|
rte_eth_copy_pci_info(list[i].eth_dev, pci_dev);
|
2021-07-20 15:38:19 +00:00
|
|
|
/**
|
|
|
|
* Each representor has a dedicated interrupts vector.
|
|
|
|
* rte_eth_copy_pci_info() assigns PF interrupts handle to
|
|
|
|
* representor eth_dev object because representor and PF
|
|
|
|
* share the same PCI address.
|
|
|
|
* Override representor device with a dedicated
|
|
|
|
* interrupts handle here.
|
|
|
|
* Representor interrupts handle is released in mlx5_dev_stop().
|
|
|
|
*/
|
|
|
|
if (list[i].info.representor) {
|
2021-10-22 20:49:32 +00:00
|
|
|
struct rte_intr_handle *intr_handle =
|
|
|
|
rte_intr_instance_alloc(RTE_INTR_INSTANCE_F_SHARED);
|
|
|
|
if (intr_handle == NULL) {
|
2021-07-20 15:38:19 +00:00
|
|
|
DRV_LOG(ERR,
|
|
|
|
"port %u failed to allocate memory for interrupt handler "
|
|
|
|
"Rx interrupts will not be supported",
|
|
|
|
i);
|
|
|
|
rte_errno = ENOMEM;
|
|
|
|
ret = -rte_errno;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
list[i].eth_dev->intr_handle = intr_handle;
|
|
|
|
}
|
2020-06-03 15:06:00 +00:00
|
|
|
/* Restore non-PCI flags cleared by the above call. */
|
|
|
|
list[i].eth_dev->data->dev_flags |= restore;
|
|
|
|
rte_eth_dev_probing_finish(list[i].eth_dev);
|
|
|
|
}
|
|
|
|
if (i != ns) {
|
|
|
|
DRV_LOG(ERR,
|
|
|
|
"probe of PCI device " PCI_PRI_FMT " aborted after"
|
|
|
|
" encountering an error: %s",
|
net/mlx5: refactor bonding representor probing
To probe representor on 2nd PF of kernel bonding device, had to specify
PF1 BDF in devarg:
<PF1_BDF>,representor=0
When closing bonding device, all representors had to be closed together
and this implies all representors have to use primary PF of bonding
device. So after probing representor port on 2nd PF, when locating new
probed device using device argument, the filter used 2nd PF as PCI
address and failed to locate new device.
Conflict happened by using current representor devargs:
- Use PCI BDF to specify representor owner PF
- Use PCI BDF to locate probed representor device.
- PMD uses primary PCI BDF as PCI device.
To resolve such conflicts, new representor syntax is introduced here:
<primary BDF>,representor=pfXvfY
All representors must use primary PF as owner PCI device, PMD internally
locate owner PCI address by checking representor "pfX" part. To EAL, all
representors are registered to primary PCI device, the 2nd PF is hidden
to EAL, thus all search should be consistent.
Same to VF representor, HPF (host PF on BlueField) uses same syntax to
probe, example: representor=pf1vf[0-3,-1]
This patch also adds pf index into kernel bonding representor port name:
<BDF>_<ib_name>_representor_pf<X>vf<Y>
Signed-off-by: Xueming Li <xuemingl@nvidia.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
2021-03-28 13:48:10 +00:00
|
|
|
owner_pci.domain, owner_pci.bus,
|
|
|
|
owner_pci.devid, owner_pci.function,
|
2020-06-03 15:06:00 +00:00
|
|
|
strerror(rte_errno));
|
|
|
|
ret = -rte_errno;
|
|
|
|
/* Roll back. */
|
|
|
|
while (i--) {
|
|
|
|
if (!list[i].eth_dev)
|
|
|
|
continue;
|
|
|
|
mlx5_dev_close(list[i].eth_dev);
|
|
|
|
/* mac_addrs must not be freed because in dev_private */
|
|
|
|
list[i].eth_dev->data->mac_addrs = NULL;
|
|
|
|
claim_zero(rte_eth_dev_release_port(list[i].eth_dev));
|
|
|
|
}
|
|
|
|
/* Restore original error. */
|
|
|
|
rte_errno = -ret;
|
|
|
|
} else {
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
exit:
|
|
|
|
/*
|
|
|
|
* Do the routine cleanup:
|
|
|
|
* - close opened Netlink sockets
|
|
|
|
* - free allocated spawn data array
|
|
|
|
* - free the Infiniband device list
|
|
|
|
*/
|
|
|
|
if (nl_rdma >= 0)
|
|
|
|
close(nl_rdma);
|
|
|
|
if (nl_route >= 0)
|
|
|
|
close(nl_route);
|
|
|
|
if (list)
|
2020-06-28 09:02:44 +00:00
|
|
|
mlx5_free(list);
|
2020-06-03 15:06:00 +00:00
|
|
|
MLX5_ASSERT(ibv_list);
|
|
|
|
mlx5_glue->free_device_list(ibv_list);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-07-21 14:37:35 +00:00
|
|
|
static int
|
|
|
|
mlx5_os_parse_eth_devargs(struct rte_device *dev,
|
|
|
|
struct rte_eth_devargs *eth_da)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (dev->devargs == NULL)
|
|
|
|
return 0;
|
|
|
|
memset(eth_da, 0, sizeof(*eth_da));
|
|
|
|
/* Parse representor information first from class argument. */
|
|
|
|
if (dev->devargs->cls_str)
|
|
|
|
ret = rte_eth_devargs_parse(dev->devargs->cls_str, eth_da);
|
|
|
|
if (ret != 0) {
|
|
|
|
DRV_LOG(ERR, "failed to parse device arguments: %s",
|
|
|
|
dev->devargs->cls_str);
|
|
|
|
return -rte_errno;
|
|
|
|
}
|
2022-10-24 12:33:35 +00:00
|
|
|
if (eth_da->type == RTE_ETH_REPRESENTOR_NONE && dev->devargs->args) {
|
2021-07-21 14:37:35 +00:00
|
|
|
/* Parse legacy device argument */
|
|
|
|
ret = rte_eth_devargs_parse(dev->devargs->args, eth_da);
|
|
|
|
if (ret) {
|
|
|
|
DRV_LOG(ERR, "failed to parse device arguments: %s",
|
|
|
|
dev->devargs->args);
|
|
|
|
return -rte_errno;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-03-28 13:48:11 +00:00
|
|
|
/**
|
2021-07-21 14:37:34 +00:00
|
|
|
* Callback to register a PCI device.
|
2021-03-28 13:48:11 +00:00
|
|
|
*
|
|
|
|
* This function spawns Ethernet devices out of a given PCI device.
|
|
|
|
*
|
2021-10-19 20:55:46 +00:00
|
|
|
* @param[in] cdev
|
|
|
|
* Pointer to common mlx5 device structure.
|
2022-02-14 09:35:11 +00:00
|
|
|
* @param[in, out] mkvlist
|
|
|
|
* Pointer to mlx5 kvargs control, can be NULL if there is no devargs.
|
2021-03-28 13:48:11 +00:00
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on success, a negative errno value otherwise and rte_errno is set.
|
|
|
|
*/
|
2021-07-21 14:37:34 +00:00
|
|
|
static int
|
2022-02-14 09:35:11 +00:00
|
|
|
mlx5_os_pci_probe(struct mlx5_common_device *cdev,
|
|
|
|
struct mlx5_kvargs_ctrl *mkvlist)
|
2021-03-28 13:48:11 +00:00
|
|
|
{
|
2021-10-19 20:55:46 +00:00
|
|
|
struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(cdev->dev);
|
2021-07-21 14:37:35 +00:00
|
|
|
struct rte_eth_devargs eth_da = { .nb_ports = 0 };
|
2021-03-28 13:48:11 +00:00
|
|
|
int ret = 0;
|
|
|
|
uint16_t p;
|
|
|
|
|
2021-10-19 20:55:46 +00:00
|
|
|
ret = mlx5_os_parse_eth_devargs(cdev->dev, ð_da);
|
2021-07-21 14:37:35 +00:00
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
2021-03-28 13:48:11 +00:00
|
|
|
|
|
|
|
if (eth_da.nb_ports > 0) {
|
|
|
|
/* Iterate all port if devargs pf is range: "pf[0-1]vf[...]". */
|
2021-09-12 10:36:24 +00:00
|
|
|
for (p = 0; p < eth_da.nb_ports; p++) {
|
2021-10-19 20:55:52 +00:00
|
|
|
ret = mlx5_os_pci_probe_pf(cdev, ð_da,
|
2022-02-14 09:35:11 +00:00
|
|
|
eth_da.ports[p], mkvlist);
|
2022-04-06 07:12:24 +00:00
|
|
|
if (ret) {
|
|
|
|
DRV_LOG(INFO, "Probe of PCI device " PCI_PRI_FMT " "
|
|
|
|
"aborted due to proding failure of PF %u",
|
|
|
|
pci_dev->addr.domain, pci_dev->addr.bus,
|
|
|
|
pci_dev->addr.devid, pci_dev->addr.function,
|
|
|
|
eth_da.ports[p]);
|
|
|
|
mlx5_net_remove(cdev);
|
|
|
|
if (p != 0)
|
|
|
|
break;
|
|
|
|
}
|
2021-09-12 10:36:24 +00:00
|
|
|
}
|
2021-03-28 13:48:11 +00:00
|
|
|
} else {
|
2022-02-14 09:35:11 +00:00
|
|
|
ret = mlx5_os_pci_probe_pf(cdev, ð_da, 0, mkvlist);
|
2021-03-28 13:48:11 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-07-21 14:37:35 +00:00
|
|
|
/* Probe a single SF device on auxiliary bus, no representor support. */
|
|
|
|
static int
|
2022-02-14 09:35:11 +00:00
|
|
|
mlx5_os_auxiliary_probe(struct mlx5_common_device *cdev,
|
|
|
|
struct mlx5_kvargs_ctrl *mkvlist)
|
2021-07-21 14:37:35 +00:00
|
|
|
{
|
|
|
|
struct rte_eth_devargs eth_da = { .nb_ports = 0 };
|
|
|
|
struct mlx5_dev_spawn_data spawn = { .pf_bond = -1 };
|
2021-10-19 20:55:46 +00:00
|
|
|
struct rte_device *dev = cdev->dev;
|
2021-07-21 14:37:35 +00:00
|
|
|
struct rte_auxiliary_device *adev = RTE_DEV_TO_AUXILIARY(dev);
|
|
|
|
struct rte_eth_dev *eth_dev;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* Parse ethdev devargs. */
|
|
|
|
ret = mlx5_os_parse_eth_devargs(dev, ð_da);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
/* Init spawn data. */
|
|
|
|
spawn.max_port = 1;
|
|
|
|
spawn.phys_port = 1;
|
2021-10-19 20:55:52 +00:00
|
|
|
spawn.phys_dev_name = mlx5_os_get_ctx_device_name(cdev->ctx);
|
2021-07-21 14:37:35 +00:00
|
|
|
ret = mlx5_auxiliary_get_ifindex(dev->name);
|
|
|
|
if (ret < 0) {
|
|
|
|
DRV_LOG(ERR, "failed to get ethdev ifindex: %s", dev->name);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
spawn.ifindex = ret;
|
2021-10-19 20:55:46 +00:00
|
|
|
spawn.cdev = cdev;
|
2021-07-21 14:37:35 +00:00
|
|
|
/* Spawn device. */
|
2022-02-14 09:35:11 +00:00
|
|
|
eth_dev = mlx5_dev_spawn(dev, &spawn, ð_da, mkvlist);
|
2021-07-21 14:37:35 +00:00
|
|
|
if (eth_dev == NULL)
|
|
|
|
return -rte_errno;
|
|
|
|
/* Post create. */
|
2021-10-22 20:49:32 +00:00
|
|
|
eth_dev->intr_handle = adev->intr_handle;
|
2021-07-21 14:37:35 +00:00
|
|
|
if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
|
|
|
|
eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
|
|
|
|
eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_RMV;
|
|
|
|
eth_dev->data->numa_node = dev->numa_node;
|
|
|
|
}
|
|
|
|
rte_eth_dev_probing_finish(eth_dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-07-21 14:37:34 +00:00
|
|
|
/**
|
|
|
|
* Net class driver callback to probe a device.
|
|
|
|
*
|
2021-07-21 14:37:35 +00:00
|
|
|
* This function probe PCI bus device(s) or a single SF on auxiliary bus.
|
2021-07-21 14:37:34 +00:00
|
|
|
*
|
2021-10-19 20:55:46 +00:00
|
|
|
* @param[in] cdev
|
|
|
|
* Pointer to the common mlx5 device.
|
2022-02-14 09:35:11 +00:00
|
|
|
* @param[in, out] mkvlist
|
|
|
|
* Pointer to mlx5 kvargs control, can be NULL if there is no devargs.
|
2021-07-21 14:37:34 +00:00
|
|
|
*
|
|
|
|
* @return
|
2021-10-19 20:55:46 +00:00
|
|
|
* 0 on success, a negative errno value otherwise and rte_errno is set.
|
2021-07-21 14:37:34 +00:00
|
|
|
*/
|
|
|
|
int
|
2022-02-14 09:35:11 +00:00
|
|
|
mlx5_os_net_probe(struct mlx5_common_device *cdev,
|
|
|
|
struct mlx5_kvargs_ctrl *mkvlist)
|
2021-07-21 14:37:34 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2021-10-19 20:55:52 +00:00
|
|
|
if (rte_eal_process_type() == RTE_PROC_PRIMARY)
|
2021-07-21 14:37:34 +00:00
|
|
|
mlx5_pmd_socket_init();
|
|
|
|
ret = mlx5_init_once();
|
|
|
|
if (ret) {
|
2021-10-19 20:55:46 +00:00
|
|
|
DRV_LOG(ERR, "Unable to init PMD global data: %s",
|
2021-07-21 14:37:34 +00:00
|
|
|
strerror(rte_errno));
|
|
|
|
return -rte_errno;
|
|
|
|
}
|
2022-02-14 09:35:11 +00:00
|
|
|
ret = mlx5_probe_again_args_validate(cdev, mkvlist);
|
2022-02-14 09:35:07 +00:00
|
|
|
if (ret) {
|
|
|
|
DRV_LOG(ERR, "Probe again parameters are not compatible : %s",
|
|
|
|
strerror(rte_errno));
|
|
|
|
return -rte_errno;
|
|
|
|
}
|
2021-10-19 20:55:46 +00:00
|
|
|
if (mlx5_dev_is_pci(cdev->dev))
|
2022-02-14 09:35:11 +00:00
|
|
|
return mlx5_os_pci_probe(cdev, mkvlist);
|
2020-06-03 15:06:00 +00:00
|
|
|
else
|
2022-02-14 09:35:11 +00:00
|
|
|
return mlx5_os_auxiliary_probe(cdev, mkvlist);
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
|
|
|
|
2021-10-14 08:55:28 +00:00
|
|
|
/**
|
|
|
|
* Cleanup resources when the last device is closed.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
mlx5_os_net_cleanup(void)
|
|
|
|
{
|
|
|
|
mlx5_pmd_socket_uninit();
|
|
|
|
}
|
|
|
|
|
2020-06-03 15:06:00 +00:00
|
|
|
/**
|
|
|
|
* Install shared asynchronous device events handler.
|
|
|
|
* This function is implemented to support event sharing
|
|
|
|
* between multiple ports of single IB device.
|
|
|
|
*
|
|
|
|
* @param sh
|
|
|
|
* Pointer to mlx5_dev_ctx_shared object.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
mlx5_os_dev_shared_handler_install(struct mlx5_dev_ctx_shared *sh)
|
|
|
|
{
|
2021-10-19 20:55:52 +00:00
|
|
|
struct ibv_context *ctx = sh->cdev->ctx;
|
2022-06-16 08:41:50 +00:00
|
|
|
int nlsk_fd;
|
2020-06-03 15:06:00 +00:00
|
|
|
|
2022-06-16 08:41:50 +00:00
|
|
|
sh->intr_handle = mlx5_os_interrupt_handler_create
|
|
|
|
(RTE_INTR_INSTANCE_F_SHARED, true,
|
|
|
|
ctx->async_fd, mlx5_dev_interrupt_handler, sh);
|
|
|
|
if (!sh->intr_handle) {
|
|
|
|
DRV_LOG(ERR, "Failed to allocate intr_handle.");
|
2021-10-22 20:49:32 +00:00
|
|
|
return;
|
|
|
|
}
|
2022-06-16 08:41:50 +00:00
|
|
|
nlsk_fd = mlx5_nl_init(NETLINK_ROUTE, RTMGRP_LINK);
|
|
|
|
if (nlsk_fd < 0) {
|
|
|
|
DRV_LOG(ERR, "Failed to create a socket for Netlink events: %s",
|
|
|
|
rte_strerror(rte_errno));
|
|
|
|
return;
|
2020-06-03 15:06:00 +00:00
|
|
|
}
|
2022-06-16 08:41:50 +00:00
|
|
|
sh->intr_handle_nl = mlx5_os_interrupt_handler_create
|
|
|
|
(RTE_INTR_INSTANCE_F_SHARED, true,
|
|
|
|
nlsk_fd, mlx5_dev_interrupt_handler_nl, sh);
|
2022-03-01 12:15:13 +00:00
|
|
|
if (sh->intr_handle_nl == NULL) {
|
|
|
|
DRV_LOG(ERR, "Fail to allocate intr_handle");
|
|
|
|
return;
|
|
|
|
}
|
2022-02-14 09:34:59 +00:00
|
|
|
if (sh->cdev->config.devx) {
|
2020-06-03 15:06:00 +00:00
|
|
|
#ifdef HAVE_IBV_DEVX_ASYNC
|
2022-06-16 08:41:50 +00:00
|
|
|
struct mlx5dv_devx_cmd_comp *devx_comp;
|
|
|
|
|
2021-10-19 20:55:52 +00:00
|
|
|
sh->devx_comp = (void *)mlx5_glue->devx_create_cmd_comp(ctx);
|
2022-06-16 08:41:50 +00:00
|
|
|
devx_comp = sh->devx_comp;
|
2020-06-10 09:32:26 +00:00
|
|
|
if (!devx_comp) {
|
2020-06-03 15:06:00 +00:00
|
|
|
DRV_LOG(INFO, "failed to allocate devx_comp.");
|
|
|
|
return;
|
|
|
|
}
|
2022-06-16 08:41:50 +00:00
|
|
|
sh->intr_handle_devx = mlx5_os_interrupt_handler_create
|
|
|
|
(RTE_INTR_INSTANCE_F_SHARED, true,
|
|
|
|
devx_comp->fd,
|
|
|
|
mlx5_dev_interrupt_handler_devx, sh);
|
|
|
|
if (!sh->intr_handle_devx) {
|
|
|
|
DRV_LOG(ERR, "Failed to allocate intr_handle.");
|
2020-06-03 15:06:00 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* HAVE_IBV_DEVX_ASYNC */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Uninstall shared asynchronous device events handler.
|
|
|
|
* This function is implemented to support event sharing
|
|
|
|
* between multiple ports of single IB device.
|
|
|
|
*
|
|
|
|
* @param dev
|
|
|
|
* Pointer to mlx5_dev_ctx_shared object.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
mlx5_os_dev_shared_handler_uninstall(struct mlx5_dev_ctx_shared *sh)
|
|
|
|
{
|
2022-06-16 08:41:50 +00:00
|
|
|
mlx5_os_interrupt_handler_destroy(sh->intr_handle,
|
|
|
|
mlx5_dev_interrupt_handler, sh);
|
|
|
|
mlx5_os_interrupt_handler_destroy(sh->intr_handle_nl,
|
|
|
|
mlx5_dev_interrupt_handler_nl, sh);
|
2020-06-03 15:06:00 +00:00
|
|
|
#ifdef HAVE_IBV_DEVX_ASYNC
|
2022-06-16 08:41:50 +00:00
|
|
|
mlx5_os_interrupt_handler_destroy(sh->intr_handle_devx,
|
|
|
|
mlx5_dev_interrupt_handler_devx, sh);
|
2020-06-03 15:06:00 +00:00
|
|
|
if (sh->devx_comp)
|
|
|
|
mlx5_glue->devx_destroy_cmd_comp(sh->devx_comp);
|
|
|
|
#endif
|
|
|
|
}
|
2020-06-10 09:32:30 +00:00
|
|
|
|
2020-06-10 09:32:33 +00:00
|
|
|
/**
|
|
|
|
* Read statistics by a named counter.
|
|
|
|
*
|
|
|
|
* @param[in] priv
|
|
|
|
* Pointer to the private device data structure.
|
|
|
|
* @param[in] ctr_name
|
|
|
|
* Pointer to the name of the statistic counter to read
|
|
|
|
* @param[out] stat
|
|
|
|
* Pointer to read statistic value.
|
|
|
|
* @return
|
|
|
|
* 0 on success and stat is valud, 1 if failed to read the value
|
|
|
|
* rte_errno is set.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
mlx5_os_read_dev_stat(struct mlx5_priv *priv, const char *ctr_name,
|
|
|
|
uint64_t *stat)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (priv->sh) {
|
2021-02-25 10:45:01 +00:00
|
|
|
if (priv->q_counters != NULL &&
|
|
|
|
strcmp(ctr_name, "out_of_buffer") == 0)
|
2021-04-28 09:31:45 +00:00
|
|
|
return mlx5_devx_cmd_queue_counter_query
|
|
|
|
(priv->q_counters, 0, (uint32_t *)stat);
|
2020-06-10 09:32:33 +00:00
|
|
|
MKSTR(path, "%s/ports/%d/hw_counters/%s",
|
2020-07-15 10:50:55 +00:00
|
|
|
priv->sh->ibdev_path,
|
|
|
|
priv->dev_port,
|
|
|
|
ctr_name);
|
2020-06-10 09:32:33 +00:00
|
|
|
fd = open(path, O_RDONLY);
|
2020-07-15 10:50:55 +00:00
|
|
|
/*
|
|
|
|
* in switchdev the file location is not per port
|
|
|
|
* but rather in <ibdev_path>/hw_counters/<file_name>.
|
|
|
|
*/
|
|
|
|
if (fd == -1) {
|
|
|
|
MKSTR(path1, "%s/hw_counters/%s",
|
|
|
|
priv->sh->ibdev_path,
|
|
|
|
ctr_name);
|
|
|
|
fd = open(path1, O_RDONLY);
|
|
|
|
}
|
2020-06-10 09:32:33 +00:00
|
|
|
if (fd != -1) {
|
|
|
|
char buf[21] = {'\0'};
|
|
|
|
ssize_t n = read(fd, buf, sizeof(buf));
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
if (n != -1) {
|
|
|
|
*stat = strtoull(buf, NULL, 10);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*stat = 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2020-07-19 10:18:11 +00:00
|
|
|
/**
|
|
|
|
* Remove a MAC address from device
|
|
|
|
*
|
|
|
|
* @param dev
|
|
|
|
* Pointer to Ethernet device structure.
|
|
|
|
* @param index
|
|
|
|
* MAC address index.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
mlx5_os_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
|
|
|
|
{
|
|
|
|
struct mlx5_priv *priv = dev->data->dev_private;
|
2022-02-14 09:35:06 +00:00
|
|
|
const int vf = priv->sh->dev_cap.vf;
|
2020-07-19 10:18:11 +00:00
|
|
|
|
|
|
|
if (vf)
|
|
|
|
mlx5_nl_mac_addr_remove(priv->nl_socket_route,
|
|
|
|
mlx5_ifindex(dev), priv->mac_own,
|
|
|
|
&dev->data->mac_addrs[index], index);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds a MAC address to the device
|
|
|
|
*
|
|
|
|
* @param dev
|
|
|
|
* Pointer to Ethernet device structure.
|
|
|
|
* @param mac_addr
|
|
|
|
* MAC address to register.
|
|
|
|
* @param index
|
|
|
|
* MAC address index.
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on success, a negative errno value otherwise
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
mlx5_os_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
|
|
|
|
uint32_t index)
|
|
|
|
{
|
|
|
|
struct mlx5_priv *priv = dev->data->dev_private;
|
2022-02-14 09:35:06 +00:00
|
|
|
const int vf = priv->sh->dev_cap.vf;
|
2020-07-19 10:18:11 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (vf)
|
|
|
|
ret = mlx5_nl_mac_addr_add(priv->nl_socket_route,
|
|
|
|
mlx5_ifindex(dev), priv->mac_own,
|
|
|
|
mac, index);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Modify a VF MAC address
|
|
|
|
*
|
|
|
|
* @param priv
|
|
|
|
* Pointer to device private data.
|
|
|
|
* @param mac_addr
|
|
|
|
* MAC address to modify into.
|
|
|
|
* @param iface_idx
|
|
|
|
* Net device interface index
|
|
|
|
* @param vf_index
|
|
|
|
* VF index
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on success, a negative errno value otherwise
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
mlx5_os_vf_mac_addr_modify(struct mlx5_priv *priv,
|
|
|
|
unsigned int iface_idx,
|
|
|
|
struct rte_ether_addr *mac_addr,
|
|
|
|
int vf_index)
|
|
|
|
{
|
|
|
|
return mlx5_nl_vf_mac_addr_modify
|
|
|
|
(priv->nl_socket_route, iface_idx, mac_addr, vf_index);
|
|
|
|
}
|
|
|
|
|
2020-07-19 10:18:12 +00:00
|
|
|
/**
|
|
|
|
* Set device promiscuous mode
|
|
|
|
*
|
|
|
|
* @param dev
|
|
|
|
* Pointer to Ethernet device structure.
|
|
|
|
* @param enable
|
|
|
|
* 0 - promiscuous is disabled, otherwise - enabled
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on success, a negative error value otherwise
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
mlx5_os_set_promisc(struct rte_eth_dev *dev, int enable)
|
|
|
|
{
|
|
|
|
struct mlx5_priv *priv = dev->data->dev_private;
|
|
|
|
|
|
|
|
return mlx5_nl_promisc(priv->nl_socket_route,
|
|
|
|
mlx5_ifindex(dev), !!enable);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set device promiscuous mode
|
|
|
|
*
|
|
|
|
* @param dev
|
|
|
|
* Pointer to Ethernet device structure.
|
|
|
|
* @param enable
|
|
|
|
* 0 - all multicase is disabled, otherwise - enabled
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
* 0 on success, a negative error value otherwise
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
mlx5_os_set_allmulti(struct rte_eth_dev *dev, int enable)
|
|
|
|
{
|
|
|
|
struct mlx5_priv *priv = dev->data->dev_private;
|
|
|
|
|
|
|
|
return mlx5_nl_allmulti(priv->nl_socket_route,
|
|
|
|
mlx5_ifindex(dev), !!enable);
|
|
|
|
}
|
|
|
|
|
2020-08-25 09:31:09 +00:00
|
|
|
/**
|
|
|
|
* Flush device MAC addresses
|
|
|
|
*
|
|
|
|
* @param dev
|
|
|
|
* Pointer to Ethernet device structure.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
mlx5_os_mac_addr_flush(struct rte_eth_dev *dev)
|
|
|
|
{
|
|
|
|
struct mlx5_priv *priv = dev->data->dev_private;
|
|
|
|
|
|
|
|
mlx5_nl_mac_addr_flush(priv->nl_socket_route, mlx5_ifindex(dev),
|
|
|
|
dev->data->mac_addrs,
|
|
|
|
MLX5_MAX_MAC_ADDRESSES, priv->mac_own);
|
|
|
|
}
|