X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fmlx5%2Fmlx5_rxmode.c;h=096fd18078389d5bf2eaadf37168aebceead2d46;hb=6069d815bc4dd73e82396a607882fe8395e592ed;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..096fd18078 100644 --- a/drivers/net/mlx5/mlx5_rxmode.c +++ b/drivers/net/mlx5/mlx5_rxmode.c @@ -58,44 +58,77 @@ #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 *); + /** - * Enable promiscuous mode in a RX queue. + * Enable promiscuous mode in a hash RX queue. * - * @param rxq - * Pointer to RX queue structure. + * @param hash_rxq + * Pointer to hash RX queue structure. * * @return * 0 on success, errno value on failure. */ -int -rxq_promiscuous_enable(struct rxq *rxq) +static int +hash_rxq_promiscuous_enable(struct hash_rxq *hash_rxq) { - 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 ibv_exp_flow *flow; + FLOW_ATTR_SPEC_ETH(data, hash_rxq_flow_attr(hash_rxq, NULL, 0)); + struct ibv_exp_flow_attr *attr = &data->attr; - if (rxq->priv->vf) + if (hash_rxq->promisc_flow != NULL) return 0; - if (rxq->promisc_flow != NULL) - return 0; - DEBUG("%p: enabling promiscuous mode", (void *)rxq); + 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)); 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->promisc_flow = flow; + DEBUG("%p: promiscuous mode enabled", (void *)hash_rxq); + return 0; +} + +/** + * Enable promiscuous mode in all hash RX queues. + * + * @param priv + * Private structure. + * + * @return + * 0 on success, errno value on failure. + */ +int +priv_promiscuous_enable(struct priv *priv) +{ + 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; + + 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; } @@ -109,56 +142,50 @@ void 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 = 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; + 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); } - for (i = 0; (i != priv->rxqs_n); ++i) { - if ((*priv->rxqs)[i] == NULL) - continue; - ret = rxq_promiscuous_enable((*priv->rxqs)[i]); - if (!ret) - continue; - /* Failure, rollback. */ - while (i != 0) - if ((*priv->rxqs)[--i] != NULL) - rxq_promiscuous_disable((*priv->rxqs)[i]); - priv_unlock(priv); - return; - } -end: priv_unlock(priv); } /** - * Disable promiscuous mode in a RX queue. + * Disable promiscuous mode in a hash RX queue. * - * @param rxq - * Pointer to RX queue structure. + * @param hash_rxq + * Pointer to hash RX queue structure. */ -void -rxq_promiscuous_disable(struct rxq *rxq) +static void +hash_rxq_promiscuous_disable(struct hash_rxq *hash_rxq) { - if (rxq->priv->vf) - return; - if (rxq->promisc_flow == NULL) + if (hash_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); + DEBUG("%p: disabling promiscuous mode", (void *)hash_rxq); + claim_zero(ibv_exp_destroy_flow(hash_rxq->promisc_flow)); + hash_rxq->promisc_flow = NULL; + DEBUG("%p: promiscuous mode disabled", (void *)hash_rxq); +} + +/** + * Disable promiscuous mode in all hash RX queues. + * + * @param priv + * Private structure. + */ +void +priv_promiscuous_disable(struct priv *priv) +{ + unsigned int i; + + for (i = 0; (i != priv->hash_rxqs_n); ++i) + hash_rxq_promiscuous_disable(&(*priv->hash_rxqs)[i]); } /** @@ -171,57 +198,101 @@ void mlx5_promiscuous_disable(struct rte_eth_dev *dev) { struct priv *priv = dev->data->dev_private; - unsigned int i; 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_promiscuous_disable(priv); + priv_mac_addrs_enable(priv); + priv_allmulticast_enable(priv); priv_unlock(priv); } /** - * Enable allmulti mode in a RX queue. + * Enable allmulti mode in a hash RX queue. * - * @param rxq - * Pointer to RX queue structure. + * @param hash_rxq + * Pointer to hash RX queue structure. * * @return * 0 on success, errno value on failure. */ -int -rxq_allmulticast_enable(struct rxq *rxq) +static int +hash_rxq_allmulticast_enable(struct hash_rxq *hash_rxq) { - 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 ibv_exp_flow *flow; + FLOW_ATTR_SPEC_ETH(data, hash_rxq_flow_attr(hash_rxq, NULL, 0)); + struct ibv_exp_flow_attr *attr = &data->attr; + struct ibv_exp_flow_spec_eth *spec = &data->spec; - if (rxq->allmulti_flow != NULL) + if (hash_rxq->allmulti_flow != NULL) return 0; - DEBUG("%p: enabling allmulticast mode", (void *)rxq); + 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_exp_flow_spec_eth){ + .type = IBV_EXP_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(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->allmulti_flow = flow; - DEBUG("%p: allmulticast mode enabled", (void *)rxq); + 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. + * + * @param priv + * Private structure. + * + * @return + * 0 on success, errno value on failure. + */ +int +priv_allmulticast_enable(struct priv *priv) +{ + unsigned int i; + + 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]; + int ret; + + /* allmulticast not relevant for TCP. */ + if (hash_rxq->type == HASH_RXQ_TCPV4) + continue; + ret = hash_rxq_allmulticast_enable(hash_rxq); + if (!ret) + continue; + /* Failure, rollback. */ + while (i != 0) { + hash_rxq = &(*priv->hash_rxqs)[--i]; + hash_rxq_allmulticast_disable(hash_rxq); + } + return ret; + } return 0; } @@ -235,54 +306,46 @@ 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_allmulticast_enable(priv); + if (ret) + ERROR("cannot enable allmulticast mode: %s", strerror(ret)); priv_unlock(priv); } /** - * Disable allmulti mode in a RX queue. + * Disable allmulti mode in a hash RX queue. * - * @param rxq - * Pointer to RX queue structure. + * @param hash_rxq + * Pointer to hash RX queue structure. */ -void -rxq_allmulticast_disable(struct rxq *rxq) +static void +hash_rxq_allmulticast_disable(struct hash_rxq *hash_rxq) { - if (rxq->allmulti_flow == NULL) + if (hash_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); + DEBUG("%p: disabling allmulticast mode", (void *)hash_rxq); + claim_zero(ibv_exp_destroy_flow(hash_rxq->allmulti_flow)); + hash_rxq->allmulti_flow = NULL; + DEBUG("%p: allmulticast mode disabled", (void *)hash_rxq); +} + +/** + * Disable allmulti mode in all hash RX queues. + * + * @param priv + * Private structure. + */ +void +priv_allmulticast_disable(struct priv *priv) +{ + unsigned int i; + + for (i = 0; (i != priv->hash_rxqs_n); ++i) + hash_rxq_allmulticast_disable(&(*priv->hash_rxqs)[i]); } /** @@ -295,17 +358,9 @@ void mlx5_allmulticast_disable(struct rte_eth_dev *dev) { struct priv *priv = dev->data->dev_private; - unsigned int i; 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: + priv_allmulticast_disable(priv); priv_unlock(priv); }