Commit c8299cb6 authored by Michal Nazarewicz's avatar Michal Nazarewicz Committed by Linus Torvalds

kernel.h: make abs() work with 64-bit types

For 64-bit arguments, the abs macro casts it to an int which leads to
lost precision and may cause incorrect results.  To deal with 64-bit
types abs64 macro has been introduced but still there are places where
abs macro is used incorrectly.

To deal with the problem, expand abs macro such that it operates on s64
type when dealing with 64-bit types while still returning long when
dealing with smaller types.

This fixes one known bug (per John):

The internal clocksteering done for fine-grained error correction uses a
: logarithmic approximation, so any time adjtimex() adjusts the clock
: steering, timekeeping_freqadjust() quickly approximates the correct clock
: frequency over a series of ticks.
:
: Unfortunately, the logic in timekeeping_freqadjust(), introduced in commit
: dc491596 (Rework frequency adjustments to work better w/ nohz),
: used the abs() function with a s64 error value to calculate the size of
: the approximated adjustment to be made.
:
: Per include/linux/kernel.h: "abs() should not be used for 64-bit types
: (s64, u64, long long) - use abs64()".
:
: Thus on 32-bit platforms, this resulted in the clocksteering to take a
: quite dampended random walk trying to converge on the proper frequency,
: which caused the adjustments to be made much slower then intended (most
: easily observed when large adjustments are made).
Signed-off-by: default avatarMichal Nazarewicz <mina86@mina86.com>
Reported-by: default avatarJohn Stultz <john.stultz@linaro.org>
Tested-by: default avatarJohn Stultz <john.stultz@linaro.org>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 9c2d5eeb
...@@ -200,28 +200,31 @@ extern int _cond_resched(void); ...@@ -200,28 +200,31 @@ extern int _cond_resched(void);
#define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0) #define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)
/* /**
* abs() handles unsigned and signed longs, ints, shorts and chars. For all * abs - return absolute value of an argument
* input types abs() returns a signed long. * @x: the value. If it is unsigned type, it is converted to signed type first
* abs() should not be used for 64-bit types (s64, u64, long long) - use abs64() * (s64, long or int depending on its size).
* for those. *
* Return: an absolute value of x. If x is 64-bit, macro's return type is s64,
* otherwise it is signed long.
*/ */
#define abs(x) ({ \ #define abs(x) __builtin_choose_expr(sizeof(x) == sizeof(s64), ({ \
long ret; \ s64 __x = (x); \
if (sizeof(x) == sizeof(long)) { \ (__x < 0) ? -__x : __x; \
long __x = (x); \ }), ({ \
ret = (__x < 0) ? -__x : __x; \ long ret; \
} else { \ if (sizeof(x) == sizeof(long)) { \
int __x = (x); \ long __x = (x); \
ret = (__x < 0) ? -__x : __x; \ ret = (__x < 0) ? -__x : __x; \
} \ } else { \
ret; \ int __x = (x); \
}) ret = (__x < 0) ? -__x : __x; \
} \
#define abs64(x) ({ \ ret; \
s64 __x = (x); \ }))
(__x < 0) ? -__x : __x; \
}) /* Deprecated, use abs instead. */
#define abs64(x) abs((s64)(x))
/** /**
* reciprocal_scale - "scale" a value into range [0, ep_ro) * reciprocal_scale - "scale" a value into range [0, ep_ro)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment