[PATCH] net/ice: fix statistics read error

[PATCH] net/ice: fix statistics read error

[Zhichao Zeng]

The statistics contain 40 bits. The lower 32 bits are read first, followed
by the upper 8 bits.

In some cases, after reading the lower 32 bits, a carry occurs from the
lower bits, which causes the final statistics to be incorrect.

This commit fixes this issue.

Fixes: a37bde56314d ("net/ice: support statistics")
Cc: stable@dpdk.org

Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>
---
 drivers/net/intel/ice/ice_ethdev.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/drivers/net/intel/ice/ice_ethdev.c b/drivers/net/intel/ice/ice_ethdev.c
index 513777e372..be08be0826 100644
--- a/drivers/net/intel/ice/ice_ethdev.c
+++ b/drivers/net/intel/ice/ice_ethdev.c
@@ -6036,10 +6036,19 @@ ice_stat_update_40(struct ice_hw *hw,
 		   uint64_t *stat)
 {
 	uint64_t new_data;
+	uint32_t lo, hi, lo2;
 
-	new_data = (uint64_t)ICE_READ_REG(hw, loreg);
-	new_data |= (uint64_t)(ICE_READ_REG(hw, hireg) & ICE_8_BIT_MASK) <<
-		    ICE_32_BIT_WIDTH;
+	lo = ICE_READ_REG(hw, loreg);
+	hi = ICE_READ_REG(hw, hireg);
+	lo2 = ICE_READ_REG(hw, loreg);
+
+	if (lo2 < lo) {
+		lo = ICE_READ_REG(hw, loreg);
+		hi = ICE_READ_REG(hw, hireg);
+	}
+
+	new_data = (uint64_t)lo;
+	new_data |= (uint64_t)(hi & ICE_8_BIT_MASK) << ICE_32_BIT_WIDTH;
 
 	if (!offset_loaded)
 		*offset = new_data;
-- 
2.34.1

Re: [PATCH] net/ice: fix statistics read error

[Bruce Richardson]

On Fri, Nov 07, 2025 at 03:43:38PM +0800, Zhichao Zeng wrote:
> The statistics contain 40 bits. The lower 32 bits are read first, followed
> by the upper 8 bits.
> 
> In some cases, after reading the lower 32 bits, a carry occurs from the
> lower bits, which causes the final statistics to be incorrect.
> 
> This commit fixes this issue.
> 
> Fixes: a37bde56314d ("net/ice: support statistics")
> Cc: stable@dpdk.org
> 
> Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>
> ---

See comments inline below.

/Bruce

>  drivers/net/intel/ice/ice_ethdev.c | 15 ++++++++++++---
>  1 file changed, 12 insertions(+), 3 deletions(-)
> 
> diff --git a/drivers/net/intel/ice/ice_ethdev.c b/drivers/net/intel/ice/ice_ethdev.c
> index 513777e372..be08be0826 100644
> --- a/drivers/net/intel/ice/ice_ethdev.c
> +++ b/drivers/net/intel/ice/ice_ethdev.c
> @@ -6036,10 +6036,19 @@ ice_stat_update_40(struct ice_hw *hw,
>  		   uint64_t *stat)
>  {
>  	uint64_t new_data;
> +	uint32_t lo, hi, lo2;
>  
> -	new_data = (uint64_t)ICE_READ_REG(hw, loreg);
> -	new_data |= (uint64_t)(ICE_READ_REG(hw, hireg) & ICE_8_BIT_MASK) <<
> -		    ICE_32_BIT_WIDTH;
> +	lo = ICE_READ_REG(hw, loreg);
> +	hi = ICE_READ_REG(hw, hireg);
> +	lo2 = ICE_READ_REG(hw, loreg);
> +
> +	if (lo2 < lo) {
> +		lo = ICE_READ_REG(hw, loreg);
> +		hi = ICE_READ_REG(hw, hireg);
> +	}
> +

While I can't see multiple wrap-arounds occuring, it is theoretically
possible e.g. if a process gets context switched out. Therefore, I think
using a "while" construction would be better. For example:

	uint32_t lo_old, hi, lo;
	do {
		lo_old = ...
		hi = ...
		lo = ...
	} while (lo_old > lo);

> +	new_data = (uint64_t)lo;
> +	new_data |= (uint64_t)(hi & ICE_8_BIT_MASK) << ICE_32_BIT_WIDTH;
>  

Using "lo" rather than "lo2" here means we are returning data we know is
old. We should be returning the second value read. Suggest using something
like what I suggest above, where we make "lo" the second read rather than
the first.

>  	if (!offset_loaded)
>  		*offset = new_data;
> -- 
> 2.34.1
> 

[PATCH v2] net/ice: fix statistics read error

[Zhichao Zeng]

The statistics contain 40 bits. The lower 32 bits are read first, followed
by the upper 8 bits.

In some cases, after reading the lower 32 bits, a carry occurs from
the lower bits, which causes the final statistics to be incorrect.

This commit fixes this issue.

Fixes: a37bde56314d ("net/ice: support statistics")
Cc: stable@dpdk.org

Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>

---
v2: replace single retries with loops
---
 drivers/net/intel/ice/ice_ethdev.c | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/drivers/net/intel/ice/ice_ethdev.c b/drivers/net/intel/ice/ice_ethdev.c
index 4669eba7c7..016b25c63a 100644
--- a/drivers/net/intel/ice/ice_ethdev.c
+++ b/drivers/net/intel/ice/ice_ethdev.c
@@ -6351,10 +6351,16 @@ ice_stat_update_40(struct ice_hw *hw,
 		   uint64_t *stat)
 {
 	uint64_t new_data;
+	uint32_t lo_old, hi, lo;
 
-	new_data = (uint64_t)ICE_READ_REG(hw, loreg);
-	new_data |= (uint64_t)(ICE_READ_REG(hw, hireg) & ICE_8_BIT_MASK) <<
-		    ICE_32_BIT_WIDTH;
+	do {
+		lo_old = ICE_READ_REG(hw, loreg);
+		hi = ICE_READ_REG(hw, hireg);
+		lo = ICE_READ_REG(hw, loreg);
+	} while (lo_old > lo);
+
+	new_data = (uint64_t)lo;
+	new_data |= (uint64_t)(hi & ICE_8_BIT_MASK) << ICE_32_BIT_WIDTH;
 
 	if (!offset_loaded)
 		*offset = new_data;
@@ -6363,10 +6369,8 @@ ice_stat_update_40(struct ice_hw *hw,
 		*stat = new_data - *offset;
 	else
 		*stat = (uint64_t)((new_data +
-				    ((uint64_t)1 << ICE_40_BIT_WIDTH)) -
-				   *offset);
-
-	*stat &= ICE_40_BIT_MASK;
+					((uint64_t)1 << ICE_32_BIT_WIDTH))
+				   - *offset);
 }
 
 /**
-- 
2.34.1

Re: [PATCH v2] net/ice: fix statistics read error

[Bruce Richardson]

On Mon, Nov 10, 2025 at 04:05:14PM +0800, Zhichao Zeng wrote:
> The statistics contain 40 bits. The lower 32 bits are read first, followed
> by the upper 8 bits.
> 
> In some cases, after reading the lower 32 bits, a carry occurs from
> the lower bits, which causes the final statistics to be incorrect.
> 
> This commit fixes this issue.
> 
> Fixes: a37bde56314d ("net/ice: support statistics")
> Cc: stable@dpdk.org
> 
> Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>
> 
> ---
> v2: replace single retries with loops
> ---
>  drivers/net/intel/ice/ice_ethdev.c | 18 +++++++++++-------
>  1 file changed, 11 insertions(+), 7 deletions(-)
> 
> diff --git a/drivers/net/intel/ice/ice_ethdev.c b/drivers/net/intel/ice/ice_ethdev.c
> index 4669eba7c7..016b25c63a 100644
> --- a/drivers/net/intel/ice/ice_ethdev.c
> +++ b/drivers/net/intel/ice/ice_ethdev.c
> @@ -6351,10 +6351,16 @@ ice_stat_update_40(struct ice_hw *hw,
>  		   uint64_t *stat)
>  {
>  	uint64_t new_data;
> +	uint32_t lo_old, hi, lo;
>  
> -	new_data = (uint64_t)ICE_READ_REG(hw, loreg);
> -	new_data |= (uint64_t)(ICE_READ_REG(hw, hireg) & ICE_8_BIT_MASK) <<
> -		    ICE_32_BIT_WIDTH;
> +	do {
> +		lo_old = ICE_READ_REG(hw, loreg);
> +		hi = ICE_READ_REG(hw, hireg);
> +		lo = ICE_READ_REG(hw, loreg);
> +	} while (lo_old > lo);
> +
> +	new_data = (uint64_t)lo;
> +	new_data |= (uint64_t)(hi & ICE_8_BIT_MASK) << ICE_32_BIT_WIDTH;
>  
>  	if (!offset_loaded)
>  		*offset = new_data;
> @@ -6363,10 +6369,8 @@ ice_stat_update_40(struct ice_hw *hw,
>  		*stat = new_data - *offset;
>  	else
>  		*stat = (uint64_t)((new_data +
> -				    ((uint64_t)1 << ICE_40_BIT_WIDTH)) -
> -				   *offset);
> -
> -	*stat &= ICE_40_BIT_MASK;
> +					((uint64_t)1 << ICE_32_BIT_WIDTH))
> +				   - *offset);

This part wasn't in v1, was it? It looks wrong to me, and the original code
looks correct. Given that offset and new_data should both be 40-bit
quantities, any wraparound would be at 40-bits rather than 32-bits no? Can
you explain why we would use a 32-bit shift here?

>  }
>  
>  /**
> -- 
> 2.34.1
> 

回复: [PATCH v2] net/ice: fix statistics read error

[Zeng, ZhichaoX]

[-- Attachment #1: Type: text/plain, Size: 3089 bytes --]

Hi Bruce,

Thank you for your comments and you're right.

My apologies―since this patch was submitted some time ago, I lost track of the context when sending v2 and made an incorrect modification. I'll remove the erroneous code.


Regards

Zhichao

________________________________
发件人: Richardson, Bruce <bruce.richardson@intel.com>
已发送: 2025 年 11 月 12 日 星期三 20:04
收件人: Zeng, ZhichaoX <zhichaox.zeng@intel.com>
抄送: dev@dpdk.org <dev@dpdk.org>; stable@dpdk.org <stable@dpdk.org>; Burakov, Anatoly <anatoly.burakov@intel.com>; Jeff Guo <jia.guo@intel.com>; Ferruh Yigit <ferruh.yigit@amd.com>; Wenzhuo Lu <wenzhuo.lu@intel.com>
主题: Re: [PATCH v2] net/ice: fix statistics read error

On Mon, Nov 10, 2025 at 04:05:14PM +0800, Zhichao Zeng wrote:
> The statistics contain 40 bits. The lower 32 bits are read first, followed
> by the upper 8 bits.
>
> In some cases, after reading the lower 32 bits, a carry occurs from
> the lower bits, which causes the final statistics to be incorrect.
>
> This commit fixes this issue.
>
> Fixes: a37bde56314d ("net/ice: support statistics")
> Cc: stable@dpdk.org
>
> Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>
>
> ---
> v2: replace single retries with loops
> ---
>  drivers/net/intel/ice/ice_ethdev.c | 18 +++++++++++-------
>  1 file changed, 11 insertions(+), 7 deletions(-)
>
> diff --git a/drivers/net/intel/ice/ice_ethdev.c b/drivers/net/intel/ice/ice_ethdev.c
> index 4669eba7c7..016b25c63a 100644
> --- a/drivers/net/intel/ice/ice_ethdev.c
> +++ b/drivers/net/intel/ice/ice_ethdev.c
> @@ -6351,10 +6351,16 @@ ice_stat_update_40(struct ice_hw *hw,
>                   uint64_t *stat)
>  {
>        uint64_t new_data;
> +     uint32_t lo_old, hi, lo;
>
> -     new_data = (uint64_t)ICE_READ_REG(hw, loreg);
> -     new_data |= (uint64_t)(ICE_READ_REG(hw, hireg) & ICE_8_BIT_MASK) <<
> -                 ICE_32_BIT_WIDTH;
> +     do {
> +             lo_old = ICE_READ_REG(hw, loreg);
> +             hi = ICE_READ_REG(hw, hireg);
> +             lo = ICE_READ_REG(hw, loreg);
> +     } while (lo_old > lo);
> +
> +     new_data = (uint64_t)lo;
> +     new_data |= (uint64_t)(hi & ICE_8_BIT_MASK) << ICE_32_BIT_WIDTH;
>
>        if (!offset_loaded)
>                *offset = new_data;
> @@ -6363,10 +6369,8 @@ ice_stat_update_40(struct ice_hw *hw,
>                *stat = new_data - *offset;
>        else
>                *stat = (uint64_t)((new_data +
> -                                 ((uint64_t)1 << ICE_40_BIT_WIDTH)) -
> -                                *offset);
> -
> -     *stat &= ICE_40_BIT_MASK;
> +                                     ((uint64_t)1 << ICE_32_BIT_WIDTH))
> +                                - *offset);

This part wasn't in v1, was it? It looks wrong to me, and the original code
looks correct. Given that offset and new_data should both be 40-bit
quantities, any wraparound would be at 40-bits rather than 32-bits no? Can
you explain why we would use a 32-bit shift here?

>  }
>
>  /**
> --
> 2.34.1
>

[-- Attachment #2: Type: text/html, Size: 7262 bytes --]

[PATCH v3] net/ice: fix statistics read error

[Zhichao Zeng]

The statistics contain 40 bits. The lower 32 bits are read first, followed
by the upper 8 bits.

In some cases, after reading the lower 32 bits, a carry occurs from
the lower bits, which causes the final statistics to be incorrect.

This commit fixes this issue.

Fixes: a37bde56314d ("net/ice: support statistics")
Cc: stable@dpdk.org

Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>

---
v2: replace single retries with loops
v3: fix wrong logic
---
 drivers/net/intel/ice/ice_ethdev.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/drivers/net/intel/ice/ice_ethdev.c b/drivers/net/intel/ice/ice_ethdev.c
index 4669eba7c7..5ec57ee2b0 100644
--- a/drivers/net/intel/ice/ice_ethdev.c
+++ b/drivers/net/intel/ice/ice_ethdev.c
@@ -6351,10 +6351,16 @@ ice_stat_update_40(struct ice_hw *hw,
 		   uint64_t *stat)
 {
 	uint64_t new_data;
+	uint32_t lo_old, hi, lo;
 
-	new_data = (uint64_t)ICE_READ_REG(hw, loreg);
-	new_data |= (uint64_t)(ICE_READ_REG(hw, hireg) & ICE_8_BIT_MASK) <<
-		    ICE_32_BIT_WIDTH;
+	do {
+		lo_old = ICE_READ_REG(hw, loreg);
+		hi = ICE_READ_REG(hw, hireg);
+		lo = ICE_READ_REG(hw, loreg);
+	} while (lo_old > lo);
+
+	new_data = (uint64_t)lo;
+	new_data |= (uint64_t)(hi & ICE_8_BIT_MASK) << ICE_32_BIT_WIDTH;
 
 	if (!offset_loaded)
 		*offset = new_data;
-- 
2.34.1

Re: [PATCH v3] net/ice: fix statistics read error

[Bruce Richardson]

On Thu, Nov 13, 2025 at 03:47:10PM +0800, Zhichao Zeng wrote:
> The statistics contain 40 bits. The lower 32 bits are read first, followed
> by the upper 8 bits.
> 
> In some cases, after reading the lower 32 bits, a carry occurs from
> the lower bits, which causes the final statistics to be incorrect.
> 
> This commit fixes this issue.
> 
> Fixes: a37bde56314d ("net/ice: support statistics")
> Cc: stable@dpdk.org
> 
> Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>
> 
Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Re: [PATCH v3] net/ice: fix statistics read error

[Bruce Richardson]

On Thu, Nov 13, 2025 at 08:42:55AM +0000, Bruce Richardson wrote:
> On Thu, Nov 13, 2025 at 03:47:10PM +0800, Zhichao Zeng wrote:
> > The statistics contain 40 bits. The lower 32 bits are read first, followed
> > by the upper 8 bits.
> > 
> > In some cases, after reading the lower 32 bits, a carry occurs from
> > the lower bits, which causes the final statistics to be incorrect.
> > 
> > This commit fixes this issue.
> > 
> > Fixes: a37bde56314d ("net/ice: support statistics")
> > Cc: stable@dpdk.org
> > 
> > Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>
> > 
> Acked-by: Bruce Richardson <bruce.richardson@intel.com>

Applied to dpdk-next-net-intel

/Bruce

Re: [PATCH] net/ice: fix statistics read error

[Stephen Hemminger]

On Fri,  7 Nov 2025 15:43:38 +0800
Zhichao Zeng <zhichaox.zeng@intel.com> wrote:

> The statistics contain 40 bits. The lower 32 bits are read first, followed
> by the upper 8 bits.
> 
> In some cases, after reading the lower 32 bits, a carry occurs from the
> lower bits, which causes the final statistics to be incorrect.
> 
> This commit fixes this issue.
> 
> Fixes: a37bde56314d ("net/ice: support statistics")
> Cc: stable@dpdk.org
> 
> Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>

This works but may still have issues under really high load.
I have seen code like this (from ChatGPT)


/*
 * Safely read a 64-bit counter split across two 32-bit registers.
 * Handles rollover and avoids inconsistency if low overflows
 * between high and low reads.
 */
static inline uint64_t read_hw_counter_64(void)
{
    uint32_t hi1, lo, hi2;

    /*
     * Read high-low-high and check for wraparound:
     * if high changed, low overflowed during read — reread.
     */
    do {
        hi1 = read_reg32_high();
        lo  = read_reg32_low();
        hi2 = read_reg32_high();
    } while (hi1 != hi2);

    return ((uint64_t)hi1 << 32) | lo;
}

Re: [PATCH] net/ice: fix statistics read error

[Bruce Richardson]

On Thu, Nov 13, 2025 at 09:29:10AM -0800, Stephen Hemminger wrote:
> On Fri,  7 Nov 2025 15:43:38 +0800
> Zhichao Zeng <zhichaox.zeng@intel.com> wrote:
> 
> > The statistics contain 40 bits. The lower 32 bits are read first, followed
> > by the upper 8 bits.
> > 
> > In some cases, after reading the lower 32 bits, a carry occurs from the
> > lower bits, which causes the final statistics to be incorrect.
> > 
> > This commit fixes this issue.
> > 
> > Fixes: a37bde56314d ("net/ice: support statistics")
> > Cc: stable@dpdk.org
> > 
> > Signed-off-by: Zhichao Zeng <zhichaox.zeng@intel.com>
> 
> This works but may still have issues under really high load.
> I have seen code like this (from ChatGPT)
>

How is checking high for equality better? I considered when reviewing
having the high be double-read, but I though we'd get better accuracy by
reading the more frequency-changing counter (lo) last.

/Bruce
 
> 
> /*
>  * Safely read a 64-bit counter split across two 32-bit registers.
>  * Handles rollover and avoids inconsistency if low overflows
>  * between high and low reads.
>  */
> static inline uint64_t read_hw_counter_64(void)
> {
>     uint32_t hi1, lo, hi2;
> 
>     /*
>      * Read high-low-high and check for wraparound:
>      * if high changed, low overflowed during read — reread.
>      */
>     do {
>         hi1 = read_reg32_high();
>         lo  = read_reg32_low();
>         hi2 = read_reg32_high();
>     } while (hi1 != hi2);
> 
>     return ((uint64_t)hi1 << 32) | lo;
> }