2018-01-29 13:11:30 +00:00
|
|
|
/* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
* Copyright 2015 6WIND S.A.
|
2018-03-20 19:20:35 +00:00
|
|
|
* Copyright 2015 Mellanox Technologies, Ltd
|
2015-10-30 18:52:30 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef RTE_PMD_MLX5_H_
|
|
|
|
#define RTE_PMD_MLX5_H_
|
|
|
|
|
|
|
|
#include <stddef.h>
|
2019-07-05 13:10:30 +00:00
|
|
|
#include <stdbool.h>
|
2015-10-30 18:52:30 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <limits.h>
|
2017-10-09 14:44:53 +00:00
|
|
|
#include <sys/queue.h>
|
2015-10-30 18:52:30 +00:00
|
|
|
|
2017-07-07 00:04:20 +00:00
|
|
|
#include <rte_pci.h>
|
2015-10-30 18:52:30 +00:00
|
|
|
#include <rte_ether.h>
|
2021-01-29 16:48:19 +00:00
|
|
|
#include <ethdev_driver.h>
|
net/mlx5: add new memory region support
This is the new design of Memory Region (MR) for mlx PMD, in order to:
- Accommodate the new memory hotplug model.
- Support non-contiguous Mempool.
There are multiple layers for MR search.
L0 is to look up the last-hit entry which is pointed by mr_ctrl->mru (Most
Recently Used). If L0 misses, L1 is to look up the address in a fixed-sized
array by linear search. L0/L1 is in an inline function -
mlx5_mr_lookup_cache().
If L1 misses, the bottom-half function is called to look up the address
from the bigger local cache of the queue. This is L2 - mlx5_mr_addr2mr_bh()
and it is not an inline function. Data structure for L2 is the Binary Tree.
If L2 misses, the search falls into the slowest path which takes locks in
order to access global device cache (priv->mr.cache) which is also a B-tree
and caches the original MR list (priv->mr.mr_list) of the device. Unless
the global cache is overflowed, it is all-inclusive of the MR list. This is
L3 - mlx5_mr_lookup_dev(). The size of the L3 cache table is limited and
can't be expanded on the fly due to deadlock. Refer to the comments in the
code for the details - mr_lookup_dev(). If L3 is overflowed, the list will
have to be searched directly bypassing the cache although it is slower.
If L3 misses, a new MR for the address should be created -
mlx5_mr_create(). When it creates a new MR, it tries to register adjacent
memsegs as much as possible which are virtually contiguous around the
address. This must take two locks - memory_hotplug_lock and
priv->mr.rwlock. Due to memory_hotplug_lock, there can't be any
allocation/free of memory inside.
In the free callback of the memory hotplug event, freed space is searched
from the MR list and corresponding bits are cleared from the bitmap of MRs.
This can fragment a MR and the MR will have multiple search entries in the
caches. Once there's a change by the event, the global cache must be
rebuilt and all the per-queue caches will be flushed as well. If memory is
frequently freed in run-time, that may cause jitter on dataplane processing
in the worst case by incurring MR cache flush and rebuild. But, it would be
the least probable scenario.
To guarantee the most optimal performance, it is highly recommended to use
an EAL option - '--socket-mem'. Then, the reserved memory will be pinned
and won't be freed dynamically. And it is also recommended to configure
per-lcore cache of Mempool. Even though there're many MRs for a device or
MRs are highly fragmented, the cache of Mempool will be much helpful to
reduce misses on per-queue caches anyway.
'--legacy-mem' is also supported.
Signed-off-by: Yongseok Koh <yskoh@mellanox.com>
2018-05-09 11:09:04 +00:00
|
|
|
#include <rte_rwlock.h>
|
2015-10-30 18:57:23 +00:00
|
|
|
#include <rte_interrupts.h>
|
2016-03-17 15:38:55 +00:00
|
|
|
#include <rte_errno.h>
|
2016-12-29 15:15:17 +00:00
|
|
|
#include <rte_flow.h>
|
2021-04-20 10:55:16 +00:00
|
|
|
#include <rte_mtr.h>
|
2015-10-30 18:52:30 +00:00
|
|
|
|
2020-01-29 12:38:27 +00:00
|
|
|
#include <mlx5_glue.h>
|
|
|
|
#include <mlx5_devx_cmds.h>
|
|
|
|
#include <mlx5_prm.h>
|
2020-04-13 21:17:47 +00:00
|
|
|
#include <mlx5_common_mp.h>
|
2020-04-13 21:17:48 +00:00
|
|
|
#include <mlx5_common_mr.h>
|
2021-01-06 08:19:29 +00:00
|
|
|
#include <mlx5_common_devx.h>
|
2020-01-29 12:38:27 +00:00
|
|
|
|
|
|
|
#include "mlx5_defs.h"
|
2015-10-30 18:52:30 +00:00
|
|
|
#include "mlx5_utils.h"
|
2020-06-03 15:06:01 +00:00
|
|
|
#include "mlx5_os.h"
|
2015-10-30 18:52:30 +00:00
|
|
|
#include "mlx5_autoconf.h"
|
|
|
|
|
2020-10-28 09:33:43 +00:00
|
|
|
|
|
|
|
#define MLX5_SH(dev) (((struct mlx5_priv *)(dev)->data->dev_private)->sh)
|
|
|
|
|
2020-04-16 02:42:02 +00:00
|
|
|
enum mlx5_ipool_index {
|
2020-12-28 12:32:55 +00:00
|
|
|
#if defined(HAVE_IBV_FLOW_DV_SUPPORT) || !defined(HAVE_INFINIBAND_VERBS_H)
|
2020-04-16 02:42:02 +00:00
|
|
|
MLX5_IPOOL_DECAP_ENCAP = 0, /* Pool for encap/decap resource. */
|
2020-04-16 02:42:03 +00:00
|
|
|
MLX5_IPOOL_PUSH_VLAN, /* Pool for push vlan resource. */
|
2020-04-16 02:42:04 +00:00
|
|
|
MLX5_IPOOL_TAG, /* Pool for tag resource. */
|
2020-04-16 02:42:05 +00:00
|
|
|
MLX5_IPOOL_PORT_ID, /* Pool for port id resource. */
|
2020-04-16 02:42:06 +00:00
|
|
|
MLX5_IPOOL_JUMP, /* Pool for jump resource. */
|
2020-10-13 14:11:46 +00:00
|
|
|
MLX5_IPOOL_SAMPLE, /* Pool for sample resource. */
|
2020-10-13 14:11:50 +00:00
|
|
|
MLX5_IPOOL_DEST_ARRAY, /* Pool for destination array resource. */
|
2020-11-16 14:02:21 +00:00
|
|
|
MLX5_IPOOL_TUNNEL_ID, /* Pool for tunnel offload context */
|
|
|
|
MLX5_IPOOL_TNL_TBL_ID, /* Pool for tunnel table ID. */
|
2020-04-16 02:42:08 +00:00
|
|
|
#endif
|
2020-04-16 08:34:26 +00:00
|
|
|
MLX5_IPOOL_MTR, /* Pool for meter resource. */
|
2020-04-16 08:34:27 +00:00
|
|
|
MLX5_IPOOL_MCP, /* Pool for metadata resource. */
|
2020-04-16 02:42:07 +00:00
|
|
|
MLX5_IPOOL_HRXQ, /* Pool for hrxq resource. */
|
2020-04-16 02:42:08 +00:00
|
|
|
MLX5_IPOOL_MLX5_FLOW, /* Pool for mlx5 flow handle. */
|
2020-04-16 08:34:30 +00:00
|
|
|
MLX5_IPOOL_RTE_FLOW, /* Pool for rte_flow. */
|
2020-10-28 09:33:24 +00:00
|
|
|
MLX5_IPOOL_RSS_EXPANTION_FLOW_ID, /* Pool for Queue/RSS flow ID. */
|
2020-11-01 17:57:50 +00:00
|
|
|
MLX5_IPOOL_RSS_SHARED_ACTIONS, /* Pool for RSS shared actions. */
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
MLX5_IPOOL_MTR_POLICY, /* Pool for meter policy resource. */
|
2020-04-16 02:42:02 +00:00
|
|
|
MLX5_IPOOL_MAX,
|
|
|
|
};
|
|
|
|
|
net/mlx5: add reclaim memory mode
Currently, when flow destroyed, some memory resources may still be kept
as cached to help next time create flow more efficiently.
Some system may need the resources to be more flexible with flow create
and destroy. After peak time, with millions of flows destroyed, the
system would prefer the resources to be reclaimed completely, no cache
is needed. Then the resources can be allocated and used by other
components. The system is not so sensitive about the flow insertion
rate, but more care about the resources.
Both DPDK mlx5 PMD driver and the low level component rdma-core have
provided the flow resources to be configured cached or not, but there is
no APIs or parameters exposed to user to configure the flow resources
cache mode. In this case, introduce a new PMD devarg to let user
configure the flow resources cache mode will be helpful.
This commit is to add a new "reclaim_mem_mode" to help user configure if
the destroyed flows' cache resources should be kept or not.
Their will be three mode can be chosen:
1. 0(none). It means the flow resources will be cached as usual. The
resources will be cached, helpful with flow insertion rate.
2. 1(light). It will only enable the DPDK PMD level resources reclaim.
3. 2(aggressive). Both DPDK PMD level and rdma-core low level will be
configured as reclaimed mode.
With these three mode, user can configure the resources cache mode with
different levels.
Signed-off-by: Suanming Mou <suanmingm@mellanox.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@mellanox.com>
2020-06-01 06:09:43 +00:00
|
|
|
/*
|
|
|
|
* There are three reclaim memory mode supported.
|
|
|
|
* 0(none) means no memory reclaim.
|
|
|
|
* 1(light) means only PMD level reclaim.
|
|
|
|
* 2(aggressive) means both PMD and rdma-core level reclaim.
|
|
|
|
*/
|
|
|
|
enum mlx5_reclaim_mem_mode {
|
|
|
|
MLX5_RCM_NONE, /* Don't reclaim memory. */
|
|
|
|
MLX5_RCM_LIGHT, /* Reclaim PMD level. */
|
|
|
|
MLX5_RCM_AGGR, /* Reclaim PMD and rdma-core level. */
|
|
|
|
};
|
|
|
|
|
2020-10-28 09:33:42 +00:00
|
|
|
/* Hash and cache list callback context. */
|
|
|
|
struct mlx5_flow_cb_ctx {
|
|
|
|
struct rte_eth_dev *dev;
|
|
|
|
struct rte_flow_error *error;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2020-06-03 15:05:58 +00:00
|
|
|
/* Device attributes used in mlx5 PMD */
|
|
|
|
struct mlx5_dev_attr {
|
|
|
|
uint64_t device_cap_flags_ex;
|
|
|
|
int max_qp_wr;
|
|
|
|
int max_sge;
|
|
|
|
int max_cq;
|
|
|
|
int max_qp;
|
2020-12-28 09:54:06 +00:00
|
|
|
int max_cqe;
|
|
|
|
uint32_t max_pd;
|
|
|
|
uint32_t max_mr;
|
|
|
|
uint32_t max_srq;
|
|
|
|
uint32_t max_srq_wr;
|
2020-06-03 15:05:58 +00:00
|
|
|
uint32_t raw_packet_caps;
|
|
|
|
uint32_t max_rwq_indirection_table_size;
|
|
|
|
uint32_t max_tso;
|
|
|
|
uint32_t tso_supported_qpts;
|
|
|
|
uint64_t flags;
|
|
|
|
uint64_t comp_mask;
|
|
|
|
uint32_t sw_parsing_offloads;
|
|
|
|
uint32_t min_single_stride_log_num_of_bytes;
|
|
|
|
uint32_t max_single_stride_log_num_of_bytes;
|
|
|
|
uint32_t min_single_wqe_log_num_of_strides;
|
|
|
|
uint32_t max_single_wqe_log_num_of_strides;
|
|
|
|
uint32_t stride_supported_qpts;
|
|
|
|
uint32_t tunnel_offloads_caps;
|
|
|
|
char fw_ver[64];
|
|
|
|
};
|
|
|
|
|
2020-06-03 15:06:00 +00:00
|
|
|
/** Data associated with devices to spawn. */
|
|
|
|
struct mlx5_dev_spawn_data {
|
|
|
|
uint32_t ifindex; /**< Network interface index. */
|
2020-06-03 15:06:02 +00:00
|
|
|
uint32_t max_port; /**< Device maximal port index. */
|
|
|
|
uint32_t phys_port; /**< Device physical port index. */
|
2020-06-03 15:06:00 +00:00
|
|
|
int pf_bond; /**< bonding device PF index. < 0 - no bonding */
|
|
|
|
struct mlx5_switch_info info; /**< Switch information. */
|
2020-06-03 15:06:02 +00:00
|
|
|
void *phys_dev; /**< Associated physical device. */
|
2020-06-03 15:06:00 +00:00
|
|
|
struct rte_eth_dev *eth_dev; /**< Associated Ethernet device. */
|
|
|
|
struct rte_pci_device *pci_dev; /**< Backend PCI device. */
|
2021-03-28 13:48:12 +00:00
|
|
|
struct mlx5_bond_info *bond_info;
|
2020-06-03 15:06:00 +00:00
|
|
|
};
|
|
|
|
|
2021-04-15 11:19:24 +00:00
|
|
|
/** Data associated with socket messages. */
|
|
|
|
struct mlx5_flow_dump_req {
|
|
|
|
uint32_t port_id; /**< There are plans in DPDK to extend port_id. */
|
|
|
|
uint64_t flow_id;
|
|
|
|
} __rte_packed;
|
|
|
|
|
|
|
|
struct mlx5_flow_dump_ack {
|
|
|
|
int rc; /**< Return code. */
|
|
|
|
};
|
|
|
|
|
2019-04-01 21:12:54 +00:00
|
|
|
/** Key string for IPC. */
|
|
|
|
#define MLX5_MP_NAME "net_mlx5_mp"
|
|
|
|
|
2018-07-10 16:04:52 +00:00
|
|
|
|
2020-06-03 15:05:55 +00:00
|
|
|
LIST_HEAD(mlx5_dev_list, mlx5_dev_ctx_shared);
|
net/mlx5: add new memory region support
This is the new design of Memory Region (MR) for mlx PMD, in order to:
- Accommodate the new memory hotplug model.
- Support non-contiguous Mempool.
There are multiple layers for MR search.
L0 is to look up the last-hit entry which is pointed by mr_ctrl->mru (Most
Recently Used). If L0 misses, L1 is to look up the address in a fixed-sized
array by linear search. L0/L1 is in an inline function -
mlx5_mr_lookup_cache().
If L1 misses, the bottom-half function is called to look up the address
from the bigger local cache of the queue. This is L2 - mlx5_mr_addr2mr_bh()
and it is not an inline function. Data structure for L2 is the Binary Tree.
If L2 misses, the search falls into the slowest path which takes locks in
order to access global device cache (priv->mr.cache) which is also a B-tree
and caches the original MR list (priv->mr.mr_list) of the device. Unless
the global cache is overflowed, it is all-inclusive of the MR list. This is
L3 - mlx5_mr_lookup_dev(). The size of the L3 cache table is limited and
can't be expanded on the fly due to deadlock. Refer to the comments in the
code for the details - mr_lookup_dev(). If L3 is overflowed, the list will
have to be searched directly bypassing the cache although it is slower.
If L3 misses, a new MR for the address should be created -
mlx5_mr_create(). When it creates a new MR, it tries to register adjacent
memsegs as much as possible which are virtually contiguous around the
address. This must take two locks - memory_hotplug_lock and
priv->mr.rwlock. Due to memory_hotplug_lock, there can't be any
allocation/free of memory inside.
In the free callback of the memory hotplug event, freed space is searched
from the MR list and corresponding bits are cleared from the bitmap of MRs.
This can fragment a MR and the MR will have multiple search entries in the
caches. Once there's a change by the event, the global cache must be
rebuilt and all the per-queue caches will be flushed as well. If memory is
frequently freed in run-time, that may cause jitter on dataplane processing
in the worst case by incurring MR cache flush and rebuild. But, it would be
the least probable scenario.
To guarantee the most optimal performance, it is highly recommended to use
an EAL option - '--socket-mem'. Then, the reserved memory will be pinned
and won't be freed dynamically. And it is also recommended to configure
per-lcore cache of Mempool. Even though there're many MRs for a device or
MRs are highly fragmented, the cache of Mempool will be much helpful to
reduce misses on per-queue caches anyway.
'--legacy-mem' is also supported.
Signed-off-by: Yongseok Koh <yskoh@mellanox.com>
2018-05-09 11:09:04 +00:00
|
|
|
|
2019-04-01 21:12:55 +00:00
|
|
|
/* Shared data between primary and secondary processes. */
|
net/mlx5: add new memory region support
This is the new design of Memory Region (MR) for mlx PMD, in order to:
- Accommodate the new memory hotplug model.
- Support non-contiguous Mempool.
There are multiple layers for MR search.
L0 is to look up the last-hit entry which is pointed by mr_ctrl->mru (Most
Recently Used). If L0 misses, L1 is to look up the address in a fixed-sized
array by linear search. L0/L1 is in an inline function -
mlx5_mr_lookup_cache().
If L1 misses, the bottom-half function is called to look up the address
from the bigger local cache of the queue. This is L2 - mlx5_mr_addr2mr_bh()
and it is not an inline function. Data structure for L2 is the Binary Tree.
If L2 misses, the search falls into the slowest path which takes locks in
order to access global device cache (priv->mr.cache) which is also a B-tree
and caches the original MR list (priv->mr.mr_list) of the device. Unless
the global cache is overflowed, it is all-inclusive of the MR list. This is
L3 - mlx5_mr_lookup_dev(). The size of the L3 cache table is limited and
can't be expanded on the fly due to deadlock. Refer to the comments in the
code for the details - mr_lookup_dev(). If L3 is overflowed, the list will
have to be searched directly bypassing the cache although it is slower.
If L3 misses, a new MR for the address should be created -
mlx5_mr_create(). When it creates a new MR, it tries to register adjacent
memsegs as much as possible which are virtually contiguous around the
address. This must take two locks - memory_hotplug_lock and
priv->mr.rwlock. Due to memory_hotplug_lock, there can't be any
allocation/free of memory inside.
In the free callback of the memory hotplug event, freed space is searched
from the MR list and corresponding bits are cleared from the bitmap of MRs.
This can fragment a MR and the MR will have multiple search entries in the
caches. Once there's a change by the event, the global cache must be
rebuilt and all the per-queue caches will be flushed as well. If memory is
frequently freed in run-time, that may cause jitter on dataplane processing
in the worst case by incurring MR cache flush and rebuild. But, it would be
the least probable scenario.
To guarantee the most optimal performance, it is highly recommended to use
an EAL option - '--socket-mem'. Then, the reserved memory will be pinned
and won't be freed dynamically. And it is also recommended to configure
per-lcore cache of Mempool. Even though there're many MRs for a device or
MRs are highly fragmented, the cache of Mempool will be much helpful to
reduce misses on per-queue caches anyway.
'--legacy-mem' is also supported.
Signed-off-by: Yongseok Koh <yskoh@mellanox.com>
2018-05-09 11:09:04 +00:00
|
|
|
struct mlx5_shared_data {
|
2019-04-01 21:12:55 +00:00
|
|
|
rte_spinlock_t lock;
|
|
|
|
/* Global spinlock for primary and secondary processes. */
|
|
|
|
int init_done; /* Whether primary has done initialization. */
|
|
|
|
unsigned int secondary_cnt; /* Number of secondary processes init'd. */
|
net/mlx5: add new memory region support
This is the new design of Memory Region (MR) for mlx PMD, in order to:
- Accommodate the new memory hotplug model.
- Support non-contiguous Mempool.
There are multiple layers for MR search.
L0 is to look up the last-hit entry which is pointed by mr_ctrl->mru (Most
Recently Used). If L0 misses, L1 is to look up the address in a fixed-sized
array by linear search. L0/L1 is in an inline function -
mlx5_mr_lookup_cache().
If L1 misses, the bottom-half function is called to look up the address
from the bigger local cache of the queue. This is L2 - mlx5_mr_addr2mr_bh()
and it is not an inline function. Data structure for L2 is the Binary Tree.
If L2 misses, the search falls into the slowest path which takes locks in
order to access global device cache (priv->mr.cache) which is also a B-tree
and caches the original MR list (priv->mr.mr_list) of the device. Unless
the global cache is overflowed, it is all-inclusive of the MR list. This is
L3 - mlx5_mr_lookup_dev(). The size of the L3 cache table is limited and
can't be expanded on the fly due to deadlock. Refer to the comments in the
code for the details - mr_lookup_dev(). If L3 is overflowed, the list will
have to be searched directly bypassing the cache although it is slower.
If L3 misses, a new MR for the address should be created -
mlx5_mr_create(). When it creates a new MR, it tries to register adjacent
memsegs as much as possible which are virtually contiguous around the
address. This must take two locks - memory_hotplug_lock and
priv->mr.rwlock. Due to memory_hotplug_lock, there can't be any
allocation/free of memory inside.
In the free callback of the memory hotplug event, freed space is searched
from the MR list and corresponding bits are cleared from the bitmap of MRs.
This can fragment a MR and the MR will have multiple search entries in the
caches. Once there's a change by the event, the global cache must be
rebuilt and all the per-queue caches will be flushed as well. If memory is
frequently freed in run-time, that may cause jitter on dataplane processing
in the worst case by incurring MR cache flush and rebuild. But, it would be
the least probable scenario.
To guarantee the most optimal performance, it is highly recommended to use
an EAL option - '--socket-mem'. Then, the reserved memory will be pinned
and won't be freed dynamically. And it is also recommended to configure
per-lcore cache of Mempool. Even though there're many MRs for a device or
MRs are highly fragmented, the cache of Mempool will be much helpful to
reduce misses on per-queue caches anyway.
'--legacy-mem' is also supported.
Signed-off-by: Yongseok Koh <yskoh@mellanox.com>
2018-05-09 11:09:04 +00:00
|
|
|
struct mlx5_dev_list mem_event_cb_list;
|
|
|
|
rte_rwlock_t mem_event_rwlock;
|
|
|
|
};
|
|
|
|
|
2019-04-01 21:12:55 +00:00
|
|
|
/* Per-process data structure, not visible to other processes. */
|
|
|
|
struct mlx5_local_data {
|
|
|
|
int init_done; /* Whether a secondary has done initialization. */
|
|
|
|
};
|
|
|
|
|
net/mlx5: add new memory region support
This is the new design of Memory Region (MR) for mlx PMD, in order to:
- Accommodate the new memory hotplug model.
- Support non-contiguous Mempool.
There are multiple layers for MR search.
L0 is to look up the last-hit entry which is pointed by mr_ctrl->mru (Most
Recently Used). If L0 misses, L1 is to look up the address in a fixed-sized
array by linear search. L0/L1 is in an inline function -
mlx5_mr_lookup_cache().
If L1 misses, the bottom-half function is called to look up the address
from the bigger local cache of the queue. This is L2 - mlx5_mr_addr2mr_bh()
and it is not an inline function. Data structure for L2 is the Binary Tree.
If L2 misses, the search falls into the slowest path which takes locks in
order to access global device cache (priv->mr.cache) which is also a B-tree
and caches the original MR list (priv->mr.mr_list) of the device. Unless
the global cache is overflowed, it is all-inclusive of the MR list. This is
L3 - mlx5_mr_lookup_dev(). The size of the L3 cache table is limited and
can't be expanded on the fly due to deadlock. Refer to the comments in the
code for the details - mr_lookup_dev(). If L3 is overflowed, the list will
have to be searched directly bypassing the cache although it is slower.
If L3 misses, a new MR for the address should be created -
mlx5_mr_create(). When it creates a new MR, it tries to register adjacent
memsegs as much as possible which are virtually contiguous around the
address. This must take two locks - memory_hotplug_lock and
priv->mr.rwlock. Due to memory_hotplug_lock, there can't be any
allocation/free of memory inside.
In the free callback of the memory hotplug event, freed space is searched
from the MR list and corresponding bits are cleared from the bitmap of MRs.
This can fragment a MR and the MR will have multiple search entries in the
caches. Once there's a change by the event, the global cache must be
rebuilt and all the per-queue caches will be flushed as well. If memory is
frequently freed in run-time, that may cause jitter on dataplane processing
in the worst case by incurring MR cache flush and rebuild. But, it would be
the least probable scenario.
To guarantee the most optimal performance, it is highly recommended to use
an EAL option - '--socket-mem'. Then, the reserved memory will be pinned
and won't be freed dynamically. And it is also recommended to configure
per-lcore cache of Mempool. Even though there're many MRs for a device or
MRs are highly fragmented, the cache of Mempool will be much helpful to
reduce misses on per-queue caches anyway.
'--legacy-mem' is also supported.
Signed-off-by: Yongseok Koh <yskoh@mellanox.com>
2018-05-09 11:09:04 +00:00
|
|
|
extern struct mlx5_shared_data *mlx5_shared_data;
|
2020-06-03 15:06:00 +00:00
|
|
|
|
|
|
|
/* Dev ops structs */
|
2020-12-28 12:32:56 +00:00
|
|
|
extern const struct eth_dev_ops mlx5_dev_ops;
|
|
|
|
extern const struct eth_dev_ops mlx5_dev_sec_ops;
|
|
|
|
extern const struct eth_dev_ops mlx5_dev_ops_isolate;
|
net/mlx5: add new memory region support
This is the new design of Memory Region (MR) for mlx PMD, in order to:
- Accommodate the new memory hotplug model.
- Support non-contiguous Mempool.
There are multiple layers for MR search.
L0 is to look up the last-hit entry which is pointed by mr_ctrl->mru (Most
Recently Used). If L0 misses, L1 is to look up the address in a fixed-sized
array by linear search. L0/L1 is in an inline function -
mlx5_mr_lookup_cache().
If L1 misses, the bottom-half function is called to look up the address
from the bigger local cache of the queue. This is L2 - mlx5_mr_addr2mr_bh()
and it is not an inline function. Data structure for L2 is the Binary Tree.
If L2 misses, the search falls into the slowest path which takes locks in
order to access global device cache (priv->mr.cache) which is also a B-tree
and caches the original MR list (priv->mr.mr_list) of the device. Unless
the global cache is overflowed, it is all-inclusive of the MR list. This is
L3 - mlx5_mr_lookup_dev(). The size of the L3 cache table is limited and
can't be expanded on the fly due to deadlock. Refer to the comments in the
code for the details - mr_lookup_dev(). If L3 is overflowed, the list will
have to be searched directly bypassing the cache although it is slower.
If L3 misses, a new MR for the address should be created -
mlx5_mr_create(). When it creates a new MR, it tries to register adjacent
memsegs as much as possible which are virtually contiguous around the
address. This must take two locks - memory_hotplug_lock and
priv->mr.rwlock. Due to memory_hotplug_lock, there can't be any
allocation/free of memory inside.
In the free callback of the memory hotplug event, freed space is searched
from the MR list and corresponding bits are cleared from the bitmap of MRs.
This can fragment a MR and the MR will have multiple search entries in the
caches. Once there's a change by the event, the global cache must be
rebuilt and all the per-queue caches will be flushed as well. If memory is
frequently freed in run-time, that may cause jitter on dataplane processing
in the worst case by incurring MR cache flush and rebuild. But, it would be
the least probable scenario.
To guarantee the most optimal performance, it is highly recommended to use
an EAL option - '--socket-mem'. Then, the reserved memory will be pinned
and won't be freed dynamically. And it is also recommended to configure
per-lcore cache of Mempool. Even though there're many MRs for a device or
MRs are highly fragmented, the cache of Mempool will be much helpful to
reduce misses on per-queue caches anyway.
'--legacy-mem' is also supported.
Signed-off-by: Yongseok Koh <yskoh@mellanox.com>
2018-05-09 11:09:04 +00:00
|
|
|
|
2018-09-17 09:46:34 +00:00
|
|
|
struct mlx5_counter_ctrl {
|
|
|
|
/* Name of the counter. */
|
|
|
|
char dpdk_name[RTE_ETH_XSTATS_NAME_SIZE];
|
|
|
|
/* Name of the counter on the device table. */
|
|
|
|
char ctr_name[RTE_ETH_XSTATS_NAME_SIZE];
|
2020-06-10 09:32:33 +00:00
|
|
|
uint32_t dev:1; /**< Nonzero for dev counters. */
|
2018-09-17 09:46:34 +00:00
|
|
|
};
|
|
|
|
|
2017-01-17 14:37:08 +00:00
|
|
|
struct mlx5_xstats_ctrl {
|
|
|
|
/* Number of device stats. */
|
|
|
|
uint16_t stats_n;
|
2018-09-17 09:46:34 +00:00
|
|
|
/* Number of device stats identified by PMD. */
|
|
|
|
uint16_t mlx5_stats_n;
|
2017-01-17 14:37:08 +00:00
|
|
|
/* Index in the device counters table. */
|
|
|
|
uint16_t dev_table_idx[MLX5_MAX_XSTATS];
|
|
|
|
uint64_t base[MLX5_MAX_XSTATS];
|
2020-03-30 03:02:10 +00:00
|
|
|
uint64_t xstats[MLX5_MAX_XSTATS];
|
|
|
|
uint64_t hw_stats[MLX5_MAX_XSTATS];
|
2018-09-17 09:46:34 +00:00
|
|
|
struct mlx5_counter_ctrl info[MLX5_MAX_XSTATS];
|
2017-01-17 14:37:08 +00:00
|
|
|
};
|
|
|
|
|
2018-11-23 08:03:37 +00:00
|
|
|
struct mlx5_stats_ctrl {
|
|
|
|
/* Base for imissed counter. */
|
|
|
|
uint64_t imissed_base;
|
2020-03-30 03:02:10 +00:00
|
|
|
uint64_t imissed;
|
2018-11-23 08:03:37 +00:00
|
|
|
};
|
|
|
|
|
2018-01-10 09:16:58 +00:00
|
|
|
/* Default PMD specific parameter value. */
|
|
|
|
#define MLX5_ARG_UNSET (-1)
|
|
|
|
|
2019-07-22 14:51:59 +00:00
|
|
|
#define MLX5_LRO_SUPPORTED(dev) \
|
|
|
|
(((struct mlx5_priv *)((dev)->data->dev_private))->config.lro.supported)
|
|
|
|
|
2019-12-18 07:51:39 +00:00
|
|
|
/* Maximal size of coalesced segment for LRO is set in chunks of 256 Bytes. */
|
|
|
|
#define MLX5_LRO_SEG_CHUNK_SIZE 256u
|
|
|
|
|
2019-11-11 17:47:34 +00:00
|
|
|
/* Maximal size of aggregated LRO packet. */
|
2019-12-18 07:51:39 +00:00
|
|
|
#define MLX5_MAX_LRO_SIZE (UINT8_MAX * MLX5_LRO_SEG_CHUNK_SIZE)
|
2019-11-11 17:47:34 +00:00
|
|
|
|
2020-10-26 11:55:00 +00:00
|
|
|
/* Maximal number of segments to split. */
|
|
|
|
#define MLX5_MAX_RXQ_NSEG (1u << MLX5_MAX_LOG_RQ_SEGS)
|
|
|
|
|
2019-07-22 14:51:59 +00:00
|
|
|
/* LRO configurations structure. */
|
|
|
|
struct mlx5_lro_config {
|
|
|
|
uint32_t supported:1; /* Whether LRO is supported. */
|
|
|
|
uint32_t timeout; /* User configuration. */
|
|
|
|
};
|
|
|
|
|
2018-01-10 09:16:58 +00:00
|
|
|
/*
|
|
|
|
* Device configuration structure.
|
|
|
|
*
|
|
|
|
* Merged configuration from:
|
|
|
|
*
|
|
|
|
* - Device capabilities,
|
|
|
|
* - User device parameters disabled features.
|
|
|
|
*/
|
|
|
|
struct mlx5_dev_config {
|
|
|
|
unsigned int hw_csum:1; /* Checksum offload is supported. */
|
|
|
|
unsigned int hw_vlan_strip:1; /* VLAN stripping is supported. */
|
2019-07-21 14:24:57 +00:00
|
|
|
unsigned int hw_vlan_insert:1; /* VLAN insertion in WQE is supported. */
|
2018-01-10 09:16:58 +00:00
|
|
|
unsigned int hw_fcs_strip:1; /* FCS stripping is supported. */
|
|
|
|
unsigned int hw_padding:1; /* End alignment padding is supported. */
|
2018-04-05 15:07:19 +00:00
|
|
|
unsigned int vf:1; /* This is a VF. */
|
2018-02-25 07:28:37 +00:00
|
|
|
unsigned int tunnel_en:1;
|
|
|
|
/* Whether tunnel stateless offloads are supported. */
|
2018-05-15 11:07:14 +00:00
|
|
|
unsigned int mpls_en:1; /* MPLS over GRE/UDP is enabled. */
|
2018-01-10 09:16:58 +00:00
|
|
|
unsigned int cqe_comp:1; /* CQE compression is enabled. */
|
2020-11-01 16:27:39 +00:00
|
|
|
unsigned int cqe_comp_fmt:3; /* CQE compression format. */
|
2018-01-10 09:17:00 +00:00
|
|
|
unsigned int tso:1; /* Whether TSO is supported. */
|
2018-01-10 09:16:58 +00:00
|
|
|
unsigned int rx_vec_en:1; /* Rx vector is enabled. */
|
2019-04-01 21:17:54 +00:00
|
|
|
unsigned int mr_ext_memseg_en:1;
|
|
|
|
/* Whether memseg should be extended for MR creation. */
|
2018-04-23 12:33:02 +00:00
|
|
|
unsigned int l3_vxlan_en:1; /* Enable L3 VXLAN flow creation. */
|
2018-04-05 15:07:21 +00:00
|
|
|
unsigned int vf_nl_en:1; /* Enable Netlink requests in VF mode. */
|
2019-04-18 13:16:01 +00:00
|
|
|
unsigned int dv_esw_en:1; /* Enable E-Switch DV flow. */
|
2018-09-24 23:17:54 +00:00
|
|
|
unsigned int dv_flow_en:1; /* Enable DV flow. */
|
net/mlx5: add devarg for extensive metadata support
The PMD parameter dv_xmeta_en is added to control extensive
metadata support. A nonzero value enables extensive flow
metadata support if device is capable and driver supports it.
This can enable extensive support of MARK and META item of
rte_flow. The newly introduced SET_TAG and SET_META actions
do not depend on dv_xmeta_en parameter, because there is
no compatibility issue for new entities. The dv_xmeta_en is
disabled by default.
There are some possible configurations, depending on parameter
value:
- 0, this is default value, defines the legacy mode, the MARK
and META related actions and items operate only within NIC Tx
and NIC Rx steering domains, no MARK and META information
crosses the domain boundaries. The MARK item is 24 bits wide,
the META item is 32 bits wide.
- 1, this engages extensive metadata mode, the MARK and META
related actions and items operate within all supported steering
domains, including FDB, MARK and META information may cross
the domain boundaries. The ``MARK`` item is 24 bits wide, the
META item width depends on kernel and firmware configurations
and might be 0, 16 or 32 bits. Within NIC Tx domain META data
width is 32 bits for compatibility, the actual width of data
transferred to the FDB domain depends on kernel configuration
and may be vary. The actual supported width can be retrieved
in runtime by series of rte_flow_validate() trials.
- 2, this engages extensive metadata mode, the MARK and META
related actions and items operate within all supported steering
domains, including FDB, MARK and META information may cross
the domain boundaries. The META item is 32 bits wide, the MARK
item width depends on kernel and firmware configurations and
might be 0, 16 or 24 bits. The actual supported width can be
retrieved in runtime by series of rte_flow_validate() trials.
If there is no E-Switch configuration the ``dv_xmeta_en`` parameter is
ignored and the device is configured to operate in legacy mode (0).
Signed-off-by: Yongseok Koh <yskoh@mellanox.com>
Signed-off-by: Viacheslav Ovsiienko <viacheslavo@mellanox.com>
Acked-by: Matan Azrad <matan@mellanox.com>
2019-11-07 17:09:54 +00:00
|
|
|
unsigned int dv_xmeta_en:2; /* Enable extensive flow metadata. */
|
2020-06-23 08:41:07 +00:00
|
|
|
unsigned int lacp_by_user:1;
|
|
|
|
/* Enable user to manage LACP traffic. */
|
2018-04-08 12:41:20 +00:00
|
|
|
unsigned int swp:1; /* Tx generic tunnel checksum and TSO offload. */
|
2019-01-03 15:06:37 +00:00
|
|
|
unsigned int devx:1; /* Whether devx interface is available or not. */
|
2019-07-22 14:52:02 +00:00
|
|
|
unsigned int dest_tir:1; /* Whether advanced DR API is available. */
|
net/mlx5: add reclaim memory mode
Currently, when flow destroyed, some memory resources may still be kept
as cached to help next time create flow more efficiently.
Some system may need the resources to be more flexible with flow create
and destroy. After peak time, with millions of flows destroyed, the
system would prefer the resources to be reclaimed completely, no cache
is needed. Then the resources can be allocated and used by other
components. The system is not so sensitive about the flow insertion
rate, but more care about the resources.
Both DPDK mlx5 PMD driver and the low level component rdma-core have
provided the flow resources to be configured cached or not, but there is
no APIs or parameters exposed to user to configure the flow resources
cache mode. In this case, introduce a new PMD devarg to let user
configure the flow resources cache mode will be helpful.
This commit is to add a new "reclaim_mem_mode" to help user configure if
the destroyed flows' cache resources should be kept or not.
Their will be three mode can be chosen:
1. 0(none). It means the flow resources will be cached as usual. The
resources will be cached, helpful with flow insertion rate.
2. 1(light). It will only enable the DPDK PMD level resources reclaim.
3. 2(aggressive). Both DPDK PMD level and rdma-core low level will be
configured as reclaimed mode.
With these three mode, user can configure the resources cache mode with
different levels.
Signed-off-by: Suanming Mou <suanmingm@mellanox.com>
Acked-by: Viacheslav Ovsiienko <viacheslavo@mellanox.com>
2020-06-01 06:09:43 +00:00
|
|
|
unsigned int reclaim_mode:2; /* Memory reclaim mode. */
|
2020-07-16 08:23:20 +00:00
|
|
|
unsigned int rt_timestamp:1; /* realtime timestamp format. */
|
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
|
|
|
unsigned int sys_mem_en:1; /* The default memory allocator. */
|
2020-07-15 13:10:21 +00:00
|
|
|
unsigned int decap_en:1; /* Whether decap will be used or not. */
|
2020-10-25 14:08:09 +00:00
|
|
|
unsigned int dv_miss_info:1; /* restore packet after partial hw miss */
|
2018-05-09 11:13:50 +00:00
|
|
|
struct {
|
|
|
|
unsigned int enabled:1; /* Whether MPRQ is enabled. */
|
|
|
|
unsigned int stride_num_n; /* Number of strides. */
|
2020-04-09 22:23:51 +00:00
|
|
|
unsigned int stride_size_n; /* Size of a stride. */
|
2018-05-09 11:13:50 +00:00
|
|
|
unsigned int min_stride_size_n; /* Min size of a stride. */
|
|
|
|
unsigned int max_stride_size_n; /* Max size of a stride. */
|
|
|
|
unsigned int max_memcpy_len;
|
|
|
|
/* Maximum packet size to memcpy Rx packets. */
|
|
|
|
unsigned int min_rxqs_num;
|
|
|
|
/* Rx queue count threshold to enable MPRQ. */
|
|
|
|
} mprq; /* Configurations for Multi-Packet RQ. */
|
2018-08-13 06:47:57 +00:00
|
|
|
int mps; /* Multi-packet send supported mode. */
|
2019-11-08 15:07:50 +00:00
|
|
|
int dbnc; /* Skip doorbell register write barrier. */
|
2018-07-12 09:30:49 +00:00
|
|
|
unsigned int flow_prio; /* Number of flow priorities. */
|
2019-11-07 17:09:53 +00:00
|
|
|
enum modify_reg flow_mreg_c[MLX5_MREG_C_NUM];
|
|
|
|
/* Availibility of mreg_c's. */
|
2018-01-10 09:16:58 +00:00
|
|
|
unsigned int tso_max_payload_sz; /* Maximum TCP payload for TSO. */
|
|
|
|
unsigned int ind_table_max_size; /* Maximum indirection table size. */
|
2019-05-30 10:20:32 +00:00
|
|
|
unsigned int max_dump_files_num; /* Maximum dump files per queue. */
|
2020-03-24 12:59:01 +00:00
|
|
|
unsigned int log_hp_size; /* Single hairpin queue data size in total. */
|
2018-01-10 09:16:58 +00:00
|
|
|
int txqs_inline; /* Queue number threshold for inlining. */
|
2019-07-21 14:24:54 +00:00
|
|
|
int txq_inline_min; /* Minimal amount of data bytes to inline. */
|
|
|
|
int txq_inline_max; /* Max packet size for inlining with SEND. */
|
|
|
|
int txq_inline_mpw; /* Max packet size for inlining with eMPW. */
|
2020-07-16 08:23:05 +00:00
|
|
|
int tx_pp; /* Timestamp scheduling granularity in nanoseconds. */
|
|
|
|
int tx_skew; /* Tx scheduling skew between WQE and data on wire. */
|
2019-04-18 13:16:01 +00:00
|
|
|
struct mlx5_hca_attr hca_attr; /* HCA attributes. */
|
2019-07-22 14:51:59 +00:00
|
|
|
struct mlx5_lro_config lro; /* LRO configuration. */
|
2018-01-10 09:16:58 +00:00
|
|
|
};
|
|
|
|
|
2019-10-30 23:53:15 +00:00
|
|
|
|
2019-07-30 09:20:24 +00:00
|
|
|
/* Structure for VF VLAN workaround. */
|
|
|
|
struct mlx5_vf_vlan {
|
|
|
|
uint32_t tag:12;
|
|
|
|
uint32_t created:1;
|
|
|
|
};
|
|
|
|
|
2018-07-12 09:30:48 +00:00
|
|
|
/* Flow drop context necessary due to Verbs API. */
|
|
|
|
struct mlx5_drop {
|
|
|
|
struct mlx5_hrxq *hrxq; /* Hash Rx queue queue. */
|
2019-07-22 14:52:11 +00:00
|
|
|
struct mlx5_rxq_obj *rxq; /* Rx queue object. */
|
2018-07-12 09:30:48 +00:00
|
|
|
};
|
|
|
|
|
2021-05-17 15:18:41 +00:00
|
|
|
/* Loopback dummy queue resources required due to Verbs API. */
|
|
|
|
struct mlx5_lb_ctx {
|
|
|
|
struct ibv_qp *qp; /* QP object. */
|
|
|
|
void *ibv_cq; /* Completion queue. */
|
|
|
|
uint16_t refcnt; /* Reference count for representors. */
|
|
|
|
};
|
|
|
|
|
2019-07-16 14:34:53 +00:00
|
|
|
#define MLX5_COUNTERS_PER_POOL 512
|
2019-07-16 14:34:55 +00:00
|
|
|
#define MLX5_MAX_PENDING_QUERIES 4
|
2020-04-07 03:59:42 +00:00
|
|
|
#define MLX5_CNT_CONTAINER_RESIZE 64
|
2020-10-20 03:02:22 +00:00
|
|
|
#define MLX5_CNT_SHARED_OFFSET 0x80000000
|
2021-04-29 09:55:38 +00:00
|
|
|
#define IS_LEGACY_SHARED_CNT(cnt) (!!((cnt) & MLX5_CNT_SHARED_OFFSET))
|
2020-10-20 03:02:22 +00:00
|
|
|
#define IS_BATCH_CNT(cnt) (((cnt) & (MLX5_CNT_SHARED_OFFSET - 1)) >= \
|
|
|
|
MLX5_CNT_BATCH_OFFSET)
|
2020-10-20 03:02:27 +00:00
|
|
|
#define MLX5_CNT_SIZE (sizeof(struct mlx5_flow_counter))
|
|
|
|
#define MLX5_AGE_SIZE (sizeof(struct mlx5_age_param))
|
2020-10-20 03:02:23 +00:00
|
|
|
|
2020-04-29 02:25:08 +00:00
|
|
|
#define MLX5_CNT_LEN(pool) \
|
2020-10-20 03:02:27 +00:00
|
|
|
(MLX5_CNT_SIZE + \
|
2020-10-20 03:02:28 +00:00
|
|
|
((pool)->is_aged ? MLX5_AGE_SIZE : 0))
|
2020-04-29 02:25:08 +00:00
|
|
|
#define MLX5_POOL_GET_CNT(pool, index) \
|
|
|
|
((struct mlx5_flow_counter *) \
|
|
|
|
((uint8_t *)((pool) + 1) + (index) * (MLX5_CNT_LEN(pool))))
|
|
|
|
#define MLX5_CNT_ARRAY_IDX(pool, cnt) \
|
|
|
|
((int)(((uint8_t *)(cnt) - (uint8_t *)((pool) + 1)) / \
|
|
|
|
MLX5_CNT_LEN(pool)))
|
2020-04-07 03:59:42 +00:00
|
|
|
/*
|
|
|
|
* The pool index and offset of counter in the pool array makes up the
|
|
|
|
* counter index. In case the counter is from pool 0 and offset 0, it
|
|
|
|
* should plus 1 to avoid index 0, since 0 means invalid counter index
|
|
|
|
* currently.
|
|
|
|
*/
|
|
|
|
#define MLX5_MAKE_CNT_IDX(pi, offset) \
|
|
|
|
((pi) * MLX5_COUNTERS_PER_POOL + (offset) + 1)
|
2020-04-29 02:25:09 +00:00
|
|
|
#define MLX5_CNT_TO_AGE(cnt) \
|
|
|
|
((struct mlx5_age_param *)((cnt) + 1))
|
2020-06-18 07:24:44 +00:00
|
|
|
/*
|
|
|
|
* The maximum single counter is 0x800000 as MLX5_CNT_BATCH_OFFSET
|
|
|
|
* defines. The pool size is 512, pool index should never reach
|
|
|
|
* INT16_MAX.
|
|
|
|
*/
|
|
|
|
#define POOL_IDX_INVALID UINT16_MAX
|
2019-07-16 14:34:53 +00:00
|
|
|
|
2020-10-19 13:52:50 +00:00
|
|
|
/* Age status. */
|
2020-04-29 02:25:09 +00:00
|
|
|
enum {
|
|
|
|
AGE_FREE, /* Initialized state. */
|
|
|
|
AGE_CANDIDATE, /* Counter assigned to flows. */
|
|
|
|
AGE_TMOUT, /* Timeout, wait for rte_flow_get_aged_flows and destroy. */
|
|
|
|
};
|
|
|
|
|
2020-10-20 03:02:21 +00:00
|
|
|
enum mlx5_counter_type {
|
|
|
|
MLX5_COUNTER_TYPE_ORIGIN,
|
|
|
|
MLX5_COUNTER_TYPE_AGE,
|
|
|
|
MLX5_COUNTER_TYPE_MAX,
|
|
|
|
};
|
|
|
|
|
2020-04-29 02:25:09 +00:00
|
|
|
/* Counter age parameter. */
|
|
|
|
struct mlx5_age_param {
|
2020-10-19 13:52:50 +00:00
|
|
|
uint16_t state; /**< Age state (atomically accessed). */
|
2020-04-29 02:25:09 +00:00
|
|
|
uint16_t port_id; /**< Port id of the counter. */
|
2020-10-19 13:52:50 +00:00
|
|
|
uint32_t timeout:24; /**< Aging timeout in seconds. */
|
|
|
|
uint32_t sec_since_last_hit;
|
|
|
|
/**< Time in seconds since last hit (atomically accessed). */
|
2020-04-29 02:25:09 +00:00
|
|
|
void *context; /**< Flow counter age context. */
|
|
|
|
};
|
|
|
|
|
2019-07-16 14:34:53 +00:00
|
|
|
struct flow_counter_stats {
|
|
|
|
uint64_t hits;
|
|
|
|
uint64_t bytes;
|
|
|
|
};
|
|
|
|
|
2020-10-20 03:02:22 +00:00
|
|
|
/* Shared counters information for counters. */
|
|
|
|
struct mlx5_flow_counter_shared {
|
2021-04-29 09:55:38 +00:00
|
|
|
union {
|
|
|
|
uint32_t refcnt; /* Only for shared action management. */
|
|
|
|
uint32_t id; /* User counter ID for legacy sharing. */
|
|
|
|
};
|
2020-10-20 03:02:22 +00:00
|
|
|
};
|
|
|
|
|
2020-10-20 03:02:26 +00:00
|
|
|
/* Shared counter configuration. */
|
|
|
|
struct mlx5_shared_counter_conf {
|
|
|
|
struct rte_eth_dev *dev; /* The device shared counter belongs to. */
|
|
|
|
uint32_t id; /* The shared counter ID. */
|
|
|
|
};
|
|
|
|
|
2020-10-20 03:02:22 +00:00
|
|
|
struct mlx5_flow_counter_pool;
|
2020-04-07 03:59:46 +00:00
|
|
|
/* Generic counters information. */
|
2019-07-16 14:34:53 +00:00
|
|
|
struct mlx5_flow_counter {
|
2020-10-20 03:02:22 +00:00
|
|
|
union {
|
|
|
|
/*
|
|
|
|
* User-defined counter shared info is only used during
|
|
|
|
* counter active time. And aging counter sharing is not
|
|
|
|
* supported, so active shared counter will not be chained
|
|
|
|
* to the aging list. For shared counter, only when it is
|
|
|
|
* released, the TAILQ entry memory will be used, at that
|
|
|
|
* time, shared memory is not used anymore.
|
2020-10-20 03:02:28 +00:00
|
|
|
*
|
|
|
|
* Similarly to none-batch counter dcs, since it doesn't
|
|
|
|
* support aging, while counter is allocated, the entry
|
|
|
|
* memory is not used anymore. In this case, as bytes
|
|
|
|
* memory is used only when counter is allocated, and
|
|
|
|
* entry memory is used only when counter is free. The
|
|
|
|
* dcs pointer can be saved to these two different place
|
|
|
|
* at different stage. It will eliminate the individual
|
|
|
|
* counter extend struct.
|
2020-10-20 03:02:22 +00:00
|
|
|
*/
|
|
|
|
TAILQ_ENTRY(mlx5_flow_counter) next;
|
|
|
|
/**< Pointer to the next flow counter structure. */
|
2020-10-20 03:02:28 +00:00
|
|
|
struct {
|
|
|
|
struct mlx5_flow_counter_shared shared_info;
|
|
|
|
/**< Shared counter information. */
|
|
|
|
void *dcs_when_active;
|
|
|
|
/*
|
|
|
|
* For non-batch mode, the dcs will be saved
|
|
|
|
* here when the counter is free.
|
|
|
|
*/
|
|
|
|
};
|
2020-10-20 03:02:22 +00:00
|
|
|
};
|
2020-04-07 03:59:46 +00:00
|
|
|
union {
|
|
|
|
uint64_t hits; /**< Reset value of hits packets. */
|
2020-06-18 08:12:50 +00:00
|
|
|
struct mlx5_flow_counter_pool *pool; /**< Counter pool. */
|
2020-04-07 03:59:46 +00:00
|
|
|
};
|
2020-10-20 03:02:22 +00:00
|
|
|
union {
|
2020-10-20 03:02:28 +00:00
|
|
|
uint64_t bytes; /**< Reset value of bytes. */
|
|
|
|
void *dcs_when_free;
|
|
|
|
/*
|
|
|
|
* For non-batch mode, the dcs will be saved here
|
|
|
|
* when the counter is free.
|
|
|
|
*/
|
2019-07-16 14:34:53 +00:00
|
|
|
};
|
2020-10-20 03:02:28 +00:00
|
|
|
void *action; /**< Pointer to the dv action. */
|
2019-07-16 14:34:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
TAILQ_HEAD(mlx5_counters, mlx5_flow_counter);
|
|
|
|
|
2020-04-07 03:59:46 +00:00
|
|
|
/* Generic counter pool structure - query is in pool resolution. */
|
2019-07-16 14:34:53 +00:00
|
|
|
struct mlx5_flow_counter_pool {
|
|
|
|
TAILQ_ENTRY(mlx5_flow_counter_pool) next;
|
2020-06-18 08:12:50 +00:00
|
|
|
struct mlx5_counters counters[2]; /* Free counter list. */
|
2020-10-27 15:28:24 +00:00
|
|
|
struct mlx5_devx_obj *min_dcs;
|
2019-07-16 14:34:55 +00:00
|
|
|
/* The devx object of the minimum counter ID. */
|
2020-10-19 13:52:50 +00:00
|
|
|
uint64_t time_of_last_age_check;
|
|
|
|
/* System time (from rte_rdtsc()) read in the last aging check. */
|
2020-10-20 03:02:28 +00:00
|
|
|
uint32_t index:30; /* Pool index in container. */
|
|
|
|
uint32_t is_aged:1; /* Pool with aging counter. */
|
2020-06-18 08:12:50 +00:00
|
|
|
volatile uint32_t query_gen:1; /* Query round. */
|
2019-07-16 14:34:55 +00:00
|
|
|
rte_spinlock_t sl; /* The pool lock. */
|
2020-10-20 03:02:24 +00:00
|
|
|
rte_spinlock_t csl; /* The pool counter free list lock. */
|
2019-07-16 14:34:55 +00:00
|
|
|
struct mlx5_counter_stats_raw *raw;
|
2020-10-20 03:02:24 +00:00
|
|
|
struct mlx5_counter_stats_raw *raw_hw;
|
|
|
|
/* The raw on HW working. */
|
2019-07-16 14:34:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Memory management structure for group of counter statistics raws. */
|
|
|
|
struct mlx5_counter_stats_mem_mng {
|
|
|
|
LIST_ENTRY(mlx5_counter_stats_mem_mng) next;
|
|
|
|
struct mlx5_counter_stats_raw *raws;
|
|
|
|
struct mlx5_devx_obj *dm;
|
2020-06-03 15:05:59 +00:00
|
|
|
void *umem;
|
2019-07-16 14:34:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Raw memory structure for the counter statistics values of a pool. */
|
|
|
|
struct mlx5_counter_stats_raw {
|
|
|
|
LIST_ENTRY(mlx5_counter_stats_raw) next;
|
|
|
|
struct mlx5_counter_stats_mem_mng *mem_mng;
|
|
|
|
volatile struct flow_counter_stats *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
TAILQ_HEAD(mlx5_counter_pools, mlx5_flow_counter_pool);
|
|
|
|
|
2020-10-20 03:02:23 +00:00
|
|
|
/* Counter global management structure. */
|
|
|
|
struct mlx5_flow_counter_mng {
|
2020-10-20 03:02:24 +00:00
|
|
|
volatile uint16_t n_valid; /* Number of valid pools. */
|
2019-07-16 14:34:53 +00:00
|
|
|
uint16_t n; /* Number of pools. */
|
2020-06-18 07:24:44 +00:00
|
|
|
uint16_t last_pool_idx; /* Last used pool index */
|
|
|
|
int min_id; /* The minimum counter ID in the pools. */
|
|
|
|
int max_id; /* The maximum counter ID in the pools. */
|
2020-10-20 03:02:24 +00:00
|
|
|
rte_spinlock_t pool_update_sl; /* The pool update lock. */
|
2020-10-20 03:02:23 +00:00
|
|
|
rte_spinlock_t csl[MLX5_COUNTER_TYPE_MAX];
|
|
|
|
/* The counter free list lock. */
|
2020-10-20 03:02:21 +00:00
|
|
|
struct mlx5_counters counters[MLX5_COUNTER_TYPE_MAX];
|
|
|
|
/* Free counter list. */
|
2019-07-16 14:34:53 +00:00
|
|
|
struct mlx5_flow_counter_pool **pools; /* Counter pool array. */
|
2020-05-12 12:52:13 +00:00
|
|
|
struct mlx5_counter_stats_mem_mng *mem_mng;
|
2019-07-16 14:34:53 +00:00
|
|
|
/* Hold the memory management for the next allocated pools raws. */
|
|
|
|
struct mlx5_counters flow_counters; /* Legacy flow counter list. */
|
2019-07-16 14:34:55 +00:00
|
|
|
uint8_t pending_queries;
|
|
|
|
uint16_t pool_index;
|
|
|
|
uint8_t query_thread_on;
|
2020-11-03 08:51:22 +00:00
|
|
|
bool relaxed_ordering_read;
|
|
|
|
bool relaxed_ordering_write;
|
2020-10-20 03:02:28 +00:00
|
|
|
bool counter_fallback; /* Use counter fallback management. */
|
2019-07-16 14:34:53 +00:00
|
|
|
LIST_HEAD(mem_mngs, mlx5_counter_stats_mem_mng) mem_mngs;
|
2019-07-16 14:34:55 +00:00
|
|
|
LIST_HEAD(stat_raws, mlx5_counter_stats_raw) free_stat_raws;
|
2019-07-16 14:34:53 +00:00
|
|
|
};
|
2020-05-12 12:52:13 +00:00
|
|
|
|
2020-11-01 17:57:49 +00:00
|
|
|
/* ASO structures. */
|
|
|
|
#define MLX5_ASO_QUEUE_LOG_DESC 10
|
|
|
|
|
|
|
|
struct mlx5_aso_cq {
|
|
|
|
uint16_t log_desc_n;
|
|
|
|
uint32_t cq_ci:24;
|
2021-01-06 08:19:30 +00:00
|
|
|
struct mlx5_devx_cq cq_obj;
|
2020-11-01 17:57:49 +00:00
|
|
|
uint64_t errors;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct mlx5_aso_sq_elem {
|
2021-04-20 10:55:17 +00:00
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
struct mlx5_aso_age_pool *pool;
|
|
|
|
uint16_t burst_size;
|
|
|
|
};
|
|
|
|
struct mlx5_aso_mtr *mtr;
|
2021-05-05 12:23:20 +00:00
|
|
|
struct {
|
|
|
|
struct mlx5_aso_ct_action *ct;
|
|
|
|
char *query_data;
|
|
|
|
};
|
2021-04-20 10:55:17 +00:00
|
|
|
};
|
2020-11-01 17:57:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct mlx5_aso_sq {
|
|
|
|
uint16_t log_desc_n;
|
2021-04-20 10:55:20 +00:00
|
|
|
rte_spinlock_t sqsl;
|
2020-11-01 17:57:49 +00:00
|
|
|
struct mlx5_aso_cq cq;
|
2021-01-06 08:19:38 +00:00
|
|
|
struct mlx5_devx_sq sq_obj;
|
2020-11-01 17:57:49 +00:00
|
|
|
volatile uint64_t *uar_addr;
|
2021-04-26 12:48:10 +00:00
|
|
|
struct mlx5_pmd_mr mr;
|
2020-11-01 17:57:49 +00:00
|
|
|
uint16_t pi;
|
2020-11-03 10:38:04 +00:00
|
|
|
uint32_t head;
|
|
|
|
uint32_t tail;
|
2020-11-01 17:57:49 +00:00
|
|
|
uint32_t sqn;
|
|
|
|
struct mlx5_aso_sq_elem elts[1 << MLX5_ASO_QUEUE_LOG_DESC];
|
|
|
|
uint16_t next; /* Pool index of the next pool to query. */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct mlx5_aso_age_action {
|
|
|
|
LIST_ENTRY(mlx5_aso_age_action) next;
|
|
|
|
void *dr_action;
|
2020-11-01 17:57:51 +00:00
|
|
|
uint32_t refcnt;
|
2020-11-01 17:57:49 +00:00
|
|
|
/* Following fields relevant only when action is active. */
|
|
|
|
uint16_t offset; /* Offset of ASO Flow Hit flag in DevX object. */
|
|
|
|
struct mlx5_age_param age_params;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define MLX5_ASO_AGE_ACTIONS_PER_POOL 512
|
|
|
|
|
|
|
|
struct mlx5_aso_age_pool {
|
|
|
|
struct mlx5_devx_obj *flow_hit_aso_obj;
|
|
|
|
uint16_t index; /* Pool index in pools array. */
|
|
|
|
uint64_t time_of_last_age_check; /* In seconds. */
|
|
|
|
struct mlx5_aso_age_action actions[MLX5_ASO_AGE_ACTIONS_PER_POOL];
|
|
|
|
};
|
|
|
|
|
|
|
|
LIST_HEAD(aso_age_list, mlx5_aso_age_action);
|
|
|
|
|
|
|
|
struct mlx5_aso_age_mng {
|
|
|
|
struct mlx5_aso_age_pool **pools;
|
|
|
|
uint16_t n; /* Total number of pools. */
|
|
|
|
uint16_t next; /* Number of pools in use, index of next free pool. */
|
|
|
|
rte_spinlock_t resize_sl; /* Lock for resize objects. */
|
|
|
|
rte_spinlock_t free_sl; /* Lock for free list access. */
|
|
|
|
struct aso_age_list free; /* Free age actions list - ready to use. */
|
|
|
|
struct mlx5_aso_sq aso_sq; /* ASO queue objects. */
|
|
|
|
};
|
|
|
|
|
2021-01-17 10:21:20 +00:00
|
|
|
/* Management structure for geneve tlv option */
|
|
|
|
struct mlx5_geneve_tlv_option_resource {
|
|
|
|
struct mlx5_devx_obj *obj; /* Pointer to the geneve tlv opt object. */
|
|
|
|
rte_be16_t option_class; /* geneve tlv opt class.*/
|
|
|
|
uint8_t option_type; /* geneve tlv opt type.*/
|
|
|
|
uint8_t length; /* geneve tlv opt length. */
|
|
|
|
uint32_t refcnt; /* geneve tlv object reference counter */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2020-04-29 02:25:09 +00:00
|
|
|
#define MLX5_AGE_EVENT_NEW 1
|
|
|
|
#define MLX5_AGE_TRIGGER 2
|
|
|
|
#define MLX5_AGE_SET(age_info, BIT) \
|
|
|
|
((age_info)->flags |= (1 << (BIT)))
|
2021-04-29 09:55:41 +00:00
|
|
|
#define MLX5_AGE_UNSET(age_info, BIT) \
|
|
|
|
((age_info)->flags &= ~(1 << (BIT)))
|
2020-04-29 02:25:09 +00:00
|
|
|
#define MLX5_AGE_GET(age_info, BIT) \
|
|
|
|
((age_info)->flags & (1 << (BIT)))
|
|
|
|
#define GET_PORT_AGE_INFO(priv) \
|
2020-06-10 09:32:27 +00:00
|
|
|
(&((priv)->sh->port[(priv)->dev_port - 1].age_info))
|
2020-10-19 13:52:50 +00:00
|
|
|
/* Current time in seconds. */
|
|
|
|
#define MLX5_CURR_TIME_SEC (rte_rdtsc() / rte_get_tsc_hz())
|
2020-04-29 02:25:09 +00:00
|
|
|
|
|
|
|
/* Aging information for per port. */
|
|
|
|
struct mlx5_age_info {
|
2020-10-19 13:52:50 +00:00
|
|
|
uint8_t flags; /* Indicate if is new event or need to be triggered. */
|
2020-11-01 17:57:52 +00:00
|
|
|
struct mlx5_counters aged_counters; /* Aged counter list. */
|
|
|
|
struct aso_age_list aged_aso; /* Aged ASO actions list. */
|
2020-11-01 17:57:49 +00:00
|
|
|
rte_spinlock_t aged_sl; /* Aged flow list lock. */
|
2020-04-29 02:25:09 +00:00
|
|
|
};
|
2020-05-12 12:52:13 +00:00
|
|
|
|
2019-03-27 13:15:39 +00:00
|
|
|
/* Per port data of shared IB device. */
|
2020-06-10 09:32:27 +00:00
|
|
|
struct mlx5_dev_shared_port {
|
2019-03-27 13:15:39 +00:00
|
|
|
uint32_t ih_port_id;
|
2019-10-22 07:33:35 +00:00
|
|
|
uint32_t devx_ih_port_id;
|
2019-03-27 13:15:39 +00:00
|
|
|
/*
|
|
|
|
* Interrupt handler port_id. Used by shared interrupt
|
|
|
|
* handler to find the corresponding rte_eth device
|
|
|
|
* by IB port index. If value is equal or greater
|
|
|
|
* RTE_MAX_ETHPORTS it means there is no subhandler
|
|
|
|
* installed for specified IB port index.
|
|
|
|
*/
|
2020-04-29 02:25:09 +00:00
|
|
|
struct mlx5_age_info age_info;
|
|
|
|
/* Aging information for per port. */
|
2019-03-27 13:15:39 +00:00
|
|
|
};
|
|
|
|
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
/*
|
|
|
|
* Max number of actions per DV flow.
|
|
|
|
* See CREATE_FLOW_MAX_FLOW_ACTIONS_SUPPORTED
|
|
|
|
* in rdma-core file providers/mlx5/verbs.c.
|
|
|
|
*/
|
|
|
|
#define MLX5_DV_MAX_NUMBER_OF_ACTIONS 8
|
|
|
|
|
2021-04-20 10:55:16 +00:00
|
|
|
/*ASO flow meter structures*/
|
|
|
|
/* Modify this value if enum rte_mtr_color changes. */
|
|
|
|
#define RTE_MTR_DROPPED RTE_COLORS
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
/* Yellow is not supported. */
|
|
|
|
#define MLX5_MTR_RTE_COLORS (RTE_COLOR_GREEN + 1)
|
|
|
|
/* table_id 22 bits in mlx5_flow_tbl_key so limit policy number. */
|
|
|
|
#define MLX5_MAX_SUB_POLICY_TBL_NUM 0x3FFFFF
|
|
|
|
#define MLX5_INVALID_POLICY_ID UINT32_MAX
|
|
|
|
/* Suffix table_id on MLX5_FLOW_TABLE_LEVEL_METER. */
|
|
|
|
#define MLX5_MTR_TABLE_ID_SUFFIX 1
|
|
|
|
/* Drop table_id on MLX5_FLOW_TABLE_LEVEL_METER. */
|
|
|
|
#define MLX5_MTR_TABLE_ID_DROP 2
|
|
|
|
|
|
|
|
enum mlx5_meter_domain {
|
|
|
|
MLX5_MTR_DOMAIN_INGRESS,
|
|
|
|
MLX5_MTR_DOMAIN_EGRESS,
|
|
|
|
MLX5_MTR_DOMAIN_TRANSFER,
|
|
|
|
MLX5_MTR_DOMAIN_MAX,
|
|
|
|
};
|
|
|
|
#define MLX5_MTR_DOMAIN_INGRESS_BIT (1 << MLX5_MTR_DOMAIN_INGRESS)
|
|
|
|
#define MLX5_MTR_DOMAIN_EGRESS_BIT (1 << MLX5_MTR_DOMAIN_EGRESS)
|
|
|
|
#define MLX5_MTR_DOMAIN_TRANSFER_BIT (1 << MLX5_MTR_DOMAIN_TRANSFER)
|
|
|
|
#define MLX5_MTR_ALL_DOMAIN_BIT (MLX5_MTR_DOMAIN_INGRESS_BIT | \
|
|
|
|
MLX5_MTR_DOMAIN_EGRESS_BIT | \
|
|
|
|
MLX5_MTR_DOMAIN_TRANSFER_BIT)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Meter sub-policy structure.
|
|
|
|
* Each RSS TIR in meter policy need its own sub-policy resource.
|
|
|
|
*/
|
|
|
|
struct mlx5_flow_meter_sub_policy {
|
|
|
|
uint32_t main_policy_id:1;
|
|
|
|
/* Main policy id is same as this sub_policy id. */
|
|
|
|
uint32_t idx:31;
|
|
|
|
/* Index to sub_policy ipool entity. */
|
|
|
|
void *main_policy;
|
|
|
|
/* Point to struct mlx5_flow_meter_policy. */
|
|
|
|
struct mlx5_flow_tbl_resource *tbl_rsc;
|
|
|
|
/* The sub-policy table resource. */
|
|
|
|
uint32_t rix_hrxq[MLX5_MTR_RTE_COLORS];
|
|
|
|
/* Index to TIR resource. */
|
|
|
|
struct mlx5_flow_tbl_resource *jump_tbl[MLX5_MTR_RTE_COLORS];
|
|
|
|
/* Meter jump/drop table. */
|
|
|
|
struct mlx5_flow_dv_matcher *color_matcher[RTE_COLORS];
|
|
|
|
/* Matcher for Color. */
|
|
|
|
void *color_rule[RTE_COLORS];
|
|
|
|
/* Meter green/yellow/drop rule. */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct mlx5_meter_policy_acts {
|
|
|
|
uint8_t actions_n;
|
|
|
|
/* Number of actions. */
|
|
|
|
void *dv_actions[MLX5_DV_MAX_NUMBER_OF_ACTIONS];
|
|
|
|
/* Action list. */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct mlx5_meter_policy_action_container {
|
|
|
|
uint32_t rix_mark;
|
|
|
|
/* Index to the mark action. */
|
|
|
|
struct mlx5_flow_dv_modify_hdr_resource *modify_hdr;
|
|
|
|
/* Pointer to modify header resource in cache. */
|
|
|
|
uint8_t fate_action;
|
|
|
|
/* Fate action type. */
|
|
|
|
union {
|
|
|
|
struct rte_flow_action *rss;
|
|
|
|
/* Rss action configuration. */
|
|
|
|
uint32_t rix_port_id_action;
|
|
|
|
/* Index to port ID action resource. */
|
|
|
|
void *dr_jump_action[MLX5_MTR_DOMAIN_MAX];
|
|
|
|
/* Jump/drop action per color. */
|
2021-05-13 08:35:44 +00:00
|
|
|
uint16_t queue;
|
|
|
|
/* Queue action configuration. */
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Flow meter policy parameter structure. */
|
|
|
|
struct mlx5_flow_meter_policy {
|
2021-07-02 09:14:46 +00:00
|
|
|
struct rte_eth_dev *dev;
|
|
|
|
/* The port dev on which policy is created. */
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
uint32_t is_rss:1;
|
|
|
|
/* Is RSS policy table. */
|
|
|
|
uint32_t ingress:1;
|
|
|
|
/* Rule applies to ingress domain. */
|
|
|
|
uint32_t egress:1;
|
|
|
|
/* Rule applies to egress domain. */
|
|
|
|
uint32_t transfer:1;
|
|
|
|
/* Rule applies to transfer domain. */
|
2021-05-13 08:35:44 +00:00
|
|
|
uint32_t is_queue:1;
|
|
|
|
/* Is queue action in policy table. */
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
rte_spinlock_t sl;
|
|
|
|
uint32_t ref_cnt;
|
|
|
|
/* Use count. */
|
|
|
|
struct mlx5_meter_policy_action_container act_cnt[MLX5_MTR_RTE_COLORS];
|
|
|
|
/* Policy actions container. */
|
|
|
|
void *dr_drop_action[MLX5_MTR_DOMAIN_MAX];
|
|
|
|
/* drop action for red color. */
|
|
|
|
uint16_t sub_policy_num;
|
|
|
|
/* Count sub policy tables, 3 bits per domain. */
|
|
|
|
struct mlx5_flow_meter_sub_policy **sub_policys[MLX5_MTR_DOMAIN_MAX];
|
|
|
|
/* Sub policy table array must be the end of struct. */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* The maximum sub policy is relate to struct mlx5_rss_hash_fields[]. */
|
|
|
|
#define MLX5_MTR_RSS_MAX_SUB_POLICY 7
|
|
|
|
#define MLX5_MTR_SUB_POLICY_NUM_SHIFT 3
|
|
|
|
#define MLX5_MTR_SUB_POLICY_NUM_MASK 0x7
|
|
|
|
#define MLX5_MTRS_DEFAULT_RULE_PRIORITY 0xFFFF
|
|
|
|
|
|
|
|
/* Flow meter default policy parameter structure.
|
|
|
|
* Policy index 0 is reserved by default policy table.
|
|
|
|
* Action per color as below:
|
|
|
|
* green - do nothing, yellow - do nothing, red - drop
|
|
|
|
*/
|
|
|
|
struct mlx5_flow_meter_def_policy {
|
|
|
|
struct mlx5_flow_meter_sub_policy sub_policy;
|
|
|
|
/* Policy rules jump to other tables. */
|
|
|
|
void *dr_jump_action[RTE_COLORS];
|
|
|
|
/* Jump action per color. */
|
|
|
|
};
|
2021-04-20 10:55:16 +00:00
|
|
|
|
|
|
|
/* Meter parameter structure. */
|
|
|
|
struct mlx5_flow_meter_info {
|
2021-04-27 10:43:52 +00:00
|
|
|
uint32_t meter_id;
|
|
|
|
/**< Meter id. */
|
|
|
|
uint32_t policy_id;
|
|
|
|
/* Policy id, the first sub_policy idx. */
|
2021-04-20 10:55:16 +00:00
|
|
|
struct mlx5_flow_meter_profile *profile;
|
|
|
|
/**< Meter profile parameters. */
|
|
|
|
rte_spinlock_t sl; /**< Meter action spinlock. */
|
|
|
|
/** Set of stats counters to be enabled.
|
|
|
|
* @see enum rte_mtr_stats_type
|
|
|
|
*/
|
|
|
|
uint32_t bytes_dropped:1;
|
|
|
|
/** Set bytes dropped stats to be enabled. */
|
|
|
|
uint32_t pkts_dropped:1;
|
|
|
|
/** Set packets dropped stats to be enabled. */
|
|
|
|
uint32_t active_state:1;
|
|
|
|
/**< Meter hw active state. */
|
|
|
|
uint32_t shared:1;
|
|
|
|
/**< Meter shared or not. */
|
|
|
|
uint32_t is_enable:1;
|
|
|
|
/**< Meter disable/enable state. */
|
|
|
|
uint32_t ingress:1;
|
|
|
|
/**< Rule applies to egress traffic. */
|
|
|
|
uint32_t egress:1;
|
|
|
|
/**
|
|
|
|
* Instead of simply matching the properties of traffic as it would
|
|
|
|
* appear on a given DPDK port ID, enabling this attribute transfers
|
|
|
|
* a flow rule to the lowest possible level of any device endpoints
|
|
|
|
* found in the pattern.
|
|
|
|
*
|
|
|
|
* When supported, this effectively enables an application to
|
|
|
|
* re-route traffic not necessarily intended for it (e.g. coming
|
|
|
|
* from or addressed to different physical ports, VFs or
|
|
|
|
* applications) at the device level.
|
|
|
|
*
|
|
|
|
* It complements the behavior of some pattern items such as
|
|
|
|
* RTE_FLOW_ITEM_TYPE_PHY_PORT and is meaningless without them.
|
|
|
|
*
|
|
|
|
* When transferring flow rules, ingress and egress attributes keep
|
|
|
|
* their original meaning, as if processing traffic emitted or
|
|
|
|
* received by the application.
|
|
|
|
*/
|
|
|
|
uint32_t transfer:1;
|
2021-04-27 10:43:52 +00:00
|
|
|
uint32_t def_policy:1;
|
|
|
|
/* Meter points to default policy. */
|
|
|
|
void *drop_rule[MLX5_MTR_DOMAIN_MAX];
|
|
|
|
/* Meter drop rule in drop table. */
|
2021-04-20 14:04:49 +00:00
|
|
|
uint32_t drop_cnt;
|
|
|
|
/**< Color counter for drop. */
|
2021-04-20 10:55:16 +00:00
|
|
|
uint32_t ref_cnt;
|
|
|
|
/**< Use count. */
|
|
|
|
struct mlx5_indexed_pool *flow_ipool;
|
|
|
|
/**< Index pool for flow id. */
|
2021-04-20 10:55:19 +00:00
|
|
|
void *meter_action;
|
|
|
|
/**< Flow meter action. */
|
2021-04-20 10:55:16 +00:00
|
|
|
};
|
|
|
|
|
2021-04-27 10:43:52 +00:00
|
|
|
/* PPS(packets per second) map to BPS(Bytes per second).
|
|
|
|
* HW treat packet as 128bytes in PPS mode
|
|
|
|
*/
|
|
|
|
#define MLX5_MTRS_PPS_MAP_BPS_SHIFT 7
|
|
|
|
|
2021-04-20 10:55:16 +00:00
|
|
|
/* RFC2697 parameter structure. */
|
|
|
|
struct mlx5_flow_meter_srtcm_rfc2697_prm {
|
|
|
|
rte_be32_t cbs_cir;
|
|
|
|
/*
|
|
|
|
* bit 24-28: cbs_exponent, bit 16-23 cbs_mantissa,
|
|
|
|
* bit 8-12: cir_exponent, bit 0-7 cir_mantissa.
|
|
|
|
*/
|
|
|
|
rte_be32_t ebs_eir;
|
|
|
|
/*
|
|
|
|
* bit 24-28: ebs_exponent, bit 16-23 ebs_mantissa,
|
|
|
|
* bit 8-12: eir_exponent, bit 0-7 eir_mantissa.
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Flow meter profile structure. */
|
|
|
|
struct mlx5_flow_meter_profile {
|
|
|
|
TAILQ_ENTRY(mlx5_flow_meter_profile) next;
|
|
|
|
/**< Pointer to the next flow meter structure. */
|
|
|
|
uint32_t id; /**< Profile id. */
|
|
|
|
struct rte_mtr_meter_profile profile; /**< Profile detail. */
|
|
|
|
union {
|
|
|
|
struct mlx5_flow_meter_srtcm_rfc2697_prm srtcm_prm;
|
|
|
|
/**< srtcm_rfc2697 struct. */
|
|
|
|
};
|
|
|
|
uint32_t ref_cnt; /**< Use count. */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 2 meters in each ASO cache line */
|
|
|
|
#define MLX5_MTRS_CONTAINER_RESIZE 64
|
|
|
|
/*
|
|
|
|
* The pool index and offset of meter in the pool array makes up the
|
|
|
|
* meter index. In case the meter is from pool 0 and offset 0, it
|
|
|
|
* should plus 1 to avoid index 0, since 0 means invalid meter index
|
|
|
|
* currently.
|
|
|
|
*/
|
|
|
|
#define MLX5_MAKE_MTR_IDX(pi, offset) \
|
|
|
|
((pi) * MLX5_ASO_MTRS_PER_POOL + (offset) + 1)
|
|
|
|
|
|
|
|
/*aso flow meter state*/
|
|
|
|
enum mlx5_aso_mtr_state {
|
|
|
|
ASO_METER_FREE, /* In free list. */
|
|
|
|
ASO_METER_WAIT, /* ACCESS_ASO WQE in progress. */
|
|
|
|
ASO_METER_READY, /* CQE received. */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Generic aso_flow_meter information. */
|
|
|
|
struct mlx5_aso_mtr {
|
|
|
|
LIST_ENTRY(mlx5_aso_mtr) next;
|
|
|
|
struct mlx5_flow_meter_info fm;
|
|
|
|
/**< Pointer to the next aso flow meter structure. */
|
|
|
|
uint8_t state; /**< ASO flow meter state. */
|
|
|
|
uint8_t offset;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Generic aso_flow_meter pool structure. */
|
|
|
|
struct mlx5_aso_mtr_pool {
|
|
|
|
struct mlx5_aso_mtr mtrs[MLX5_ASO_MTRS_PER_POOL];
|
|
|
|
/*Must be the first in pool*/
|
|
|
|
struct mlx5_devx_obj *devx_obj;
|
|
|
|
/* The devx object of the minimum aso flow meter ID. */
|
|
|
|
uint32_t index; /* Pool index in management structure. */
|
|
|
|
};
|
|
|
|
|
|
|
|
LIST_HEAD(aso_meter_list, mlx5_aso_mtr);
|
|
|
|
/* Pools management structure for ASO flow meter pools. */
|
|
|
|
struct mlx5_aso_mtr_pools_mng {
|
|
|
|
volatile uint16_t n_valid; /* Number of valid pools. */
|
|
|
|
uint16_t n; /* Number of pools. */
|
|
|
|
rte_spinlock_t mtrsl; /* The ASO flow meter free list lock. */
|
|
|
|
struct aso_meter_list meters; /* Free ASO flow meter list. */
|
|
|
|
struct mlx5_aso_sq sq; /*SQ using by ASO flow meter. */
|
|
|
|
struct mlx5_aso_mtr_pool **pools; /* ASO flow meter pool array. */
|
|
|
|
};
|
|
|
|
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
/* Meter management structure for global flow meter resource. */
|
|
|
|
struct mlx5_flow_mtr_mng {
|
|
|
|
struct mlx5_aso_mtr_pools_mng pools_mng;
|
|
|
|
/* Pools management structure for ASO flow meter pools. */
|
|
|
|
struct mlx5_flow_meter_def_policy *def_policy[MLX5_MTR_DOMAIN_MAX];
|
|
|
|
/* Default policy table. */
|
|
|
|
uint32_t def_policy_id;
|
|
|
|
/* Default policy id. */
|
|
|
|
uint32_t def_policy_ref_cnt;
|
|
|
|
/** def_policy meter use count. */
|
|
|
|
struct mlx5_flow_tbl_resource *drop_tbl[MLX5_MTR_DOMAIN_MAX];
|
|
|
|
/* Meter drop table. */
|
2021-04-27 10:43:52 +00:00
|
|
|
struct mlx5_flow_dv_matcher *
|
|
|
|
drop_matcher[MLX5_MTR_DOMAIN_MAX][MLX5_REG_BITS];
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
/* Matcher meter in drop table. */
|
|
|
|
struct mlx5_flow_dv_matcher *def_matcher[MLX5_MTR_DOMAIN_MAX];
|
|
|
|
/* Default matcher in drop table. */
|
|
|
|
void *def_rule[MLX5_MTR_DOMAIN_MAX];
|
|
|
|
/* Default rule in drop table. */
|
2021-04-27 10:43:52 +00:00
|
|
|
uint8_t max_mtr_bits;
|
|
|
|
/* Indicate how many bits are used by meter id at the most. */
|
|
|
|
uint8_t max_mtr_flow_bits;
|
|
|
|
/* Indicate how many bits are used by meter flow id at the most. */
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
};
|
|
|
|
|
2019-11-08 15:23:08 +00:00
|
|
|
/* Table key of the hash organization. */
|
|
|
|
union mlx5_flow_tbl_key {
|
|
|
|
struct {
|
|
|
|
/* Table ID should be at the lowest address. */
|
2021-04-20 10:55:21 +00:00
|
|
|
uint32_t level; /**< Level of the table. */
|
|
|
|
uint32_t id:22; /**< ID of the table. */
|
|
|
|
uint32_t dummy:1; /**< Dummy table for DV API. */
|
|
|
|
uint32_t is_fdb:1; /**< 1 - FDB, 0 - NIC TX/RX. */
|
|
|
|
uint32_t is_egress:1; /**< 1 - egress, 0 - ingress. */
|
|
|
|
uint32_t reserved:7; /**< must be zero for comparison. */
|
2019-11-08 15:23:08 +00:00
|
|
|
};
|
|
|
|
uint64_t v64; /**< full 64bits value of key */
|
|
|
|
};
|
|
|
|
|
2019-04-04 13:04:25 +00:00
|
|
|
/* Table structure. */
|
|
|
|
struct mlx5_flow_tbl_resource {
|
|
|
|
void *obj; /**< Pointer to DR table object. */
|
2020-10-27 15:28:24 +00:00
|
|
|
uint32_t refcnt; /**< Reference counter. */
|
2019-04-04 13:04:25 +00:00
|
|
|
};
|
|
|
|
|
2019-09-11 11:03:36 +00:00
|
|
|
#define MLX5_MAX_TABLES UINT16_MAX
|
2019-10-30 23:53:22 +00:00
|
|
|
#define MLX5_HAIRPIN_TX_TABLE (UINT16_MAX - 1)
|
2019-11-07 17:09:53 +00:00
|
|
|
/* Reserve the last two tables for metadata register copy. */
|
|
|
|
#define MLX5_FLOW_MREG_ACT_TABLE_GROUP (MLX5_MAX_TABLES - 1)
|
2019-11-07 17:10:04 +00:00
|
|
|
#define MLX5_FLOW_MREG_CP_TABLE_GROUP (MLX5_MAX_TABLES - 2)
|
|
|
|
/* Tables for metering splits should be added here. */
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
#define MLX5_FLOW_TABLE_LEVEL_METER (MLX5_MAX_TABLES - 3)
|
|
|
|
#define MLX5_FLOW_TABLE_LEVEL_POLICY (MLX5_MAX_TABLES - 4)
|
|
|
|
#define MLX5_MAX_TABLES_EXTERNAL MLX5_FLOW_TABLE_LEVEL_POLICY
|
2019-09-11 11:03:36 +00:00
|
|
|
#define MLX5_MAX_TABLES_FDB UINT16_MAX
|
2020-10-13 14:11:46 +00:00
|
|
|
#define MLX5_FLOW_TABLE_FACTOR 10
|
2019-04-04 13:04:25 +00:00
|
|
|
|
2019-10-30 23:53:23 +00:00
|
|
|
/* ID generation structure. */
|
|
|
|
struct mlx5_flow_id_pool {
|
|
|
|
uint32_t *free_arr; /**< Pointer to the a array of free values. */
|
|
|
|
uint32_t base_index;
|
|
|
|
/**< The next index that can be used without any free elements. */
|
|
|
|
uint32_t *curr; /**< Pointer to the index to pop. */
|
|
|
|
uint32_t *last; /**< Pointer to the last element in the empty arrray. */
|
2020-01-23 06:01:01 +00:00
|
|
|
uint32_t max_id; /**< Maximum id can be allocated from the pool. */
|
2019-10-30 23:53:23 +00:00
|
|
|
};
|
|
|
|
|
2020-07-16 08:23:08 +00:00
|
|
|
/* Tx pacing queue structure - for Clock and Rearm queues. */
|
|
|
|
struct mlx5_txpp_wq {
|
|
|
|
/* Completion Queue related data.*/
|
2021-01-06 08:19:29 +00:00
|
|
|
struct mlx5_devx_cq cq_obj;
|
2020-07-16 08:23:08 +00:00
|
|
|
uint32_t cq_ci:24;
|
|
|
|
uint32_t arm_sn:2;
|
|
|
|
/* Send Queue related data.*/
|
2021-01-06 08:19:36 +00:00
|
|
|
struct mlx5_devx_sq sq_obj;
|
2020-07-16 08:23:08 +00:00
|
|
|
uint16_t sq_size; /* Number of WQEs in the queue. */
|
|
|
|
uint16_t sq_ci; /* Next WQE to execute. */
|
|
|
|
};
|
|
|
|
|
2020-07-16 08:23:12 +00:00
|
|
|
/* Tx packet pacing internal timestamp. */
|
|
|
|
struct mlx5_txpp_ts {
|
2020-10-28 12:44:47 +00:00
|
|
|
uint64_t ci_ts;
|
|
|
|
uint64_t ts;
|
2020-07-16 08:23:12 +00:00
|
|
|
};
|
|
|
|
|
2020-07-16 08:23:08 +00:00
|
|
|
/* Tx packet pacing structure. */
|
|
|
|
struct mlx5_dev_txpp {
|
|
|
|
pthread_mutex_t mutex; /* Pacing create/destroy mutex. */
|
|
|
|
uint32_t refcnt; /* Pacing reference counter. */
|
|
|
|
uint32_t freq; /* Timestamp frequency, Hz. */
|
|
|
|
uint32_t tick; /* Completion tick duration in nanoseconds. */
|
|
|
|
uint32_t test; /* Packet pacing test mode. */
|
|
|
|
int32_t skew; /* Scheduling skew. */
|
|
|
|
struct rte_intr_handle intr_handle; /* Periodic interrupt. */
|
2020-08-25 09:31:13 +00:00
|
|
|
void *echan; /* Event Channel. */
|
2020-07-16 08:23:08 +00:00
|
|
|
struct mlx5_txpp_wq clock_queue; /* Clock Queue. */
|
2020-07-16 08:23:09 +00:00
|
|
|
struct mlx5_txpp_wq rearm_queue; /* Clock Queue. */
|
2020-08-25 09:31:13 +00:00
|
|
|
void *pp; /* Packet pacing context. */
|
2020-07-16 08:23:11 +00:00
|
|
|
uint16_t pp_id; /* Packet pacing context index. */
|
2020-07-16 08:23:12 +00:00
|
|
|
uint16_t ts_n; /* Number of captured timestamps. */
|
|
|
|
uint16_t ts_p; /* Pointer to statisticks timestamp. */
|
|
|
|
struct mlx5_txpp_ts *tsa; /* Timestamps sliding window stats. */
|
|
|
|
struct mlx5_txpp_ts ts; /* Cached completion id/timestamp. */
|
|
|
|
uint32_t sync_lost:1; /* ci/timestamp synchronization lost. */
|
|
|
|
/* Statistics counters. */
|
2020-10-28 12:44:47 +00:00
|
|
|
uint64_t err_miss_int; /* Missed service interrupt. */
|
|
|
|
uint64_t err_rearm_queue; /* Rearm Queue errors. */
|
|
|
|
uint64_t err_clock_queue; /* Clock Queue errors. */
|
|
|
|
uint64_t err_ts_past; /* Timestamp in the past. */
|
|
|
|
uint64_t err_ts_future; /* Timestamp in the distant future. */
|
2020-07-16 08:23:08 +00:00
|
|
|
};
|
|
|
|
|
2020-07-17 07:11:46 +00:00
|
|
|
/* Supported flex parser profile ID. */
|
|
|
|
enum mlx5_flex_parser_profile_id {
|
|
|
|
MLX5_FLEX_PARSER_ECPRI_0 = 0,
|
|
|
|
MLX5_FLEX_PARSER_MAX = 8,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Sample ID information of flex parser structure. */
|
|
|
|
struct mlx5_flex_parser_profiles {
|
|
|
|
uint32_t num; /* Actual number of samples. */
|
|
|
|
uint32_t ids[8]; /* Sample IDs for this profile. */
|
2020-07-17 07:11:47 +00:00
|
|
|
uint8_t offset[8]; /* Bytes offset of each parser. */
|
2020-07-17 07:11:46 +00:00
|
|
|
void *obj; /* Flex parser node object. */
|
|
|
|
};
|
|
|
|
|
2021-03-28 13:48:12 +00:00
|
|
|
/* Max member ports per bonding device. */
|
|
|
|
#define MLX5_BOND_MAX_PORTS 2
|
|
|
|
|
|
|
|
/* Bonding device information. */
|
|
|
|
struct mlx5_bond_info {
|
|
|
|
int n_port; /* Number of bond member ports. */
|
|
|
|
uint32_t ifindex;
|
|
|
|
char ifname[MLX5_NAMESIZE + 1];
|
|
|
|
struct {
|
|
|
|
char ifname[MLX5_NAMESIZE + 1];
|
|
|
|
uint32_t ifindex;
|
|
|
|
struct rte_pci_addr pci_addr;
|
|
|
|
} ports[MLX5_BOND_MAX_PORTS];
|
|
|
|
};
|
|
|
|
|
2021-05-05 12:23:15 +00:00
|
|
|
/* Number of connection tracking objects per pool: must be a power of 2. */
|
|
|
|
#define MLX5_ASO_CT_ACTIONS_PER_POOL 64
|
|
|
|
|
2021-05-05 12:23:18 +00:00
|
|
|
/* Generate incremental and unique CT index from pool and offset. */
|
|
|
|
#define MLX5_MAKE_CT_IDX(pool, offset) \
|
|
|
|
((pool) * MLX5_ASO_CT_ACTIONS_PER_POOL + (offset) + 1)
|
|
|
|
|
2021-05-05 12:23:15 +00:00
|
|
|
/* ASO Conntrack state. */
|
|
|
|
enum mlx5_aso_ct_state {
|
|
|
|
ASO_CONNTRACK_FREE, /* Inactive, in the free list. */
|
|
|
|
ASO_CONNTRACK_WAIT, /* WQE sent in the SQ. */
|
|
|
|
ASO_CONNTRACK_READY, /* CQE received w/o error. */
|
|
|
|
ASO_CONNTRACK_QUERY, /* WQE for query sent. */
|
|
|
|
ASO_CONNTRACK_MAX, /* Guard. */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Generic ASO connection tracking structure. */
|
|
|
|
struct mlx5_aso_ct_action {
|
|
|
|
LIST_ENTRY(mlx5_aso_ct_action) next; /* Pointer to the next ASO CT. */
|
|
|
|
void *dr_action_orig; /* General action object for original dir. */
|
|
|
|
void *dr_action_rply; /* General action object for reply dir. */
|
|
|
|
uint32_t refcnt; /* Action used count in device flows. */
|
|
|
|
uint16_t offset; /* Offset of ASO CT in DevX objects bulk. */
|
|
|
|
uint16_t peer; /* The only peer port index could also use this CT. */
|
|
|
|
enum mlx5_aso_ct_state state; /* ASO CT state. */
|
|
|
|
bool is_original; /* The direction of the DR action to be used. */
|
|
|
|
};
|
|
|
|
|
2021-05-05 12:23:17 +00:00
|
|
|
/* CT action object state update. */
|
|
|
|
#define MLX5_ASO_CT_UPDATE_STATE(c, s) \
|
|
|
|
__atomic_store_n(&((c)->state), (s), __ATOMIC_RELAXED)
|
|
|
|
|
2021-05-05 12:23:15 +00:00
|
|
|
/* ASO connection tracking software pool definition. */
|
|
|
|
struct mlx5_aso_ct_pool {
|
|
|
|
uint16_t index; /* Pool index in pools array. */
|
|
|
|
struct mlx5_devx_obj *devx_obj;
|
|
|
|
/* The first devx object in the bulk, used for freeing (not yet). */
|
|
|
|
struct mlx5_aso_ct_action actions[MLX5_ASO_CT_ACTIONS_PER_POOL];
|
|
|
|
/* CT action structures bulk. */
|
|
|
|
};
|
|
|
|
|
|
|
|
LIST_HEAD(aso_ct_list, mlx5_aso_ct_action);
|
|
|
|
|
|
|
|
/* Pools management structure for ASO connection tracking pools. */
|
|
|
|
struct mlx5_aso_ct_pools_mng {
|
|
|
|
struct mlx5_aso_ct_pool **pools;
|
|
|
|
uint16_t n; /* Total number of pools. */
|
|
|
|
uint16_t next; /* Number of pools in use, index of next free pool. */
|
|
|
|
rte_spinlock_t ct_sl; /* The ASO CT free list lock. */
|
|
|
|
rte_rwlock_t resize_rwl; /* The ASO CT pool resize lock. */
|
|
|
|
struct aso_ct_list free_cts; /* Free ASO CT objects list. */
|
|
|
|
struct mlx5_aso_sq aso_sq; /* ASO queue objects. */
|
|
|
|
};
|
|
|
|
|
2019-03-27 13:15:39 +00:00
|
|
|
/*
|
|
|
|
* Shared Infiniband device context for Master/Representors
|
|
|
|
* which belong to same IB device with multiple IB ports.
|
|
|
|
**/
|
2020-06-03 15:05:55 +00:00
|
|
|
struct mlx5_dev_ctx_shared {
|
|
|
|
LIST_ENTRY(mlx5_dev_ctx_shared) next;
|
2019-03-27 13:15:39 +00:00
|
|
|
uint32_t refcnt;
|
|
|
|
uint32_t devx:1; /* Opened with DV. */
|
2020-11-01 17:57:49 +00:00
|
|
|
uint32_t flow_hit_aso_en:1; /* Flow Hit ASO is supported. */
|
2021-03-14 12:12:59 +00:00
|
|
|
uint32_t rq_ts_format:2; /* RQ timestamp formats supported. */
|
|
|
|
uint32_t sq_ts_format:2; /* SQ timestamp formats supported. */
|
|
|
|
uint32_t qp_ts_format:2; /* QP timestamp formats supported. */
|
2021-04-20 10:55:16 +00:00
|
|
|
uint32_t meter_aso_en:1; /* Flow Meter ASO is supported. */
|
2021-05-05 12:23:15 +00:00
|
|
|
uint32_t ct_aso_en:1; /* Connection Tracking ASO is supported. */
|
2019-03-27 13:15:39 +00:00
|
|
|
uint32_t max_port; /* Maximal IB device port index. */
|
2021-03-28 13:48:12 +00:00
|
|
|
struct mlx5_bond_info bond; /* Bonding information. */
|
2020-06-03 15:05:56 +00:00
|
|
|
void *ctx; /* Verbs/DV/DevX context. */
|
2020-06-03 15:05:57 +00:00
|
|
|
void *pd; /* Protection Domain. */
|
2019-07-22 14:52:15 +00:00
|
|
|
uint32_t pdn; /* Protection Domain number. */
|
2019-07-22 14:52:05 +00:00
|
|
|
uint32_t tdn; /* Transport Domain number. */
|
2020-12-28 12:32:29 +00:00
|
|
|
char ibdev_name[MLX5_FS_NAME_MAX]; /* SYSFS dev name. */
|
|
|
|
char ibdev_path[MLX5_FS_PATH_MAX]; /* SYSFS dev path for secondary */
|
2020-06-03 15:05:58 +00:00
|
|
|
struct mlx5_dev_attr device_attr; /* Device properties. */
|
2020-07-16 08:23:08 +00:00
|
|
|
int numa_node; /* Numa node of backing physical device. */
|
2020-06-03 15:05:55 +00:00
|
|
|
LIST_ENTRY(mlx5_dev_ctx_shared) mem_event_cb;
|
2019-04-27 04:32:57 +00:00
|
|
|
/**< Called by memory event callback. */
|
2020-04-13 21:17:48 +00:00
|
|
|
struct mlx5_mr_share_cache share_cache;
|
2020-07-16 08:23:08 +00:00
|
|
|
/* Packet pacing related structure. */
|
|
|
|
struct mlx5_dev_txpp txpp;
|
2019-04-04 13:04:24 +00:00
|
|
|
/* Shared DV/DR flow data section. */
|
2019-11-07 17:09:55 +00:00
|
|
|
uint32_t dv_meta_mask; /* flow META metadata supported mask. */
|
|
|
|
uint32_t dv_mark_mask; /* flow MARK metadata supported mask. */
|
|
|
|
uint32_t dv_regc0_mask; /* available bits of metatada reg_c[0]. */
|
2019-05-01 20:40:45 +00:00
|
|
|
void *fdb_domain; /* FDB Direct Rules name space handle. */
|
|
|
|
void *rx_domain; /* RX Direct Rules name space handle. */
|
|
|
|
void *tx_domain; /* TX Direct Rules name space handle. */
|
2020-07-16 08:23:06 +00:00
|
|
|
#ifndef RTE_ARCH_64
|
|
|
|
rte_spinlock_t uar_lock_cq; /* CQs share a common distinct UAR */
|
|
|
|
rte_spinlock_t uar_lock[MLX5_UAR_PAGE_NUM_MAX];
|
|
|
|
/* UAR same-page access control required in 32bit implementations. */
|
|
|
|
#endif
|
2019-11-08 15:23:08 +00:00
|
|
|
struct mlx5_hlist *flow_tbls;
|
2020-10-25 14:08:09 +00:00
|
|
|
struct mlx5_flow_tunnel_hub *tunnel_hub;
|
2019-11-08 15:23:08 +00:00
|
|
|
/* Direct Rules tables for FDB, NIC TX+RX */
|
2021-04-05 09:59:01 +00:00
|
|
|
void *dr_drop_action; /* Pointer to DR drop action, any domain. */
|
2019-09-09 15:56:45 +00:00
|
|
|
void *pop_vlan_action; /* Pointer to DR pop VLAN action. */
|
2020-09-16 10:19:48 +00:00
|
|
|
struct mlx5_hlist *encaps_decaps; /* Encap/decap action hash list. */
|
2020-07-31 03:34:18 +00:00
|
|
|
struct mlx5_hlist *modify_cmds;
|
2019-11-08 05:26:57 +00:00
|
|
|
struct mlx5_hlist *tag_table;
|
2020-10-28 09:33:44 +00:00
|
|
|
struct mlx5_cache_list port_id_action_list; /* Port ID action cache. */
|
2020-10-28 09:33:45 +00:00
|
|
|
struct mlx5_cache_list push_vlan_action_list; /* Push VLAN actions. */
|
2020-10-28 09:33:48 +00:00
|
|
|
struct mlx5_cache_list sample_action_list; /* List of sample actions. */
|
|
|
|
struct mlx5_cache_list dest_array_list;
|
|
|
|
/* List of destination array actions. */
|
2019-07-16 14:34:53 +00:00
|
|
|
struct mlx5_flow_counter_mng cmng; /* Counters management structure. */
|
2020-10-28 09:33:29 +00:00
|
|
|
void *default_miss_action; /* Default miss action. */
|
2020-04-16 02:42:02 +00:00
|
|
|
struct mlx5_indexed_pool *ipool[MLX5_IPOOL_MAX];
|
|
|
|
/* Memory Pool for mlx5 flow resources. */
|
2020-06-18 07:24:43 +00:00
|
|
|
struct mlx5_l3t_tbl *cnt_id_tbl; /* Shared counter lookup table. */
|
2019-04-04 13:04:24 +00:00
|
|
|
/* Shared interrupt handler section. */
|
2019-03-27 13:15:39 +00:00
|
|
|
struct rte_intr_handle intr_handle; /* Interrupt handler for device. */
|
2019-07-16 14:34:55 +00:00
|
|
|
struct rte_intr_handle intr_handle_devx; /* DEVX interrupt handler. */
|
2020-06-10 09:32:26 +00:00
|
|
|
void *devx_comp; /* DEVX async comp obj. */
|
2019-10-30 23:53:15 +00:00
|
|
|
struct mlx5_devx_obj *tis; /* TIS object. */
|
|
|
|
struct mlx5_devx_obj *td; /* Transport domain. */
|
2020-08-25 09:31:13 +00:00
|
|
|
void *tx_uar; /* Tx/packet pacing shared UAR. */
|
2020-07-17 07:11:46 +00:00
|
|
|
struct mlx5_flex_parser_profiles fp[MLX5_FLEX_PARSER_MAX];
|
|
|
|
/* Flex parser profiles information. */
|
2020-08-25 09:31:13 +00:00
|
|
|
void *devx_rx_uar; /* DevX UAR for Rx. */
|
2020-11-01 17:57:49 +00:00
|
|
|
struct mlx5_aso_age_mng *aso_age_mng;
|
|
|
|
/* Management data for aging mechanism using ASO Flow Hit. */
|
2021-01-17 10:21:20 +00:00
|
|
|
struct mlx5_geneve_tlv_option_resource *geneve_tlv_option_resource;
|
|
|
|
/* Management structure for geneve tlv option */
|
|
|
|
rte_spinlock_t geneve_tlv_opt_sl; /* Lock for geneve tlv resource */
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
struct mlx5_flow_mtr_mng *mtrmng;
|
|
|
|
/* Meter management structure. */
|
2021-05-05 12:23:15 +00:00
|
|
|
struct mlx5_aso_ct_pools_mng *ct_mng;
|
|
|
|
/* Management data for ASO connection tracking. */
|
2021-05-17 15:18:41 +00:00
|
|
|
struct mlx5_lb_ctx self_lb; /* QP to enable self loopback for Devx. */
|
2020-06-10 09:32:27 +00:00
|
|
|
struct mlx5_dev_shared_port port[]; /* per device port data array. */
|
2019-03-27 13:15:39 +00:00
|
|
|
};
|
|
|
|
|
2021-01-24 11:02:05 +00:00
|
|
|
/*
|
|
|
|
* Per-process private structure.
|
|
|
|
* Caution, secondary process may rebuild the struct during port start.
|
|
|
|
*/
|
2019-04-10 18:41:17 +00:00
|
|
|
struct mlx5_proc_priv {
|
|
|
|
size_t uar_table_sz;
|
|
|
|
/* Size of UAR register table. */
|
|
|
|
void *uar_table[];
|
|
|
|
/* Table of UAR registers for each process. */
|
|
|
|
};
|
|
|
|
|
2019-11-08 03:49:10 +00:00
|
|
|
/* MTR profile list. */
|
|
|
|
TAILQ_HEAD(mlx5_mtr_profiles, mlx5_flow_meter_profile);
|
2019-11-08 03:49:14 +00:00
|
|
|
/* MTR list. */
|
2021-04-20 10:55:16 +00:00
|
|
|
TAILQ_HEAD(mlx5_legacy_flow_meters, mlx5_legacy_flow_meter);
|
2019-11-08 03:49:10 +00:00
|
|
|
|
2020-10-28 09:33:42 +00:00
|
|
|
/* RSS description. */
|
|
|
|
struct mlx5_flow_rss_desc {
|
|
|
|
uint32_t level;
|
|
|
|
uint32_t queue_num; /**< Number of entries in @p queue. */
|
|
|
|
uint64_t types; /**< Specific RSS hash types (see ETH_RSS_*). */
|
|
|
|
uint64_t hash_fields; /* Verbs Hash fields. */
|
|
|
|
uint8_t key[MLX5_RSS_HASH_KEY_LEN]; /**< RSS hash key. */
|
|
|
|
uint32_t key_len; /**< RSS hash key len. */
|
|
|
|
uint32_t tunnel; /**< Queue in tunnel. */
|
2020-11-10 03:28:02 +00:00
|
|
|
uint32_t shared_rss; /**< Shared RSS index. */
|
2020-11-22 14:49:51 +00:00
|
|
|
struct mlx5_ind_table_obj *ind_tbl;
|
|
|
|
/**< Indirection table for shared RSS hash RX queues. */
|
2020-10-28 09:33:42 +00:00
|
|
|
union {
|
|
|
|
uint16_t *queue; /**< Destination queues. */
|
|
|
|
const uint16_t *const_q; /**< Const pointer convert. */
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2019-04-10 18:41:17 +00:00
|
|
|
#define MLX5_PROC_PRIV(port_id) \
|
|
|
|
((struct mlx5_proc_priv *)rte_eth_devices[port_id].process_private)
|
|
|
|
|
2020-09-03 10:13:36 +00:00
|
|
|
/* Verbs/DevX Rx queue elements. */
|
|
|
|
struct mlx5_rxq_obj {
|
|
|
|
LIST_ENTRY(mlx5_rxq_obj) next; /* Pointer to the next element. */
|
|
|
|
struct mlx5_rxq_ctrl *rxq_ctrl; /* Back pointer to parent. */
|
|
|
|
int fd; /* File descriptor for event channel */
|
|
|
|
RTE_STD_C11
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
void *wq; /* Work Queue. */
|
|
|
|
void *ibv_cq; /* Completion Queue. */
|
|
|
|
void *ibv_channel;
|
|
|
|
};
|
2021-01-06 08:19:40 +00:00
|
|
|
struct mlx5_devx_obj *rq; /* DevX RQ object for hairpin. */
|
2020-09-03 10:13:36 +00:00
|
|
|
struct {
|
2021-01-06 08:19:40 +00:00
|
|
|
struct mlx5_devx_rq rq_obj; /* DevX RQ object. */
|
2021-01-06 08:19:32 +00:00
|
|
|
struct mlx5_devx_cq cq_obj; /* DevX CQ object. */
|
2020-09-03 10:13:36 +00:00
|
|
|
void *devx_channel;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2020-09-03 10:13:43 +00:00
|
|
|
/* Indirection table. */
|
|
|
|
struct mlx5_ind_table_obj {
|
|
|
|
LIST_ENTRY(mlx5_ind_table_obj) next; /* Pointer to the next element. */
|
2020-10-27 15:28:23 +00:00
|
|
|
uint32_t refcnt; /* Reference counter. */
|
2020-09-03 10:13:43 +00:00
|
|
|
RTE_STD_C11
|
|
|
|
union {
|
|
|
|
void *ind_table; /**< Indirection table. */
|
|
|
|
struct mlx5_devx_obj *rqt; /* DevX RQT object. */
|
|
|
|
};
|
|
|
|
uint32_t queues_n; /**< Number of queues in the list. */
|
2020-11-22 14:49:51 +00:00
|
|
|
uint16_t *queues; /**< Queue list. */
|
2020-09-03 10:13:43 +00:00
|
|
|
};
|
|
|
|
|
2020-09-03 10:13:44 +00:00
|
|
|
/* Hash Rx queue. */
|
2020-10-26 11:55:01 +00:00
|
|
|
__extension__
|
2020-09-03 10:13:44 +00:00
|
|
|
struct mlx5_hrxq {
|
2020-10-28 09:33:42 +00:00
|
|
|
struct mlx5_cache_entry entry; /* Cache entry. */
|
2020-10-28 09:33:41 +00:00
|
|
|
uint32_t standalone:1; /* This object used in shared action. */
|
2020-09-03 10:13:44 +00:00
|
|
|
struct mlx5_ind_table_obj *ind_table; /* Indirection table. */
|
|
|
|
RTE_STD_C11
|
|
|
|
union {
|
|
|
|
void *qp; /* Verbs queue pair. */
|
|
|
|
struct mlx5_devx_obj *tir; /* DevX TIR object. */
|
|
|
|
};
|
2020-12-28 12:32:55 +00:00
|
|
|
#if defined(HAVE_IBV_FLOW_DV_SUPPORT) || !defined(HAVE_INFINIBAND_VERBS_H)
|
2020-09-03 10:13:44 +00:00
|
|
|
void *action; /* DV QP action pointer. */
|
|
|
|
#endif
|
|
|
|
uint64_t hash_fields; /* Verbs Hash fields. */
|
|
|
|
uint32_t rss_key_len; /* Hash key length in bytes. */
|
2020-10-28 09:33:42 +00:00
|
|
|
uint32_t idx; /* Hash Rx queue index. */
|
2020-09-03 10:13:44 +00:00
|
|
|
uint8_t rss_key[]; /* Hash key. */
|
|
|
|
};
|
|
|
|
|
2020-10-01 14:09:18 +00:00
|
|
|
/* Verbs/DevX Tx queue elements. */
|
|
|
|
struct mlx5_txq_obj {
|
|
|
|
LIST_ENTRY(mlx5_txq_obj) next; /* Pointer to the next element. */
|
|
|
|
struct mlx5_txq_ctrl *txq_ctrl; /* Pointer to the control queue. */
|
|
|
|
RTE_STD_C11
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
void *cq; /* Completion Queue. */
|
|
|
|
void *qp; /* Queue Pair. */
|
|
|
|
};
|
|
|
|
struct {
|
|
|
|
struct mlx5_devx_obj *sq;
|
|
|
|
/* DevX object for Sx queue. */
|
|
|
|
struct mlx5_devx_obj *tis; /* The TIS object. */
|
|
|
|
};
|
|
|
|
struct {
|
|
|
|
struct rte_eth_dev *dev;
|
2021-01-06 08:19:31 +00:00
|
|
|
struct mlx5_devx_cq cq_obj;
|
2021-01-06 08:19:37 +00:00
|
|
|
/* DevX CQ object and its resources. */
|
|
|
|
struct mlx5_devx_sq sq_obj;
|
|
|
|
/* DevX SQ object and its resources. */
|
2020-10-01 14:09:18 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2020-10-01 14:09:25 +00:00
|
|
|
enum mlx5_rxq_modify_type {
|
|
|
|
MLX5_RXQ_MOD_ERR2RST, /* modify state from error to reset. */
|
|
|
|
MLX5_RXQ_MOD_RST2RDY, /* modify state from reset to ready. */
|
|
|
|
MLX5_RXQ_MOD_RDY2ERR, /* modify state from ready to error. */
|
|
|
|
MLX5_RXQ_MOD_RDY2RST, /* modify state from ready to reset. */
|
|
|
|
};
|
|
|
|
|
2020-10-01 14:09:22 +00:00
|
|
|
enum mlx5_txq_modify_type {
|
|
|
|
MLX5_TXQ_MOD_RST2RDY, /* modify state from reset to ready. */
|
|
|
|
MLX5_TXQ_MOD_RDY2RST, /* modify state from ready to reset. */
|
|
|
|
MLX5_TXQ_MOD_ERR2RDY, /* modify state from error to ready. */
|
|
|
|
};
|
|
|
|
|
2020-08-25 09:31:15 +00:00
|
|
|
/* HW objects operations structure. */
|
|
|
|
struct mlx5_obj_ops {
|
|
|
|
int (*rxq_obj_modify_vlan_strip)(struct mlx5_rxq_obj *rxq_obj, int on);
|
2020-09-03 10:13:38 +00:00
|
|
|
int (*rxq_obj_new)(struct rte_eth_dev *dev, uint16_t idx);
|
2020-09-03 10:13:37 +00:00
|
|
|
int (*rxq_event_get)(struct mlx5_rxq_obj *rxq_obj);
|
2020-10-01 14:09:25 +00:00
|
|
|
int (*rxq_obj_modify)(struct mlx5_rxq_obj *rxq_obj, uint8_t type);
|
2020-09-03 10:13:36 +00:00
|
|
|
void (*rxq_obj_release)(struct mlx5_rxq_obj *rxq_obj);
|
2020-09-03 10:13:46 +00:00
|
|
|
int (*ind_table_new)(struct rte_eth_dev *dev, const unsigned int log_n,
|
|
|
|
struct mlx5_ind_table_obj *ind_tbl);
|
2020-11-22 14:49:51 +00:00
|
|
|
int (*ind_table_modify)(struct rte_eth_dev *dev,
|
|
|
|
const unsigned int log_n,
|
|
|
|
const uint16_t *queues, const uint32_t queues_n,
|
|
|
|
struct mlx5_ind_table_obj *ind_tbl);
|
2020-09-03 10:13:46 +00:00
|
|
|
void (*ind_table_destroy)(struct mlx5_ind_table_obj *ind_tbl);
|
2020-09-03 10:13:47 +00:00
|
|
|
int (*hrxq_new)(struct rte_eth_dev *dev, struct mlx5_hrxq *hrxq,
|
|
|
|
int tunnel __rte_unused);
|
2020-10-23 10:24:08 +00:00
|
|
|
int (*hrxq_modify)(struct rte_eth_dev *dev, struct mlx5_hrxq *hrxq,
|
|
|
|
const uint8_t *rss_key,
|
|
|
|
uint64_t hash_fields,
|
|
|
|
const struct mlx5_ind_table_obj *ind_tbl);
|
2020-09-03 10:13:44 +00:00
|
|
|
void (*hrxq_destroy)(struct mlx5_hrxq *hrxq);
|
2020-09-03 10:13:49 +00:00
|
|
|
int (*drop_action_create)(struct rte_eth_dev *dev);
|
|
|
|
void (*drop_action_destroy)(struct rte_eth_dev *dev);
|
2020-10-01 14:09:19 +00:00
|
|
|
int (*txq_obj_new)(struct rte_eth_dev *dev, uint16_t idx);
|
2020-10-01 14:09:22 +00:00
|
|
|
int (*txq_obj_modify)(struct mlx5_txq_obj *obj,
|
|
|
|
enum mlx5_txq_modify_type type, uint8_t dev_port);
|
2020-10-01 14:09:18 +00:00
|
|
|
void (*txq_obj_release)(struct mlx5_txq_obj *txq_obj);
|
2021-05-17 15:18:41 +00:00
|
|
|
int (*lb_dummy_queue_create)(struct rte_eth_dev *dev);
|
|
|
|
void (*lb_dummy_queue_release)(struct rte_eth_dev *dev);
|
2020-08-25 09:31:15 +00:00
|
|
|
};
|
|
|
|
|
2020-11-01 17:57:50 +00:00
|
|
|
#define MLX5_RSS_HASH_FIELDS_LEN RTE_DIM(mlx5_rss_hash_fields)
|
|
|
|
|
2020-12-28 09:54:31 +00:00
|
|
|
/* MR operations structure. */
|
|
|
|
struct mlx5_mr_ops {
|
|
|
|
mlx5_reg_mr_t reg_mr;
|
|
|
|
mlx5_dereg_mr_t dereg_mr;
|
|
|
|
};
|
|
|
|
|
2019-02-21 09:29:14 +00:00
|
|
|
struct mlx5_priv {
|
2018-05-09 11:04:50 +00:00
|
|
|
struct rte_eth_dev_data *dev_data; /* Pointer to device data. */
|
2020-06-03 15:05:55 +00:00
|
|
|
struct mlx5_dev_ctx_shared *sh; /* Shared device context. */
|
2020-06-10 09:32:27 +00:00
|
|
|
uint32_t dev_port; /* Device port number. */
|
2019-09-25 07:53:24 +00:00
|
|
|
struct rte_pci_device *pci_dev; /* Backend PCI device. */
|
2019-05-21 16:13:03 +00:00
|
|
|
struct rte_ether_addr mac[MLX5_MAX_MAC_ADDRESSES]; /* MAC addresses. */
|
2018-04-05 15:07:19 +00:00
|
|
|
BITFIELD_DECLARE(mac_own, uint64_t, MLX5_MAX_MAC_ADDRESSES);
|
|
|
|
/* Bit-field of MAC addresses owned by the PMD. */
|
2015-10-30 18:52:40 +00:00
|
|
|
uint16_t vlan_filter[MLX5_MAX_VLAN_IDS]; /* VLAN filters table. */
|
|
|
|
unsigned int vlan_filter_n; /* Number of configured VLAN filters. */
|
2015-10-30 18:52:30 +00:00
|
|
|
/* Device properties. */
|
|
|
|
uint16_t mtu; /* Configured MTU. */
|
2017-05-24 13:44:08 +00:00
|
|
|
unsigned int isolated:1; /* Whether isolated mode is enabled. */
|
2018-07-10 16:04:54 +00:00
|
|
|
unsigned int representor:1; /* Device is a port representor. */
|
2019-03-27 13:15:35 +00:00
|
|
|
unsigned int master:1; /* Device is a E-Switch master. */
|
2020-07-16 08:23:08 +00:00
|
|
|
unsigned int txpp_en:1; /* Tx packet pacing enabled. */
|
2021-04-20 10:55:10 +00:00
|
|
|
unsigned int sampler_en:1; /* Whether support sampler. */
|
2019-11-08 03:49:08 +00:00
|
|
|
unsigned int mtr_en:1; /* Whether support meter. */
|
2020-01-23 06:01:02 +00:00
|
|
|
unsigned int mtr_reg_share:1; /* Whether support meter REG_C share. */
|
2021-05-17 15:18:41 +00:00
|
|
|
unsigned int lb_used:1; /* Loopback queue is referred to. */
|
2018-07-10 16:04:54 +00:00
|
|
|
uint16_t domain_id; /* Switch domain identifier. */
|
2019-03-27 13:15:35 +00:00
|
|
|
uint16_t vport_id; /* Associated VF vport index (if any). */
|
2019-09-25 07:53:30 +00:00
|
|
|
uint32_t vport_meta_tag; /* Used for vport index match ove VF LAG. */
|
|
|
|
uint32_t vport_meta_mask; /* Used for vport index field match mask. */
|
2021-06-29 06:59:53 +00:00
|
|
|
uint16_t representor_id; /* UINT16_MAX if not a representor. */
|
2021-03-28 13:48:12 +00:00
|
|
|
int32_t pf_bond; /* >=0, representor owner PF index in bonding. */
|
2019-07-21 14:56:40 +00:00
|
|
|
unsigned int if_index; /* Associated kernel network device index. */
|
2015-10-30 18:52:31 +00:00
|
|
|
/* RX/TX queues. */
|
|
|
|
unsigned int rxqs_n; /* RX queues array size. */
|
|
|
|
unsigned int txqs_n; /* TX queues array size. */
|
2017-10-09 14:44:39 +00:00
|
|
|
struct mlx5_rxq_data *(*rxqs)[]; /* RX queues. */
|
2017-10-09 14:44:40 +00:00
|
|
|
struct mlx5_txq_data *(*txqs)[]; /* TX queues. */
|
2018-05-09 11:13:50 +00:00
|
|
|
struct rte_mempool *mprq_mp; /* Mempool for Multi-Packet RQ. */
|
2017-10-09 14:44:56 +00:00
|
|
|
struct rte_eth_rss_conf rss_conf; /* RSS configuration. */
|
2015-11-02 18:11:57 +00:00
|
|
|
unsigned int (*reta_idx)[]; /* RETA index table. */
|
|
|
|
unsigned int reta_idx_n; /* RETA index size. */
|
2018-07-12 09:30:48 +00:00
|
|
|
struct mlx5_drop drop_queue; /* Flow drop queues. */
|
2020-04-16 08:34:30 +00:00
|
|
|
uint32_t flows; /* RTE Flow rules. */
|
|
|
|
uint32_t ctrl_flows; /* Control flow rules. */
|
2020-10-28 09:33:25 +00:00
|
|
|
rte_spinlock_t flow_list_lock;
|
2020-09-03 10:13:48 +00:00
|
|
|
struct mlx5_obj_ops obj_ops; /* HW objects operations. */
|
2017-10-09 14:44:49 +00:00
|
|
|
LIST_HEAD(rxq, mlx5_rxq_ctrl) rxqsctrl; /* DPDK Rx queues. */
|
2019-07-22 14:52:11 +00:00
|
|
|
LIST_HEAD(rxqobj, mlx5_rxq_obj) rxqsobj; /* Verbs/DevX Rx queues. */
|
2020-10-28 09:33:42 +00:00
|
|
|
struct mlx5_cache_list hrxqs; /* Hash Rx queues. */
|
2017-10-09 14:44:48 +00:00
|
|
|
LIST_HEAD(txq, mlx5_txq_ctrl) txqsctrl; /* DPDK Tx queues. */
|
2019-10-30 23:53:14 +00:00
|
|
|
LIST_HEAD(txqobj, mlx5_txq_obj) txqsobj; /* Verbs/DevX Tx queues. */
|
2019-07-22 14:52:12 +00:00
|
|
|
/* Indirection tables. */
|
|
|
|
LIST_HEAD(ind_tables, mlx5_ind_table_obj) ind_tbls;
|
2019-04-04 09:54:08 +00:00
|
|
|
/* Pointer to next element. */
|
2020-10-27 15:28:23 +00:00
|
|
|
uint32_t refcnt; /**< Reference counter. */
|
2019-04-04 09:54:08 +00:00
|
|
|
/**< Verbs modify header action object. */
|
|
|
|
uint8_t ft_type; /**< Flow table type, Rx or Tx. */
|
2019-07-22 14:52:24 +00:00
|
|
|
uint8_t max_lro_msg_size;
|
2019-04-04 09:54:06 +00:00
|
|
|
/* Tags resources cache. */
|
2016-10-26 09:44:01 +00:00
|
|
|
uint32_t link_speed_capa; /* Link speed capabilities. */
|
2017-01-17 14:37:08 +00:00
|
|
|
struct mlx5_xstats_ctrl xstats_ctrl; /* Extended stats control. */
|
2018-11-23 08:03:37 +00:00
|
|
|
struct mlx5_stats_ctrl stats_ctrl; /* Stats control. */
|
2018-01-10 09:16:58 +00:00
|
|
|
struct mlx5_dev_config config; /* Device configuration. */
|
2018-01-22 12:33:38 +00:00
|
|
|
/* Context for Verbs allocator. */
|
2018-07-10 16:04:52 +00:00
|
|
|
int nl_socket_rdma; /* Netlink socket (NETLINK_RDMA). */
|
|
|
|
int nl_socket_route; /* Netlink socket (NETLINK_ROUTE). */
|
2020-01-29 12:38:47 +00:00
|
|
|
struct mlx5_nl_vlan_vmwa_context *vmwa_context; /* VLAN WA context. */
|
2019-11-07 17:10:04 +00:00
|
|
|
struct mlx5_hlist *mreg_cp_tbl;
|
|
|
|
/* Hash table of Rx metadata register copy table. */
|
2019-11-08 03:49:09 +00:00
|
|
|
uint8_t mtr_sfx_reg; /* Meter prefix-suffix flow match REG_C. */
|
|
|
|
uint8_t mtr_color_reg; /* Meter color match REG_C. */
|
2021-04-20 10:55:16 +00:00
|
|
|
struct mlx5_legacy_flow_meters flow_meters; /* MTR list. */
|
2021-07-02 09:14:43 +00:00
|
|
|
struct mlx5_l3t_tbl *mtr_profile_tbl; /* Meter index lookup table. */
|
2021-07-02 09:14:44 +00:00
|
|
|
struct mlx5_l3t_tbl *policy_idx_tbl; /* Policy index lookup table. */
|
2021-04-20 10:55:17 +00:00
|
|
|
struct mlx5_l3t_tbl *mtr_idx_tbl; /* Meter index lookup table. */
|
2019-10-30 23:53:19 +00:00
|
|
|
uint8_t skip_default_rss_reta; /* Skip configuration of default reta. */
|
2020-01-28 17:06:43 +00:00
|
|
|
uint8_t fdb_def_rule; /* Whether fdb jump to table 1 is configured. */
|
2020-04-13 21:17:47 +00:00
|
|
|
struct mlx5_mp_id mp_id; /* ID of a multi-process process */
|
2020-04-16 08:34:28 +00:00
|
|
|
LIST_HEAD(fdir, mlx5_fdir_flow) fdir_flows; /* fdir flows. */
|
2020-10-28 09:33:52 +00:00
|
|
|
rte_spinlock_t shared_act_sl; /* Shared actions spinlock. */
|
2020-11-01 17:57:50 +00:00
|
|
|
uint32_t rss_shared_actions; /* RSS shared actions. */
|
2021-02-25 10:45:01 +00:00
|
|
|
struct mlx5_devx_obj *q_counters; /* DevX queue counter object. */
|
|
|
|
uint32_t counter_set_id; /* Queue counter ID to set in DevX objects. */
|
2015-10-30 18:52:30 +00:00
|
|
|
};
|
|
|
|
|
2018-05-09 11:04:50 +00:00
|
|
|
#define PORT_ID(priv) ((priv)->dev_data->port_id)
|
|
|
|
#define ETH_DEV(priv) (&rte_eth_devices[PORT_ID(priv)])
|
|
|
|
|
2020-10-26 16:37:42 +00:00
|
|
|
struct rte_hairpin_peer_info {
|
|
|
|
uint32_t qp_id;
|
|
|
|
uint32_t vhca_id;
|
|
|
|
uint16_t peer_q;
|
|
|
|
uint16_t tx_explicit;
|
|
|
|
uint16_t manual_bind;
|
|
|
|
};
|
|
|
|
|
2016-03-17 15:38:57 +00:00
|
|
|
/* mlx5.c */
|
|
|
|
|
|
|
|
int mlx5_getenv_int(const char *);
|
2019-04-10 18:41:17 +00:00
|
|
|
int mlx5_proc_priv_init(struct rte_eth_dev *dev);
|
2021-01-24 11:02:05 +00:00
|
|
|
void mlx5_proc_priv_uninit(struct rte_eth_dev *dev);
|
2019-08-22 10:15:52 +00:00
|
|
|
int mlx5_udp_tunnel_port_add(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_udp_tunnel *udp_tunnel);
|
2019-10-07 13:56:19 +00:00
|
|
|
uint16_t mlx5_eth_find_next(uint16_t port_id, struct rte_pci_device *pci_dev);
|
2020-09-28 23:14:10 +00:00
|
|
|
int mlx5_dev_close(struct rte_eth_dev *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
|
|
|
bool mlx5_is_hpf(struct rte_eth_dev *dev);
|
2020-11-01 17:57:49 +00:00
|
|
|
void mlx5_age_event_prepare(struct mlx5_dev_ctx_shared *sh);
|
2019-09-25 07:53:33 +00:00
|
|
|
|
|
|
|
/* Macro to iterate over all valid ports for mlx5 driver. */
|
2019-10-07 13:56:19 +00:00
|
|
|
#define MLX5_ETH_FOREACH_DEV(port_id, pci_dev) \
|
|
|
|
for (port_id = mlx5_eth_find_next(0, pci_dev); \
|
2019-09-25 07:53:33 +00:00
|
|
|
port_id < RTE_MAX_ETHPORTS; \
|
2019-10-07 13:56:19 +00:00
|
|
|
port_id = mlx5_eth_find_next(port_id + 1, pci_dev))
|
2020-06-03 15:06:00 +00:00
|
|
|
int mlx5_args(struct mlx5_dev_config *config, struct rte_devargs *devargs);
|
|
|
|
struct mlx5_dev_ctx_shared *
|
2020-06-10 09:32:27 +00:00
|
|
|
mlx5_alloc_shared_dev_ctx(const struct mlx5_dev_spawn_data *spawn,
|
|
|
|
const struct mlx5_dev_config *config);
|
|
|
|
void mlx5_free_shared_dev_ctx(struct mlx5_dev_ctx_shared *sh);
|
2020-06-03 15:06:00 +00:00
|
|
|
void mlx5_free_table_hash_list(struct mlx5_priv *priv);
|
|
|
|
int mlx5_alloc_table_hash_list(struct mlx5_priv *priv);
|
|
|
|
void mlx5_set_min_inline(struct mlx5_dev_spawn_data *spawn,
|
|
|
|
struct mlx5_dev_config *config);
|
|
|
|
void mlx5_set_metadata_mask(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_dev_check_sibling_config(struct mlx5_priv *priv,
|
|
|
|
struct mlx5_dev_config *config);
|
2020-06-10 09:32:30 +00:00
|
|
|
int mlx5_dev_configure(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *info);
|
|
|
|
int mlx5_fw_version_get(struct rte_eth_dev *dev, char *fw_ver, size_t fw_size);
|
|
|
|
int mlx5_dev_set_mtu(struct rte_eth_dev *dev, uint16_t mtu);
|
|
|
|
int mlx5_hairpin_cap_get(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_hairpin_cap *cap);
|
2020-07-17 07:11:46 +00:00
|
|
|
bool mlx5_flex_parser_ecpri_exist(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_flex_parser_ecpri_alloc(struct rte_eth_dev *dev);
|
2020-11-01 17:57:49 +00:00
|
|
|
int mlx5_flow_aso_age_mng_init(struct mlx5_dev_ctx_shared *sh);
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
int mlx5_aso_flow_mtrs_mng_init(struct mlx5_dev_ctx_shared *sh);
|
2021-05-05 12:23:15 +00:00
|
|
|
int mlx5_flow_aso_ct_mng_init(struct mlx5_dev_ctx_shared *sh);
|
2016-03-17 15:38:57 +00:00
|
|
|
|
2015-10-30 18:52:30 +00:00
|
|
|
/* mlx5_ethdev.c */
|
|
|
|
|
2020-06-10 09:32:29 +00:00
|
|
|
int mlx5_dev_configure(struct rte_eth_dev *dev);
|
2021-03-28 13:48:08 +00:00
|
|
|
int mlx5_representor_info_get(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_representor_info *info);
|
|
|
|
#define MLX5_REPRESENTOR_ID(pf, type, repr) \
|
|
|
|
(((pf) << 14) + ((type) << 12) + ((repr) & 0xfff))
|
|
|
|
#define MLX5_REPRESENTOR_REPR(repr_id) \
|
|
|
|
((repr_id) & 0xfff)
|
|
|
|
#define MLX5_REPRESENTOR_TYPE(repr_id) \
|
|
|
|
(((repr_id) >> 12) & 3)
|
2021-03-28 13:48:15 +00:00
|
|
|
uint16_t mlx5_representor_id_encode(const struct mlx5_switch_info *info,
|
|
|
|
enum rte_eth_representor_type hpf_type);
|
2020-06-10 09:32:29 +00:00
|
|
|
int mlx5_fw_version_get(struct rte_eth_dev *dev, char *fw_ver,
|
|
|
|
size_t fw_size);
|
|
|
|
int mlx5_dev_infos_get(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_dev_info *info);
|
|
|
|
const uint32_t *mlx5_dev_supported_ptypes_get(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_dev_set_mtu(struct rte_eth_dev *dev, uint16_t mtu);
|
|
|
|
int mlx5_hairpin_cap_get(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_hairpin_cap *cap);
|
2020-07-19 10:18:14 +00:00
|
|
|
eth_rx_burst_t mlx5_select_rx_function(struct rte_eth_dev *dev);
|
|
|
|
struct mlx5_priv *mlx5_port_to_eswitch_info(uint16_t port, bool valid);
|
|
|
|
struct mlx5_priv *mlx5_dev_to_eswitch_info(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_dev_configure_rss_reta(struct rte_eth_dev *dev);
|
2020-06-10 09:32:29 +00:00
|
|
|
|
|
|
|
/* mlx5_ethdev_os.c */
|
|
|
|
|
2020-12-28 12:32:57 +00:00
|
|
|
int mlx5_get_ifname(const struct rte_eth_dev *dev,
|
|
|
|
char (*ifname)[MLX5_NAMESIZE]);
|
2018-07-25 11:24:33 +00:00
|
|
|
unsigned int mlx5_ifindex(const struct rte_eth_dev *dev);
|
2020-07-19 10:18:13 +00:00
|
|
|
int mlx5_get_mac(struct rte_eth_dev *dev, uint8_t (*mac)[RTE_ETHER_ADDR_LEN]);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_get_mtu(struct rte_eth_dev *dev, uint16_t *mtu);
|
2020-06-10 09:32:29 +00:00
|
|
|
int mlx5_set_mtu(struct rte_eth_dev *dev, uint16_t mtu);
|
2019-05-02 12:11:34 +00:00
|
|
|
int mlx5_read_clock(struct rte_eth_dev *dev, uint64_t *clock);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_link_update(struct rte_eth_dev *dev, int wait_to_complete);
|
|
|
|
int mlx5_dev_get_flow_ctrl(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_fc_conf *fc_conf);
|
|
|
|
int mlx5_dev_set_flow_ctrl(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_fc_conf *fc_conf);
|
2018-03-05 12:21:04 +00:00
|
|
|
void mlx5_dev_interrupt_handler(void *arg);
|
2019-07-16 14:34:55 +00:00
|
|
|
void mlx5_dev_interrupt_handler_devx(void *arg);
|
2016-03-17 15:38:54 +00:00
|
|
|
int mlx5_set_link_down(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_set_link_up(struct rte_eth_dev *dev);
|
2018-01-20 21:12:21 +00:00
|
|
|
int mlx5_is_removed(struct rte_eth_dev *dev);
|
2018-07-24 08:36:45 +00:00
|
|
|
int mlx5_sysfs_switch_info(unsigned int ifindex,
|
|
|
|
struct mlx5_switch_info *info);
|
net/mlx5: support PF representor
On BlueField platform we have the new entity - PF representor.
This one represents the PCI PF attached to external host on the
side of ARM. The traffic sent by the external host to the NIC
via PF will be seem by ARM on this PF representor.
This patch refactors port recognizing capability on the base of
physical port name. We have two groups of name formats. Legacy
name formats are supported by kernels before ver 5.0 (being
more precise - before the patch [1]) or before Mellanox OFED 4.6,
and new naming formats added by the patch [1].
Legacy 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
New naming formats are supported:
- "p" followed by decimal digits, for example "p2", master
is assumed
- "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.
Note: do not specify representor=[0-65535], it causes devargs
processing error, because number of ports (rte_eth_dev) is
limited.
Applications should distinguish representors and master devices
exclusively by device flag RTE_ETH_DEV_REPRESENTOR and do not
rely on switch port_id (mlx5 PMD deduces ones from representor_id)
values returned by dev_infos_get() API.
[1] https://www.spinics.net/lists/netdev/msg547007.html
Linux-tree: c12ecc23 (Or Gerlitz 2018-04-25 17:32 +0300)
"net/mlx5e: Move to use common phys port names for vport representors"
Signed-off-by: Viacheslav Ovsiienko <viacheslavo@mellanox.com>
Acked-by: Shahaf Shuler <shahafs@mellanox.com>
2019-04-16 14:10:28 +00:00
|
|
|
void mlx5_translate_port_name(const char *port_name_in,
|
2019-03-17 06:23:03 +00:00
|
|
|
struct mlx5_switch_info *port_info_out);
|
2019-05-27 04:58:32 +00:00
|
|
|
void mlx5_intr_callback_unregister(const struct rte_intr_handle *handle,
|
|
|
|
rte_intr_callback_fn cb_fn, void *cb_arg);
|
2020-09-15 03:05:53 +00:00
|
|
|
int mlx5_sysfs_bond_info(unsigned int pf_ifindex, unsigned int *ifindex,
|
|
|
|
char *ifname);
|
2019-09-09 11:04:35 +00:00
|
|
|
int mlx5_get_module_info(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_dev_module_info *modinfo);
|
|
|
|
int mlx5_get_module_eeprom(struct rte_eth_dev *dev,
|
|
|
|
struct rte_dev_eeprom_info *info);
|
2020-07-19 10:18:13 +00:00
|
|
|
int mlx5_os_read_dev_stat(struct mlx5_priv *priv,
|
|
|
|
const char *ctr_name, uint64_t *stat);
|
|
|
|
int mlx5_os_read_dev_counters(struct rte_eth_dev *dev, uint64_t *stats);
|
|
|
|
int mlx5_os_get_stats_n(struct rte_eth_dev *dev);
|
|
|
|
void mlx5_os_stats_init(struct rte_eth_dev *dev);
|
2019-10-30 23:53:19 +00:00
|
|
|
|
2015-10-30 18:52:30 +00:00
|
|
|
/* mlx5_mac.c */
|
|
|
|
|
2018-03-05 12:20:58 +00:00
|
|
|
void mlx5_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index);
|
2019-05-21 16:13:03 +00:00
|
|
|
int mlx5_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
|
2018-03-05 12:20:58 +00:00
|
|
|
uint32_t index, uint32_t vmdq);
|
2019-05-21 16:13:03 +00:00
|
|
|
int mlx5_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr);
|
2018-04-23 11:09:28 +00:00
|
|
|
int mlx5_set_mc_addr_list(struct rte_eth_dev *dev,
|
2019-05-21 16:13:03 +00:00
|
|
|
struct rte_ether_addr *mc_addr_set,
|
|
|
|
uint32_t nb_mc_addr);
|
2015-10-30 18:52:30 +00:00
|
|
|
|
2015-10-30 18:55:11 +00:00
|
|
|
/* mlx5_rss.c */
|
|
|
|
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_rss_hash_update(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_rss_conf *rss_conf);
|
|
|
|
int mlx5_rss_hash_conf_get(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_rss_conf *rss_conf);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_rss_reta_index_resize(struct rte_eth_dev *dev, unsigned int reta_size);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_dev_rss_reta_query(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_rss_reta_entry64 *reta_conf,
|
|
|
|
uint16_t reta_size);
|
|
|
|
int mlx5_dev_rss_reta_update(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_rss_reta_entry64 *reta_conf,
|
|
|
|
uint16_t reta_size);
|
2015-10-30 18:55:11 +00:00
|
|
|
|
2015-10-30 18:52:37 +00:00
|
|
|
/* mlx5_rxmode.c */
|
|
|
|
|
2019-09-14 11:37:24 +00:00
|
|
|
int mlx5_promiscuous_enable(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_promiscuous_disable(struct rte_eth_dev *dev);
|
2019-09-24 12:56:10 +00:00
|
|
|
int mlx5_allmulticast_enable(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_allmulticast_disable(struct rte_eth_dev *dev);
|
2015-10-30 18:52:37 +00:00
|
|
|
|
2015-10-30 18:52:36 +00:00
|
|
|
/* mlx5_stats.c */
|
|
|
|
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats);
|
2019-09-06 14:34:54 +00:00
|
|
|
int mlx5_stats_reset(struct rte_eth_dev *dev);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *stats,
|
|
|
|
unsigned int n);
|
2019-09-06 14:34:54 +00:00
|
|
|
int mlx5_xstats_reset(struct rte_eth_dev *dev);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_xstats_get_names(struct rte_eth_dev *dev __rte_unused,
|
2018-03-05 12:20:58 +00:00
|
|
|
struct rte_eth_xstat_name *xstats_names,
|
|
|
|
unsigned int n);
|
2015-10-30 18:52:36 +00:00
|
|
|
|
2015-10-30 18:52:40 +00:00
|
|
|
/* mlx5_vlan.c */
|
|
|
|
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on);
|
|
|
|
void mlx5_vlan_strip_queue_set(struct rte_eth_dev *dev, uint16_t queue, int on);
|
|
|
|
int mlx5_vlan_offload_set(struct rte_eth_dev *dev, int mask);
|
2020-08-25 09:31:16 +00:00
|
|
|
|
|
|
|
/* mlx5_vlan_os.c */
|
|
|
|
|
|
|
|
void mlx5_vlan_vmwa_exit(void *ctx);
|
2020-01-29 12:38:47 +00:00
|
|
|
void mlx5_vlan_vmwa_release(struct rte_eth_dev *dev,
|
|
|
|
struct mlx5_vf_vlan *vf_vlan);
|
|
|
|
void mlx5_vlan_vmwa_acquire(struct rte_eth_dev *dev,
|
|
|
|
struct mlx5_vf_vlan *vf_vlan);
|
2020-08-25 09:31:16 +00:00
|
|
|
void *mlx5_vlan_vmwa_init(struct rte_eth_dev *dev, uint32_t ifindex);
|
2015-10-30 18:52:40 +00:00
|
|
|
|
2015-10-30 18:52:33 +00:00
|
|
|
/* mlx5_trigger.c */
|
|
|
|
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_dev_start(struct rte_eth_dev *dev);
|
2020-10-15 13:30:45 +00:00
|
|
|
int mlx5_dev_stop(struct rte_eth_dev *dev);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_traffic_enable(struct rte_eth_dev *dev);
|
2018-03-05 12:21:05 +00:00
|
|
|
void mlx5_traffic_disable(struct rte_eth_dev *dev);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_traffic_restart(struct rte_eth_dev *dev);
|
2020-10-26 16:37:42 +00:00
|
|
|
int mlx5_hairpin_queue_peer_update(struct rte_eth_dev *dev, uint16_t peer_queue,
|
|
|
|
struct rte_hairpin_peer_info *current_info,
|
|
|
|
struct rte_hairpin_peer_info *peer_info,
|
|
|
|
uint32_t direction);
|
|
|
|
int mlx5_hairpin_queue_peer_bind(struct rte_eth_dev *dev, uint16_t cur_queue,
|
|
|
|
struct rte_hairpin_peer_info *peer_info,
|
|
|
|
uint32_t direction);
|
|
|
|
int mlx5_hairpin_queue_peer_unbind(struct rte_eth_dev *dev, uint16_t cur_queue,
|
|
|
|
uint32_t direction);
|
|
|
|
int mlx5_hairpin_bind(struct rte_eth_dev *dev, uint16_t rx_port);
|
|
|
|
int mlx5_hairpin_unbind(struct rte_eth_dev *dev, uint16_t rx_port);
|
2020-10-26 16:37:43 +00:00
|
|
|
int mlx5_hairpin_get_peer_ports(struct rte_eth_dev *dev, uint16_t *peer_ports,
|
|
|
|
size_t len, uint32_t direction);
|
2015-10-30 18:52:33 +00:00
|
|
|
|
2017-10-09 14:44:38 +00:00
|
|
|
/* mlx5_flow.c */
|
2016-03-03 14:26:43 +00:00
|
|
|
|
2019-11-07 17:09:53 +00:00
|
|
|
int mlx5_flow_discover_mreg_c(struct rte_eth_dev *eth_dev);
|
|
|
|
bool mlx5_flow_ext_mreg_supported(struct rte_eth_dev *dev);
|
2018-07-12 09:30:48 +00:00
|
|
|
void mlx5_flow_print(struct rte_flow *flow);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_flow_validate(struct rte_eth_dev *dev,
|
|
|
|
const struct rte_flow_attr *attr,
|
|
|
|
const struct rte_flow_item items[],
|
|
|
|
const struct rte_flow_action actions[],
|
|
|
|
struct rte_flow_error *error);
|
|
|
|
struct rte_flow *mlx5_flow_create(struct rte_eth_dev *dev,
|
|
|
|
const struct rte_flow_attr *attr,
|
|
|
|
const struct rte_flow_item items[],
|
|
|
|
const struct rte_flow_action actions[],
|
|
|
|
struct rte_flow_error *error);
|
|
|
|
int mlx5_flow_destroy(struct rte_eth_dev *dev, struct rte_flow *flow,
|
|
|
|
struct rte_flow_error *error);
|
2020-04-16 08:34:30 +00:00
|
|
|
void mlx5_flow_list_flush(struct rte_eth_dev *dev, uint32_t *list, bool active);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error);
|
|
|
|
int mlx5_flow_query(struct rte_eth_dev *dev, struct rte_flow *flow,
|
2018-04-26 17:29:19 +00:00
|
|
|
const struct rte_flow_action *action, void *data,
|
2018-03-05 12:20:58 +00:00
|
|
|
struct rte_flow_error *error);
|
|
|
|
int mlx5_flow_isolate(struct rte_eth_dev *dev, int enable,
|
|
|
|
struct rte_flow_error *error);
|
2021-03-21 09:00:00 +00:00
|
|
|
int mlx5_flow_ops_get(struct rte_eth_dev *dev, const struct rte_flow_ops **ops);
|
2020-03-24 15:33:57 +00:00
|
|
|
int mlx5_flow_start_default(struct rte_eth_dev *dev);
|
|
|
|
void mlx5_flow_stop_default(struct rte_eth_dev *dev);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_flow_verify(struct rte_eth_dev *dev);
|
2019-10-30 23:53:22 +00:00
|
|
|
int mlx5_ctrl_flow_source_queue(struct rte_eth_dev *dev, uint32_t queue);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_ctrl_flow_vlan(struct rte_eth_dev *dev,
|
|
|
|
struct rte_flow_item_eth *eth_spec,
|
|
|
|
struct rte_flow_item_eth *eth_mask,
|
|
|
|
struct rte_flow_item_vlan *vlan_spec,
|
|
|
|
struct rte_flow_item_vlan *vlan_mask);
|
|
|
|
int mlx5_ctrl_flow(struct rte_eth_dev *dev,
|
|
|
|
struct rte_flow_item_eth *eth_spec,
|
|
|
|
struct rte_flow_item_eth *eth_mask);
|
2020-06-23 08:41:06 +00:00
|
|
|
int mlx5_flow_lacp_miss(struct rte_eth_dev *dev);
|
2019-09-11 11:03:36 +00:00
|
|
|
struct rte_flow *mlx5_flow_create_esw_table_zero_flow(struct rte_eth_dev *dev);
|
2020-06-03 15:05:55 +00:00
|
|
|
void mlx5_flow_async_pool_query_handle(struct mlx5_dev_ctx_shared *sh,
|
2019-07-16 14:34:55 +00:00
|
|
|
uint64_t async_id, int status);
|
2020-06-03 15:05:55 +00:00
|
|
|
void mlx5_set_query_alarm(struct mlx5_dev_ctx_shared *sh);
|
2019-07-16 14:34:55 +00:00
|
|
|
void mlx5_flow_query_alarm(void *arg);
|
2020-04-07 03:59:45 +00:00
|
|
|
uint32_t mlx5_counter_alloc(struct rte_eth_dev *dev);
|
|
|
|
void mlx5_counter_free(struct rte_eth_dev *dev, uint32_t cnt);
|
|
|
|
int mlx5_counter_query(struct rte_eth_dev *dev, uint32_t cnt,
|
2019-11-08 03:49:18 +00:00
|
|
|
bool clear, uint64_t *pkts, uint64_t *bytes);
|
2021-04-14 10:19:59 +00:00
|
|
|
int mlx5_flow_dev_dump(struct rte_eth_dev *dev, struct rte_flow *flow,
|
|
|
|
FILE *file, struct rte_flow_error *error);
|
2020-04-17 17:14:53 +00:00
|
|
|
void mlx5_flow_rxq_dynf_metadata_set(struct rte_eth_dev *dev);
|
2020-04-29 02:25:09 +00:00
|
|
|
int mlx5_flow_get_aged_flows(struct rte_eth_dev *dev, void **contexts,
|
|
|
|
uint32_t nb_contexts, struct rte_flow_error *error);
|
2021-05-05 12:23:25 +00:00
|
|
|
int mlx5_validate_action_ct(struct rte_eth_dev *dev,
|
|
|
|
const struct rte_flow_action_conntrack *conntrack,
|
|
|
|
struct rte_flow_error *error);
|
|
|
|
|
2016-12-29 15:15:17 +00:00
|
|
|
|
2020-07-19 10:18:15 +00:00
|
|
|
/* mlx5_mp_os.c */
|
2020-07-19 15:35:37 +00:00
|
|
|
|
2020-07-19 10:18:15 +00:00
|
|
|
int mlx5_mp_os_primary_handle(const struct rte_mp_msg *mp_msg,
|
|
|
|
const void *peer);
|
|
|
|
int mlx5_mp_os_secondary_handle(const struct rte_mp_msg *mp_msg,
|
|
|
|
const void *peer);
|
|
|
|
void mlx5_mp_os_req_start_rxtx(struct rte_eth_dev *dev);
|
|
|
|
void mlx5_mp_os_req_stop_rxtx(struct rte_eth_dev *dev);
|
2020-07-19 15:35:37 +00:00
|
|
|
int mlx5_mp_os_req_queue_control(struct rte_eth_dev *dev, uint16_t queue_id,
|
|
|
|
enum mlx5_mp_req_type req_type);
|
2017-10-06 15:45:49 +00:00
|
|
|
|
2020-01-17 11:56:02 +00:00
|
|
|
/* mlx5_socket.c */
|
|
|
|
|
|
|
|
int mlx5_pmd_socket_init(void);
|
|
|
|
|
2019-11-08 03:49:07 +00:00
|
|
|
/* mlx5_flow_meter.c */
|
|
|
|
|
|
|
|
int mlx5_flow_meter_ops_get(struct rte_eth_dev *dev, void *arg);
|
2021-04-20 10:55:16 +00:00
|
|
|
struct mlx5_flow_meter_info *mlx5_flow_meter_find(struct mlx5_priv *priv,
|
|
|
|
uint32_t meter_id, uint32_t *mtr_idx);
|
|
|
|
struct mlx5_flow_meter_info *
|
|
|
|
flow_dv_meter_find_by_idx(struct mlx5_priv *priv, uint32_t idx);
|
2021-04-20 10:55:10 +00:00
|
|
|
int mlx5_flow_meter_attach(struct mlx5_priv *priv,
|
2021-04-20 10:55:16 +00:00
|
|
|
struct mlx5_flow_meter_info *fm,
|
2021-04-20 10:55:10 +00:00
|
|
|
const struct rte_flow_attr *attr,
|
|
|
|
struct rte_flow_error *error);
|
2021-04-20 10:55:19 +00:00
|
|
|
void mlx5_flow_meter_detach(struct mlx5_priv *priv,
|
|
|
|
struct mlx5_flow_meter_info *fm);
|
net/mlx5: support meter policy operations
MLX5 PMD checks the validation of actions in policy while add
a new meter policy, if pass the validation, allocates the new
policy object from the meter policy indexed memory pool.
It is common to use the same policy for multiple meters.
MLX5 PMD supports two types of policy: termination policy and
no-termination policy.
Implement the next policy operations:
validate:
The driver doesn't support to configure actions in the flow
after the meter action except one case when the meter policy
is configured to do nothing in GREEN\YELLOW and only DROP action
in RED, this special policy is called non-terminated policy
and is handed as a singleton object internally.
For all the terminated policies, the next actions are supported:
GREEN - QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
YELLOW - not supported at all -> must be empty.
RED - must include DROP action.
Hence, in ingress case, for example,
QUEUE\RSS\JUMP must be configured as last action for GREEN color.
All the above limitations will be validated.
create:
Validate the policy configuration.
Prepare the related tables and actions.
destroy:
Release the created policy resources.
Signed-off-by: Li Zhang <lizh@nvidia.com>
Acked-by: Matan Azrad <matan@nvidia.com>
2021-04-27 10:43:51 +00:00
|
|
|
struct mlx5_flow_meter_policy *mlx5_flow_meter_policy_find
|
|
|
|
(struct rte_eth_dev *dev,
|
|
|
|
uint32_t policy_id,
|
|
|
|
uint32_t *policy_idx);
|
|
|
|
int mlx5_flow_meter_flush(struct rte_eth_dev *dev,
|
|
|
|
struct rte_mtr_error *error);
|
2021-05-13 08:35:44 +00:00
|
|
|
void mlx5_flow_meter_rxq_flush(struct rte_eth_dev *dev);
|
2019-11-08 03:49:07 +00:00
|
|
|
|
2020-06-03 15:05:56 +00:00
|
|
|
/* mlx5_os.c */
|
2020-06-03 15:06:00 +00:00
|
|
|
struct rte_pci_driver;
|
2020-06-03 15:05:58 +00:00
|
|
|
int mlx5_os_get_dev_attr(void *ctx, struct mlx5_dev_attr *dev_attr);
|
2020-06-03 15:06:00 +00:00
|
|
|
void mlx5_os_free_shared_dr(struct mlx5_priv *priv);
|
|
|
|
int mlx5_os_open_device(const struct mlx5_dev_spawn_data *spawn,
|
|
|
|
const struct mlx5_dev_config *config,
|
|
|
|
struct mlx5_dev_ctx_shared *sh);
|
|
|
|
int mlx5_os_get_pdn(void *pd, uint32_t *pdn);
|
|
|
|
int mlx5_os_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
|
|
|
|
struct rte_pci_device *pci_dev);
|
|
|
|
void mlx5_os_dev_shared_handler_install(struct mlx5_dev_ctx_shared *sh);
|
|
|
|
void mlx5_os_dev_shared_handler_uninstall(struct mlx5_dev_ctx_shared *sh);
|
2020-06-16 09:44:45 +00:00
|
|
|
void mlx5_os_set_reg_mr_cb(mlx5_reg_mr_t *reg_mr_cb,
|
|
|
|
mlx5_dereg_mr_t *dereg_mr_cb);
|
2020-07-19 10:18:11 +00:00
|
|
|
void mlx5_os_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index);
|
|
|
|
int mlx5_os_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac,
|
|
|
|
uint32_t index);
|
|
|
|
int mlx5_os_vf_mac_addr_modify(struct mlx5_priv *priv, unsigned int iface_idx,
|
|
|
|
struct rte_ether_addr *mac_addr,
|
|
|
|
int vf_index);
|
2020-07-19 10:18:12 +00:00
|
|
|
int mlx5_os_set_promisc(struct rte_eth_dev *dev, int enable);
|
|
|
|
int mlx5_os_set_allmulti(struct rte_eth_dev *dev, int enable);
|
2020-07-19 11:13:06 +00:00
|
|
|
int mlx5_os_set_nonblock_channel_fd(int fd);
|
2020-08-25 09:31:09 +00:00
|
|
|
void mlx5_os_mac_addr_flush(struct rte_eth_dev *dev);
|
2020-07-17 07:11:49 +00:00
|
|
|
|
2020-07-16 08:23:08 +00:00
|
|
|
/* mlx5_txpp.c */
|
|
|
|
|
|
|
|
int mlx5_txpp_start(struct rte_eth_dev *dev);
|
|
|
|
void mlx5_txpp_stop(struct rte_eth_dev *dev);
|
2020-07-16 08:23:17 +00:00
|
|
|
int mlx5_txpp_read_clock(struct rte_eth_dev *dev, uint64_t *timestamp);
|
2020-07-16 08:23:18 +00:00
|
|
|
int mlx5_txpp_xstats_get(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_xstat *stats,
|
|
|
|
unsigned int n, unsigned int n_used);
|
|
|
|
int mlx5_txpp_xstats_reset(struct rte_eth_dev *dev);
|
|
|
|
int mlx5_txpp_xstats_get_names(struct rte_eth_dev *dev,
|
|
|
|
struct rte_eth_xstat_name *xstats_names,
|
|
|
|
unsigned int n, unsigned int n_used);
|
2020-07-16 08:23:12 +00:00
|
|
|
void mlx5_txpp_interrupt_handler(void *cb_arg);
|
2020-07-16 08:23:08 +00:00
|
|
|
|
2020-07-19 10:18:14 +00:00
|
|
|
/* mlx5_rxtx.c */
|
|
|
|
|
|
|
|
eth_tx_burst_t mlx5_select_tx_function(struct rte_eth_dev *dev);
|
|
|
|
|
2021-04-20 10:55:16 +00:00
|
|
|
/* mlx5_flow_aso.c */
|
2020-11-01 17:57:49 +00:00
|
|
|
|
2021-04-20 10:55:17 +00:00
|
|
|
int mlx5_aso_queue_init(struct mlx5_dev_ctx_shared *sh,
|
|
|
|
enum mlx5_access_aso_opc_mod aso_opc_mod);
|
|
|
|
int mlx5_aso_flow_hit_queue_poll_start(struct mlx5_dev_ctx_shared *sh);
|
|
|
|
int mlx5_aso_flow_hit_queue_poll_stop(struct mlx5_dev_ctx_shared *sh);
|
|
|
|
void mlx5_aso_queue_uninit(struct mlx5_dev_ctx_shared *sh,
|
|
|
|
enum mlx5_access_aso_opc_mod aso_opc_mod);
|
2021-04-20 10:55:18 +00:00
|
|
|
int mlx5_aso_meter_update_by_wqe(struct mlx5_dev_ctx_shared *sh,
|
|
|
|
struct mlx5_aso_mtr *mtr);
|
|
|
|
int mlx5_aso_mtr_wait(struct mlx5_dev_ctx_shared *sh,
|
|
|
|
struct mlx5_aso_mtr *mtr);
|
2021-05-05 12:23:17 +00:00
|
|
|
int mlx5_aso_ct_update_by_wqe(struct mlx5_dev_ctx_shared *sh,
|
|
|
|
struct mlx5_aso_ct_action *ct,
|
|
|
|
const struct rte_flow_action_conntrack *profile);
|
2021-05-05 12:23:20 +00:00
|
|
|
int mlx5_aso_ct_wait_ready(struct mlx5_dev_ctx_shared *sh,
|
|
|
|
struct mlx5_aso_ct_action *ct);
|
|
|
|
int mlx5_aso_ct_query_by_wqe(struct mlx5_dev_ctx_shared *sh,
|
|
|
|
struct mlx5_aso_ct_action *ct,
|
|
|
|
struct rte_flow_action_conntrack *profile);
|
2021-05-05 12:23:22 +00:00
|
|
|
int mlx5_aso_ct_available(struct mlx5_dev_ctx_shared *sh,
|
|
|
|
struct mlx5_aso_ct_action *ct);
|
2020-11-01 17:57:49 +00:00
|
|
|
|
2015-10-30 18:52:30 +00:00
|
|
|
#endif /* RTE_PMD_MLX5_H_ */
|