mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-11-04 10:40:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

compiler.h: Remove ACCESS_ONCE()

Browse source 
There are no longer any kernelspace uses of ACCESS_ONCE(), so we can
remove the definition from <linux/compiler.h>.

This patch removes the ACCESS_ONCE() definition, and updates comments
which referred to it. At the same time, some inconsistent and redundant
whitespace is removed from comments.

Tested-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Joe Perches <joe@perches.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: apw@canonical.com
Link: http://lkml.kernel.org/r/20171127103824.36526-4-mark.rutland@arm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
Mark Rutland 2017-11-27 10:38:23 +00:00 committed by Ingo Molnar
parent 2a22f692bb
commit b899a85043
1 changed files with 11 additions and 36 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

45
include/linux/compiler.h
View file

@ -220,17 +220,17 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
/* /*
* Prevent the compiler from merging or refetching reads or writes. The * Prevent the compiler from merging or refetching reads or writes. The
* compiler is also forbidden from reordering successive instances of * compiler is also forbidden from reordering successive instances of
* READ_ONCE, WRITE_ONCE and ACCESS_ONCE (see below), but only when the * READ_ONCE and WRITE_ONCE, but only when the compiler is aware of some
* compiler is aware of some particular ordering. One way to make the * particular ordering. One way to make the compiler aware of ordering is to
* compiler aware of ordering is to put the two invocations of READ_ONCE, * put the two invocations of READ_ONCE or WRITE_ONCE in different C
* WRITE_ONCE or ACCESS_ONCE() in different C statements. * statements.
* *
* In contrast to ACCESS_ONCE these two macros will also work on aggregate * These two macros will also work on aggregate data types like structs or
* data types like structs or unions. If the size of the accessed data * unions. If the size of the accessed data type exceeds the word size of
* type exceeds the word size of the machine (e.g., 32 bits or 64 bits) * the machine (e.g., 32 bits or 64 bits) READ_ONCE() and WRITE_ONCE() will
* READ_ONCE() and WRITE_ONCE() will fall back to memcpy(). There's at * fall back to memcpy(). There's at least two memcpy()s: one for the
* least two memcpy()s: one for the __builtin_memcpy() and then one for * __builtin_memcpy() and then one for the macro doing the copy of variable
* the macro doing the copy of variable - '__u' allocated on the stack. * - '__u' allocated on the stack.
* *
* Their two major use cases are: (1) Mediating communication between * Their two major use cases are: (1) Mediating communication between
* process-level code and irq/NMI handlers, all running on the same CPU, * process-level code and irq/NMI handlers, all running on the same CPU,
@ -327,29 +327,4 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
compiletime_assert(__native_word(t), \ compiletime_assert(__native_word(t), \
"Need native word sized stores/loads for atomicity.") "Need native word sized stores/loads for atomicity.")
/*
* Prevent the compiler from merging or refetching accesses. The compiler
* is also forbidden from reordering successive instances of ACCESS_ONCE(),
* but only when the compiler is aware of some particular ordering. One way
* to make the compiler aware of ordering is to put the two invocations of
* ACCESS_ONCE() in different C statements.
*
* ACCESS_ONCE will only work on scalar types. For union types, ACCESS_ONCE
* on a union member will work as long as the size of the member matches the
* size of the union and the size is smaller than word size.
*
* The major use cases of ACCESS_ONCE used to be (1) Mediating communication
* between process-level code and irq/NMI handlers, all running on the same CPU,
* and (2) Ensuring that the compiler does not fold, spindle, or otherwise
* mutilate accesses that either do not require ordering or that interact
* with an explicit memory barrier or atomic instruction that provides the
* required ordering.
*
* If possible use READ_ONCE()/WRITE_ONCE() instead.
*/
#define __ACCESS_ONCE(x) ({ \
__maybe_unused typeof(x) __var = (__force typeof(x)) 0; \
(volatile typeof(x) *)&(x); })
#define ACCESS_ONCE(x) (*__ACCESS_ONCE(x))
#endif /* __LINUX_COMPILER_H */ #endif /* __LINUX_COMPILER_H */