system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-11-05 18:23:50 +00:00
Code Issues Projects Releases Packages Wiki Activity

iio: afe: rescale: reduce risk of integer overflow

Browse source 
Reduce the risk of integer overflow by doing the scale calculation on
a 64-bit integer. Since the rescaling is only performed on *val, reuse
the IIO_VAL_FRACTIONAL_LOG2 case.

Signed-off-by: Liam Beguin <liambeguin@gmail.com>
Reviewed-by: Peter Rosin <peda@axentia.se>
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
Link: https://lore.kernel.org/r/20220213025739.2561834-6-liambeguin@gmail.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
This commit is contained in:
Liam Beguin 2022-02-12 21:57:34 -05:00 committed by Jonathan Cameron
parent f5fc003d48
commit 2eb30577f2
1 changed files with 18 additions and 5 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
drivers/iio/afe/iio-rescale.c
View file

@ -24,21 +24,31 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
int *val, int *val2) int *val, int *val2)
{ {
s64 tmp; s64 tmp;
int _val, _val2;
s32 rem, rem2; s32 rem, rem2;
u32 mult; u32 mult;
u32 neg; u32 neg;
switch (scale_type) { switch (scale_type) {
case IIO_VAL_FRACTIONAL:
*val *= rescale->numerator;
*val2 *= rescale->denominator;
return scale_type;
case IIO_VAL_INT: case IIO_VAL_INT:
*val *= rescale->numerator; *val *= rescale->numerator;
if (rescale->denominator == 1) if (rescale->denominator == 1)
return scale_type; return scale_type;
*val2 = rescale->denominator; *val2 = rescale->denominator;
return IIO_VAL_FRACTIONAL; return IIO_VAL_FRACTIONAL;
case IIO_VAL_FRACTIONAL:
/*
* When the product of both scales doesn't overflow, avoid
* potential accuracy loss (for in kernel consumers) by
* keeping a fractional representation.
*/
if (!check_mul_overflow(*val, rescale->numerator, &_val) &&
!check_mul_overflow(*val2, rescale->denominator, &_val2)) {
*val = _val;
*val2 = _val2;
return IIO_VAL_FRACTIONAL;
}
fallthrough;
case IIO_VAL_FRACTIONAL_LOG2: case IIO_VAL_FRACTIONAL_LOG2:
tmp = (s64)*val * 1000000000LL; tmp = (s64)*val * 1000000000LL;
tmp = div_s64(tmp, rescale->denominator); tmp = div_s64(tmp, rescale->denominator);
@ -50,7 +60,10 @@ int rescale_process_scale(struct rescale *rescale, int scale_type,
if (!rem) if (!rem)
return scale_type; return scale_type;
tmp = 1 << *val2; if (scale_type == IIO_VAL_FRACTIONAL)
tmp = *val2;
else
tmp = ULL(1) << *val2;
rem2 = *val % (int)tmp; rem2 = *val % (int)tmp;
*val = *val / (int)tmp; *val = *val / (int)tmp;