leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

kernel: Change ASSIGN_ONCE(val, x) to WRITE_ONCE(x, val)

Browse Source 
Feedback has shown that WRITE_ONCE(x, val) is easier to use than
ASSIGN_ONCE(val,x).
There are no in-tree users yet, so lets change it for 3.19.

Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Acked-by: Davidlohr Bueso <dave@stgolabs.net>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
This commit is contained in:
Christian Borntraeger 2015-01-13 10:46:42 +01:00
parent eaa27f34e9
commit 43239cbe79
1 changed files with 6 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/linux/compiler.h
View File

@ -215,7 +215,7 @@ static __always_inline void __read_once_size(volatile void *p, void *res, int si
} }
} }
static __always_inline void __assign_once_size(volatile void *p, void *res, int size) static __always_inline void __write_once_size(volatile void *p, void *res, int size)
{ {
switch (size) { switch (size) {
case 1: *(volatile __u8 *)p = *(__u8 *)res; break; case 1: *(volatile __u8 *)p = *(__u8 *)res; break;
@ -235,15 +235,15 @@ static __always_inline void __assign_once_size(volatile void *p, void *res, int
/* /*
* 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, ASSIGN_ONCE and ACCESS_ONCE (see below), but only when the * 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 is aware of some particular ordering. One way to make the
* compiler aware of ordering is to put the two invocations of READ_ONCE, * compiler aware of ordering is to put the two invocations of READ_ONCE,
* ASSIGN_ONCE or ACCESS_ONCE() in different C statements. * WRITE_ONCE or ACCESS_ONCE() in different C statements.
* *
* In contrast to ACCESS_ONCE these two macros will also work on aggregate * 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 * 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) * type exceeds the word size of the machine (e.g., 32 bits or 64 bits)
* READ_ONCE() and ASSIGN_ONCE() will fall back to memcpy and print a * READ_ONCE() and WRITE_ONCE() will fall back to memcpy and print a
* compile-time warning. * compile-time warning.
* *
* Their two major use cases are: (1) Mediating communication between * Their two major use cases are: (1) Mediating communication between
@ -257,8 +257,8 @@ static __always_inline void __assign_once_size(volatile void *p, void *res, int
#define READ_ONCE(x) \ #define READ_ONCE(x) \
({ typeof(x) __val; __read_once_size(&x, &__val, sizeof(__val)); __val; }) ({ typeof(x) __val; __read_once_size(&x, &__val, sizeof(__val)); __val; })
#define ASSIGN_ONCE(val, x) \ #define WRITE_ONCE(x, val) \
({ typeof(x) __val; __val = val; __assign_once_size(&x, &__val, sizeof(__val)); __val; }) ({ typeof(x) __val; __val = val; __write_once_size(&x, &__val, sizeof(__val)); __val; })
#endif /* __KERNEL__ */ #endif /* __KERNEL__ */