iopoll: avoid -Wint-in-bool-context warning
PATCH v2 1/1 iopoll: avoid -Wint-in-bool-context warning
When we pass the result of a multiplication as the timeout or the delay, we can get a warning:
drivers/mmc/host/bcm2835.c:596:149: error: '*' in boolean context, suggest '&&' instead [-Werror=int-in-bool-context] drivers/mfd/arizona-core.c:247:195: error: '*' in boolean context, suggest '&&' instead [-Werror=int-in-bool-context] drivers/gpu/drm/sun4i/sun4i_hdmi_i2c.c:49:27: error: '*' in boolean context, suggest '&&' instead [-Werror=int-in-bool-context]
The warning is a bit questionable inside of a macro, but this is intentional on the side of the gcc developers. It is also an indication of another problem: we evaluate the timeout and sleep arguments multiple times, which can have undesired side-effects when those are complex expressions.
This changes the three iopoll variants to use local variables for storing copies of the timeouts. This adds some more type safety, and avoids both the double-evaluation and the gcc warning.
---
v2: - use temporary variables instead of zero-comparison, to
avoid double evaluation
- also address the delay, not just timout handling
--- include/linux/iopoll.h | 24 +++++++++++++++--------- include/linux/regmap.h | 12 +++++++----- 2 files changed, 22 insertions(+), 14 deletions(-)
include/linux/iopoll.h +15 -9
@@ -42,18 +42,21 @@*/ #define readx_poll_timeout (op, addr, val, cond, sleep_us, timeout_us) \ ({ \ - ktime_t timeout = ktime_add_us(ktime_get(), timeout_us); \ - might_sleep_if(sleep_us); \ + u64 __timeout_us = (timeout_us); \ + unsigned long __sleep_us = (sleep_us); \ + ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \ + might_sleep_if((__sleep_us) != 0); \ for (;;) { \ (val) = op(addr); \ if (cond) \ break; \ - if (timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \ + if (__timeout_us && \ + ktime_compare(ktime_get(), __timeout) > 0) { \ (val) = op(addr); \ break; \ } \ - if (sleep_us) \ - usleep_range((sleep_us >> 2) + 1, sleep_us); \ + if (__sleep_us) \ + usleep_range((__sleep_us >> 2) + 1, __sleep_us); \ } \ (cond) ? 0 : -ETIMEDOUT; \ })
@@ -77,17 +80,20 @@*/ #define readx_poll_timeout_atomic (op, addr, val, cond, delay_us, timeout_us) \ ({ \ - ktime_t timeout = ktime_add_us(ktime_get(), timeout_us); \ + u64 __timeout_us = (timeout_us); \ + unsigned long __delay_us = (delay_us); \ + ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \ for (;;) { \ (val) = op(addr); \ if (cond) \ break; \ - if (timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \ + if (__timeout_us && \ + ktime_compare(ktime_get(), __timeout) > 0) { \ (val) = op(addr); \ break; \ } \ - if (delay_us) \ - udelay(delay_us); \ + if (__delay_us) \ + udelay(__delay_us); \ } \ (cond) ? 0 : -ETIMEDOUT; \ })
include/linux/regmap.h +7 -5
@@ -120,22 +120,24 @@ struct reg_sequence {*/ #define regmap_read_poll_timeout (map, addr, val, cond, sleep_us, timeout_us) \ ({ \ - ktime_t __timeout = ktime_add_us(ktime_get(), timeout_us); \ + u64 __timeout_us = (timeout_us); \ + unsigned long __sleep_us = (sleep_us); \ + ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \ int __ret; \ - might_sleep_if(sleep_us); \ + might_sleep_if(__sleep_us); \ for (;;) { \ __ret = regmap_read((map), (addr), &(val)); \ if (__ret) \ break; \ if (cond) \ break; \ - if ((timeout_us) && \ + if (__timeout_us && \ ktime_compare(ktime_get(), __timeout) > 0) { \ __ret = regmap_read((map), (addr), &(val)); \ break; \ } \ - if (sleep_us) \ - usleep_range(((sleep_us) >> 2) + 1, sleep_us); \ + if (__sleep_us) \ + usleep_range((__sleep_us >> 2) + 1, __sleep_us); \ } \ __ret ?: ((cond) ? 0 : -ETIMEDOUT); \ })
Signature · 1 line
2.9.0
Mark Brown
maintainerQuoted 2 lines · Arnd Bergmann
When we pass the result of a multiplication as the timeout or the delay, we can get a warning:
This'd be easier if you sent each of the changes separately...
Quoted 3 lines
include/linux/iopoll.h | 24 +++++++++++++++--------- include/linux/regmap.h | 12 +++++++----- 2 files changed, 22 insertions(+), 14 deletions(-)
Quoted 5 lines · On Wed, 26 Jul 2017 15:28:06 +0100 Mark Brown <[email protected]> wrote:
Quoted 2 lines · Arnd Bergmann
When we pass the result of a multiplication as the timeout or the delay, we can get a warning:
This'd be easier if you sent each of the changes separately...
I think it's OK - the patch encapsulates a single concept. Doesn't matter much either way, unless someone wants to take one part only into a particular tree(?).
Mark Brown
maintainerQuoted 11 lines · Andrew Morton
Quoted 5 lines · On Wed, 26 Jul 2017 15:28:06 +0100 Mark Brown <[email protected]> wrote:
Quoted 2 lines · Arnd Bergmann
When we pass the result of a multiplication as the timeout or the delay, we can get a warning:
This'd be easier if you sent each of the changes separately...
I think it's OK - the patch encapsulates a single concept. Doesn't matter much either way, unless someone wants to take one part only into a particular tree(?).
I'd have applied the regmap bit if it weren't wrapped up with the iopoll change.
Quoted 2 lines · On Wed, 26 Jul 2017 15:37:32 +0200 Arnd Bergmann <[email protected]> wrote:
When we pass the result of a multiplication as the timeout or the delay, we can get a warning:
from? gcc-7 I assume?
Quoted 6 lines · Andrew Morton
Quoted 2 lines · On Wed, 26 Jul 2017 15:37:32 +0200 Arnd Bergmann <[email protected]> wrote:
When we pass the result of a multiplication as the timeout or the delay, we can get a warning:
from? gcc-7 I assume?
Correct, sorry for missing this. In fact, the warning is currently disabled on mainline kernels, but there are only a couple of instance remaining, so I expect to be able to turn it back on in the future.
Arnd