X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;ds=sidebyside;f=drivers%2Fnet%2Fmlx5%2Fmlx5_rxmode.c;h=9ac7a4113fb64779bdcc8b71dbec46b6b1922999;hb=0dc02cca8b40b5b5190c2679058672a65ab7218d;hp=7efa21b2bb22db3023b1957db864bae33c806138;hpb=1bdbe1af99b27acadb7993b429e6625b2f9fa6ff;p=dpdk.git

diff --git a/drivers/net/mlx5/mlx5_rxmode.c b/drivers/net/mlx5/mlx5_rxmode.c
index 7efa21b2bb..9ac7a4113f 100644
--- a/drivers/net/mlx5/mlx5_rxmode.c
+++ b/drivers/net/mlx5/mlx5_rxmode.c
@@ -58,171 +58,255 @@
 #include "mlx5_rxtx.h"
 #include "mlx5_utils.h"
 
+/* 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 |
+#ifdef HAVE_FLOW_SPEC_IPV6
+			1 << HASH_RXQ_TCPV6 |
+			1 << HASH_RXQ_UDPV6 |
+			1 << HASH_RXQ_IPV6 |
+#endif /* HAVE_FLOW_SPEC_IPV6 */
+			1 << HASH_RXQ_ETH |
+			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 |
+#ifdef HAVE_FLOW_SPEC_IPV6
+			1 << HASH_RXQ_UDPV6 |
+			1 << HASH_RXQ_IPV6 |
+#endif /* HAVE_FLOW_SPEC_IPV6 */
+			1 << HASH_RXQ_ETH |
+			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 |
+#ifdef HAVE_FLOW_SPEC_IPV6
+			1 << HASH_RXQ_UDPV6 |
+			1 << HASH_RXQ_IPV6 |
+#endif /* HAVE_FLOW_SPEC_IPV6 */
+			1 << HASH_RXQ_ETH |
+			0,
+	},
+#ifdef HAVE_FLOW_SPEC_IPV6
+	[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,
+	},
+#endif /* HAVE_FLOW_SPEC_IPV6 */
+};
+
 /**
- * Enable promiscuous mode in a RX queue.
+ * Enable a special flow in a hash RX queue.
  *
- * @param rxq
- *   Pointer to RX queue structure.
+ * @param hash_rxq
+ *   Pointer to hash RX queue structure.
+ * @param flow_type
+ *   Special flow type.
  *
  * @return
  *   0 on success, errno value on failure.
  */
-int
-rxq_promiscuous_enable(struct rxq *rxq)
+static int
+hash_rxq_special_flow_enable(struct hash_rxq *hash_rxq,
+			     enum hash_rxq_flow_type flow_type)
 {
-	struct ibv_flow *flow;
-	struct ibv_flow_attr attr = {
-		.type = IBV_FLOW_ATTR_ALL_DEFAULT,
-		.num_of_specs = 0,
-		.port = rxq->priv->port,
-		.flags = 0
-	};
+	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;
 
-	if (rxq->priv->vf)
+	/* Check if flow is relevant for this hash_rxq. */
+	if (!(special_flow_init[flow_type].hash_types & (1 << hash_rxq->type)))
 		return 0;
-	if (rxq->promisc_flow != NULL)
+	/* Check if flow already exists. */
+	if (hash_rxq->special_flow[flow_type] != NULL)
 		return 0;
-	DEBUG("%p: enabling promiscuous mode", (void *)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);
+	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],
+			},
+		},
+		.mask = {
+			.dst_mac = {
+				mask[0], mask[1], mask[2],
+				mask[3], mask[4], mask[5],
+			},
+		},
+	};
+
 	errno = 0;
-	flow = ibv_create_flow(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",
-		      (void *)rxq, errno,
+		      (void *)hash_rxq, errno,
 		      (errno ? strerror(errno) : "Unknown error"));
 		if (errno)
 			return errno;
 		return EINVAL;
 	}
-	rxq->promisc_flow = flow;
-	DEBUG("%p: promiscuous mode enabled", (void *)rxq);
+	hash_rxq->special_flow[flow_type] = flow;
+	DEBUG("%p: enabling special flow %s (%d)",
+	      (void *)hash_rxq, hash_rxq_flow_type_str(flow_type), flow_type);
 	return 0;
 }
 
 /**
- * DPDK callback to enable promiscuous mode.
+ * Disable 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.
  */
