X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fmlx5%2Fmlx5_rxmode.c;h=173e6e842bbc7090d022e52929447ab79f9ace9d;hb=aee3d4d6d5a6dbfa0a503f25f0f2bec8e6476477;hp=f7de1b861d84f9fc49dc9bd8bff42924032d449e;hpb=5b45c208f808d854c98d75fabeedabb00780fd4f;p=dpdk.git

diff --git a/drivers/net/mlx5/mlx5_rxmode.c b/drivers/net/mlx5/mlx5_rxmode.c
index f7de1b861d..173e6e842b 100644
--- a/drivers/net/mlx5/mlx5_rxmode.c
+++ b/drivers/net/mlx5/mlx5_rxmode.c
@@ -38,53 +38,147 @@
 /* Verbs header. */
 /* ISO C doesn't support unnamed structs/unions, disabling -pedantic. */
 #ifdef PEDANTIC
-#pragma GCC diagnostic ignored "-pedantic"
+#pragma GCC diagnostic ignored "-Wpedantic"
 #endif
 #include <infiniband/verbs.h>
 #ifdef PEDANTIC
-#pragma GCC diagnostic error "-pedantic"
+#pragma GCC diagnostic error "-Wpedantic"
 #endif
 
 /* DPDK headers don't like -pedantic. */
 #ifdef PEDANTIC
-#pragma GCC diagnostic ignored "-pedantic"
+#pragma GCC diagnostic ignored "-Wpedantic"
 #endif
 #include <rte_ethdev.h>
 #ifdef PEDANTIC
-#pragma GCC diagnostic error "-pedantic"
+#pragma GCC diagnostic error "-Wpedantic"
 #endif
 
 #include "mlx5.h"
 #include "mlx5_rxtx.h"
 #include "mlx5_utils.h"
 
-static void hash_rxq_promiscuous_disable(struct hash_rxq *);
-static void hash_rxq_allmulticast_disable(struct hash_rxq *);
+/* Initialization data for special flows. */
+static const struct special_flow_init special_flow_init[] = {
+	[HASH_RXQ_FLOW_TYPE_PROMISC] = {
+		.dst_mac_val = "\x00\x00\x00\x00\x00\x00",
+		.dst_mac_mask = "\x00\x00\x00\x00\x00\x00",
+		.hash_types =
+			1 << HASH_RXQ_TCPV4 |
+			1 << HASH_RXQ_UDPV4 |
+			1 << HASH_RXQ_IPV4 |
+			1 << HASH_RXQ_TCPV6 |
+			1 << HASH_RXQ_UDPV6 |
+			1 << HASH_RXQ_IPV6 |
+			1 << HASH_RXQ_ETH |
+			0,
+		.per_vlan = 0,
+	},
+	[HASH_RXQ_FLOW_TYPE_ALLMULTI] = {
+		.dst_mac_val = "\x01\x00\x00\x00\x00\x00",
+		.dst_mac_mask = "\x01\x00\x00\x00\x00\x00",
+		.hash_types =
+			1 << HASH_RXQ_UDPV4 |
+			1 << HASH_RXQ_IPV4 |
+			1 << HASH_RXQ_UDPV6 |
+			1 << HASH_RXQ_IPV6 |
+			1 << HASH_RXQ_ETH |
+			0,
+		.per_vlan = 0,
+	},
+	[HASH_RXQ_FLOW_TYPE_BROADCAST] = {
+		.dst_mac_val = "\xff\xff\xff\xff\xff\xff",
+		.dst_mac_mask = "\xff\xff\xff\xff\xff\xff",
+		.hash_types =
+			1 << HASH_RXQ_UDPV4 |
+			1 << HASH_RXQ_IPV4 |
+			1 << HASH_RXQ_UDPV6 |
+			1 << HASH_RXQ_IPV6 |
+			1 << HASH_RXQ_ETH |
+			0,
+		.per_vlan = 1,
+	},
+	[HASH_RXQ_FLOW_TYPE_IPV6MULTI] = {
+		.dst_mac_val = "\x33\x33\x00\x00\x00\x00",
+		.dst_mac_mask = "\xff\xff\x00\x00\x00\x00",
+		.hash_types =
+			1 << HASH_RXQ_UDPV6 |
+			1 << HASH_RXQ_IPV6 |
+			1 << HASH_RXQ_ETH |
+			0,
+		.per_vlan = 1,
+	},
+};
 
 /**
- * Enable promiscuous mode in a hash RX queue.
+ * Enable a special flow in a hash RX queue for a given VLAN index.
  *
  * @param hash_rxq
  *   Pointer to hash RX queue structure.
+ * @param flow_type
+ *   Special flow type.
+ * @param vlan_index
+ *   VLAN index to use.
  *
  * @return
  *   0 on success, errno value on failure.
  */
 static int
