Commit b899a850 authored by Mark Rutland's avatar Mark Rutland Committed by Ingo Molnar
Browse files

compiler.h: Remove ACCESS_ONCE() 



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: default avatarPaul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: default avatarMark 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: default avatarIngo Molnar <mingo@kernel.org>
parent 2a22f692

include/linux/compiler.h

+11 −36
Original line number Diff line number Diff line
@@ -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

 * compiler is also forbidden from reordering successive instances of

 * READ_ONCE, WRITE_ONCE and ACCESS_ONCE (see below), 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 READ_ONCE,

 * WRITE_ONCE or ACCESS_ONCE() in different C statements.

 * READ_ONCE and WRITE_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 READ_ONCE or WRITE_ONCE in different C

 * statements.

 *

 * In contrast to ACCESS_ONCE these two macros will also work on aggregate

 * data types like structs or unions. If the size of the accessed data

 * type exceeds the word size of the machine (e.g., 32 bits or 64 bits)

 * READ_ONCE() and WRITE_ONCE() will fall back to memcpy(). There's at

 * least two memcpy()s: one for the __builtin_memcpy() and then one for

 * the macro doing the copy of variable - '__u' allocated on the stack.

 * These two macros will also work on aggregate data types like structs or

 * unions. If the size of the accessed data type exceeds the word size of

 * the machine (e.g., 32 bits or 64 bits) READ_ONCE() and WRITE_ONCE() will

 * fall back to memcpy(). There's at least two memcpy()s: one for the

 * __builtin_memcpy() and then one for the macro doing the copy of variable

 * - '__u' allocated on the stack.

 *

 * Their two major use cases are: (1) Mediating communication between

 * 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),				\

		"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 */