-void
-mlx5_promiscuous_enable(struct rte_eth_dev *dev)
+static void
+hash_rxq_special_flow_disable(struct hash_rxq *hash_rxq,
+			      enum hash_rxq_flow_type flow_type)
+{
+	if (hash_rxq->special_flow[flow_type] == NULL)
+		return;
+	DEBUG("%p: disabling special flow %s (%d)",
+	      (void *)hash_rxq, hash_rxq_flow_type_str(flow_type), flow_type);
+	claim_zero(ibv_exp_destroy_flow(hash_rxq->special_flow[flow_type]));
+	hash_rxq->special_flow[flow_type] = NULL;
+	DEBUG("%p: special flow %s (%d) disabled",
+	      (void *)hash_rxq, hash_rxq_flow_type_str(flow_type), flow_type);
+}
+
+/**
+ * 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.
+ */
+int
+priv_special_flow_enable(struct priv *priv, enum hash_rxq_flow_type flow_type)
 {
-	struct priv *priv = dev->data->dev_private;
 	unsigned int i;
-	int ret;
 
-	priv_lock(priv);
-	priv->promisc_req = 1;
-	/* If device isn't started, this is all we need to do. */
-	if (!priv->started)
-		goto end;
-	if (priv->rss) {
-		ret = rxq_promiscuous_enable(&priv->rxq_parent);
-		if (ret) {
-			priv_unlock(priv);
-			return;
-		}
-		goto end;
-	}
-	for (i = 0; (i != priv->rxqs_n); ++i) {
-		if ((*priv->rxqs)[i] == NULL)
-			continue;
-		ret = rxq_promiscuous_enable((*priv->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)
-			if ((*priv->rxqs)[--i] != NULL)
-				rxq_promiscuous_disable((*priv->rxqs)[i]);
-		priv_unlock(priv);
-		return;
+		while (i != 0) {
+			hash_rxq = &(*priv->hash_rxqs)[--i];
+			hash_rxq_special_flow_disable(hash_rxq, flow_type);
+		}
+		return ret;
 	}
-end:
-	priv_unlock(priv);
+	return 0;
 }
 
 /**
- * Disable promiscuous mode in a RX queue.
+ * Disable a special flow in all hash RX queues.
  *
- * @param rxq
- *   Pointer to RX queue structure.
+ * @param priv
+ *   Private structure.
+ * @param flow_type
+ *   Special flow type.
  */
 void
-rxq_promiscuous_disable(struct rxq *rxq)
+priv_special_flow_disable(struct priv *priv, enum hash_rxq_flow_type flow_type)
 {
-	if (rxq->priv->vf)
-		return;
-	if (rxq->promisc_flow == NULL)
-		return;
-	DEBUG("%p: disabling promiscuous mode", (void *)rxq);
-	claim_zero(ibv_destroy_flow(rxq->promisc_flow));
-	rxq->promisc_flow = NULL;
-	DEBUG("%p: promiscuous mode disabled", (void *)rxq);
+	unsigned int i;
+
+	for (i = 0; (i != priv->hash_rxqs_n); ++i) {
+		struct hash_rxq *hash_rxq = &(*priv->hash_rxqs)[i];
+
+		hash_rxq_special_flow_disable(hash_rxq, flow_type);
+	}
 }
 
 /**
- * DPDK callback to disable promiscuous mode.
+ * DPDK callback to enable promiscuous mode.
  *
  * @param dev
  *   Pointer to Ethernet device structure.
  */
 void
-mlx5_promiscuous_disable(struct rte_eth_dev *dev)
+mlx5_promiscuous_enable(struct rte_eth_dev *dev)
 {
 	struct priv *priv = dev->data->dev_private;
-	unsigned int i;
+	int ret;
 
 	priv_lock(priv);
-	priv->promisc_req = 0;
-	if (priv->rss) {
-		rxq_promiscuous_disable(&priv->rxq_parent);
-		goto end;
-	}
-	for (i = 0; (i != priv->rxqs_n); ++i)
-		if ((*priv->rxqs)[i] != NULL)
-			rxq_promiscuous_disable((*priv->rxqs)[i]);
-end:
+	priv->promisc_req = 1;
+	ret = priv_rehash_flows(priv);
+	if (ret)
+		ERROR("error while enabling promiscuous mode: %s",
+		      strerror(ret));
 	priv_unlock(priv);
 }
 
 /**
- * Enable allmulti mode in a RX queue.
- *
- * @param rxq
- *   Pointer to RX queue structure.
+ * DPDK callback to disable promiscuous mode.
  *
- * @return
- *   0 on success, errno value on failure.
+ * @param dev
+ *   Pointer to Ethernet device structure.
  */
-int
-rxq_allmulticast_enable(struct rxq *rxq)
+void
+mlx5_promiscuous_disable(struct rte_eth_dev *dev)
 {
-	struct ibv_flow *flow;
-	struct ibv_flow_attr attr = {
-		.type = IBV_FLOW_ATTR_MC_DEFAULT,
-		.num_of_specs = 0,
-		.port = rxq->priv->port,
-		.flags = 0
-	};
+	struct priv *priv = dev->data->dev_private;
+	int ret;
 
-	if (rxq->allmulti_flow != NULL)
-		return 0;
-	DEBUG("%p: enabling allmulticast mode", (void *)rxq);
-	errno = 0;
-	flow = ibv_create_flow(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 *)rxq, errno,
-		      (errno ? strerror(errno) : "Unknown error"));
-		if (errno)
-			return errno;
-		return EINVAL;
-	}
-	rxq->allmulti_flow = flow;
-	DEBUG("%p: allmulticast mode enabled", (void *)rxq);
-	return 0;
+	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);
 }
 
 /**
@@ -235,56 +319,17 @@ void
 mlx5_allmulticast_enable(struct rte_eth_dev *dev)
 {
 	struct priv *priv = dev->data->dev_private;
-	unsigned int i;
 	int ret;
 
 	priv_lock(priv);
 	priv->allmulti_req = 1;
-	/* If device isn't started, this is all we need to do. */
-	if (!priv->started)
-		goto end;
-	if (priv->rss) {
-		ret = rxq_allmulticast_enable(&priv->rxq_parent);
-		if (ret) {
-			priv_unlock(priv);
-			return;
-		}
-		goto end;
-	}
-	for (i = 0; (i != priv->rxqs_n); ++i) {
-		if ((*priv->rxqs)[i] == NULL)
-			continue;
-		ret = rxq_allmulticast_enable((*priv->rxqs)[i]);
-		if (!ret)
-			continue;
-		/* Failure, rollback. */
-		while (i != 0)
-			if ((*priv->rxqs)[--i] != NULL)
-				rxq_allmulticast_disable((*priv->rxqs)[i]);
-		priv_unlock(priv);
-		return;
-	}
-end:
+	ret = priv_rehash_flows(priv);
+	if (ret)
+		ERROR("error while enabling allmulticast mode: %s",
+		      strerror(ret));
 	priv_unlock(priv);
 }
 
