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>
|
|
|
|
|
#include <stdint.h>
|
|
|
|
|
#include <limits.h>
|
|
|
|
|
#include <net/if.h>
|
|
|
|
|
#include <netinet/in.h>
|
2017-10-09 14:44:53 +00:00
|
|
|
#include <sys/queue.h>
|
2015-10-30 18:52:30 +00:00
|
|
|
|
|
|
|
|
/* Verbs header. */
|
|
|
|
|
/* ISO C doesn't support unnamed structs/unions, disabling -pedantic. */
|
|
|
|
|
#ifdef PEDANTIC
|
2016-09-19 14:36:54 +00:00
|
|
|
#pragma GCC diagnostic ignored "-Wpedantic"
|
2015-10-30 18:52:30 +00:00
|
|
|
#endif
|
|
|
|
|
#include <infiniband/verbs.h>
|
|
|
|
|
#ifdef PEDANTIC
|
2016-09-19 14:36:54 +00:00
|
|
|
#pragma GCC diagnostic error "-Wpedantic"
|
2015-10-30 18:52:30 +00:00
|
|
|
#endif
|
|
|
|
|
|
2017-07-07 00:04:20 +00:00
|
|
|
#include <rte_pci.h>
|
2015-10-30 18:52:30 +00:00
|
|
|
#include <rte_ether.h>
|
2018-01-22 00:16:22 +00:00
|
|
|
#include <rte_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>
|
2015-10-30 18:52:30 +00:00
|
|
|
|
|
|
|
|
#include "mlx5_utils.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 "mlx5_mr.h"
|
2015-10-30 18:52:31 +00:00
|
|
|
#include "mlx5_rxtx.h"
|
2015-10-30 18:52:30 +00:00
|
|
|
#include "mlx5_autoconf.h"
|
|
|
|
|
#include "mlx5_defs.h"
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
PCI_VENDOR_ID_MELLANOX = 0x15b3,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX4 = 0x1013,
|
|
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX4VF = 0x1014,
|
|
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX4LX = 0x1015,
|
|
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX4LXVF = 0x1016,
|
2017-01-06 00:49:31 +00:00
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX5 = 0x1017,
|
|
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX5VF = 0x1018,
|
|
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX5EX = 0x1019,
|
|
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX5EXVF = 0x101a,
|
2018-05-15 06:12:50 +00:00
|
|
|
PCI_DEVICE_ID_MELLANOX_CONNECTX5BF = 0xa2d2,
|
2015-10-30 18:52:30 +00:00
|
|
|
};
|
|
|
|
|
|
2018-07-10 16:04:52 +00:00
|
|
|
/** Switch information returned by mlx5_nl_switch_info(). */
|
|
|
|
|
struct mlx5_switch_info {
|
|
|
|
|
uint32_t master:1; /**< Master device. */
|
|
|
|
|
uint32_t representor:1; /**< Representor device. */
|
|
|
|
|
int32_t port_name; /**< Representor port name. */
|
|
|
|
|
uint64_t switch_id; /**< Switch identifier. */
|
|
|
|
|
};
|
|
|
|
|
|
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
|
|
|
LIST_HEAD(mlx5_dev_list, priv);
|
|
|
|
|
|
|
|
|
|
/* Shared memory between primary and secondary processes. */
|
|
|
|
|
struct mlx5_shared_data {
|
|
|
|
|
struct mlx5_dev_list mem_event_cb_list;
|
|
|
|
|
rte_rwlock_t mem_event_rwlock;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern struct mlx5_shared_data *mlx5_shared_data;
|
|
|
|
|
|
2017-01-17 14:37:08 +00:00
|
|
|
struct mlx5_xstats_ctrl {
|
|
|
|
|
/* Number of device stats. */
|
|
|
|
|
uint16_t stats_n;
|
|
|
|
|
/* Index in the device counters table. */
|
|
|
|
|
uint16_t dev_table_idx[MLX5_MAX_XSTATS];
|
|
|
|
|
uint64_t base[MLX5_MAX_XSTATS];
|
|
|
|
|
};
|
|
|
|
|
|
2017-10-09 14:44:53 +00:00
|
|
|
/* Flow list . */
|
|
|
|
|
TAILQ_HEAD(mlx5_flows, rte_flow);
|
|
|
|
|
|
2018-01-10 09:16:58 +00:00
|
|
|
/* Default PMD specific parameter value. */
|
|
|
|
|
#define MLX5_ARG_UNSET (-1)
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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. */
|
|
|
|
|
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-01-10 09:16:58 +00:00
|
|
|
unsigned int mps:2; /* Multi-packet send supported mode. */
|
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:59 +00:00
|
|
|
unsigned int flow_counter_en:1; /* Whether flow counter is supported. */
|
2018-01-10 09:16:58 +00:00
|
|
|
unsigned int cqe_comp:1; /* CQE compression is enabled. */
|
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 tx_vec_en:1; /* Tx vector is enabled. */
|
|
|
|
|
unsigned int rx_vec_en:1; /* Rx vector is enabled. */
|
|
|
|
|
unsigned int mpw_hdr_dseg:1; /* Enable DSEGs in the title WQEBB. */
|
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. */
|
2018-04-08 12:41:20 +00:00
|
|
|
unsigned int swp:1; /* Tx generic tunnel checksum and TSO offload. */
|
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. */
|
|
|
|
|
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-07-12 09:30:49 +00:00
|
|
|
unsigned int flow_prio; /* Number of flow priorities. */
|
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. */
|
|
|
|
|
int txq_inline; /* Maximum packet size for inlining. */
|
|
|
|
|
int txqs_inline; /* Queue number threshold for inlining. */
|
|
|
|
|
int inline_max_packet_sz; /* Max packet size for inlining. */
|
|
|
|
|
};
|
|
|
|
|
|
2018-01-22 12:33:38 +00:00
|
|
|
/**
|
|
|
|
|
* Type of objet being allocated.
|
|
|
|
|
*/
|
|
|
|
|
enum mlx5_verbs_alloc_type {
|
|
|
|
|
MLX5_VERBS_ALLOC_TYPE_NONE,
|
|
|
|
|
MLX5_VERBS_ALLOC_TYPE_TX_QUEUE,
|
|
|
|
|
MLX5_VERBS_ALLOC_TYPE_RX_QUEUE,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Verbs allocator needs a context to know in the callback which kind of
|
|
|
|
|
* resources it is allocating.
|
|
|
|
|
*/
|
|
|
|
|
struct mlx5_verbs_alloc_ctx {
|
|
|
|
|
enum mlx5_verbs_alloc_type type; /* Kind of object being allocated. */
|
|
|
|
|
const void *obj; /* Pointer to the DPDK object. */
|
|
|
|
|
};
|
|
|
|
|
|
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
|
|
|
LIST_HEAD(mlx5_mr_list, mlx5_mr);
|
|
|
|
|
|
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. */
|
|
|
|
|
struct mlx5_rxq_ibv *rxq; /* Verbs Rx queue. */
|
|
|
|
|
};
|
|
|
|
|
|
2018-07-13 09:40:39 +00:00
|
|
|
/** DPDK port to network interface index (ifindex) conversion. */
|
|
|
|
|
struct mlx5_nl_flow_ptoi {
|
|
|
|
|
uint16_t port_id; /**< DPDK port ID. */
|
|
|
|
|
unsigned int ifindex; /**< Network interface index. */
|
|
|
|
|
};
|
|
|
|
|
|
2018-07-13 09:40:37 +00:00
|
|
|
struct mnl_socket;
|
|
|
|
|
|
2015-10-30 18:52:30 +00:00
|
|
|
struct priv {
|
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
|
|
|
LIST_ENTRY(priv) mem_event_cb; /* Called by memory event callback. */
|
2018-05-09 11:04:50 +00:00
|
|
|
struct rte_eth_dev_data *dev_data; /* Pointer to device data. */
|
2015-10-30 18:52:30 +00:00
|
|
|
struct ibv_context *ctx; /* Verbs context. */
|
2017-09-26 15:38:24 +00:00
|
|
|
struct ibv_device_attr_ex device_attr; /* Device properties. */
|
2015-10-30 18:52:30 +00:00
|
|
|
struct ibv_pd *pd; /* Protection Domain. */
|
2018-07-10 16:04:54 +00:00
|
|
|
char ibdev_name[IBV_SYSFS_NAME_MAX]; /* IB device name. */
|
2017-10-06 15:45:51 +00:00
|
|
|
char ibdev_path[IBV_SYSFS_PATH_MAX]; /* IB device path for secondary */
|
2017-10-09 14:44:55 +00:00
|
|
|
struct 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. */
|
|
|
|
|
uint16_t domain_id; /* Switch domain identifier. */
|
|
|
|
|
int32_t representor_id; /* Port representor identifier. */
|
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-10-30 18:57:23 +00:00
|
|
|
struct rte_intr_handle intr_handle; /* Interrupt handler. */
|
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. */
|
2017-10-09 14:44:53 +00:00
|
|
|
struct mlx5_flows flows; /* RTE Flow rules. */
|
|
|
|
|
struct mlx5_flows ctrl_flows; /* Control flow rules. */
|
2018-07-12 09:31:07 +00:00
|
|
|
LIST_HEAD(counters, mlx5_flow_counter) flow_counters;
|
|
|
|
|
/* Flow counters. */
|
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 {
|
|
|
|
|
uint32_t dev_gen; /* Generation number to flush local caches. */
|
|
|
|
|
rte_rwlock_t rwlock; /* MR Lock. */
|
|
|
|
|
struct mlx5_mr_btree cache; /* Global MR cache table. */
|
|
|
|
|
struct mlx5_mr_list mr_list; /* Registered MR list. */
|
|
|
|
|
struct mlx5_mr_list mr_free_list; /* Freed MR list. */
|
|
|
|
|
} mr;
|
2017-10-09 14:44:49 +00:00
|
|
|
LIST_HEAD(rxq, mlx5_rxq_ctrl) rxqsctrl; /* DPDK Rx queues. */
|
2017-10-09 14:44:46 +00:00
|
|
|
LIST_HEAD(rxqibv, mlx5_rxq_ibv) rxqsibv; /* Verbs Rx queues. */
|
2017-10-09 14:44:51 +00:00
|
|
|
LIST_HEAD(hrxq, mlx5_hrxq) hrxqs; /* Verbs Hash Rx queues. */
|
2017-10-09 14:44:48 +00:00
|
|
|
LIST_HEAD(txq, mlx5_txq_ctrl) txqsctrl; /* DPDK Tx queues. */
|
2017-10-09 14:44:47 +00:00
|
|
|
LIST_HEAD(txqibv, mlx5_txq_ibv) txqsibv; /* Verbs Tx queues. */
|
2017-10-09 14:44:50 +00:00
|
|
|
/* Verbs Indirection tables. */
|
|
|
|
|
LIST_HEAD(ind_tables, mlx5_ind_table_ibv) ind_tbls;
|
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. */
|
2017-10-06 15:45:49 +00:00
|
|
|
int primary_socket; /* Unix socket for primary process. */
|
2018-01-25 15:00:24 +00:00
|
|
|
void *uar_base; /* Reserved address space for UAR mapping */
|
2017-10-06 15:45:49 +00:00
|
|
|
struct rte_intr_handle intr_handle_socket; /* Interrupt handler. */
|
2018-01-10 09:16:58 +00:00
|
|
|
struct mlx5_dev_config config; /* Device configuration. */
|
2018-01-22 12:33:38 +00:00
|
|
|
struct mlx5_verbs_alloc_ctx verbs_alloc_ctx;
|
|
|
|
|
/* 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). */
|
2018-04-05 15:07:19 +00:00
|
|
|
uint32_t nl_sn; /* Netlink message sequence number. */
|
2018-07-12 12:01:31 +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
|
2018-07-13 09:40:37 +00:00
|
|
|
struct mnl_socket *mnl_socket; /* Libmnl socket. */
|
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)])
|
|
|
|
|
|
2016-03-17 15:38:57 +00:00
|
|
|
/* mlx5.c */
|
|
|
|
|
|
|
|
|
|
int mlx5_getenv_int(const char *);
|
|
|
|
|
|
2015-10-30 18:52:30 +00:00
|
|
|
/* mlx5_ethdev.c */
|
|
|
|
|
|
2018-07-10 16:04:54 +00:00
|
|
|
int mlx5_get_master_ifname(const struct rte_eth_dev *dev,
|
|
|
|
|
char (*ifname)[IF_NAMESIZE]);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_get_ifname(const struct rte_eth_dev *dev, char (*ifname)[IF_NAMESIZE]);
|
2018-04-05 15:07:19 +00:00
|
|
|
int mlx5_ifindex(const struct rte_eth_dev *dev);
|
2018-07-10 16:04:54 +00:00
|
|
|
int mlx5_ifreq(const struct rte_eth_dev *dev, int req, struct ifreq *ifr,
|
|
|
|
|
int master);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_get_mtu(struct rte_eth_dev *dev, uint16_t *mtu);
|
|
|
|
|
int mlx5_set_flags(struct rte_eth_dev *dev, unsigned int keep,
|
|
|
|
|
unsigned int flags);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_dev_configure(struct rte_eth_dev *dev);
|
|
|
|
|
void mlx5_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *info);
|
2016-03-14 20:50:50 +00:00
|
|
|
const uint32_t *mlx5_dev_supported_ptypes_get(struct rte_eth_dev *dev);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_link_update(struct rte_eth_dev *dev, int wait_to_complete);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_force_link_status_change(struct rte_eth_dev *dev, int status);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_dev_set_mtu(struct rte_eth_dev *dev, uint16_t mtu);
|
|
|
|
|
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);
|
|
|
|
|
int mlx5_ibv_device_to_pci_addr(const struct ibv_device *device,
|
|
|
|
|
struct rte_pci_addr *pci_addr);
|
|
|
|
|
void mlx5_dev_link_status_handler(void *arg);
|
2018-03-05 12:21:04 +00:00
|
|
|
void mlx5_dev_interrupt_handler(void *arg);
|
|
|
|
|
void mlx5_dev_interrupt_handler_uninstall(struct rte_eth_dev *dev);
|
|
|
|
|
void mlx5_dev_interrupt_handler_install(struct rte_eth_dev *dev);
|
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-03-05 12:21:04 +00:00
|
|
|
eth_tx_burst_t mlx5_select_tx_function(struct rte_eth_dev *dev);
|
|
|
|
|
eth_rx_burst_t mlx5_select_rx_function(struct rte_eth_dev *dev);
|
2018-07-10 16:04:54 +00:00
|
|
|
unsigned int mlx5_dev_to_port_id(const struct rte_device *dev,
|
|
|
|
|
uint16_t *port_list,
|
|
|
|
|
unsigned int port_list_n);
|
2018-07-24 08:36:45 +00:00
|
|
|
int mlx5_sysfs_switch_info(unsigned int ifindex,
|
|
|
|
|
struct mlx5_switch_info *info);
|
2015-10-30 18:52:30 +00:00
|
|
|
|
|
|
|
|
/* mlx5_mac.c */
|
|
|
|
|
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_get_mac(struct rte_eth_dev *dev, uint8_t (*mac)[ETHER_ADDR_LEN]);
|
2018-03-05 12:20:58 +00:00
|
|
|
void mlx5_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index);
|
|
|
|
|
int mlx5_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
|
|
|
|
|
uint32_t index, uint32_t vmdq);
|
2018-04-11 16:32:51 +00:00
|
|
|
int mlx5_mac_addr_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr);
|
2018-04-23 11:09:28 +00:00
|
|
|
int mlx5_set_mc_addr_list(struct rte_eth_dev *dev,
|
|
|
|
|
struct 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 */
|
|
|
|
|
|
2018-03-05 12:20:58 +00:00
|
|
|
void mlx5_promiscuous_enable(struct rte_eth_dev *dev);
|
|
|
|
|
void mlx5_promiscuous_disable(struct rte_eth_dev *dev);
|
|
|
|
|
void mlx5_allmulticast_enable(struct rte_eth_dev *dev);
|
|
|
|
|
void 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:21:04 +00:00
|
|
|
void mlx5_xstats_init(struct rte_eth_dev *dev);
|
2018-03-05 12:20:58 +00:00
|
|
|
int mlx5_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats);
|
|
|
|
|
void 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);
|
2018-03-05 12:20:58 +00:00
|
|
|
void 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);
|
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);
|
|
|
|
|
void 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);
|
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
|
|
|
|
2018-07-12 09:30:49 +00:00
|
|
|
int mlx5_flow_discover_priorities(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);
|
2018-03-05 12:21:04 +00:00
|
|
|
void mlx5_flow_list_flush(struct rte_eth_dev *dev, struct mlx5_flows *list);
|
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);
|
|
|
|
|
int mlx5_dev_filter_ctrl(struct rte_eth_dev *dev,
|
|
|
|
|
enum rte_filter_type filter_type,
|
|
|
|
|
enum rte_filter_op filter_op,
|
|
|
|
|
void *arg);
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_flow_start(struct rte_eth_dev *dev, struct mlx5_flows *list);
|
|
|
|
|
void mlx5_flow_stop(struct rte_eth_dev *dev, struct mlx5_flows *list);
|
|
|
|
|
int mlx5_flow_verify(struct rte_eth_dev *dev);
|
|
|
|
|
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);
|
|
|
|
|
int mlx5_flow_create_drop_queue(struct rte_eth_dev *dev);
|
|
|
|
|
void mlx5_flow_delete_drop_queue(struct rte_eth_dev *dev);
|
2016-12-29 15:15:17 +00:00
|
|
|
|
2017-10-06 15:45:49 +00:00
|
|
|
/* mlx5_socket.c */
|
|
|
|
|
|
2018-03-05 12:21:04 +00:00
|
|
|
int mlx5_socket_init(struct rte_eth_dev *priv);
|
2018-03-05 12:21:05 +00:00
|
|
|
void mlx5_socket_uninit(struct rte_eth_dev *priv);
|
2018-03-05 12:21:04 +00:00
|
|
|
void mlx5_socket_handle(struct rte_eth_dev *priv);
|
|
|
|
|
int mlx5_socket_connect(struct rte_eth_dev *priv);
|
2017-10-06 15:45:49 +00:00
|
|
|
|
2018-04-05 15:07:19 +00:00
|
|
|
/* mlx5_nl.c */
|
|
|
|
|
|
2018-07-24 06:50:27 +00:00
|
|
|
int mlx5_nl_init(int protocol);
|
2018-04-05 15:07:19 +00:00
|
|
|
int mlx5_nl_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac,
|
|
|
|
|
uint32_t index);
|
|
|
|
|
int mlx5_nl_mac_addr_remove(struct rte_eth_dev *dev, struct ether_addr *mac,
|
|
|
|
|
uint32_t index);
|
|
|
|
|
void mlx5_nl_mac_addr_sync(struct rte_eth_dev *dev);
|
|
|
|
|
void mlx5_nl_mac_addr_flush(struct rte_eth_dev *dev);
|
2018-04-05 15:07:20 +00:00
|
|
|
int mlx5_nl_promisc(struct rte_eth_dev *dev, int enable);
|
|
|
|
|
int mlx5_nl_allmulti(struct rte_eth_dev *dev, int enable);
|
2018-07-10 16:04:52 +00:00
|
|
|
unsigned int mlx5_nl_ifindex(int nl, const char *name);
|
|
|
|
|
int mlx5_nl_switch_info(int nl, unsigned int ifindex,
|
|
|
|
|
struct mlx5_switch_info *info);
|
2018-04-05 15:07:19 +00:00
|
|
|
|
2018-07-13 09:40:37 +00:00
|
|
|
/* mlx5_nl_flow.c */
|
|
|
|
|
|
2018-07-13 09:40:39 +00:00
|
|
|
int mlx5_nl_flow_transpose(void *buf,
|
|
|
|
|
size_t size,
|
|
|
|
|
const struct mlx5_nl_flow_ptoi *ptoi,
|
|
|
|
|
const struct rte_flow_attr *attr,
|
|
|
|
|
const struct rte_flow_item *pattern,
|
|
|
|
|
const struct rte_flow_action *actions,
|
|
|
|
|
struct rte_flow_error *error);
|
|
|
|
|
void mlx5_nl_flow_brand(void *buf, uint32_t handle);
|
|
|
|
|
int mlx5_nl_flow_create(struct mnl_socket *nl, void *buf,
|
|
|
|
|
struct rte_flow_error *error);
|
|
|
|
|
int mlx5_nl_flow_destroy(struct mnl_socket *nl, void *buf,
|
|
|
|
|
struct rte_flow_error *error);
|
2018-07-13 09:40:37 +00:00
|
|
|
int mlx5_nl_flow_init(struct mnl_socket *nl, unsigned int ifindex,
|
|
|
|
|
struct rte_flow_error *error);
|
|
|
|
|
struct mnl_socket *mlx5_nl_flow_socket_create(void);
|
|
|
|
|
void mlx5_nl_flow_socket_destroy(struct mnl_socket *nl);
|
|
|
|
|
|
2015-10-30 18:52:30 +00:00
|
|
|
#endif /* RTE_PMD_MLX5_H_ */
|
