2019-08-20 02:49:40 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This file provides wrappers with sanitizer instrumentation for non-atomic
|
|
|
|
|
* bit operations.
|
|
|
|
|
*
|
|
|
|
|
* To use this functionality, an arch's bitops.h file needs to define each of
|
|
|
|
|
* the below bit operations with an arch_ prefix (e.g. arch_set_bit(),
|
|
|
|
|
* arch___set_bit(), etc.).
|
|
|
|
|
*/
|
|
|
|
|
#ifndef _ASM_GENERIC_BITOPS_INSTRUMENTED_NON_ATOMIC_H
|
|
|
|
|
#define _ASM_GENERIC_BITOPS_INSTRUMENTED_NON_ATOMIC_H
|
|
|
|
|
|
2020-01-21 16:05:10 +00:00
|
|
|
#include <linux/instrumented.h>
|
2019-08-20 02:49:40 +00:00
|
|
|
|
|
|
|
|
/**
|
2022-06-24 12:13:09 +00:00
|
|
|
* ___set_bit - Set a bit in memory
|
2019-08-20 02:49:40 +00:00
|
|
|
* @nr: the bit to set
|
|
|
|
|
* @addr: the address to start counting from
|
|
|
|
|
*
|
|
|
|
|
* Unlike set_bit(), this function is non-atomic. If it is called on the same
|
|
|
|
|
* region of memory concurrently, the effect may be that only one operation
|
|
|
|
|
* succeeds.
|
|
|
|
|
*/
|
bitops: unify non-atomic bitops prototypes across architectures
Currently, there is a mess with the prototypes of the non-atomic
bitops across the different architectures:
ret bool, int, unsigned long
nr int, long, unsigned int, unsigned long
addr volatile unsigned long *, volatile void *
Thankfully, it doesn't provoke any bugs, but can sometimes make
the compiler angry when it's not handy at all.
Adjust all the prototypes to the following standard:
ret bool retval can be only 0 or 1
nr unsigned long native; signed makes no sense
addr volatile unsigned long * bitmaps are arrays of ulongs
Next, some architectures don't define 'arch_' versions as they don't
support instrumentation, others do. To make sure there is always the
same set of callables present and to ease any potential future
changes, make them all follow the rule:
* architecture-specific files define only 'arch_' versions;
* non-prefixed versions can be defined only in asm-generic files;
and place the non-prefixed definitions into a new file in
asm-generic to be included by non-instrumented architectures.
Finally, add some static assertions in order to prevent people from
making a mess in this room again.
I also used the %__always_inline attribute consistently, so that
they always get resolved to the actual operations.
Suggested-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Alexander Lobakin <alexandr.lobakin@intel.com>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: Yury Norov <yury.norov@gmail.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Yury Norov <yury.norov@gmail.com>
2022-06-24 12:13:07 +00:00
|
|
|
static __always_inline void
|
2022-06-24 12:13:09 +00:00
|
|
|
___set_bit(unsigned long nr, volatile unsigned long *addr)
|
2019-08-20 02:49:40 +00:00
|
|
|
{
|
2020-01-21 16:05:10 +00:00
|
|
|
instrument_write(addr + BIT_WORD(nr), sizeof(long));
|
2019-08-20 02:49:40 +00:00
|
|
|
arch___set_bit(nr, addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2022-06-24 12:13:09 +00:00
|
|
|
* ___clear_bit - Clears a bit in memory
|
2019-08-20 02:49:40 +00:00
|
|
|
* @nr: the bit to clear
|
|
|
|
|
* @addr: the address to start counting from
|
|
|
|
|
*
|
|
|
|
|
* Unlike clear_bit(), this function is non-atomic. If it is called on the same
|
|
|
|
|
* region of memory concurrently, the effect may be that only one operation
|
|
|
|
|
* succeeds.
|
|
|
|
|
*/
|
bitops: unify non-atomic bitops prototypes across architectures
Currently, there is a mess with the prototypes of the non-atomic
bitops across the different architectures:
ret bool, int, unsigned long
nr int, long, unsigned int, unsigned long
addr volatile unsigned long *, volatile void *
Thankfully, it doesn't provoke any bugs, but can sometimes make
the compiler angry when it's not handy at all.
Adjust all the prototypes to the following standard:
ret bool retval can be only 0 or 1
nr unsigned long native; signed makes no sense
addr volatile unsigned long * bitmaps are arrays of ulongs
Next, some architectures don't define 'arch_' versions as they don't
support instrumentation, others do. To make sure there is always the
same set of callables present and to ease any potential future
changes, make them all follow the rule:
* architecture-specific files define only 'arch_' versions;
* non-prefixed versions can be defined only in asm-generic files;
and place the non-prefixed definitions into a new file in
asm-generic to be included by non-instrumented architectures.
Finally, add some static assertions in order to prevent people from
making a mess in this room again.
I also used the %__always_inline attribute consistently, so that
they always get resolved to the actual operations.
Suggested-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Alexander Lobakin <alexandr.lobakin@intel.com>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: Yury Norov <yury.norov@gmail.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Yury Norov <yury.norov@gmail.com>
2022-06-24 12:13:07 +00:00
|
|
|
static __always_inline void
|
2022-06-24 12:13:09 +00:00
|
|
|
___clear_bit(unsigned long nr, volatile unsigned long *addr)
|
2019-08-20 02:49:40 +00:00
|
|
|
{
|
2020-01-21 16:05:10 +00:00
|
|
|
instrument_write(addr + BIT_WORD(nr), sizeof(long));
|
2019-08-20 02:49:40 +00:00
|
|
|
arch___clear_bit(nr, addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2022-06-24 12:13:09 +00:00
|
|
|
* ___change_bit - Toggle a bit in memory
|
2019-08-20 02:49:40 +00:00
|
|
|
* @nr: the bit to change
|
|
|
|
|
* @addr: the address to start counting from
|
|
|
|
|
*
|
|
|
|
|
* Unlike change_bit(), this function is non-atomic. If it is called on the same
|
|
|
|
|
* region of memory concurrently, the effect may be that only one operation
|
|
|
|
|
* succeeds.
|
|
|
|
|
*/
|
bitops: unify non-atomic bitops prototypes across architectures
Currently, there is a mess with the prototypes of the non-atomic
bitops across the different architectures:
ret bool, int, unsigned long
nr int, long, unsigned int, unsigned long
addr volatile unsigned long *, volatile void *
Thankfully, it doesn't provoke any bugs, but can sometimes make
the compiler angry when it's not handy at all.
Adjust all the prototypes to the following standard:
ret bool retval can be only 0 or 1
nr unsigned long native; signed makes no sense
addr volatile unsigned long * bitmaps are arrays of ulongs
Next, some architectures don't define 'arch_' versions as they don't
support instrumentation, others do. To make sure there is always the
same set of callables present and to ease any potential future
changes, make them all follow the rule:
* architecture-specific files define only 'arch_' versions;
* non-prefixed versions can be defined only in asm-generic files;
and place the non-prefixed definitions into a new file in
asm-generic to be included by non-instrumented architectures.
Finally, add some static assertions in order to prevent people from
making a mess in this room again.
I also used the %__always_inline attribute consistently, so that
they always get resolved to the actual operations.
Suggested-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Alexander Lobakin <alexandr.lobakin@intel.com>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: Yury Norov <yury.norov@gmail.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Yury Norov <yury.norov@gmail.com>
2022-06-24 12:13:07 +00:00
|
|
|
static __always_inline void
|
2022-06-24 12:13:09 +00:00
|
|
|
___change_bit(unsigned long nr, volatile unsigned long *addr)
|
2019-08-20 02:49:40 +00:00
|
|
|
{
|
2020-01-21 16:05:10 +00:00
|
|
|
instrument_write(addr + BIT_WORD(nr), sizeof(long));
|
2019-08-20 02:49:40 +00:00
|
|
|
arch___change_bit(nr, addr);
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-13 15:53:56 +00:00
|
|
|
static __always_inline void __instrument_read_write_bitop(long nr, volatile unsigned long *addr)
|
bitops, kcsan: Partially revert instrumentation for non-atomic bitops
Previous to the change to distinguish read-write accesses, when
CONFIG_KCSAN_ASSUME_PLAIN_WRITES_ATOMIC=y is set, KCSAN would consider
the non-atomic bitops as atomic. We want to partially revert to this
behaviour, but with one important distinction: report racing
modifications, since lost bits due to non-atomicity are certainly
possible.
Given the operations here only modify a single bit, assuming
non-atomicity of the writer is sufficient may be reasonable for certain
usage (and follows the permissible nature of the "assume plain writes
atomic" rule). In other words:
1. We want non-atomic read-modify-write races to be reported;
this is accomplished by kcsan_check_read(), where any
concurrent write (atomic or not) will generate a report.
2. We do not want to report races with marked readers, but -do-
want to report races with unmarked readers; this is
accomplished by the instrument_write() ("assume atomic
write" with Kconfig option set).
With the above rules, when KCSAN_ASSUME_PLAIN_WRITES_ATOMIC is selected,
it is hoped that KCSAN's reporting behaviour is better aligned with
current expected permissible usage for non-atomic bitops.
Note that, a side-effect of not telling KCSAN that the accesses are
read-writes, is that this information is not displayed in the access
summary in the report. It is, however, visible in inline-expanded stack
traces. For now, it does not make sense to introduce yet another special
case to KCSAN's runtime, only to cater to the case here.
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Paul E. McKenney <paulmck@kernel.org>
Cc: Will Deacon <will@kernel.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Daniel Axtens <dja@axtens.net>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: <linux-arch@vger.kernel.org>
Signed-off-by: Marco Elver <elver@google.com>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2020-08-13 16:38:59 +00:00
|
|
|
{
|
|
|
|
|
if (IS_ENABLED(CONFIG_KCSAN_ASSUME_PLAIN_WRITES_ATOMIC)) {
|
|
|
|
|
/*
|
|
|
|
|
* We treat non-atomic read-write bitops a little more special.
|
|
|
|
|
* Given the operations here only modify a single bit, assuming
|
|
|
|
|
* non-atomicity of the writer is sufficient may be reasonable
|
|
|
|
|
* for certain usage (and follows the permissible nature of the
|
|
|
|
|
* assume-plain-writes-atomic rule):
|
|
|
|
|
* 1. report read-modify-write races -> check read;
|
|
|
|
|
* 2. do not report races with marked readers, but do report
|
|
|
|
|
* races with unmarked readers -> check "atomic" write.
|
|
|
|
|
*/
|
|
|
|
|
kcsan_check_read(addr + BIT_WORD(nr), sizeof(long));
|
|
|
|
|
/*
|
|
|
|
|
* Use generic write instrumentation, in case other sanitizers
|
|
|
|
|
* or tools are enabled alongside KCSAN.
|
|
|
|
|
*/
|
|
|
|
|
instrument_write(addr + BIT_WORD(nr), sizeof(long));
|
|
|
|
|
} else {
|
|
|
|
|
instrument_read_write(addr + BIT_WORD(nr), sizeof(long));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-20 02:49:40 +00:00
|
|
|
/**
|
2022-06-24 12:13:09 +00:00
|
|
|
* ___test_and_set_bit - Set a bit and return its old value
|
2019-08-20 02:49:40 +00:00
|
|
|
* @nr: Bit to set
|
|
|
|
|
* @addr: Address to count from
|
|
|
|
|
*
|
|
|
|
|
* This operation is non-atomic. If two instances of this operation race, one
|
|
|
|
|
* can appear to succeed but actually fail.
|
|
|
|
|
*/
|
bitops: unify non-atomic bitops prototypes across architectures
Currently, there is a mess with the prototypes of the non-atomic
bitops across the different architectures:
ret bool, int, unsigned long
nr int, long, unsigned int, unsigned long
addr volatile unsigned long *, volatile void *
Thankfully, it doesn't provoke any bugs, but can sometimes make
the compiler angry when it's not handy at all.
Adjust all the prototypes to the following standard:
ret bool retval can be only 0 or 1
nr unsigned long native; signed makes no sense
addr volatile unsigned long * bitmaps are arrays of ulongs
Next, some architectures don't define 'arch_' versions as they don't
support instrumentation, others do. To make sure there is always the
same set of callables present and to ease any potential future
changes, make them all follow the rule:
* architecture-specific files define only 'arch_' versions;
* non-prefixed versions can be defined only in asm-generic files;
and place the non-prefixed definitions into a new file in
asm-generic to be included by non-instrumented architectures.
Finally, add some static assertions in order to prevent people from
making a mess in this room again.
I also used the %__always_inline attribute consistently, so that
they always get resolved to the actual operations.
Suggested-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Alexander Lobakin <alexandr.lobakin@intel.com>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: Yury Norov <yury.norov@gmail.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Yury Norov <yury.norov@gmail.com>
2022-06-24 12:13:07 +00:00
|
|
|
static __always_inline bool
|
2022-06-24 12:13:09 +00:00
|
|
|
___test_and_set_bit(unsigned long nr, volatile unsigned long *addr)
|
2019-08-20 02:49:40 +00:00
|
|
|
{
|
bitops, kcsan: Partially revert instrumentation for non-atomic bitops
Previous to the change to distinguish read-write accesses, when
CONFIG_KCSAN_ASSUME_PLAIN_WRITES_ATOMIC=y is set, KCSAN would consider
the non-atomic bitops as atomic. We want to partially revert to this
behaviour, but with one important distinction: report racing
modifications, since lost bits due to non-atomicity are certainly
possible.
Given the operations here only modify a single bit, assuming
non-atomicity of the writer is sufficient may be reasonable for certain
usage (and follows the permissible nature of the "assume plain writes
atomic" rule). In other words:
1. We want non-atomic read-modify-write races to be reported;
this is accomplished by kcsan_check_read(), where any
concurrent write (atomic or not) will generate a report.
2. We do not want to report races with marked readers, but -do-
want to report races with unmarked readers; this is
accomplished by the instrument_write() ("assume atomic
write" with Kconfig option set).
With the above rules, when KCSAN_ASSUME_PLAIN_WRITES_ATOMIC is selected,
it is hoped that KCSAN's reporting behaviour is better aligned with
current expected permissible usage for non-atomic bitops.
Note that, a side-effect of not telling KCSAN that the accesses are
read-writes, is that this information is not displayed in the access
summary in the report. It is, however, visible in inline-expanded stack
traces. For now, it does not make sense to introduce yet another special
case to KCSAN's runtime, only to cater to the case here.
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Paul E. McKenney <paulmck@kernel.org>
Cc: Will Deacon <will@kernel.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Daniel Axtens <dja@axtens.net>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: <linux-arch@vger.kernel.org>
Signed-off-by: Marco Elver <elver@google.com>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2020-08-13 16:38:59 +00:00
|
|
|
__instrument_read_write_bitop(nr, addr);
|
2019-08-20 02:49:40 +00:00
|
|
|
return arch___test_and_set_bit(nr, addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2022-06-24 12:13:09 +00:00
|
|
|
* ___test_and_clear_bit - Clear a bit and return its old value
|
2019-08-20 02:49:40 +00:00
|
|
|
* @nr: Bit to clear
|
|
|
|
|
* @addr: Address to count from
|
|
|
|
|
*
|
|
|
|
|
* This operation is non-atomic. If two instances of this operation race, one
|
|
|
|
|
* can appear to succeed but actually fail.
|
|
|
|
|
*/
|
bitops: unify non-atomic bitops prototypes across architectures
Currently, there is a mess with the prototypes of the non-atomic
bitops across the different architectures:
ret bool, int, unsigned long
nr int, long, unsigned int, unsigned long
addr volatile unsigned long *, volatile void *
Thankfully, it doesn't provoke any bugs, but can sometimes make
the compiler angry when it's not handy at all.
Adjust all the prototypes to the following standard:
ret bool retval can be only 0 or 1
nr unsigned long native; signed makes no sense
addr volatile unsigned long * bitmaps are arrays of ulongs
Next, some architectures don't define 'arch_' versions as they don't
support instrumentation, others do. To make sure there is always the
same set of callables present and to ease any potential future
changes, make them all follow the rule:
* architecture-specific files define only 'arch_' versions;
* non-prefixed versions can be defined only in asm-generic files;
and place the non-prefixed definitions into a new file in
asm-generic to be included by non-instrumented architectures.
Finally, add some static assertions in order to prevent people from
making a mess in this room again.
I also used the %__always_inline attribute consistently, so that
they always get resolved to the actual operations.
Suggested-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Alexander Lobakin <alexandr.lobakin@intel.com>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: Yury Norov <yury.norov@gmail.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Yury Norov <yury.norov@gmail.com>
2022-06-24 12:13:07 +00:00
|
|
|
static __always_inline bool
|
2022-06-24 12:13:09 +00:00
|
|
|
___test_and_clear_bit(unsigned long nr, volatile unsigned long *addr)
|
2019-08-20 02:49:40 +00:00
|
|
|
{
|
bitops, kcsan: Partially revert instrumentation for non-atomic bitops
Previous to the change to distinguish read-write accesses, when
CONFIG_KCSAN_ASSUME_PLAIN_WRITES_ATOMIC=y is set, KCSAN would consider
the non-atomic bitops as atomic. We want to partially revert to this
behaviour, but with one important distinction: report racing
modifications, since lost bits due to non-atomicity are certainly
possible.
Given the operations here only modify a single bit, assuming
non-atomicity of the writer is sufficient may be reasonable for certain
usage (and follows the permissible nature of the "assume plain writes
atomic" rule). In other words:
1. We want non-atomic read-modify-write races to be reported;
this is accomplished by kcsan_check_read(), where any
concurrent write (atomic or not) will generate a report.
2. We do not want to report races with marked readers, but -do-
want to report races with unmarked readers; this is
accomplished by the instrument_write() ("assume atomic
write" with Kconfig option set).
With the above rules, when KCSAN_ASSUME_PLAIN_WRITES_ATOMIC is selected,
it is hoped that KCSAN's reporting behaviour is better aligned with
current expected permissible usage for non-atomic bitops.
Note that, a side-effect of not telling KCSAN that the accesses are
read-writes, is that this information is not displayed in the access
summary in the report. It is, however, visible in inline-expanded stack
traces. For now, it does not make sense to introduce yet another special
case to KCSAN's runtime, only to cater to the case here.
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Paul E. McKenney <paulmck@kernel.org>
Cc: Will Deacon <will@kernel.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Daniel Axtens <dja@axtens.net>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: <linux-arch@vger.kernel.org>
Signed-off-by: Marco Elver <elver@google.com>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2020-08-13 16:38:59 +00:00
|
|
|
__instrument_read_write_bitop(nr, addr);
|
2019-08-20 02:49:40 +00:00
|
|
|
return arch___test_and_clear_bit(nr, addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2022-06-24 12:13:09 +00:00
|
|
|
* ___test_and_change_bit - Change a bit and return its old value
|
2019-08-20 02:49:40 +00:00
|
|
|
* @nr: Bit to change
|
|
|
|
|
* @addr: Address to count from
|
|
|
|
|
*
|
|
|
|
|
* This operation is non-atomic. If two instances of this operation race, one
|
|
|
|
|
* can appear to succeed but actually fail.
|
|
|
|
|
*/
|
bitops: unify non-atomic bitops prototypes across architectures
Currently, there is a mess with the prototypes of the non-atomic
bitops across the different architectures:
ret bool, int, unsigned long
nr int, long, unsigned int, unsigned long
addr volatile unsigned long *, volatile void *
Thankfully, it doesn't provoke any bugs, but can sometimes make
the compiler angry when it's not handy at all.
Adjust all the prototypes to the following standard:
ret bool retval can be only 0 or 1
nr unsigned long native; signed makes no sense
addr volatile unsigned long * bitmaps are arrays of ulongs
Next, some architectures don't define 'arch_' versions as they don't
support instrumentation, others do. To make sure there is always the
same set of callables present and to ease any potential future
changes, make them all follow the rule:
* architecture-specific files define only 'arch_' versions;
* non-prefixed versions can be defined only in asm-generic files;
and place the non-prefixed definitions into a new file in
asm-generic to be included by non-instrumented architectures.
Finally, add some static assertions in order to prevent people from
making a mess in this room again.
I also used the %__always_inline attribute consistently, so that
they always get resolved to the actual operations.
Suggested-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Alexander Lobakin <alexandr.lobakin@intel.com>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: Yury Norov <yury.norov@gmail.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Yury Norov <yury.norov@gmail.com>
2022-06-24 12:13:07 +00:00
|
|
|
static __always_inline bool
|
2022-06-24 12:13:09 +00:00
|
|
|
___test_and_change_bit(unsigned long nr, volatile unsigned long *addr)
|
2019-08-20 02:49:40 +00:00
|
|
|
{
|
bitops, kcsan: Partially revert instrumentation for non-atomic bitops
Previous to the change to distinguish read-write accesses, when
CONFIG_KCSAN_ASSUME_PLAIN_WRITES_ATOMIC=y is set, KCSAN would consider
the non-atomic bitops as atomic. We want to partially revert to this
behaviour, but with one important distinction: report racing
modifications, since lost bits due to non-atomicity are certainly
possible.
Given the operations here only modify a single bit, assuming
non-atomicity of the writer is sufficient may be reasonable for certain
usage (and follows the permissible nature of the "assume plain writes
atomic" rule). In other words:
1. We want non-atomic read-modify-write races to be reported;
this is accomplished by kcsan_check_read(), where any
concurrent write (atomic or not) will generate a report.
2. We do not want to report races with marked readers, but -do-
want to report races with unmarked readers; this is
accomplished by the instrument_write() ("assume atomic
write" with Kconfig option set).
With the above rules, when KCSAN_ASSUME_PLAIN_WRITES_ATOMIC is selected,
it is hoped that KCSAN's reporting behaviour is better aligned with
current expected permissible usage for non-atomic bitops.
Note that, a side-effect of not telling KCSAN that the accesses are
read-writes, is that this information is not displayed in the access
summary in the report. It is, however, visible in inline-expanded stack
traces. For now, it does not make sense to introduce yet another special
case to KCSAN's runtime, only to cater to the case here.
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Paul E. McKenney <paulmck@kernel.org>
Cc: Will Deacon <will@kernel.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Daniel Axtens <dja@axtens.net>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: <linux-arch@vger.kernel.org>
Signed-off-by: Marco Elver <elver@google.com>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2020-08-13 16:38:59 +00:00
|
|
|
__instrument_read_write_bitop(nr, addr);
|
2019-08-20 02:49:40 +00:00
|
|
|
return arch___test_and_change_bit(nr, addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2022-06-24 12:13:09 +00:00
|
|
|
* _test_bit - Determine whether a bit is set
|
2019-08-20 02:49:40 +00:00
|
|
|
* @nr: bit number to test
|
|
|
|
|
* @addr: Address to start counting from
|
|
|
|
|
*/
|
bitops: unify non-atomic bitops prototypes across architectures
Currently, there is a mess with the prototypes of the non-atomic
bitops across the different architectures:
ret bool, int, unsigned long
nr int, long, unsigned int, unsigned long
addr volatile unsigned long *, volatile void *
Thankfully, it doesn't provoke any bugs, but can sometimes make
the compiler angry when it's not handy at all.
Adjust all the prototypes to the following standard:
ret bool retval can be only 0 or 1
nr unsigned long native; signed makes no sense
addr volatile unsigned long * bitmaps are arrays of ulongs
Next, some architectures don't define 'arch_' versions as they don't
support instrumentation, others do. To make sure there is always the
same set of callables present and to ease any potential future
changes, make them all follow the rule:
* architecture-specific files define only 'arch_' versions;
* non-prefixed versions can be defined only in asm-generic files;
and place the non-prefixed definitions into a new file in
asm-generic to be included by non-instrumented architectures.
Finally, add some static assertions in order to prevent people from
making a mess in this room again.
I also used the %__always_inline attribute consistently, so that
they always get resolved to the actual operations.
Suggested-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Alexander Lobakin <alexandr.lobakin@intel.com>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Reviewed-by: Yury Norov <yury.norov@gmail.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Yury Norov <yury.norov@gmail.com>
2022-06-24 12:13:07 +00:00
|
|
|
static __always_inline bool
|
2022-06-24 12:13:09 +00:00
|
|
|
_test_bit(unsigned long nr, const volatile unsigned long *addr)
|
2019-08-20 02:49:40 +00:00
|
|
|
{
|
2020-01-21 16:05:10 +00:00
|
|
|
instrument_atomic_read(addr + BIT_WORD(nr), sizeof(long));
|
2019-08-20 02:49:40 +00:00
|
|
|
return arch_test_bit(nr, addr);
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-26 13:17:08 +00:00
|
|
|
/**
|
|
|
|
|
* _test_bit_acquire - Determine, with acquire semantics, whether a bit is set
|
|
|
|
|
* @nr: bit number to test
|
|
|
|
|
* @addr: Address to start counting from
|
|
|
|
|
*/
|
|
|
|
|
static __always_inline bool
|
|
|
|
|
_test_bit_acquire(unsigned long nr, const volatile unsigned long *addr)
|
|
|
|
|
{
|
|
|
|
|
instrument_atomic_read(addr + BIT_WORD(nr), sizeof(long));
|
|
|
|
|
return arch_test_bit_acquire(nr, addr);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-20 02:49:40 +00:00
|
|
|
#endif /* _ASM_GENERIC_BITOPS_INSTRUMENTED_NON_ATOMIC_H */
|