-/**
- * Disable allmulti mode in a RX queue.
- *
- * @param rxq
- *   Pointer to RX queue structure.
- */
-void
-rxq_allmulticast_disable(struct rxq *rxq)
-{
-	if (rxq->allmulti_flow == NULL)
-		return;
-	DEBUG("%p: disabling allmulticast mode", (void *)rxq);
-	claim_zero(ibv_destroy_flow(rxq->allmulti_flow));
-	rxq->allmulti_flow = NULL;
-	DEBUG("%p: allmulticast mode disabled", (void *)rxq);
-}
-
 /**
  * DPDK callback to disable allmulti mode.
  *
@@ -295,17 +340,13 @@ void
 mlx5_allmulticast_disable(struct rte_eth_dev *dev)
 {
 	struct priv *priv = dev->data->dev_private;
-	unsigned int i;
+	int ret;
 
 	priv_lock(priv);
 	priv->allmulti_req = 0;
-	if (priv->rss) {
-		rxq_allmulticast_disable(&priv->rxq_parent);
-		goto end;
-	}
-	for (i = 0; (i != priv->rxqs_n); ++i)
-		if ((*priv->rxqs)[i] != NULL)
-			rxq_allmulticast_disable((*priv->rxqs)[i]);
-end:
+	ret = priv_rehash_flows(priv);
+	if (ret)
+		ERROR("error while disabling allmulticast mode: %s",
+		      strerror(ret));
 	priv_unlock(priv);
 }