net/bonding: fix offloading configuration

[dpdk.git] / drivers / net / bonding / rte_eth_bond_pmd.c

diff --git a/drivers/net/bonding/rte_eth_bond_pmd.c b/drivers/net/bonding/rte_eth_bond_pmd.c
index 6831fcb..0f11a2f 100644 (file)
--- a/drivers/net/bonding/rte_eth_bond_pmd.c
+++ b/drivers/net/bonding/rte_eth_bond_pmd.c
@@ -112,7 +112,7 @@ is_lacp_packets(uint16_t ethertype, uint8_t subtype, struct rte_mbuf *mbuf)
        const uint16_t ether_type_slow_be =
                rte_be_to_cpu_16(RTE_ETHER_TYPE_SLOW);
 
-       return !((mbuf->ol_flags & PKT_RX_VLAN) ? mbuf->vlan_tci : 0) &&
+       return !((mbuf->ol_flags & RTE_MBUF_F_RX_VLAN) ? mbuf->vlan_tci : 0) &&
                (ethertype == ether_type_slow_be &&
                (subtype == SLOW_SUBTYPE_MARKER || subtype == SLOW_SUBTYPE_LACP));
 }
@@ -1369,8 +1369,8 @@ link_properties_set(struct rte_eth_dev *ethdev, struct rte_eth_link *slave_link)
                 * In any other mode the link properties are set to default
                 * values of AUTONEG/DUPLEX
                 */
-               ethdev->data->dev_link.link_autoneg = ETH_LINK_AUTONEG;
-               ethdev->data->dev_link.link_duplex = ETH_LINK_FULL_DUPLEX;
+               ethdev->data->dev_link.link_autoneg = RTE_ETH_LINK_AUTONEG;
+               ethdev->data->dev_link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
        }
 }
 
