tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

locking, arch: use WRITE_ONCE()/READ_ONCE() in smp_store_release()/smp_load_acquire()

Replace ACCESS_ONCE() macro in smp_store_release() and smp_load_acquire()
with WRITE_ONCE() and READ_ONCE() on x86, arm, arm64, ia64, metag, mips,
powerpc, s390, sparc and asm-generic since ACCESS_ONCE() does not work
reliably on non-scalar types.

WRITE_ONCE() and READ_ONCE() were introduced in the following commits:

230fa253df63 ("kernel: Provide READ_ONCE and ASSIGN_ONCE")
43239cbe79fc ("kernel: Change ASSIGN_ONCE(val, x) to WRITE_ONCE(x, val)")

Signed-off-by: Andrey Konovalov <andreyknvl@google.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Davidlohr Bueso <dbueso@suse.de>
Acked-by: Michael Ellerman <mpe@ellerman.id.au> (powerpc)
Acked-by: Ralf Baechle <ralf@linux-mips.org>
Cc: Alexander Duyck <alexander.h.duyck@redhat.com>
Cc: Andre Przywara <andre.przywara@arm.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Borislav Petkov <bp@suse.de>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: James Hogan <james.hogan@imgtec.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: linux-arch@vger.kernel.org
Link: http://lkml.kernel.org/r/1438528264-714-1-git-send-email-andreyknvl@google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

authored by

Andrey Konovalov and committed by
Ingo Molnar 76695af2 75d22702

