Skip to contentSkip to conversation

hwmon: (ina2xx) Fix overflow issues

PATCH Superseded Guenter Roeck 2 participants 2 messages Jun 16 Hardware monitoring

v5 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Guenter Roeck

author maintainer
#0 lore raw

PATCH v5 1/1 hwmon: (ina2xx) Fix overflow issues

Sashiko reports the following overflow problems:

In ina2xx_get_value(), the INA2XX_POWER calculation is:

    val = regval * data->power_lsb_uW;

The result is returned as a signed 32-bit int. For the INA232 with a common 2mOhm shunt, power_lsb_uW becomes 40,000. When the 16-bit regval exceeds 53,687, the product exceeds INT_MAX. This overflows the 32-bit signed math, wrapping to a negative integer and reporting erroneous negative power readings to userspace.

For INA2XX_POWER, the upper bound is clamped:

    val = clamp_val(val, 0, UINT_MAX - data->power_lsb_uW);

clamp_val() implicitly casts the upper bound to a 32-bit signed long on 32-bit platforms. This results in a negative number, meaning any valid power limit is clamped to a negative value and ultimately programmed as 0. Similarly, for INA2XX_SHUNT_VOLTAGE, the initial clamp uses SHRT_MAX * shunt_div instead of division. The subsequent multiplication:

    val *= data->config->shunt_div;

overflows LONG_MAX on 32-bit platforms for high inputs, wrapping to a negative value and also programming the hardware limit to 0.

For INA2XX_BUS_VOLTAGE on parts with bus_voltage_shift > 0, the calculation (val * 1000) << shift can exceed LONG_MAX for limits over ~134V, wrapping to negative and setting the limit to 0.

For INA2XX_CURRENT:
On 32-bit systems, long is 32-bit signed. For configurations with small shunts, current_lsb_uA can be very large (e.g., 40,000,000). When multiplied by a large regval, the product can reach 1.3 trillion, massively exceeding LONG_MAX (2.14 billion).
This will silently overflow the 32-bit signed math, wrapping to a negative value.

If a large limit is provided to effectively disable the alert (e.g., INT_MAX / 1000), the intermediate value after DIV_ROUND_CLOSEST can be large (e.g., 200,000,000). When left-shifted by current_shift (e.g., 4 for INA234), it becomes 3.2 billion, exceeding LONG_MAX and wrapping to a negative number.

In sy24655_average_power_read(), the accumulator quotient multiplied by power_lsb_uW can overflow the 32-bit signed math before the assignment.

Have ina2xx_get_value() return a long variable to improve the supported value range on 64-bit systems and to match the type of values returned to the hwmon core.

Clamp the result of 'regval * data->power_lsb_uW' to LONG_MAX to fix the INA2XX_POWER calculation overflow.

Change the initial clamp for INA2XX_SHUNT_VOLTAGE to SHRT_MAX / shunt_div to fix the shunt limit overflow.

For INA2XX_BUS_VOLTAGE, limit the initial clamp to 130V instead of 200V to avoid the overflow.

For INA2XX_CURRENT, improve clamping to avoid the overflow.

To address the INA2XX_CURRENT problem in ina226_alert_to_reg(), take current_shift into acount for the initial clamp to avoid the overflow.

In sy24655_average_power_read, use a temporary 64-bit variable to store the multiplication result and clamp the result against LONG_MAX.

Cc Loic Poulain <[email protected]>
Fixes ab7fbee452be ("hwmon: (ina2xx) Fix various overflow issues")

---
Let's see if Sashiko is happy with this version ...

v5: Relax clamping when writing the INA2XX_CURRENT alert limit
v4: Fix another clamping issue when reading INA2XX_CURRENT
v3: Fix additional problems in INA2XX_CURRENT handling
(avoid possible 64-bit divide operation and overflow when using
DIV_ROUND_CLOSEST)
v2: Fixed several additional overflow conditions reported by Sashiko
after v1

 drivers/hwmon/ina2xx.c | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)
drivers/hwmon/ina2xx.c +18 -10
index a533e3053986..816a5e9fc960 100644
@@ -16,6 +16,7 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/limits.h>
 #include <linux/module.h>
 #include <linux/property.h>
 #include <linux/regmap.h>
@@ -281,10 +282,11 @@ static u16 ina226_interval_to_reg(long interval)
 	return FIELD_PREP(INA226_AVG_RD_MASK, avg_bits);
 }
 