@@ -1700,15 +1700,12 @@ slave_configure(struct rte_eth_dev *bonded_eth_dev,
                slave_eth_dev->data->dev_conf.intr_conf.lsc = 1;
 
        /* If RSS is enabled for bonding, try to enable it for slaves  */
-       if (bonded_eth_dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG) {
-               if (internals->rss_key_len != 0) {
-                       slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len =
+       if (bonded_eth_dev->data->dev_conf.rxmode.mq_mode & RTE_ETH_MQ_RX_RSS_FLAG) {
+               /* rss_key won't be empty if RSS is configured in bonded dev */
+               slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len =
                                        internals->rss_key_len;
-                       slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key =
+               slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key =
                                        internals->rss_key;
-               } else {
-                       slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key = NULL;
-               }
 
                slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf =
                                bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf;
@@ -1716,24 +1713,23 @@ slave_configure(struct rte_eth_dev *bonded_eth_dev,
                                bonded_eth_dev->data->dev_conf.rxmode.mq_mode;
        }
 
-       if (bonded_eth_dev->data->dev_conf.rxmode.offloads &
-                       DEV_RX_OFFLOAD_VLAN_FILTER)
-               slave_eth_dev->data->dev_conf.rxmode.offloads |=
-                               DEV_RX_OFFLOAD_VLAN_FILTER;
-       else
-               slave_eth_dev->data->dev_conf.rxmode.offloads &=
-                               ~DEV_RX_OFFLOAD_VLAN_FILTER;
+       slave_eth_dev->data->dev_conf.rxmode.mtu =
+                       bonded_eth_dev->data->dev_conf.rxmode.mtu;
 
-       slave_eth_dev->data->dev_conf.rxmode.max_rx_pkt_len =
-                       bonded_eth_dev->data->dev_conf.rxmode.max_rx_pkt_len;
+       slave_eth_dev->data->dev_conf.txmode.offloads |=
+               bonded_eth_dev->data->dev_conf.txmode.offloads;
+
+       slave_eth_dev->data->dev_conf.txmode.offloads &=
+               (bonded_eth_dev->data->dev_conf.txmode.offloads |
+               ~internals->tx_offload_capa);
+
+       slave_eth_dev->data->dev_conf.rxmode.offloads |=
+               bonded_eth_dev->data->dev_conf.rxmode.offloads;
+
+       slave_eth_dev->data->dev_conf.rxmode.offloads &=
+               (bonded_eth_dev->data->dev_conf.rxmode.offloads |
+               ~internals->rx_offload_capa);
 
-       if (bonded_eth_dev->data->dev_conf.rxmode.offloads &
-                       DEV_RX_OFFLOAD_JUMBO_FRAME)
-               slave_eth_dev->data->dev_conf.rxmode.offloads |=
-                               DEV_RX_OFFLOAD_JUMBO_FRAME;
-       else
-               slave_eth_dev->data->dev_conf.rxmode.offloads &=
-                               ~DEV_RX_OFFLOAD_JUMBO_FRAME;
 
        nb_rx_queues = bonded_eth_dev->data->nb_rx_queues;
        nb_tx_queues = bonded_eth_dev->data->nb_tx_queues;
@@ -1834,7 +1830,7 @@ slave_configure(struct rte_eth_dev *bonded_eth_dev,
        }
 
        /* If RSS is enabled for bonding, synchronize RETA */
-       if (bonded_eth_dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS) {
+       if (bonded_eth_dev->data->dev_conf.rxmode.mq_mode & RTE_ETH_MQ_RX_RSS) {
                int i;
                struct bond_dev_private *internals;
 
@@ -1957,7 +1953,7 @@ bond_ethdev_start(struct rte_eth_dev *eth_dev)
                return -1;
        }
 
-       eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
+       eth_dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
        eth_dev->data->dev_started = 1;
 
        internals = eth_dev->data->dev_private;
@@ -2097,7 +2093,7 @@ bond_ethdev_stop(struct rte_eth_dev *eth_dev)
                        tlb_last_obytets[internals->active_slaves[i]] = 0;
        }
 
-       eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
+       eth_dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
        eth_dev->data->dev_started = 0;
 
        internals->link_status_polling_enabled = 0;
@@ -2251,6 +2247,7 @@ bond_ethdev_info(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
        dev_info->flow_type_rss_offloads = internals->flow_type_rss_offloads;
 
        dev_info->reta_size = internals->reta_size;
+       dev_info->hash_key_size = internals->rss_key_len;
 
        return 0;
 }
@@ -2332,8 +2329,10 @@ bond_ethdev_tx_queue_setup(struct rte_eth_dev *dev, uint16_t tx_queue_id,
 }
 
 static void
-bond_ethdev_rx_queue_release(void *queue)
+bond_ethdev_rx_queue_release(struct rte_eth_dev *dev, uint16_t queue_id)
 {
+       void *queue = dev->data->rx_queues[queue_id];
+
        if (queue == NULL)
                return;
 
@@ -2341,8 +2340,10 @@ bond_ethdev_rx_queue_release(void *queue)
 }
 
 static void
-bond_ethdev_tx_queue_release(void *queue)
+bond_ethdev_tx_queue_release(struct rte_eth_dev *dev, uint16_t queue_id)
 {
+       void *queue = dev->data->tx_queues[queue_id];
+
        if (queue == NULL)
                return;
 
@@ -2422,15 +2423,15 @@ bond_ethdev_link_update(struct rte_eth_dev *ethdev, int wait_to_complete)
 
        bond_ctx = ethdev->data->dev_private;
 
-       ethdev->data->dev_link.link_speed = ETH_SPEED_NUM_NONE;
+       ethdev->data->dev_link.link_speed = RTE_ETH_SPEED_NUM_NONE;
 
        if (ethdev->data->dev_started == 0 ||
                        bond_ctx->active_slave_count == 0) {
-               ethdev->data->dev_link.link_status = ETH_LINK_DOWN;
+               ethdev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
                return 0;
        }
 
-       ethdev->data->dev_link.link_status = ETH_LINK_UP;
+       ethdev->data->dev_link.link_status = RTE_ETH_LINK_UP;
 
        if (wait_to_complete)
                link_update = rte_eth_link_get;
@@ -2455,7 +2456,7 @@ bond_ethdev_link_update(struct rte_eth_dev *ethdev, int wait_to_complete)
                                          &slave_link);
                        if (ret < 0) {
                                ethdev->data->dev_link.link_speed =
-                                       ETH_SPEED_NUM_NONE;
+                                       RTE_ETH_SPEED_NUM_NONE;
                                RTE_BOND_LOG(ERR,
                                        "Slave (port %u) link get failed: %s",
                                        bond_ctx->active_slaves[idx],
@@ -2497,7 +2498,7 @@ bond_ethdev_link_update(struct rte_eth_dev *ethdev, int wait_to_complete)
                 * In theses mode the maximum theoretical link speed is the sum
                 * of all the slaves
                 */
-               ethdev->data->dev_link.link_speed = ETH_SPEED_NUM_NONE;
+               ethdev->data->dev_link.link_speed = RTE_ETH_SPEED_NUM_NONE;
                one_link_update_succeeded = false;
 
                for (idx = 0; idx < bond_ctx->active_slave_count; idx++) {
@@ -2871,7 +2872,7 @@ bond_ethdev_lsc_event_callback(uint16_t port_id, enum rte_eth_event_type type,
                        goto link_update;
 
                /* check link state properties if bonded link is up*/
-               if (bonded_eth_dev->data->dev_link.link_status == ETH_LINK_UP) {
+               if (bonded_eth_dev->data->dev_link.link_status == RTE_ETH_LINK_UP) {
                        if (link_properties_valid(bonded_eth_dev, &link) != 0)
                                RTE_BOND_LOG(ERR, "Invalid link properties "
                                             "for slave %d in bonding mode %d",
@@ -2887,7 +2888,7 @@ bond_ethdev_lsc_event_callback(uint16_t port_id, enum rte_eth_event_type type,
                if (internals->active_slave_count < 1) {
                        /* If first active slave, then change link status */
                        bonded_eth_dev->data->dev_link.link_status =
-                                                               ETH_LINK_UP;
+                                                               RTE_ETH_LINK_UP;
                        internals->current_primary_port = port_id;
                        lsc_flag = 1;
 
@@ -2979,12 +2980,12 @@ bond_ethdev_rss_reta_update(struct rte_eth_dev *dev,
                return -EINVAL;
 
         /* Copy RETA table */
-       reta_count = (reta_size + RTE_RETA_GROUP_SIZE - 1) /
-                       RTE_RETA_GROUP_SIZE;
+       reta_count = (reta_size + RTE_ETH_RETA_GROUP_SIZE - 1) /
+                       RTE_ETH_RETA_GROUP_SIZE;
 
        for (i = 0; i < reta_count; i++) {
                internals->reta_conf[i].mask = reta_conf[i].mask;
-               for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
+               for (j = 0; j < RTE_ETH_RETA_GROUP_SIZE; j++)
                        if ((reta_conf[i].mask >> j) & 0x01)
                                internals->reta_conf[i].reta[j] = reta_conf[i].reta[j];
        }
@@ -3017,8 +3018,8 @@ bond_ethdev_rss_reta_query(struct rte_eth_dev *dev,
                return -EINVAL;
 
         /* Copy RETA table */
-       for (i = 0; i < reta_size / RTE_RETA_GROUP_SIZE; i++)
-               for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
+       for (i = 0; i < reta_size / RTE_ETH_RETA_GROUP_SIZE; i++)
+               for (j = 0; j < RTE_ETH_RETA_GROUP_SIZE; j++)
                        if ((reta_conf[i].mask >> j) & 0x01)
                                reta_conf[i].reta[j] = internals->reta_conf[i].reta[j];
 
@@ -3040,13 +3041,15 @@ bond_ethdev_rss_hash_update(struct rte_eth_dev *dev,
        if (bond_rss_conf.rss_hf != 0)
                dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf = bond_rss_conf.rss_hf;
 
-       if (bond_rss_conf.rss_key && bond_rss_conf.rss_key_len <
-                       sizeof(internals->rss_key)) {
-               if (bond_rss_conf.rss_key_len == 0)
-                       bond_rss_conf.rss_key_len = 40;
-               internals->rss_key_len = bond_rss_conf.rss_key_len;
+       if (bond_rss_conf.rss_key) {
+               if (bond_rss_conf.rss_key_len < internals->rss_key_len)
+                       return -EINVAL;
+               else if (bond_rss_conf.rss_key_len > internals->rss_key_len)
+                       RTE_BOND_LOG(WARNING, "rss_key will be truncated");
+
                memcpy(internals->rss_key, bond_rss_conf.rss_key,
                                internals->rss_key_len);
+               bond_rss_conf.rss_key_len = internals->rss_key_len;
        }
 
        for (i = 0; i < internals->slave_count; i++) {
@@ -3278,7 +3281,7 @@ bond_alloc(struct rte_vdev_device *dev, uint8_t mode)
        internals->max_rx_pktlen = 0;
 
        /* Initially allow to choose any offload type */
-       internals->flow_type_rss_offloads = ETH_RSS_PROTO_MASK;
+       internals->flow_type_rss_offloads = RTE_ETH_RSS_PROTO_MASK;
 
        memset(&internals->default_rxconf, 0,
               sizeof(internals->default_rxconf));
@@ -3502,27 +3505,37 @@ bond_ethdev_configure(struct rte_eth_dev *dev)
 
        /*
         * If RSS is enabled, fill table with default values and
-        * set key to the the value specified in port RSS configuration.
+        * set key to the value specified in port RSS configuration.
         * Fall back to default RSS key if the key is not specified
         */
-       if (dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS) {
-               if (dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key != NULL) {
-                       internals->rss_key_len =
-                               dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len;
-                       memcpy(internals->rss_key,
-                              dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key,
+       if (dev->data->dev_conf.rxmode.mq_mode & RTE_ETH_MQ_RX_RSS) {
+               struct rte_eth_rss_conf *rss_conf =
+                       &dev->data->dev_conf.rx_adv_conf.rss_conf;
+               if (rss_conf->rss_key != NULL) {
+                       if (internals->rss_key_len > rss_conf->rss_key_len) {
+                               RTE_BOND_LOG(ERR, "Invalid rss key length(%u)",
+                                               rss_conf->rss_key_len);
+                               return -EINVAL;
+                       }
+
+                       memcpy(internals->rss_key, rss_conf->rss_key,
                               internals->rss_key_len);
                } else {
-                       internals->rss_key_len = sizeof(default_rss_key);
+                       if (internals->rss_key_len > sizeof(default_rss_key)) {
+                               RTE_BOND_LOG(ERR,
+                                      "There is no suitable default hash key");
+                               return -EINVAL;
+                       }
+
                        memcpy(internals->rss_key, default_rss_key,
                               internals->rss_key_len);
                }
 
                for (i = 0; i < RTE_DIM(internals->reta_conf); i++) {
                        internals->reta_conf[i].mask = ~0LL;
-                       for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
+                       for (j = 0; j < RTE_ETH_RETA_GROUP_SIZE; j++)
                                internals->reta_conf[i].reta[j] =
-                                               (i * RTE_RETA_GROUP_SIZE + j) %
+                                               (i * RTE_ETH_RETA_GROUP_SIZE + j) %
                                                dev->data->nb_rx_queues;
                }
        }