+22 -22
+2 -2
arch/arm/include/asm/barrier.h
··· 67 67 do { \ 68 68 compiletime_assert_atomic_type(*p); \ 69 69 smp_mb(); \ 70 - ACCESS_ONCE(*p) = (v); \ 70 + WRITE_ONCE(*p, v); \ 71 71 } while (0) 72 72 73 73 #define smp_load_acquire(p) \ 74 74 ({ \ 75 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 75 + typeof(*p) ___p1 = READ_ONCE(*p); \ 76 76 compiletime_assert_atomic_type(*p); \ 77 77 smp_mb(); \ 78 78 ___p1; \
+2 -2
arch/arm64/include/asm/barrier.h
··· 44 44 do { \ 45 45 compiletime_assert_atomic_type(*p); \ 46 46 barrier(); \ 47 - ACCESS_ONCE(*p) = (v); \ 47 + WRITE_ONCE(*p, v); \ 48 48 } while (0) 49 49 50 50 #define smp_load_acquire(p) \ 51 51 ({ \ 52 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 52 + typeof(*p) ___p1 = READ_ONCE(*p); \ 53 53 compiletime_assert_atomic_type(*p); \ 54 54 barrier(); \ 55 55 ___p1; \
+2 -2
arch/ia64/include/asm/barrier.h
··· 66 66 do { \ 67 67 compiletime_assert_atomic_type(*p); \ 68 68 barrier(); \ 69 - ACCESS_ONCE(*p) = (v); \ 69 + WRITE_ONCE(*p, v); \ 70 70 } while (0) 71 71 72 72 #define smp_load_acquire(p) \ 73 73 ({ \ 74 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 74 + typeof(*p) ___p1 = READ_ONCE(*p); \ 75 75 compiletime_assert_atomic_type(*p); \ 76 76 barrier(); \ 77 77 ___p1; \
+2 -2
arch/metag/include/asm/barrier.h
··· 90 90 do { \ 91 91 compiletime_assert_atomic_type(*p); \ 92 92 smp_mb(); \ 93 - ACCESS_ONCE(*p) = (v); \ 93 + WRITE_ONCE(*p, v); \ 94 94 } while (0) 95 95 96 96 #define smp_load_acquire(p) \ 97 97 ({ \ 98 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 98 + typeof(*p) ___p1 = READ_ONCE(*p); \ 99 99 compiletime_assert_atomic_type(*p); \ 100 100 smp_mb(); \ 101 101 ___p1; \
+2 -2
arch/mips/include/asm/barrier.h
··· 133 133 do { \ 134 134 compiletime_assert_atomic_type(*p); \ 135 135 smp_mb(); \ 136 - ACCESS_ONCE(*p) = (v); \ 136 + WRITE_ONCE(*p, v); \ 137 137 } while (0) 138 138 139 139 #define smp_load_acquire(p) \ 140 140 ({ \ 141 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 141 + typeof(*p) ___p1 = READ_ONCE(*p); \ 142 142 compiletime_assert_atomic_type(*p); \ 143 143 smp_mb(); \ 144 144 ___p1; \
+2 -2
arch/powerpc/include/asm/barrier.h
··· 76 76 do { \ 77 77 compiletime_assert_atomic_type(*p); \ 78 78 smp_lwsync(); \ 79 - ACCESS_ONCE(*p) = (v); \ 79 + WRITE_ONCE(*p, v); \ 80 80 } while (0) 81 81 82 82 #define smp_load_acquire(p) \ 83 83 ({ \ 84 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 84 + typeof(*p) ___p1 = READ_ONCE(*p); \ 85 85 compiletime_assert_atomic_type(*p); \ 86 86 smp_lwsync(); \ 87 87 ___p1; \
+2 -2
arch/s390/include/asm/barrier.h
··· 42 42 do { \ 43 43 compiletime_assert_atomic_type(*p); \ 44 44 barrier(); \ 45 - ACCESS_ONCE(*p) = (v); \ 45 + WRITE_ONCE(*p, v); \ 46 46 } while (0) 47 47 48 48 #define smp_load_acquire(p) \ 49 49 ({ \ 50 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 50 + typeof(*p) ___p1 = READ_ONCE(*p); \ 51 51 compiletime_assert_atomic_type(*p); \ 52 52 barrier(); \ 53 53 ___p1; \
+2 -2
arch/sparc/include/asm/barrier_64.h
··· 60 60 do { \ 61 61 compiletime_assert_atomic_type(*p); \ 62 62 barrier(); \ 63 - ACCESS_ONCE(*p) = (v); \ 63 + WRITE_ONCE(*p, v); \ 64 64 } while (0) 65 65 66 66 #define smp_load_acquire(p) \ 67 67 ({ \ 68 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 68 + typeof(*p) ___p1 = READ_ONCE(*p); \ 69 69 compiletime_assert_atomic_type(*p); \ 70 70 barrier(); \ 71 71 ___p1; \
+4 -4
arch/x86/include/asm/barrier.h
··· 57 57 do { \ 58 58 compiletime_assert_atomic_type(*p); \ 59 59 smp_mb(); \ 60 - ACCESS_ONCE(*p) = (v); \ 60 + WRITE_ONCE(*p, v); \ 61 61 } while (0) 62 62 63 63 #define smp_load_acquire(p) \ 64 64 ({ \ 65 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 65 + typeof(*p) ___p1 = READ_ONCE(*p); \ 66 66 compiletime_assert_atomic_type(*p); \ 67 67 smp_mb(); \ 68 68 ___p1; \ ··· 74 74 do { \ 75 75 compiletime_assert_atomic_type(*p); \ 76 76 barrier(); \ 77 - ACCESS_ONCE(*p) = (v); \ 77 + WRITE_ONCE(*p, v); \ 78 78 } while (0) 79 79 80 80 #define smp_load_acquire(p) \ 81 81 ({ \ 82 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 82 + typeof(*p) ___p1 = READ_ONCE(*p); \ 83 83 compiletime_assert_atomic_type(*p); \ 84 84 barrier(); \ 85 85 ___p1; \
+2 -2
include/asm-generic/barrier.h
··· 108 108 do { \ 109 109 compiletime_assert_atomic_type(*p); \ 110 110 smp_mb(); \ 111 - ACCESS_ONCE(*p) = (v); \ 111 + WRITE_ONCE(*p, v); \ 112 112 } while (0) 113 113 114 114 #define smp_load_acquire(p) \ 115 115 ({ \ 116 - typeof(*p) ___p1 = ACCESS_ONCE(*p); \ 116 + typeof(*p) ___p1 = READ_ONCE(*p); \ 117 117 compiletime_assert_atomic_type(*p); \ 118 118 smp_mb(); \ 119 119 ___p1; \