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

tools/include: Remove ACCESS_ONCE() 



There are no longer any usersapce uses of ACCESS_ONCE(), so we can
remove the definition from our userspace <linux/compiler.h>, which is
only used by tools in the kernel directory (i.e. it isn't a uapi
header).

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-3-mark.rutland@arm.com


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent f971e511

tools/include/linux/compiler.h

+9 −12
Original line number Diff line number Diff line
@@ -84,8 +84,6 @@ 


#define uninitialized_var(x) x = *(&(x))



#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))



#include <linux/types.h>



/*
@@ -135,16 +133,15 @@ 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 and print a

 * compile-time warning.

 * 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 and print a compile-time warning.

 *

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

 * process-level code and irq/NMI handlers, all running on the same CPU,

CRA Git | Maintained and supported by SUSTech CRA and CCSE