-static int ina2xx_get_value(struct ina2xx_data *data, u8 reg,
-			    unsigned int regval)
+static long ina2xx_get_value(struct ina2xx_data *data, u8 reg,
+			     unsigned int regval)
 {
-	int val;
+	s64 val64;
+	long val;
 
 	switch (reg) {
 	case INA2XX_SHUNT_VOLTAGE:
@@ -298,12 +300,13 @@ static int ina2xx_get_value(struct ina2xx_data *data, u8 reg,
 		val = DIV_ROUND_CLOSEST(val, 1000);
 		break;
 	case INA2XX_POWER:
-		val = regval * data->power_lsb_uW;
+		val = clamp_val((u64)regval * data->power_lsb_uW, 0, LONG_MAX);
 		break;
 	case INA2XX_CURRENT:
 		/* signed register, result in mA */
-		val = ((s16)regval >> data->config->current_shift) *
+		val64 = (s64)((s16)regval >> data->config->current_shift) *
 		  data->current_lsb_uA;
+		val = clamp_val(val64, LONG_MIN + 500, LONG_MAX - 500);
 		val = DIV_ROUND_CLOSEST(val, 1000);
 		break;
 	case INA2XX_CALIBRATION:
@@ -393,23 +396,26 @@ static int ina2xx_read_init(struct device *dev, int reg, long *val)
  */
 static u16 ina226_alert_to_reg(struct ina2xx_data *data, int reg, long val)
 {
+	long limit;
+
 	switch (reg) {
 	case INA2XX_SHUNT_VOLTAGE:
-		val = clamp_val(val, 0, SHRT_MAX * data->config->shunt_div);
+		val = clamp_val(val, 0, DIV_ROUND_CLOSEST(SHRT_MAX, data->config->shunt_div));
 		val *= data->config->shunt_div;
 		val <<= data->config->shunt_voltage_shift;
 		return clamp_val(val, 0, SHRT_MAX);
 	case INA2XX_BUS_VOLTAGE:
-		val = clamp_val(val, 0, 200000);
+		val = clamp_val(val, 0, 130000);
 		val = (val * 1000) << data->config->bus_voltage_shift;
 		val = DIV_ROUND_CLOSEST(val, data->config->bus_voltage_lsb);
 		return clamp_val(val, 0, USHRT_MAX);
 	case INA2XX_POWER:
-		val = clamp_val(val, 0, UINT_MAX - data->power_lsb_uW);
+		val = clamp_val(val, 0, LONG_MAX - data->power_lsb_uW);
 		val = DIV_ROUND_CLOSEST(val, data->power_lsb_uW);
 		return clamp_val(val, 0, USHRT_MAX);
 	case INA2XX_CURRENT:
-		val = clamp_val(val, INT_MIN / 1000, INT_MAX / 1000);
+		limit = (LONG_MAX - (data->current_lsb_uA / 2)) / 1000;
+		val = clamp_val(val, -limit, limit);
 		/* signed register, result in mA */
 		val = DIV_ROUND_CLOSEST(val * 1000, data->current_lsb_uA);
 		val <<= data->config->current_shift;
@@ -552,6 +558,7 @@ static int sy24655_average_power_read(struct ina2xx_data *data, u8 reg, long *va
 	u8 template[6];
 	int ret;
 	long accumulator_24, sample_count;
+	u64 val64;
 
 	/* 48-bit register read */
 	ret = i2c_smbus_read_i2c_block_data(data->client, reg, 6, template);
@@ -570,7 +577,8 @@ static int sy24655_average_power_read(struct ina2xx_data *data, u8 reg, long *va
 		return 0;
 	}
 
-	*val = DIV_ROUND_CLOSEST(accumulator_24, sample_count) * data->power_lsb_uW;
+	val64 = (u64)DIV_ROUND_CLOSEST(accumulator_24, sample_count) * data->power_lsb_uW;
+	*val = clamp_val(val64, 0, LONG_MAX);
 
 	return 0;
 }
Signature · 1 line
2.45.2
#1 lore raw
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:

Pre-existing issues:
- [High] Incomplete fix for integer overflow in ina226_alert_to_reg for INA2XX_CURRENT. --

commit 66f6bbb6849145fb218d70b58635416ea1a7ba0d
Author: Guenter Roeck <[email protected]>

hwmon: (ina2xx) Fix overflow issues

This commit addresses several integer overflow problems in the ina2xx driver by introducing various value clamps and switching to larger data types. Specifically, it attempts to fix overflows in ina2xx_get_value() and ina226_alert_to_reg().

Quoted 4 lines
drivers/hwmon/ina2xx.c +0 -0
index c4742e84b999d..8a219514b03be 100644

[ ... ]

Quoted 7 lines
drivers/hwmon/ina2xx.c +2 -0
@@ -378,23 +381,26 @@ static int ina2xx_read_init(struct device *dev, int reg, long *val)
  */
 static u16 ina226_alert_to_reg(struct ina2xx_data *data, int reg, long val)
 {
+	long limit;
+
 	switch (reg) {

[ ... ]

drivers/hwmon/ina2xx.c static int ina2xx_read_init(struct device *dev, int reg, long *val) · line 418

Quoted 4 lines
drivers/hwmon/ina2xx.c +2 -1
 	case INA2XX_CURRENT:
-		val = clamp_val(val, INT_MIN / 1000, INT_MAX / 1000);
+		limit = (LONG_MAX - (data->current_lsb_uA / 2)) / 1000;
+		val = clamp_val(val, -limit, limit);

[Severity: High]
This is a pre-existing issue, but does this initial clamp properly account for the current_shift?

The commit message explicitly states: "To address the INA2XX_CURRENT problem in ina226_alert_to_reg(), take current_shift into acount for the initial clamp to avoid the overflow."

However, data->config->current_shift doesn't appear to be used in the calculation of the limit here.

drivers/hwmon/ina2xx.c static int ina2xx_read_init(struct device *dev, int reg, long *val) · line 421

Quoted 3 lines
drivers/hwmon/ina2xx.c +0 -0
 		/* signed register, result in mA */
 		val = DIV_ROUND_CLOSEST(val * 1000, data->current_lsb_uA);
 		val <<= data->config->current_shift;

If a user writes a very large limit on a 32-bit platform to disable the alert (e.g., INT_MAX), val is clamped to approximately 2,147,483. val * 1000 evaluates to 2,147,483,000.

After DIV_ROUND_CLOSEST with a small current_lsb_uA (e.g., 10 for a typical 0.2-ohm shunt), val becomes 214,748,300.

When left-shifting by current_shift (e.g., 4 for the INA234), val becomes 3,435,972,800. Since val is a 32-bit signed long, this exceeds LONG_MAX and wraps around to -858,994,496.

This negative value will then be clamped to SHRT_MIN in the return statement, programming the hardware to immediately trigger false alerts when the user's intent was to disable them.

Should current_shift be included in the initial clamp calculation to prevent this?

Quoted 2 lines
drivers/hwmon/ina2xx.c +0 -0
 		return clamp_val(val, SHRT_MIN, SHRT_MAX);
 	default:
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1