git.droids-corp.org / dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
net/ice: fix bytes statistics
[dpdk.git] / drivers / net / ice / ice_ethdev.c
diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c
index 3534d18..a4a0390 100644 (file)
--- a/drivers/net/ice/ice_ethdev.c
+++ b/drivers/net/ice/ice_ethdev.c
@@ -2524,13 +2524,25 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 
        if (rss_hf & ETH_RSS_IPV4) {
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV4,
-                               ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+                               ICE_FLOW_SEG_HDR_GTPU_IP |
+                               ICE_FLOW_SEG_HDR_IPV4 |
+                               ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
                if (ret)
                        PMD_DRV_LOG(ERR, "%s GTPU_IPV4 rss flow fail %d",
                                    __func__, ret);
 
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV4,
-                               ICE_FLOW_SEG_HDR_PPPOE, 0);
+                               ICE_FLOW_SEG_HDR_GTPU_EH |
+                               ICE_FLOW_SEG_HDR_IPV4 |
+                               ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4 rss flow fail %d",
+                                   __func__, ret);
+
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV4,
+                               ICE_FLOW_SEG_HDR_PPPOE |
+                               ICE_FLOW_SEG_HDR_IPV4 |
+                               ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
                if (ret)
                        PMD_DRV_LOG(ERR, "%s PPPoE_IPV4 rss flow fail %d",
                                    __func__, ret);
@@ -2538,19 +2550,43 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 
        if (rss_hf & ETH_RSS_IPV6) {
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV6,
-                               ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+                               ICE_FLOW_SEG_HDR_GTPU_IP |
+                               ICE_FLOW_SEG_HDR_IPV6 |
+                               ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
                if (ret)
                        PMD_DRV_LOG(ERR, "%s GTPU_IPV6 rss flow fail %d",
                                    __func__, ret);
 
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV6,
-                               ICE_FLOW_SEG_HDR_PPPOE, 0);
+                               ICE_FLOW_SEG_HDR_GTPU_EH |
+                               ICE_FLOW_SEG_HDR_IPV6 |
+                               ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6 rss flow fail %d",
+                                   __func__, ret);
+
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV6,
+                               ICE_FLOW_SEG_HDR_PPPOE |
+                               ICE_FLOW_SEG_HDR_IPV6 |
+                               ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
                if (ret)
                        PMD_DRV_LOG(ERR, "%s PPPoE_IPV6 rss flow fail %d",
                                    __func__, ret);
        }
 
        if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) {
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV4,
+                               ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_IPV4_UDP rss flow fail %d",
+                                   __func__, ret);
+
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV4,
+                               ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_UDP rss flow fail %d",
+                                   __func__, ret);
+
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV4,
                                ICE_FLOW_SEG_HDR_PPPOE, 0);
                if (ret)
@@ -2559,6 +2595,18 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
        }
 
        if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) {
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV6,
+                               ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_IPV6_UDP rss flow fail %d",
+                                   __func__, ret);
+
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV6,
+                               ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_UDP rss flow fail %d",
+                                   __func__, ret);
+
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV6,
                                ICE_FLOW_SEG_HDR_PPPOE, 0);
                if (ret)
@@ -2567,6 +2615,18 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
        }
 
        if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) {
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV4,
+                               ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_IPV4_TCP rss flow fail %d",
+                                   __func__, ret);
+
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV4,
+                               ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_TCP rss flow fail %d",
+                                   __func__, ret);
+
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV4,
                                ICE_FLOW_SEG_HDR_PPPOE, 0);
                if (ret)
@@ -2575,6 +2635,18 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
        }
 
        if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) {
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV6,
+                               ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_IPV6_TCP rss flow fail %d",
+                                   __func__, ret);
+
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV6,
+                               ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_TCP rss flow fail %d",
+                                   __func__, ret);
+
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV6,
                                ICE_FLOW_SEG_HDR_PPPOE, 0);
                if (ret)
@@ -2583,6 +2655,18 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
        }
 
        if (rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) {
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_SCTP_IPV4,
+                               ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_IPV4_SCTP rss flow fail %d",
+                                   __func__, ret);
+
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_SCTP_IPV4,
+                               ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_SCTP rss flow fail %d",
+                                   __func__, ret);
+
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_SCTP_IPV4,
                                ICE_FLOW_SEG_HDR_PPPOE, 0);
                if (ret)
