#include "mlx4_rxtx.h"
#include "mlx4_utils.h"
+/** IBV supported RSS hash functions combinations */
+#define MLX4_IBV_IPV4_HF ( \
+ IBV_RX_HASH_SRC_IPV4 | \
+ IBV_RX_HASH_DST_IPV4)
+#define MLX4_IBV_IPV6_HF ( \
+ IBV_RX_HASH_SRC_IPV6 | \
+ IBV_RX_HASH_DST_IPV6)
+#define MLX4_IBV_TCP_HF ( \
+ IBV_RX_HASH_SRC_PORT_TCP | \
+ IBV_RX_HASH_DST_PORT_TCP)
+#define MLX4_IBV_UDP_HF ( \
+ IBV_RX_HASH_SRC_PORT_UDP | \
+ IBV_RX_HASH_DST_PORT_UDP)
+
+/** Supported RSS hash functions combinations */
+#define MLX4_RSS_IPV4_HF ( \
+ ETH_RSS_IPV4 | \
+ ETH_RSS_FRAG_IPV4 | \
+ ETH_RSS_NONFRAG_IPV4_OTHER)
+#define MLX4_RSS_IPV6_HF ( \
+ ETH_RSS_IPV6 | \
+ ETH_RSS_FRAG_IPV6 | \
+ ETH_RSS_NONFRAG_IPV6_OTHER | \
+ ETH_RSS_IPV6_EX)
+#define MLX4_RSS_IPV4_TCP_HF ( \
+ ETH_RSS_NONFRAG_IPV4_TCP)
+#define MLX4_RSS_IPV6_TCP_HF ( \
+ ETH_RSS_NONFRAG_IPV6_TCP | \
+ ETH_RSS_IPV6_TCP_EX)
+#define MLX4_RSS_IPV4_UDP_HF ( \
+ ETH_RSS_NONFRAG_IPV4_UDP)
+#define MLX4_RSS_IPV6_UDP_HF ( \
+ ETH_RSS_NONFRAG_IPV6_UDP | \
+ ETH_RSS_IPV6_UDP_EX)
+
/** Static initializer for a list of subsequent item types. */
#define NEXT_ITEM(...) \
(const enum rte_flow_item_type []){ \
mlx4_conv_rss_types(struct priv *priv, uint64_t types)
{
enum { IPV4, IPV6, TCP, UDP, };
- const uint64_t in[] = {
+ static const uint64_t in[] = {
[IPV4] = (ETH_RSS_IPV4 |
ETH_RSS_FRAG_IPV4 |
ETH_RSS_NONFRAG_IPV4_TCP |
ETH_RSS_NONFRAG_IPV6_UDP |
ETH_RSS_IPV6_UDP_EX),
};
- const uint64_t out[RTE_DIM(in)] = {
+ static const uint64_t out[RTE_DIM(in)] = {
[IPV4] = IBV_RX_HASH_SRC_IPV4 | IBV_RX_HASH_DST_IPV4,
[IPV6] = IBV_RX_HASH_SRC_IPV6 | IBV_RX_HASH_DST_IPV6,
[TCP] = IBV_RX_HASH_SRC_PORT_TCP | IBV_RX_HASH_DST_PORT_TCP,
uint64_t conv = 0;
unsigned int i;
+ if (types == (uint64_t)-1)
+ return priv->hw_rss_sup;
for (i = 0; i != RTE_DIM(in); ++i)
if (types & in[i]) {
seen |= types & in[i];
conv |= out[i];
}
- if ((conv & priv->hw_rss_sup) == conv) {
- if (types == (uint64_t)-1) {
- /* Include inner RSS by default if supported. */
- conv |= priv->hw_rss_sup & IBV_RX_HASH_INNER;
- return conv;
- }
- if (!(types & ~seen))
- return conv;
- }
+ if ((conv & priv->hw_rss_sup) == conv && !(types & ~seen))
+ return conv;
rte_errno = ENOTSUP;
return (uint64_t)-1;
}
+/**
+ * Convert verbs RSS types to their DPDK equivalents.
+ *
+ * This function returns a group of RSS DPDK types given their equivalent group
+ * of verbs types.
+ * For example both source IPv4 and destination IPv4 verbs types are converted
+ * into their equivalent RSS group types. If each of these verbs types existed
+ * exclusively - no conversion would take place.
+ *
+ * @param types
+ * RSS hash types in verbs format.
+ *
+ * @return
+ * DPDK RSS hash fields supported by mlx4.
+ */
+uint64_t
+mlx4_ibv_to_rss_types(uint64_t types)
+{
+ enum { IPV4, IPV6, IPV4_TCP, IPV6_TCP, IPV4_UDP, IPV6_UDP};
+
+ static const uint64_t in[] = {
+ [IPV4] = MLX4_IBV_IPV4_HF,
+ [IPV6] = MLX4_IBV_IPV6_HF,
+ [IPV4_TCP] = MLX4_IBV_IPV4_HF | MLX4_IBV_TCP_HF,
+ [IPV6_TCP] = MLX4_IBV_IPV6_HF | MLX4_IBV_TCP_HF,
+ [IPV4_UDP] = MLX4_IBV_IPV4_HF | MLX4_IBV_UDP_HF,
+ [IPV6_UDP] = MLX4_IBV_IPV6_HF | MLX4_IBV_UDP_HF,
+ };
+ static const uint64_t out[RTE_DIM(in)] = {
+ [IPV4] = MLX4_RSS_IPV4_HF,
+ [IPV6] = MLX4_RSS_IPV6_HF,
+ [IPV4_TCP] = MLX4_RSS_IPV4_HF | MLX4_RSS_IPV4_TCP_HF,
+ [IPV6_TCP] = MLX4_RSS_IPV6_HF | MLX4_RSS_IPV6_TCP_HF,
+ [IPV4_UDP] = MLX4_RSS_IPV4_HF | MLX4_RSS_IPV4_UDP_HF,
+ [IPV6_UDP] = MLX4_RSS_IPV6_HF | MLX4_RSS_IPV6_UDP_HF,
+ };
+ uint64_t conv = 0;
+ unsigned int i;
+
+ for (i = 0; i != RTE_DIM(in); ++i)
+ if ((types & in[i]) == in[i])
+ conv |= out[i];
+ return conv;
+}
+
/**
* Merge Ethernet pattern item into flow rule handle.
*
* Additional mlx4-specific constraints on supported fields:
*
* - No support for partial masks.
+ * - Due to HW/FW limitation, flow rule priority is not taken into account
+ * when matching UDP destination ports, doing is therefore only supported
+ * at the highest priority level (0).
*
* @param[in, out] flow
* Flow rule handle to update.
msg = "mlx4 does not support matching partial UDP fields";
goto error;
}
+ if (mask && mask->hdr.dst_port && flow->priority) {
+ msg = "combining UDP destination port matching with a nonzero"
+ " priority level is not supported";
+ goto error;
+ }
if (!flow->ibv_attr)
return 0;
++flow->ibv_attr->num_of_specs;
return rte_flow_error_set
(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
NULL, "egress is not supported");
+ if (attr->transfer)
+ return rte_flow_error_set
+ (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER,
+ NULL, "transfer is not supported");
if (!attr->ingress)
return rte_flow_error_set
(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
fill:
overlap = 0;
proc = mlx4_flow_proc_item_list;
+ flow->priority = attr->priority;
/* Go over pattern. */
for (item = pattern; item->type; ++item) {
const struct mlx4_flow_proc_item *next = NULL;
" is Toeplitz";
goto exit_action_not_supported;
}
+ if (rss->level) {
+ msg = "a nonzero RSS encapsulation level is"
+ " not supported";
+ goto exit_action_not_supported;
+ }
rte_errno = 0;
fields = mlx4_conv_rss_types(priv, rss->types);
if (fields == (uint64_t)-1 && rte_errno) {
uint16_t queue[queues];
struct rte_flow_action_rss action_rss = {
.func = RTE_ETH_HASH_FUNCTION_DEFAULT,
+ .level = 0,
.types = -1,
.key_len = MLX4_RSS_HASH_KEY_SIZE,
.queue_num = queues,
git.droids-corp.org / dpdk.git / blobdiff