-hash_rxq_promiscuous_enable(struct hash_rxq *hash_rxq)
+hash_rxq_special_flow_enable_vlan(struct hash_rxq *hash_rxq,
+				  enum hash_rxq_flow_type flow_type,
+				  unsigned int vlan_index)
 {
-	struct ibv_flow *flow;
-	FLOW_ATTR_SPEC_ETH(data, hash_rxq_flow_attr(hash_rxq, NULL, 0));
-	struct ibv_flow_attr *attr = &data->attr;
+	struct priv *priv = hash_rxq->priv;
+	struct ibv_exp_flow *flow;
+	FLOW_ATTR_SPEC_ETH(data, priv_flow_attr(priv, NULL, 0, hash_rxq->type));
+	struct ibv_exp_flow_attr *attr = &data->attr;
+	struct ibv_exp_flow_spec_eth *spec = &data->spec;
+	const uint8_t *mac;
+	const uint8_t *mask;
+	unsigned int vlan_enabled = (priv->vlan_filter_n &&
+				     special_flow_init[flow_type].per_vlan);
+	unsigned int vlan_id = priv->vlan_filter[vlan_index];
 
-	if (hash_rxq->promisc_flow != NULL)
+	/* Check if flow is relevant for this hash_rxq. */
+	if (!(special_flow_init[flow_type].hash_types & (1 << hash_rxq->type)))
 		return 0;
-	DEBUG("%p: enabling promiscuous mode", (void *)hash_rxq);
-	/* Promiscuous flows only differ from normal flows by not filtering
-	 * on specific MAC addresses. */
-	hash_rxq_flow_attr(hash_rxq, attr, sizeof(data));
+	/* Check if flow already exists. */
+	if (hash_rxq->special_flow[flow_type][vlan_index] != NULL)
+		return 0;
+
+	/*
+	 * No padding must be inserted by the compiler between attr and spec.
+	 * This layout is expected by libibverbs.
+	 */
+	assert(((uint8_t *)attr + sizeof(*attr)) == (uint8_t *)spec);
+	priv_flow_attr(priv, attr, sizeof(data), hash_rxq->type);
+	/* The first specification must be Ethernet. */
+	assert(spec->type == IBV_EXP_FLOW_SPEC_ETH);
+	assert(spec->size == sizeof(*spec));
+
+	mac = special_flow_init[flow_type].dst_mac_val;
+	mask = special_flow_init[flow_type].dst_mac_mask;
+	*spec = (struct ibv_exp_flow_spec_eth){
+		.type = IBV_EXP_FLOW_SPEC_ETH,
+		.size = sizeof(*spec),
+		.val = {
+			.dst_mac = {
+				mac[0], mac[1], mac[2],
+				mac[3], mac[4], mac[5],
+			},
+			.vlan_tag = (vlan_enabled ? htons(vlan_id) : 0),
+		},
+		.mask = {
+			.dst_mac = {
+				mask[0], mask[1], mask[2],
+				mask[3], mask[4], mask[5],
+			},
+			.vlan_tag = (vlan_enabled ? htons(0xfff) : 0),
+		},
+	};
+
 	errno = 0;
-	flow = ibv_create_flow(hash_rxq->qp, attr);
+	flow = ibv_exp_create_flow(hash_rxq->qp, attr);
 	if (flow == NULL) {
 		/* It's not clear whether errno is always set in this case. */
 		ERROR("%p: flow configuration failed, errno=%d: %s",
@@ -94,258 +188,268 @@ hash_rxq_promiscuous_enable(struct hash_rxq *hash_rxq)
 			return errno;
 		return EINVAL;
 	}
-	hash_rxq->promisc_flow = flow;
-	DEBUG("%p: promiscuous mode enabled", (void *)hash_rxq);
+	hash_rxq->special_flow[flow_type][vlan_index] = flow;
+	DEBUG("%p: special flow %s (index %d) VLAN %u (index %u) enabled",
+	      (void *)hash_rxq, hash_rxq_flow_type_str(flow_type), flow_type,
+	      vlan_id, vlan_index);
 	return 0;
 }
 
 /**
- * Enable promiscuous mode in all hash RX queues.
- *
- * @param priv
- *   Private structure.
+ * Disable a special flow in a hash RX queue for a given VLAN index.
  *
- * @return
- *   0 on success, errno value on failure.
+ * @param hash_rxq
+ *   Pointer to hash RX queue structure.
+ * @param flow_type
+ *   Special flow type.
+ * @param vlan_index
+ *   VLAN index to use.
  */
-int
-priv_promiscuous_enable(struct priv *priv)
+static void
+hash_rxq_special_flow_disable_vlan(struct hash_rxq *hash_rxq,
+				   enum hash_rxq_flow_type flow_type,
+				   unsigned int vlan_index)
 {
-	unsigned int i;
-
-	if (!priv_allow_flow_type(priv, HASH_RXQ_FLOW_TYPE_PROMISC))
-		return 0;
-	for (i = 0; (i != priv->hash_rxqs_n); ++i) {
-		struct hash_rxq *hash_rxq = &(*priv->hash_rxqs)[i];
-		int ret;
+	struct ibv_exp_flow *flow =
+		hash_rxq->special_flow[flow_type][vlan_index];
 
-		ret = hash_rxq_promiscuous_enable(hash_rxq);
-		if (!ret)
-			continue;
-		/* Failure, rollback. */
-		while (i != 0) {
-			hash_rxq = &(*priv->hash_rxqs)[--i];
-			hash_rxq_promiscuous_disable(hash_rxq);
-		}
-		return ret;
-	}
-	return 0;
+	if (flow == NULL)
+		return;
+	claim_zero(ibv_exp_destroy_flow(flow));
+	hash_rxq->special_flow[flow_type][vlan_index] = NULL;
+	DEBUG("%p: special flow %s (index %d) VLAN %u (index %u) disabled",
+	      (void *)hash_rxq, hash_rxq_flow_type_str(flow_type), flow_type,
+	      hash_rxq->priv->vlan_filter[vlan_index], vlan_index);
 }
 
 /**
- * DPDK callback to enable promiscuous mode.
+ * Enable a special flow in a hash RX queue.
  *
- * @param dev
- *   Pointer to Ethernet device structure.
+ * @param hash_rxq
+ *   Pointer to hash RX queue structure.
+ * @param flow_type
+ *   Special flow type.
+ * @param vlan_index
+ *   VLAN index to use.
+ *
+ * @return
+ *   0 on success, errno value on failure.
  */
-void
-mlx5_promiscuous_enable(struct rte_eth_dev *dev)
+static int
+hash_rxq_special_flow_enable(struct hash_rxq *hash_rxq,
+			     enum hash_rxq_flow_type flow_type)
 {
-	struct priv *priv = dev->data->dev_private;
+	struct priv *priv = hash_rxq->priv;
+	unsigned int i = 0;
 	int ret;
 
-	priv_lock(priv);
-	priv->promisc_req = 1;
-	ret = priv_promiscuous_enable(priv);
-	if (ret)
-		ERROR("cannot enable promiscuous mode: %s", strerror(ret));
-	else {
-		priv_mac_addrs_disable(priv);
-		priv_allmulticast_disable(priv);
-	}
-	priv_unlock(priv);
+	assert((unsigned int)flow_type < RTE_DIM(hash_rxq->special_flow));
+	assert(RTE_DIM(hash_rxq->special_flow[flow_type]) ==
+	       RTE_DIM(priv->vlan_filter));
+	/* Add a special flow for each VLAN filter when relevant. */
+	do {
+		ret = hash_rxq_special_flow_enable_vlan(hash_rxq, flow_type, i);
+		if (ret) {
+			/* Failure, rollback. */
+			while (i != 0)
+				hash_rxq_special_flow_disable_vlan(hash_rxq,
+								   flow_type,
+								   --i);
+			return ret;
+		}
+	} while (special_flow_init[flow_type].per_vlan &&
+		 ++i < priv->vlan_filter_n);
+	return 0;
 }
 
 /**
- * Disable promiscuous mode in a hash RX queue.
+ * Disable a special flow in a hash RX queue.
  *
  * @param hash_rxq
  *   Pointer to hash RX queue structure.
+ * @param flow_type
+ *   Special flow type.
  */
 static void
-hash_rxq_promiscuous_disable(struct hash_rxq *hash_rxq)
+hash_rxq_special_flow_disable(struct hash_rxq *hash_rxq,
+			      enum hash_rxq_flow_type flow_type)
 {
-	if (hash_rxq->promisc_flow == NULL)
-		return;
-	DEBUG("%p: disabling promiscuous mode", (void *)hash_rxq);
-	claim_zero(ibv_destroy_flow(hash_rxq->promisc_flow));
-	hash_rxq->promisc_flow = NULL;
-	DEBUG("%p: promiscuous mode disabled", (void *)hash_rxq);
+	unsigned int i;
+
+	assert((unsigned int)flow_type < RTE_DIM(hash_rxq->special_flow));
+	for (i = 0; (i != RTE_DIM(hash_rxq->special_flow[flow_type])); ++i)
+		hash_rxq_special_flow_disable_vlan(hash_rxq, flow_type, i);
 }
 
 /**
- * Disable promiscuous mode in all hash RX queues.
+ * Enable a special flow in all hash RX queues.
  *
  * @param priv
  *   Private structure.
+ * @param flow_type
+ *   Special flow type.
+ *
+ * @return
+ *   0 on success, errno value on failure.
  */
-void
-priv_promiscuous_disable(struct priv *priv)
+int
+priv_special_flow_enable(struct priv *priv, enum hash_rxq_flow_type flow_type)
 {
 	unsigned int i;
 
-	for (i = 0; (i != priv->hash_rxqs_n); ++i)
-		hash_rxq_promiscuous_disable(&(*priv->hash_rxqs)[i]);
+	if (!priv_allow_flow_type(priv, flow_type))
+		return 0;
+	for (i = 0; (i != priv->hash_rxqs_n); ++i) {
+		struct hash_rxq *hash_rxq = &(*priv->hash_rxqs)[i];
+		int ret;
+
+		ret = hash_rxq_special_flow_enable(hash_rxq, flow_type);
+		if (!ret)
+			continue;
+		/* Failure, rollback. */
+		while (i != 0) {
+			hash_rxq = &(*priv->hash_rxqs)[--i];
+			hash_rxq_special_flow_disable(hash_rxq, flow_type);
+		}
+		return ret;
+	}
+	return 0;
 }
 
 /**
- * DPDK callback to disable promiscuous mode.
+ * Disable a special flow in all hash RX queues.
  *
- * @param dev
- *   Pointer to Ethernet device structure.
+ * @param priv
+ *   Private structure.
+ * @param flow_type
+ *   Special flow type.
  */
 void
-mlx5_promiscuous_disable(struct rte_eth_dev *dev)
+priv_special_flow_disable(struct priv *priv, enum hash_rxq_flow_type flow_type)
 {
-	struct priv *priv = dev->data->dev_private;
-
-	priv_lock(priv);
-	priv->promisc_req = 0;
-	priv_promiscuous_disable(priv);
-	priv_mac_addrs_enable(priv);
-	priv_allmulticast_enable(priv);
-	priv_unlock(priv);
-}
+	unsigned int i;
 
-/**
- * Enable allmulti mode in a hash RX queue.
- *
- * @param hash_rxq
- *   Pointer to hash RX queue structure.
- *
- * @return
- *   0 on success, errno value on failure.
- */
-static int
-hash_rxq_allmulticast_enable(struct hash_rxq *hash_rxq)
-{
-	struct ibv_flow *flow;
-	FLOW_ATTR_SPEC_ETH(data, hash_rxq_flow_attr(hash_rxq, NULL, 0));
-	struct ibv_flow_attr *attr = &data->attr;
-	struct ibv_flow_spec_eth *spec = &data->spec;
+	for (i = 0; (i != priv->hash_rxqs_n); ++i) {
+		struct hash_rxq *hash_rxq = &(*priv->hash_rxqs)[i];
 
-	if (hash_rxq->allmulti_flow != NULL)
-		return 0;
-	DEBUG("%p: enabling allmulticast mode", (void *)hash_rxq);
-	/*
-	 * No padding must be inserted by the compiler between attr and spec.
-	 * This layout is expected by libibverbs.
-	 */
-	assert(((uint8_t *)attr + sizeof(*attr)) == (uint8_t *)spec);
-	hash_rxq_flow_attr(hash_rxq, attr, sizeof(data));
-	*spec = (struct ibv_flow_spec_eth){
-		.type = IBV_FLOW_SPEC_ETH,
-		.size = sizeof(*spec),
-		.val = {
-			.dst_mac = "\x01\x00\x00\x00\x00\x00",
-		},
-		.mask = {
-			.dst_mac = "\x01\x00\x00\x00\x00\x00",
-		},
-	};
-	errno = 0;
-	flow = ibv_create_flow(hash_rxq->qp, attr);
-	if (flow == NULL) {
-		/* It's not clear whether errno is always set in this case. */
-		ERROR("%p: flow configuration failed, errno=%d: %s",
-		      (void *)hash_rxq, errno,
-		      (errno ? strerror(errno) : "Unknown error"));
-		if (errno)
-			return errno;
-		return EINVAL;
+		hash_rxq_special_flow_disable(hash_rxq, flow_type);
 	}
-	hash_rxq->allmulti_flow = flow;
-	DEBUG("%p: allmulticast mode enabled", (void *)hash_rxq);
-	return 0;
 }
 
 /**
- * Enable allmulti mode in most hash RX queues.
- * TCP queues are exempted to save resources.
+ * Enable all special flows in all hash RX queues.
  *
  * @param priv
  *   Private structure.
- *
- * @return
- *   0 on success, errno value on failure.
  */
 int
-priv_allmulticast_enable(struct priv *priv)
+priv_special_flow_enable_all(struct priv *priv)
 {
-	unsigned int i;
+	enum hash_rxq_flow_type flow_type;
 
-	if (!priv_allow_flow_type(priv, HASH_RXQ_FLOW_TYPE_ALLMULTI))
-		return 0;
-	for (i = 0; (i != priv->hash_rxqs_n); ++i) {
-		struct hash_rxq *hash_rxq = &(*priv->hash_rxqs)[i];
+	for (flow_type = HASH_RXQ_FLOW_TYPE_PROMISC;
+			flow_type != HASH_RXQ_FLOW_TYPE_MAC;
+			++flow_type) {
 		int ret;
 
-		/* allmulticast not relevant for TCP. */
-		if (hash_rxq->type == HASH_RXQ_TCPV4)
-			continue;
-		ret = hash_rxq_allmulticast_enable(hash_rxq);
+		ret = priv_special_flow_enable(priv, flow_type);
 		if (!ret)
 			continue;
 		/* Failure, rollback. */
-		while (i != 0) {
-			hash_rxq = &(*priv->hash_rxqs)[--i];
-			hash_rxq_allmulticast_disable(hash_rxq);
-		}
+		while (flow_type)
+			priv_special_flow_disable(priv, --flow_type);
 		return ret;
 	}
 	return 0;
 }
 
 /**
- * DPDK callback to enable allmulti mode.
+ * Disable all special flows in all hash RX queues.
+ *
+ * @param priv
+ *   Private structure.
+ */
+void
+priv_special_flow_disable_all(struct priv *priv)
+{
+	enum hash_rxq_flow_type flow_type;
+
+	for (flow_type = HASH_RXQ_FLOW_TYPE_PROMISC;
+			flow_type != HASH_RXQ_FLOW_TYPE_MAC;
+			++flow_type)
+		priv_special_flow_disable(priv, flow_type);
+}
+
+/**
+ * DPDK callback to enable promiscuous mode.
  *
  * @param dev
  *   Pointer to Ethernet device structure.
  */
 void
-mlx5_allmulticast_enable(struct rte_eth_dev *dev)
+mlx5_promiscuous_enable(struct rte_eth_dev *dev)
 {
 	struct priv *priv = dev->data->dev_private;
 	int ret;
 
+	if (mlx5_is_secondary())
+		return;
+
 	priv_lock(priv);
-	priv->allmulti_req = 1;
-	ret = priv_allmulticast_enable(priv);
+	priv->promisc_req = 1;
+	ret = priv_rehash_flows(priv);
 	if (ret)
-		ERROR("cannot enable allmulticast mode: %s", strerror(ret));
+		ERROR("error while enabling promiscuous mode: %s",
+		      strerror(ret));
 	priv_unlock(priv);
 }
 
 /**
- * Disable allmulti mode in a hash RX queue.
+ * DPDK callback to disable promiscuous mode.
  *
- * @param hash_rxq
- *   Pointer to hash RX queue structure.
+ * @param dev
+ *   Pointer to Ethernet device structure.
  */
-static void
-hash_rxq_allmulticast_disable(struct hash_rxq *hash_rxq)
+void
+mlx5_promiscuous_disable(struct rte_eth_dev *dev)
 {
-	if (hash_rxq->allmulti_flow == NULL)
+	struct priv *priv = dev->data->dev_private;
+	int ret;
+
+	if (mlx5_is_secondary())
 		return;
-	DEBUG("%p: disabling allmulticast mode", (void *)hash_rxq);
-	claim_zero(ibv_destroy_flow(hash_rxq->allmulti_flow));
-	hash_rxq->allmulti_flow = NULL;
-	DEBUG("%p: allmulticast mode disabled", (void *)hash_rxq);
+
+	priv_lock(priv);
+	priv->promisc_req = 0;
+	ret = priv_rehash_flows(priv);
+	if (ret)
+		ERROR("error while disabling promiscuous mode: %s",
+		      strerror(ret));
+	priv_unlock(priv);
 }
 
 /**
- * Disable allmulti mode in all hash RX queues.
+ * DPDK callback to enable allmulti mode.
  *
- * @param priv
- *   Private structure.
+ * @param dev
+ *   Pointer to Ethernet device structure.
  */
 void
-priv_allmulticast_disable(struct priv *priv)
+mlx5_allmulticast_enable(struct rte_eth_dev *dev)
 {
-	unsigned int i;
+	struct priv *priv = dev->data->dev_private;
+	int ret;
+
+	if (mlx5_is_secondary())
+		return;
 
-	for (i = 0; (i != priv->hash_rxqs_n); ++i)
-		hash_rxq_allmulticast_disable(&(*priv->hash_rxqs)[i]);
+	priv_lock(priv);
+	priv->allmulti_req = 1;
+	ret = priv_rehash_flows(priv);
+	if (ret)
+		ERROR("error while enabling allmulticast mode: %s",
+		      strerror(ret));
+	priv_unlock(priv);
 }
 
 /**
@@ -358,9 +462,16 @@ void
 mlx5_allmulticast_disable(struct rte_eth_dev *dev)
 {
 	struct priv *priv = dev->data->dev_private;
+	int ret;
+
+	if (mlx5_is_secondary())
+		return;
 
 	priv_lock(priv);
 	priv->allmulti_req = 0;
-	priv_allmulticast_disable(priv);
+	ret = priv_rehash_flows(priv);
+	if (ret)
+		ERROR("error while disabling allmulticast mode: %s",
+		      strerror(ret));
 	priv_unlock(priv);
 }