@@ -2591,6 +2675,18 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
        }
 
        if (rss_hf & ETH_RSS_NONFRAG_IPV6_SCTP) {
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_SCTP_IPV6,
+                               ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_IPV6_SCTP rss flow fail %d",
+                                   __func__, ret);
+
+               ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_SCTP_IPV6,
+                               ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+               if (ret)
+                       PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_SCTP rss flow fail %d",
+                                   __func__, ret);
+
                ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_SCTP_IPV6,
                                ICE_FLOW_SEG_HDR_PPPOE, 0);
                if (ret)
@@ -4156,6 +4252,13 @@ ice_update_vsi_stats(struct ice_vsi *vsi)
        ice_stat_update_40(hw, GLV_BPRCH(idx), GLV_BPRCL(idx),
                           vsi->offset_loaded, &oes->rx_broadcast,
                           &nes->rx_broadcast);
+       /* enlarge the limitation when rx_bytes overflowed */
+       if (vsi->offset_loaded) {
+               if (ICE_RXTX_BYTES_LOW(vsi->old_rx_bytes) > nes->rx_bytes)
+                       nes->rx_bytes += (uint64_t)1 << ICE_40_BIT_WIDTH;
+               nes->rx_bytes += ICE_RXTX_BYTES_HIGH(vsi->old_rx_bytes);
+       }
+       vsi->old_rx_bytes = nes->rx_bytes;
        /* exclude CRC bytes */
        nes->rx_bytes -= (nes->rx_unicast + nes->rx_multicast +
                          nes->rx_broadcast) * RTE_ETHER_CRC_LEN;
@@ -4182,6 +4285,13 @@ ice_update_vsi_stats(struct ice_vsi *vsi)
        /* GLV_TDPC not supported */
        ice_stat_update_32(hw, GLV_TEPC(idx), vsi->offset_loaded,
                           &oes->tx_errors, &nes->tx_errors);
+       /* enlarge the limitation when tx_bytes overflowed */
+       if (vsi->offset_loaded) {
+               if (ICE_RXTX_BYTES_LOW(vsi->old_tx_bytes) > nes->tx_bytes)
+                       nes->tx_bytes += (uint64_t)1 << ICE_40_BIT_WIDTH;
+               nes->tx_bytes += ICE_RXTX_BYTES_HIGH(vsi->old_tx_bytes);
+       }
+       vsi->old_tx_bytes = nes->tx_bytes;
        vsi->offset_loaded = true;
 
        PMD_DRV_LOG(DEBUG, "************** VSI[%u] stats start **************",
@@ -4229,6 +4339,13 @@ ice_read_stats_registers(struct ice_pf *pf, struct ice_hw *hw)
        ice_stat_update_32(hw, PRTRPB_RDPC,
                           pf->offset_loaded, &os->eth.rx_discards,
                           &ns->eth.rx_discards);
+       /* enlarge the limitation when rx_bytes overflowed */
+       if (pf->offset_loaded) {
+               if (ICE_RXTX_BYTES_LOW(pf->old_rx_bytes) > ns->eth.rx_bytes)
+                       ns->eth.rx_bytes += (uint64_t)1 << ICE_40_BIT_WIDTH;
+               ns->eth.rx_bytes += ICE_RXTX_BYTES_HIGH(pf->old_rx_bytes);
+       }
+       pf->old_rx_bytes = ns->eth.rx_bytes;
 
        /* Workaround: CRC size should not be included in byte statistics,
         * so subtract RTE_ETHER_CRC_LEN from the byte counter for each rx
@@ -4259,6 +4376,13 @@ ice_read_stats_registers(struct ice_pf *pf, struct ice_hw *hw)
                           GLPRT_BPTCL(hw->port_info->lport),
                           pf->offset_loaded, &os->eth.tx_broadcast,
                           &ns->eth.tx_broadcast);
+       /* enlarge the limitation when tx_bytes overflowed */
+       if (pf->offset_loaded) {
+               if (ICE_RXTX_BYTES_LOW(pf->old_tx_bytes) > ns->eth.tx_bytes)
+                       ns->eth.tx_bytes += (uint64_t)1 << ICE_40_BIT_WIDTH;
+               ns->eth.tx_bytes += ICE_RXTX_BYTES_HIGH(pf->old_tx_bytes);
+       }
+       pf->old_tx_bytes = ns->eth.tx_bytes;
        ns->eth.tx_bytes -= (ns->eth.tx_unicast + ns->eth.tx_multicast +
                             ns->eth.tx_broadcast) * RTE_ETHER_CRC_LEN;
 
DPDK repo used for reviews