linux-kernel.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH v3 00/12] Rework READ_ONCE() to improve codegen
@ 2020-04-15 16:52 Will Deacon
  2020-04-15 16:52 ` [PATCH v3 01/12] compiler/gcc: Emit build-time warning for GCC prior to version 4.8 Will Deacon
                   ` (12 more replies)
  0 siblings, 13 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers

Hi everyone,

This is version three of the patches I previously posted for improving
the code generation of READ_ONCE() and moving the minimum GCC version
to 4.8:

RFC: https://lore.kernel.org/lkml/20200110165636.28035-1-will@kernel.org
v2:  https://lore.kernel.org/lkml/20200123153341.19947-1-will@kernel.org

Although v2 was queued up by Peter in -tip, it was found to break the
build for m68k and sparc32. We fixed m68k during the merge window and
I've since posted patches to fix sparc32 here:

  https://lore.kernel.org/lkml/20200414214011.2699-1-will@kernel.org

This series is a refresh on top of 5.7-rc1, the main changes being:

  * Fix another issue where 'const' is assigned to non-const via
    WRITE_ONCE(), this time in the tls code

  * Fix READ_ONCE_NOCHECK() abuse in arm64 checksum code

  * Added Reviewed-bys and Acks from v2

Hopefully this can be considered for 5.8, along with the sparc32 changes.

Cheers,

Will

Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Segher Boessenkool <segher@kernel.crashing.org>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Cc: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Peter Oberparleiter <oberpar@linux.ibm.com>
Cc: Masahiro Yamada <masahiroy@kernel.org>
Cc: Nick Desaulniers <ndesaulniers@google.com>

--->8

Will Deacon (12):
  compiler/gcc: Emit build-time warning for GCC prior to version 4.8
  netfilter: Avoid assigning 'const' pointer to non-const pointer
  net: tls: Avoid assigning 'const' pointer to non-const pointer
  fault_inject: Don't rely on "return value" from WRITE_ONCE()
  arm64: csum: Disable KASAN for do_csum()
  READ_ONCE: Simplify implementations of {READ,WRITE}_ONCE()
  READ_ONCE: Enforce atomicity for {READ,WRITE}_ONCE() memory accesses
  READ_ONCE: Drop pointer qualifiers when reading from scalar types
  locking/barriers: Use '__unqual_scalar_typeof' for load-acquire macros
  arm64: barrier: Use '__unqual_scalar_typeof' for acquire/release
    macros
  compiler/gcc: Raise minimum GCC version for kernel builds to 4.8
  gcov: Remove old GCC 3.4 support

 Documentation/process/changes.rst |   2 +-
 arch/arm/crypto/Kconfig           |  12 +-
 arch/arm64/include/asm/barrier.h  |  16 +-
 arch/arm64/lib/csum.c             |  20 +-
 crypto/Kconfig                    |   1 -
 drivers/xen/time.c                |   2 +-
 include/asm-generic/barrier.h     |  16 +-
 include/linux/compiler-gcc.h      |   5 +-
 include/linux/compiler.h          | 129 +++----
 include/linux/compiler_types.h    |  21 ++
 init/Kconfig                      |   5 +-
 kernel/gcov/Kconfig               |  24 --
 kernel/gcov/Makefile              |   3 +-
 kernel/gcov/gcc_3_4.c             | 573 ------------------------------
 lib/fault-inject.c                |   4 +-
 net/netfilter/core.c              |   2 +-
 net/tls/tls_main.c                |   2 +-
 scripts/Kconfig.include           |   6 +
 scripts/gcc-plugins/Kconfig       |   2 +-
 19 files changed, 126 insertions(+), 719 deletions(-)
 delete mode 100644 kernel/gcov/gcc_3_4.c

-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply	[flat|nested] 26+ messages in thread

* [PATCH v3 01/12] compiler/gcc: Emit build-time warning for GCC prior to version 4.8
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 17:20   ` Masahiro Yamada
  2020-04-15 16:52 ` [PATCH v3 02/12] netfilter: Avoid assigning 'const' pointer to non-const pointer Will Deacon
                   ` (11 subsequent siblings)
  12 siblings, 1 reply; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers

Prior to version 4.8, GCC may miscompile READ_ONCE() by erroneously
discarding the 'volatile' qualifier:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145

We've been working around this using some nasty hacks which make
READ_ONCE() both horribly complicated and also prevent us from enforcing
that it is only used on scalar types. Since GCC 4.8 is pretty old for
kernel builds now, emit a warning if we detect it during the build.

Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Cc: Masahiro Yamada <masahiroy@kernel.org>
Signed-off-by: Will Deacon <will@kernel.org>
---
 init/Kconfig            | 4 ++--
 scripts/Kconfig.include | 9 +++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/init/Kconfig b/init/Kconfig
index 9e22ee8fbd75..816b8b4a5e9e 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -9,11 +9,11 @@ config DEFCONFIG_LIST
 	default "arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG)"
 
 config CC_IS_GCC
-	def_bool $(success,$(CC) --version | head -n 1 | grep -q gcc)
+	def_bool $(cc-is-gcc)
 
 config GCC_VERSION
 	int
-	default $(shell,$(srctree)/scripts/gcc-version.sh $(CC)) if CC_IS_GCC
+	default $(gcc-version) if CC_IS_GCC
 	default 0
 
 config LD_VERSION
diff --git a/scripts/Kconfig.include b/scripts/Kconfig.include
index c264da2b9b30..5261e9d6b50b 100644
--- a/scripts/Kconfig.include
+++ b/scripts/Kconfig.include
@@ -54,3 +54,12 @@ $(error-if,$(success, $(LD) -v | grep -q gold), gold linker '$(LD)' not supporte
 cc-option-bit = $(if-success,$(CC) -Werror $(1) -E -x c /dev/null -o /dev/null,$(1))
 m32-flag := $(cc-option-bit,-m32)
 m64-flag := $(cc-option-bit,-m64)
+
+# gcc version including patch level
+gcc-version := $(shell,$(srctree)/scripts/gcc-version.sh $(CC))
+
+# Return y if the compiler is GCC, n otherwise
+cc-is-gcc := $(success,$(CC) --version | head -n 1 | grep -q gcc)
+
+# Warn if the compiler is GCC prior to 4.8
+$(warning-if,$(if-success,[ $(gcc-version) -lt 40800 ],$(cc-is-gcc),n),"Your compiler is old and may miscompile the kernel due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145 - please upgrade it.")
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 02/12] netfilter: Avoid assigning 'const' pointer to non-const pointer
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
  2020-04-15 16:52 ` [PATCH v3 01/12] compiler/gcc: Emit build-time warning for GCC prior to version 4.8 Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 16:52 ` [PATCH v3 03/12] net: tls: " Will Deacon
                   ` (10 subsequent siblings)
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Pablo Neira Ayuso, Jozsef Kadlecsik, Florian Westphal,
	David S. Miller

nf_remove_net_hook() uses WRITE_ONCE() to assign a 'const' pointer to a
'non-const' pointer. Cleanups to the implementation of WRITE_ONCE() mean
that this will give rise to a compiler warning, just like a plain old
assignment would do:

  | In file included from ./include/linux/export.h:43,
  |                  from ./include/linux/linkage.h:7,
  |                  from ./include/linux/kernel.h:8,
  |                  from net/netfilter/core.c:9:
  | net/netfilter/core.c: In function ‘nf_remove_net_hook’:
  | ./include/linux/compiler.h:216:30: warning: assignment discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
  |   *(volatile typeof(x) *)&(x) = (val);  \
  |                               ^
  | net/netfilter/core.c:379:3: note: in expansion of macro ‘WRITE_ONCE’
  |    WRITE_ONCE(orig_ops[i], &dummy_ops);
  |    ^~~~~~~~~~

Follow the pattern used elsewhere in this file and add a cast to 'void *'
to squash the warning.

Cc: Pablo Neira Ayuso <pablo@netfilter.org>
Cc: Jozsef Kadlecsik <kadlec@netfilter.org>
Cc: Florian Westphal <fw@strlen.de>
Cc: "David S. Miller" <davem@davemloft.net>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Will Deacon <will@kernel.org>
---
 net/netfilter/core.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/net/netfilter/core.c b/net/netfilter/core.c
index 78f046ec506f..3ac7c8c1548d 100644
--- a/net/netfilter/core.c
+++ b/net/netfilter/core.c
@@ -376,7 +376,7 @@ static bool nf_remove_net_hook(struct nf_hook_entries *old,
 		if (orig_ops[i] != unreg)
 			continue;
 		WRITE_ONCE(old->hooks[i].hook, accept_all);
-		WRITE_ONCE(orig_ops[i], &dummy_ops);
+		WRITE_ONCE(orig_ops[i], (void *)&dummy_ops);
 		return true;
 	}
 
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 03/12] net: tls: Avoid assigning 'const' pointer to non-const pointer
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
  2020-04-15 16:52 ` [PATCH v3 01/12] compiler/gcc: Emit build-time warning for GCC prior to version 4.8 Will Deacon
  2020-04-15 16:52 ` [PATCH v3 02/12] netfilter: Avoid assigning 'const' pointer to non-const pointer Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 16:52 ` [PATCH v3 04/12] fault_inject: Don't rely on "return value" from WRITE_ONCE() Will Deacon
                   ` (9 subsequent siblings)
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Boris Pismenny, Aviad Yehezkel, John Fastabend, Daniel Borkmann

tls_build_proto() uses WRITE_ONCE() to assign a 'const' pointer to a
'non-const' pointer. Cleanups to the implementation of WRITE_ONCE() mean
that this will give rise to a compiler warning, just like a plain old
assignment would do:

  | net/tls/tls_main.c: In function ‘tls_build_proto’:
  | ./include/linux/compiler.h:229:30: warning: assignment discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
  | net/tls/tls_main.c:640:4: note: in expansion of macro ‘smp_store_release’
  |   640 |    smp_store_release(&saved_tcpv6_prot, prot);
  |       |    ^~~~~~~~~~~~~~~~~

Drop the const qualifier from the local 'prot' variable, as it isn't
needed.

Cc: Boris Pismenny <borisp@mellanox.com>
Cc: Aviad Yehezkel <aviadye@mellanox.com>
Cc: John Fastabend <john.fastabend@gmail.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Will Deacon <will@kernel.org>
---
 net/tls/tls_main.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/net/tls/tls_main.c b/net/tls/tls_main.c
index 156efce50dbd..b33e11c27cfa 100644
--- a/net/tls/tls_main.c
+++ b/net/tls/tls_main.c
@@ -629,7 +629,7 @@ struct tls_context *tls_ctx_create(struct sock *sk)
 static void tls_build_proto(struct sock *sk)
 {
 	int ip_ver = sk->sk_family == AF_INET6 ? TLSV6 : TLSV4;
-	const struct proto *prot = READ_ONCE(sk->sk_prot);
+	struct proto *prot = READ_ONCE(sk->sk_prot);
 
 	/* Build IPv6 TLS whenever the address of tcpv6 _prot changes */
 	if (ip_ver == TLSV6 &&
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 04/12] fault_inject: Don't rely on "return value" from WRITE_ONCE()
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (2 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 03/12] net: tls: " Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 16:52 ` [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum() Will Deacon
                   ` (8 subsequent siblings)
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Akinobu Mita

It's a bit weird that WRITE_ONCE() evaluates to the value it stores and
it's different to smp_store_release(), which can't be used this way.

In preparation for preventing this in WRITE_ONCE(), change the fault
injection code to use a local variable instead.

Cc: Akinobu Mita <akinobu.mita@gmail.com>
Signed-off-by: Will Deacon <will@kernel.org>
---
 lib/fault-inject.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/fault-inject.c b/lib/fault-inject.c
index 8186ca84910b..ce12621b4275 100644
--- a/lib/fault-inject.c
+++ b/lib/fault-inject.c
@@ -106,7 +106,9 @@ bool should_fail(struct fault_attr *attr, ssize_t size)
 		unsigned int fail_nth = READ_ONCE(current->fail_nth);
 
 		if (fail_nth) {
-			if (!WRITE_ONCE(current->fail_nth, fail_nth - 1))
+			fail_nth--;
+			WRITE_ONCE(current->fail_nth, fail_nth);
+			if (!fail_nth)
 				goto fail;
 
 			return false;
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (3 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 04/12] fault_inject: Don't rely on "return value" from WRITE_ONCE() Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 17:28   ` Mark Rutland
  2020-04-15 19:26   ` Robin Murphy
  2020-04-15 16:52 ` [PATCH v3 06/12] READ_ONCE: Simplify implementations of {READ,WRITE}_ONCE() Will Deacon
                   ` (7 subsequent siblings)
  12 siblings, 2 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Mark Rutland, Robin Murphy

do_csum() over-reads the source buffer and therefore abuses
READ_ONCE_NOCHECK() to avoid tripping up KASAN. In preparation for
READ_ONCE_NOCHECK() becoming a macro, and therefore losing its
'__no_sanitize_address' annotation, just annotate do_csum() explicitly
and fall back to normal loads.

Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Robin Murphy <robin.murphy@arm.com>
Signed-off-by: Will Deacon <will@kernel.org>
---
 arch/arm64/lib/csum.c | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/arch/arm64/lib/csum.c b/arch/arm64/lib/csum.c
index 60eccae2abad..78b87a64ca0a 100644
--- a/arch/arm64/lib/csum.c
+++ b/arch/arm64/lib/csum.c
@@ -14,7 +14,11 @@ static u64 accumulate(u64 sum, u64 data)
 	return tmp + (tmp >> 64);
 }
 
-unsigned int do_csum(const unsigned char *buff, int len)
+/*
+ * We over-read the buffer and this makes KASAN unhappy. Instead, disable
+ * instrumentation and call kasan explicitly.
+ */
+unsigned int __no_sanitize_address do_csum(const unsigned char *buff, int len)
 {
 	unsigned int offset, shift, sum;
 	const u64 *ptr;
@@ -42,7 +46,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
 	 * odd/even alignment, and means we can ignore it until the very end.
 	 */
 	shift = offset * 8;
-	data = READ_ONCE_NOCHECK(*ptr++);
+	data = *ptr++;
 #ifdef __LITTLE_ENDIAN
 	data = (data >> shift) << shift;
 #else
@@ -58,10 +62,10 @@ unsigned int do_csum(const unsigned char *buff, int len)
 	while (unlikely(len > 64)) {
 		__uint128_t tmp1, tmp2, tmp3, tmp4;
 
-		tmp1 = READ_ONCE_NOCHECK(*(__uint128_t *)ptr);
-		tmp2 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 2));
-		tmp3 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 4));
-		tmp4 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 6));
+		tmp1 = *(__uint128_t *)ptr;
+		tmp2 = *(__uint128_t *)(ptr + 2);
+		tmp3 = *(__uint128_t *)(ptr + 4);
+		tmp4 = *(__uint128_t *)(ptr + 6);
 
 		len -= 64;
 		ptr += 8;
@@ -85,7 +89,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
 		__uint128_t tmp;
 
 		sum64 = accumulate(sum64, data);
-		tmp = READ_ONCE_NOCHECK(*(__uint128_t *)ptr);
+		tmp = *(__uint128_t *)ptr;
 
 		len -= 16;
 		ptr += 2;
@@ -100,7 +104,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
 	}
 	if (len > 0) {
 		sum64 = accumulate(sum64, data);
-		data = READ_ONCE_NOCHECK(*ptr);
+		data = *ptr;
 		len -= 8;
 	}
 	/*
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 06/12] READ_ONCE: Simplify implementations of {READ,WRITE}_ONCE()
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (4 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum() Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 16:52 ` [PATCH v3 07/12] READ_ONCE: Enforce atomicity for {READ,WRITE}_ONCE() memory accesses Will Deacon
                   ` (6 subsequent siblings)
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers

The implementations of {READ,WRITE}_ONCE() suffer from a significant
amount of indirection and complexity due to a historic GCC bug:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145

which was originally worked around by 230fa253df63 ("kernel: Provide
READ_ONCE and ASSIGN_ONCE").

Since GCC 4.8 is fairly vintage at this point and we emit a warning if
we detect it during the build, return {READ,WRITE}_ONCE() to their former
glory with an implementation that is easier to understand and, crucially,
more amenable to optimisation. A side effect of this simplification is
that WRITE_ONCE() no longer returns a value, but nobody seems to be
relying on that and the new behaviour is aligned with smp_store_release().

Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Will Deacon <will@kernel.org>
---
 include/linux/compiler.h | 104 ++++++++++-----------------------------
 1 file changed, 25 insertions(+), 79 deletions(-)

diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 034b0a644efc..0bf6c04b3f8f 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -177,60 +177,6 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,
 # define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
 #endif
 
-#include <uapi/linux/types.h>
-
-#define __READ_ONCE_SIZE						\
-({									\
-	switch (size) {							\
-	case 1: *(__u8 *)res = *(volatile __u8 *)p; break;		\
-	case 2: *(__u16 *)res = *(volatile __u16 *)p; break;		\
-	case 4: *(__u32 *)res = *(volatile __u32 *)p; break;		\
-	case 8: *(__u64 *)res = *(volatile __u64 *)p; break;		\
-	default:							\
-		barrier();						\
-		__builtin_memcpy((void *)res, (const void *)p, size);	\
-		barrier();						\
-	}								\
-})
-
-static __always_inline
-void __read_once_size(const volatile void *p, void *res, int size)
-{
-	__READ_ONCE_SIZE;
-}
-
-#ifdef CONFIG_KASAN
-/*
- * We can't declare function 'inline' because __no_sanitize_address confilcts
- * with inlining. Attempt to inline it may cause a build failure.
- * 	https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
- * '__maybe_unused' allows us to avoid defined-but-not-used warnings.
- */
-# define __no_kasan_or_inline __no_sanitize_address notrace __maybe_unused
-#else
-# define __no_kasan_or_inline __always_inline
-#endif
-
-static __no_kasan_or_inline
-void __read_once_size_nocheck(const volatile void *p, void *res, int size)
-{
-	__READ_ONCE_SIZE;
-}
-
-static __always_inline void __write_once_size(volatile void *p, void *res, int size)
-{
-	switch (size) {
-	case 1: *(volatile __u8 *)p = *(__u8 *)res; break;
-	case 2: *(volatile __u16 *)p = *(__u16 *)res; break;
-	case 4: *(volatile __u32 *)p = *(__u32 *)res; break;
-	case 8: *(volatile __u64 *)p = *(__u64 *)res; break;
-	default:
-		barrier();
-		__builtin_memcpy((void *)p, (const void *)res, size);
-		barrier();
-	}
-}
-
 /*
  * Prevent the compiler from merging or refetching reads or writes. The
  * compiler is also forbidden from reordering successive instances of
@@ -240,11 +186,7 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
  * statements.
  *
  * 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.
+ * unions.
  *
  * Their two major use cases are: (1) Mediating communication between
  * process-level code and irq/NMI handlers, all running on the same CPU,
@@ -256,23 +198,35 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
 #include <asm/barrier.h>
 #include <linux/kasan-checks.h>
 
-#define __READ_ONCE(x, check)						\
+/*
+ * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
+ * to hide memory access from KASAN.
+ */
+#define READ_ONCE_NOCHECK(x)						\
 ({									\
-	union { typeof(x) __val; char __c[1]; } __u;			\
-	if (check)							\
-		__read_once_size(&(x), __u.__c, sizeof(x));		\
-	else								\
-		__read_once_size_nocheck(&(x), __u.__c, sizeof(x));	\
-	smp_read_barrier_depends(); /* Enforce dependency ordering from x */ \
-	__u.__val;							\
+	typeof(x) __x = *(volatile typeof(x) *)&(x);			\
+	smp_read_barrier_depends();					\
+	__x;								\
 })
-#define READ_ONCE(x) __READ_ONCE(x, 1)
 
+#define READ_ONCE(x)	READ_ONCE_NOCHECK(x)
+
+#define WRITE_ONCE(x, val)				\
+do {							\
+	*(volatile typeof(x) *)&(x) = (val);		\
+} while (0)
+
+#ifdef CONFIG_KASAN
 /*
- * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
- * to hide memory access from KASAN.
+ * We can't declare function 'inline' because __no_sanitize_address conflicts
+ * with inlining. Attempt to inline it may cause a build failure.
+ *     https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
+ * '__maybe_unused' allows us to avoid defined-but-not-used warnings.
  */
-#define READ_ONCE_NOCHECK(x) __READ_ONCE(x, 0)
+# define __no_kasan_or_inline __no_sanitize_address notrace __maybe_unused
+#else
+# define __no_kasan_or_inline __always_inline
+#endif
 
 static __no_kasan_or_inline
 unsigned long read_word_at_a_time(const void *addr)
@@ -281,14 +235,6 @@ unsigned long read_word_at_a_time(const void *addr)
 	return *(unsigned long *)addr;
 }
 
-#define WRITE_ONCE(x, val) \
-({							\
-	union { typeof(x) __val; char __c[1]; } __u =	\
-		{ .__val = (__force typeof(x)) (val) }; \
-	__write_once_size(&(x), __u.__c, sizeof(x));	\
-	__u.__val;					\
-})
-
 #endif /* __KERNEL__ */
 
 /*
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 07/12] READ_ONCE: Enforce atomicity for {READ,WRITE}_ONCE() memory accesses
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (5 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 06/12] READ_ONCE: Simplify implementations of {READ,WRITE}_ONCE() Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 16:52 ` [PATCH v3 08/12] READ_ONCE: Drop pointer qualifiers when reading from scalar types Will Deacon
                   ` (5 subsequent siblings)
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers

{READ,WRITE}_ONCE() cannot guarantee atomicity for arbitrary data sizes.
This can be surprising to callers that might incorrectly be expecting
atomicity for accesses to aggregate structures, although there are other
callers where tearing is actually permissable (e.g. if they are using
something akin to sequence locking to protect the access).

Linus sayeth:

  | We could also look at being stricter for the normal READ/WRITE_ONCE(),
  | and require that they are
  |
  | (a) regular integer types
  |
  | (b) fit in an atomic word
  |
  | We actually did (b) for a while, until we noticed that we do it on
  | loff_t's etc and relaxed the rules. But maybe we could have a
  | "non-atomic" version of READ/WRITE_ONCE() that is used for the
  | questionable cases?

The slight snag is that we also have to support 64-bit accesses on 32-bit
architectures, as these appear to be widespread and tend to work out ok
if either the architecture supports atomic 64-bit accesses (x86, armv7)
or if the variable being accesses represents a virtual address and
therefore only requires 32-bit atomicity in practice.

Take a step in that direction by introducing a variant of
'compiletime_assert_atomic_type()' and use it to check the pointer
argument to {READ,WRITE}_ONCE(). Expose __{READ,WRITE_ONCE}() variants
which are allowed to tear and convert the one broken caller over to the
new macros.

Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Will Deacon <will@kernel.org>
---
 drivers/xen/time.c       |  2 +-
 include/linux/compiler.h | 37 +++++++++++++++++++++++++++++++++----
 2 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/drivers/xen/time.c b/drivers/xen/time.c
index 0968859c29d0..108edbcbc040 100644
--- a/drivers/xen/time.c
+++ b/drivers/xen/time.c
@@ -64,7 +64,7 @@ static void xen_get_runstate_snapshot_cpu_delta(
 	do {
 		state_time = get64(&state->state_entry_time);
 		rmb();	/* Hypervisor might update data. */
-		*res = READ_ONCE(*state);
+		*res = __READ_ONCE(*state);
 		rmb();	/* Hypervisor might update data. */
 	} while (get64(&state->state_entry_time) != state_time ||
 		 (state_time & XEN_RUNSTATE_UPDATE));
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 0bf6c04b3f8f..3e0b14de3504 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -198,24 +198,43 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,
 #include <asm/barrier.h>
 #include <linux/kasan-checks.h>
 
+/*
+ * Use __READ_ONCE() instead of READ_ONCE() if you do not require any
+ * atomicity or dependency ordering guarantees. Note that this may result
+ * in tears!
+ */
+#define __READ_ONCE(x)	(*(const volatile typeof(x) *)&(x))
+
+#define __READ_ONCE_SCALAR(x)						\
+({									\
+	typeof(x) __x = __READ_ONCE(x);					\
+	smp_read_barrier_depends();					\
+	__x;								\
+})
+
 /*
  * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
  * to hide memory access from KASAN.
  */
 #define READ_ONCE_NOCHECK(x)						\
 ({									\
-	typeof(x) __x = *(volatile typeof(x) *)&(x);			\
-	smp_read_barrier_depends();					\
-	__x;								\
+	compiletime_assert_rwonce_type(x);				\
+	__READ_ONCE_SCALAR(x);						\
 })
 
 #define READ_ONCE(x)	READ_ONCE_NOCHECK(x)
 
-#define WRITE_ONCE(x, val)				\
+#define __WRITE_ONCE(x, val)				\
 do {							\
 	*(volatile typeof(x) *)&(x) = (val);		\
 } while (0)
 
+#define WRITE_ONCE(x, val)				\
+do {							\
+	compiletime_assert_rwonce_type(x);		\
+	__WRITE_ONCE(x, val);				\
+} while (0)
+
 #ifdef CONFIG_KASAN
 /*
  * We can't declare function 'inline' because __no_sanitize_address conflicts
@@ -299,6 +318,16 @@ static inline void *offset_to_ptr(const int *off)
 	compiletime_assert(__native_word(t),				\
 		"Need native word sized stores/loads for atomicity.")
 
+/*
+ * Yes, this permits 64-bit accesses on 32-bit architectures. These will
+ * actually be atomic in many cases (namely x86), but for others we rely on
+ * the access being split into 2x32-bit accesses for a 32-bit quantity (e.g.
+ * a virtual address) and a strong prevailing wind.
+ */
+#define compiletime_assert_rwonce_type(t)					\
+	compiletime_assert(__native_word(t) || sizeof(t) == sizeof(long long),	\
+		"Unsupported access size for {READ,WRITE}_ONCE().")
+
 /* &a[0] degrades to a pointer: a different type from an array */
 #define __must_be_array(a)	BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
 
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 08/12] READ_ONCE: Drop pointer qualifiers when reading from scalar types
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (6 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 07/12] READ_ONCE: Enforce atomicity for {READ,WRITE}_ONCE() memory accesses Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 16:52 ` [PATCH v3 09/12] locking/barriers: Use '__unqual_scalar_typeof' for load-acquire macros Will Deacon
                   ` (4 subsequent siblings)
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers

Passing a volatile-qualified pointer to READ_ONCE() is an absolute
trainwreck for code generation: the use of 'typeof()' to define a
temporary variable inside the macro means that the final evaluation in
macro scope ends up forcing a read back from the stack. When stack
protector is enabled (the default for arm64, at least), this causes
the compiler to vomit up all sorts of junk.

Unfortunately, dropping pointer qualifiers inside the macro poses quite
a challenge, especially since the pointed-to type is permitted to be an
aggregate, and this is relied upon by mm/ code accessing things like
'pmd_t'. Based on numerous hacks and discussions on the mailing list,
this is the best I've managed to come up with.

Introduce '__unqual_scalar_typeof()' which takes an expression and, if
the expression is an optionally qualified 8, 16, 32 or 64-bit scalar
type, evaluates to the unqualified type. Other input types, including
aggregates, remain unchanged. Hopefully READ_ONCE() on volatile aggregate
pointers isn't something we do on a fast-path.

Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Reported-by: Michael Ellerman <mpe@ellerman.id.au>
Signed-off-by: Will Deacon <will@kernel.org>
---
 include/linux/compiler.h       |  6 +++---
 include/linux/compiler_types.h | 21 +++++++++++++++++++++
 2 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 3e0b14de3504..00a68063d9d5 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -203,13 +203,13 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,
  * atomicity or dependency ordering guarantees. Note that this may result
  * in tears!
  */
-#define __READ_ONCE(x)	(*(const volatile typeof(x) *)&(x))
+#define __READ_ONCE(x)	(*(const volatile __unqual_scalar_typeof(x) *)&(x))
 
 #define __READ_ONCE_SCALAR(x)						\
 ({									\
-	typeof(x) __x = __READ_ONCE(x);					\
+	__unqual_scalar_typeof(x) __x = __READ_ONCE(x);			\
 	smp_read_barrier_depends();					\
-	__x;								\
+	(typeof(x))__x;							\
 })
 
 /*
diff --git a/include/linux/compiler_types.h b/include/linux/compiler_types.h
index e970f97a7fcb..233066c92f6f 100644
--- a/include/linux/compiler_types.h
+++ b/include/linux/compiler_types.h
@@ -210,6 +210,27 @@ struct ftrace_likely_data {
 /* Are two types/vars the same type (ignoring qualifiers)? */
 #define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
 
+/*
+ * __unqual_scalar_typeof(x) - Declare an unqualified scalar type, leaving
+ *			       non-scalar types unchanged.
+ *
+ * We build this out of a couple of helper macros in a vain attempt to
+ * help you keep your lunch down while reading it.
+ */
+#define __pick_scalar_type(x, type, otherwise)					\
+	__builtin_choose_expr(__same_type(x, type), (type)0, otherwise)
+
+#define __pick_integer_type(x, type, otherwise)					\
+	__pick_scalar_type(x, unsigned type,					\
+		__pick_scalar_type(x, signed type, otherwise))
+
+#define __unqual_scalar_typeof(x) typeof(					\
+	__pick_integer_type(x, char,						\
+		__pick_integer_type(x, short,					\
+			__pick_integer_type(x, int,				\
+				__pick_integer_type(x, long,			\
+					__pick_integer_type(x, long long, x))))))
+
 /* Is this type a native word size -- useful for atomic operations */
 #define __native_word(t) \
 	(sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || \
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 09/12] locking/barriers: Use '__unqual_scalar_typeof' for load-acquire macros
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (7 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 08/12] READ_ONCE: Drop pointer qualifiers when reading from scalar types Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 16:52 ` [PATCH v3 10/12] arm64: barrier: Use '__unqual_scalar_typeof' for acquire/release macros Will Deacon
                   ` (3 subsequent siblings)
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers

Passing volatile-qualified pointers to the asm-generic implementations of
the load-acquire macros results in a re-load from the stack due to the
temporary result variable inheriting the volatile semantics thanks to the
use of 'typeof()'.

Define these temporary variables using 'unqual_scalar_typeof' to drop
the volatile qualifier in the case that they are scalar types.

Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Will Deacon <will@kernel.org>
---
 include/asm-generic/barrier.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/asm-generic/barrier.h b/include/asm-generic/barrier.h
index 85b28eb80b11..2eacaf7d62f6 100644
--- a/include/asm-generic/barrier.h
+++ b/include/asm-generic/barrier.h
@@ -128,10 +128,10 @@ do {									\
 #ifndef __smp_load_acquire
 #define __smp_load_acquire(p)						\
 ({									\
-	typeof(*p) ___p1 = READ_ONCE(*p);				\
+	__unqual_scalar_typeof(*p) ___p1 = READ_ONCE(*p);		\
 	compiletime_assert_atomic_type(*p);				\
 	__smp_mb();							\
-	___p1;								\
+	(typeof(*p))___p1;						\
 })
 #endif
 
@@ -183,10 +183,10 @@ do {									\
 #ifndef smp_load_acquire
 #define smp_load_acquire(p)						\
 ({									\
-	typeof(*p) ___p1 = READ_ONCE(*p);				\
+	__unqual_scalar_typeof(*p) ___p1 = READ_ONCE(*p);		\
 	compiletime_assert_atomic_type(*p);				\
 	barrier();							\
-	___p1;								\
+	(typeof(*p))___p1;						\
 })
 #endif
 
@@ -229,14 +229,14 @@ do {									\
 #ifndef smp_cond_load_relaxed
 #define smp_cond_load_relaxed(ptr, cond_expr) ({		\
 	typeof(ptr) __PTR = (ptr);				\
-	typeof(*ptr) VAL;					\
+	__unqual_scalar_typeof(*ptr) VAL;			\
 	for (;;) {						\
 		VAL = READ_ONCE(*__PTR);			\
 		if (cond_expr)					\
 			break;					\
 		cpu_relax();					\
 	}							\
-	VAL;							\
+	(typeof(*ptr))VAL;					\
 })
 #endif
 
@@ -250,10 +250,10 @@ do {									\
  */
 #ifndef smp_cond_load_acquire
 #define smp_cond_load_acquire(ptr, cond_expr) ({		\
-	typeof(*ptr) _val;					\
+	__unqual_scalar_typeof(*ptr) _val;			\
 	_val = smp_cond_load_relaxed(ptr, cond_expr);		\
 	smp_acquire__after_ctrl_dep();				\
-	_val;							\
+	(typeof(*ptr))_val;					\
 })
 #endif
 
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 10/12] arm64: barrier: Use '__unqual_scalar_typeof' for acquire/release macros
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (8 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 09/12] locking/barriers: Use '__unqual_scalar_typeof' for load-acquire macros Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 16:52 ` [PATCH v3 11/12] compiler/gcc: Raise minimum GCC version for kernel builds to 4.8 Will Deacon
                   ` (2 subsequent siblings)
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Mark Rutland

Passing volatile-qualified pointers to the arm64 implementations of the
load-acquire/store-release macros results in a re-load from the stack
and a bunch of associated stack-protector churn due to the temporary
result variable inheriting the volatile semantics thanks to the use of
'typeof()'.

Define these temporary variables using 'unqual_scalar_typeof' to drop
the volatile qualifier in the case that they are scalar types.

Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Acked-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Will Deacon <will@kernel.org>
---
 arch/arm64/include/asm/barrier.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/arch/arm64/include/asm/barrier.h b/arch/arm64/include/asm/barrier.h
index 7d9cc5ec4971..fb4c27506ef4 100644
--- a/arch/arm64/include/asm/barrier.h
+++ b/arch/arm64/include/asm/barrier.h
@@ -76,8 +76,8 @@ static inline unsigned long array_index_mask_nospec(unsigned long idx,
 #define __smp_store_release(p, v)					\
 do {									\
 	typeof(p) __p = (p);						\
-	union { typeof(*p) __val; char __c[1]; } __u =			\
-		{ .__val = (__force typeof(*p)) (v) };			\
+	union { __unqual_scalar_typeof(*p) __val; char __c[1]; } __u =	\
+		{ .__val = (__force __unqual_scalar_typeof(*p)) (v) };	\
 	compiletime_assert_atomic_type(*p);				\
 	kasan_check_write(__p, sizeof(*p));				\
 	switch (sizeof(*p)) {						\
@@ -110,7 +110,7 @@ do {									\
 
 #define __smp_load_acquire(p)						\
 ({									\
-	union { typeof(*p) __val; char __c[1]; } __u;			\
+	union { __unqual_scalar_typeof(*p) __val; char __c[1]; } __u;	\
 	typeof(p) __p = (p);						\
 	compiletime_assert_atomic_type(*p);				\
 	kasan_check_read(__p, sizeof(*p));				\
@@ -136,33 +136,33 @@ do {									\
 			: "Q" (*__p) : "memory");			\
 		break;							\
 	}								\
-	__u.__val;							\
+	(typeof(*p))__u.__val;						\
 })
 
 #define smp_cond_load_relaxed(ptr, cond_expr)				\
 ({									\
 	typeof(ptr) __PTR = (ptr);					\
-	typeof(*ptr) VAL;						\
+	__unqual_scalar_typeof(*ptr) VAL;				\
 	for (;;) {							\
 		VAL = READ_ONCE(*__PTR);				\
 		if (cond_expr)						\
 			break;						\
 		__cmpwait_relaxed(__PTR, VAL);				\
 	}								\
-	VAL;								\
+	(typeof(*ptr))VAL;						\
 })
 
 #define smp_cond_load_acquire(ptr, cond_expr)				\
 ({									\
 	typeof(ptr) __PTR = (ptr);					\
-	typeof(*ptr) VAL;						\
+	__unqual_scalar_typeof(*ptr) VAL;				\
 	for (;;) {							\
 		VAL = smp_load_acquire(__PTR);				\
 		if (cond_expr)						\
 			break;						\
 		__cmpwait_relaxed(__PTR, VAL);				\
 	}								\
-	VAL;								\
+	(typeof(*ptr))VAL;						\
 })
 
 #include <asm-generic/barrier.h>
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 11/12] compiler/gcc: Raise minimum GCC version for kernel builds to 4.8
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (9 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 10/12] arm64: barrier: Use '__unqual_scalar_typeof' for acquire/release macros Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-15 18:37   ` Arnd Bergmann
  2020-04-15 16:52 ` [PATCH v3 12/12] gcov: Remove old GCC 3.4 support Will Deacon
  2020-04-16 12:30 ` [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Christian Borntraeger
  12 siblings, 1 reply; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers

It is very rare to see versions of GCC prior to 4.8 being used to build
the mainline kernel. These old compilers are also know to have codegen
issues which can lead to silent miscompilation:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145

Raise the minimum GCC version for kernel build to 4.8 and remove some
tautological Kconfig dependencies as a consequence.

Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Masahiro Yamada <masahiroy@kernel.org>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Will Deacon <will@kernel.org>
---
 Documentation/process/changes.rst |  2 +-
 arch/arm/crypto/Kconfig           | 12 ++++++------
 crypto/Kconfig                    |  1 -
 include/linux/compiler-gcc.h      |  5 ++---
 init/Kconfig                      |  1 -
 scripts/Kconfig.include           |  3 ---
 scripts/gcc-plugins/Kconfig       |  2 +-
 7 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst
index 91c5ff8e161e..5cfb54c2aaa6 100644
--- a/Documentation/process/changes.rst
+++ b/Documentation/process/changes.rst
@@ -29,7 +29,7 @@ you probably needn't concern yourself with pcmciautils.
 ====================== ===============  ========================================
         Program        Minimal version       Command to check the version
 ====================== ===============  ========================================
-GNU C                  4.6              gcc --version
+GNU C                  4.8              gcc --version
 GNU make               3.81             make --version
 binutils               2.23             ld -v
 flex                   2.5.35           flex --version
diff --git a/arch/arm/crypto/Kconfig b/arch/arm/crypto/Kconfig
index 2674de6ada1f..c9bf2df85cb9 100644
--- a/arch/arm/crypto/Kconfig
+++ b/arch/arm/crypto/Kconfig
@@ -30,7 +30,7 @@ config CRYPTO_SHA1_ARM_NEON
 
 config CRYPTO_SHA1_ARM_CE
 	tristate "SHA1 digest algorithm (ARM v8 Crypto Extensions)"
-	depends on KERNEL_MODE_NEON && (CC_IS_CLANG || GCC_VERSION >= 40800)
+	depends on KERNEL_MODE_NEON
 	select CRYPTO_SHA1_ARM
 	select CRYPTO_HASH
 	help
@@ -39,7 +39,7 @@ config CRYPTO_SHA1_ARM_CE
 
 config CRYPTO_SHA2_ARM_CE
 	tristate "SHA-224/256 digest algorithm (ARM v8 Crypto Extensions)"
-	depends on KERNEL_MODE_NEON && (CC_IS_CLANG || GCC_VERSION >= 40800)
+	depends on KERNEL_MODE_NEON
 	select CRYPTO_SHA256_ARM
 	select CRYPTO_HASH
 	help
@@ -96,7 +96,7 @@ config CRYPTO_AES_ARM_BS
 
 config CRYPTO_AES_ARM_CE
 	tristate "Accelerated AES using ARMv8 Crypto Extensions"
-	depends on KERNEL_MODE_NEON && (CC_IS_CLANG || GCC_VERSION >= 40800)
+	depends on KERNEL_MODE_NEON
 	select CRYPTO_SKCIPHER
 	select CRYPTO_LIB_AES
 	select CRYPTO_SIMD
@@ -106,7 +106,7 @@ config CRYPTO_AES_ARM_CE
 
 config CRYPTO_GHASH_ARM_CE
 	tristate "PMULL-accelerated GHASH using NEON/ARMv8 Crypto Extensions"
-	depends on KERNEL_MODE_NEON && (CC_IS_CLANG || GCC_VERSION >= 40800)
+	depends on KERNEL_MODE_NEON
 	select CRYPTO_HASH
 	select CRYPTO_CRYPTD
 	select CRYPTO_GF128MUL
@@ -118,13 +118,13 @@ config CRYPTO_GHASH_ARM_CE
 
 config CRYPTO_CRCT10DIF_ARM_CE
 	tristate "CRCT10DIF digest algorithm using PMULL instructions"
-	depends on KERNEL_MODE_NEON && (CC_IS_CLANG || GCC_VERSION >= 40800)
+	depends on KERNEL_MODE_NEON
 	depends on CRC_T10DIF
 	select CRYPTO_HASH
 
 config CRYPTO_CRC32_ARM_CE
 	tristate "CRC32(C) digest algorithm using CRC and/or PMULL instructions"
-	depends on KERNEL_MODE_NEON && (CC_IS_CLANG || GCC_VERSION >= 40800)
+	depends on KERNEL_MODE_NEON
 	depends on CRC32
 	select CRYPTO_HASH
 
diff --git a/crypto/Kconfig b/crypto/Kconfig
index c24a47406f8f..34a8c5bfd062 100644
--- a/crypto/Kconfig
+++ b/crypto/Kconfig
@@ -316,7 +316,6 @@ config CRYPTO_AEGIS128
 config CRYPTO_AEGIS128_SIMD
 	bool "Support SIMD acceleration for AEGIS-128"
 	depends on CRYPTO_AEGIS128 && ((ARM || ARM64) && KERNEL_MODE_NEON)
-	depends on !ARM || CC_IS_CLANG || GCC_VERSION >= 40800
 	default y
 
 config CRYPTO_AEGIS128_AESNI_SSE2
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index d7ee4c6bad48..e2f725273261 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -10,7 +10,8 @@
 		     + __GNUC_MINOR__ * 100	\
 		     + __GNUC_PATCHLEVEL__)
 
-#if GCC_VERSION < 40600
+/* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145 */
+#if GCC_VERSION < 40800
 # error Sorry, your compiler is too old - please upgrade it.
 #endif
 
@@ -126,9 +127,7 @@
 #if defined(CONFIG_ARCH_USE_BUILTIN_BSWAP) && !defined(__CHECKER__)
 #define __HAVE_BUILTIN_BSWAP32__
 #define __HAVE_BUILTIN_BSWAP64__
-#if GCC_VERSION >= 40800
 #define __HAVE_BUILTIN_BSWAP16__
-#endif
 #endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP && !__CHECKER__ */
 
 #if GCC_VERSION >= 70000
diff --git a/init/Kconfig b/init/Kconfig
index 816b8b4a5e9e..e94e4d93a361 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -1285,7 +1285,6 @@ config LD_DEAD_CODE_DATA_ELIMINATION
 	bool "Dead code and data elimination (EXPERIMENTAL)"
 	depends on HAVE_LD_DEAD_CODE_DATA_ELIMINATION
 	depends on EXPERT
-	depends on !(FUNCTION_TRACER && CC_IS_GCC && GCC_VERSION < 40800)
 	depends on $(cc-option,-ffunction-sections -fdata-sections)
 	depends on $(ld-option,--gc-sections)
 	help
diff --git a/scripts/Kconfig.include b/scripts/Kconfig.include
index 5261e9d6b50b..b2dfba594042 100644
--- a/scripts/Kconfig.include
+++ b/scripts/Kconfig.include
@@ -60,6 +60,3 @@ gcc-version := $(shell,$(srctree)/scripts/gcc-version.sh $(CC))
 
 # Return y if the compiler is GCC, n otherwise
 cc-is-gcc := $(success,$(CC) --version | head -n 1 | grep -q gcc)
-
-# Warn if the compiler is GCC prior to 4.8
-$(warning-if,$(if-success,[ $(gcc-version) -lt 40800 ],$(cc-is-gcc),n),"Your compiler is old and may miscompile the kernel due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145 - please upgrade it.")
diff --git a/scripts/gcc-plugins/Kconfig b/scripts/gcc-plugins/Kconfig
index 013ba3a57669..ce0b99fb5847 100644
--- a/scripts/gcc-plugins/Kconfig
+++ b/scripts/gcc-plugins/Kconfig
@@ -8,7 +8,7 @@ config HAVE_GCC_PLUGINS
 menuconfig GCC_PLUGINS
 	bool "GCC plugins"
 	depends on HAVE_GCC_PLUGINS
-	depends on CC_IS_GCC && GCC_VERSION >= 40800
+	depends on CC_IS_GCC
 	depends on $(success,$(srctree)/scripts/gcc-plugin.sh $(CC))
 	default y
 	help
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* [PATCH v3 12/12] gcov: Remove old GCC 3.4 support
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (10 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 11/12] compiler/gcc: Raise minimum GCC version for kernel builds to 4.8 Will Deacon
@ 2020-04-15 16:52 ` Will Deacon
  2020-04-16 12:30 ` [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Christian Borntraeger
  12 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 16:52 UTC (permalink / raw)
  To: linux-kernel
  Cc: linux-arch, kernel-team, Will Deacon, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers

The kernel requires at least GCC 4.8 in order to build, and so there is
no need to cater for the pre-4.7 gcov format.

Remove the obsolete code.

Acked-by: Peter Oberparleiter <oberpar@linux.ibm.com>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
Signed-off-by: Will Deacon <will@kernel.org>
---
 kernel/gcov/Kconfig   |  24 --
 kernel/gcov/Makefile  |   3 +-
 kernel/gcov/gcc_3_4.c | 573 ------------------------------------------
 3 files changed, 1 insertion(+), 599 deletions(-)
 delete mode 100644 kernel/gcov/gcc_3_4.c

diff --git a/kernel/gcov/Kconfig b/kernel/gcov/Kconfig
index 3941a9c48f83..feaad597b3f4 100644
--- a/kernel/gcov/Kconfig
+++ b/kernel/gcov/Kconfig
@@ -51,28 +51,4 @@ config GCOV_PROFILE_ALL
 	larger and run slower. Also be sure to exclude files from profiling
 	which are not linked to the kernel image to prevent linker errors.
 
-choice
-	prompt "Specify GCOV format"
-	depends on GCOV_KERNEL
-	depends on CC_IS_GCC
-	---help---
-	The gcov format is usually determined by the GCC version, and the
-	default is chosen according to your GCC version. However, there are
-	exceptions where format changes are integrated in lower-version GCCs.
-	In such a case, change this option to adjust the format used in the
-	kernel accordingly.
-
-config GCOV_FORMAT_3_4
-	bool "GCC 3.4 format"
-	depends on GCC_VERSION < 40700
-	---help---
-	Select this option to use the format defined by GCC 3.4.
-
-config GCOV_FORMAT_4_7
-	bool "GCC 4.7 format"
-	---help---
-	Select this option to use the format defined by GCC 4.7.
-
-endchoice
-
 endmenu
diff --git a/kernel/gcov/Makefile b/kernel/gcov/Makefile
index d66a74b0f100..16f8ecc7d882 100644
--- a/kernel/gcov/Makefile
+++ b/kernel/gcov/Makefile
@@ -2,6 +2,5 @@
 ccflags-y := -DSRCTREE='"$(srctree)"' -DOBJTREE='"$(objtree)"'
 
 obj-y := base.o fs.o
-obj-$(CONFIG_GCOV_FORMAT_3_4) += gcc_base.o gcc_3_4.o
-obj-$(CONFIG_GCOV_FORMAT_4_7) += gcc_base.o gcc_4_7.o
+obj-$(CONFIG_CC_IS_GCC) += gcc_base.o gcc_4_7.o
 obj-$(CONFIG_CC_IS_CLANG) += clang.o
diff --git a/kernel/gcov/gcc_3_4.c b/kernel/gcov/gcc_3_4.c
deleted file mode 100644
index acb83558e5df..000000000000
--- a/kernel/gcov/gcc_3_4.c
+++ /dev/null
@@ -1,573 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- *  This code provides functions to handle gcc's profiling data format
- *  introduced with gcc 3.4. Future versions of gcc may change the gcov
- *  format (as happened before), so all format-specific information needs
- *  to be kept modular and easily exchangeable.
- *
- *  This file is based on gcc-internal definitions. Functions and data
- *  structures are defined to be compatible with gcc counterparts.
- *  For a better understanding, refer to gcc source: gcc/gcov-io.h.
- *
- *    Copyright IBM Corp. 2009
- *    Author(s): Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
- *
- *    Uses gcc-internal data definitions.
- */
-
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/seq_file.h>
-#include <linux/vmalloc.h>
-#include "gcov.h"
-
-#define GCOV_COUNTERS		5
-
-static struct gcov_info *gcov_info_head;
-
-/**
- * struct gcov_fn_info - profiling meta data per function
- * @ident: object file-unique function identifier
- * @checksum: function checksum
- * @n_ctrs: number of values per counter type belonging to this function
- *
- * This data is generated by gcc during compilation and doesn't change
- * at run-time.
- */
-struct gcov_fn_info {
-	unsigned int ident;
-	unsigned int checksum;
-	unsigned int n_ctrs[];
-};
-
-/**
- * struct gcov_ctr_info - profiling data per counter type
- * @num: number of counter values for this type
- * @values: array of counter values for this type
- * @merge: merge function for counter values of this type (unused)
- *
- * This data is generated by gcc during compilation and doesn't change
- * at run-time with the exception of the values array.
- */
-struct gcov_ctr_info {
-	unsigned int	num;
-	gcov_type	*values;
-	void		(*merge)(gcov_type *, unsigned int);
-};
-
-/**
- * struct gcov_info - profiling data per object file
- * @version: gcov version magic indicating the gcc version used for compilation
- * @next: list head for a singly-linked list
- * @stamp: time stamp
- * @filename: name of the associated gcov data file
- * @n_functions: number of instrumented functions
- * @functions: function data
- * @ctr_mask: mask specifying which counter types are active
- * @counts: counter data per counter type
- *
- * This data is generated by gcc during compilation and doesn't change
- * at run-time with the exception of the next pointer.
- */
-struct gcov_info {
-	unsigned int			version;
-	struct gcov_info		*next;
-	unsigned int			stamp;
-	const char			*filename;
-	unsigned int			n_functions;
-	const struct gcov_fn_info	*functions;
-	unsigned int			ctr_mask;
-	struct gcov_ctr_info		counts[];
-};
-
-/**
- * gcov_info_filename - return info filename
- * @info: profiling data set
- */
-const char *gcov_info_filename(struct gcov_info *info)
-{
-	return info->filename;
-}
-
-/**
- * gcov_info_version - return info version
- * @info: profiling data set
- */
-unsigned int gcov_info_version(struct gcov_info *info)
-{
-	return info->version;
-}
-
-/**
- * gcov_info_next - return next profiling data set
- * @info: profiling data set
- *
- * Returns next gcov_info following @info or first gcov_info in the chain if
- * @info is %NULL.
- */
-struct gcov_info *gcov_info_next(struct gcov_info *info)
-{
-	if (!info)
-		return gcov_info_head;
-
-	return info->next;
-}
-
-/**
- * gcov_info_link - link/add profiling data set to the list
- * @info: profiling data set
- */
-void gcov_info_link(struct gcov_info *info)
-{
-	info->next = gcov_info_head;
-	gcov_info_head = info;
-}
-
-/**
- * gcov_info_unlink - unlink/remove profiling data set from the list
- * @prev: previous profiling data set
- * @info: profiling data set
- */
-void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info)
-{
-	if (prev)
-		prev->next = info->next;
-	else
-		gcov_info_head = info->next;
-}
-
-/**
- * gcov_info_within_module - check if a profiling data set belongs to a module
- * @info: profiling data set
- * @mod: module
- *
- * Returns true if profiling data belongs module, false otherwise.
- */
-bool gcov_info_within_module(struct gcov_info *info, struct module *mod)
-{
-	return within_module((unsigned long)info, mod);
-}
-
-/* Symbolic links to be created for each profiling data file. */
-const struct gcov_link gcov_link[] = {
-	{ OBJ_TREE, "gcno" },	/* Link to .gcno file in $(objtree). */
-	{ 0, NULL},
-};
-
-/*
- * Determine whether a counter is active. Based on gcc magic. Doesn't change
- * at run-time.
- */
-static int counter_active(struct gcov_info *info, unsigned int type)
-{
-	return (1 << type) & info->ctr_mask;
-}
-
-/* Determine number of active counters. Based on gcc magic. */
-static unsigned int num_counter_active(struct gcov_info *info)
-{
-	unsigned int i;
-	unsigned int result = 0;
-
-	for (i = 0; i < GCOV_COUNTERS; i++) {
-		if (counter_active(info, i))
-			result++;
-	}
-	return result;
-}
-
-/**
- * gcov_info_reset - reset profiling data to zero
- * @info: profiling data set
- */
-void gcov_info_reset(struct gcov_info *info)
-{
-	unsigned int active = num_counter_active(info);
-	unsigned int i;
-
-	for (i = 0; i < active; i++) {
-		memset(info->counts[i].values, 0,
-		       info->counts[i].num * sizeof(gcov_type));
-	}
-}
-
-/**
- * gcov_info_is_compatible - check if profiling data can be added
- * @info1: first profiling data set
- * @info2: second profiling data set
- *
- * Returns non-zero if profiling data can be added, zero otherwise.
- */
-int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
-{
-	return (info1->stamp == info2->stamp);
-}
-
-/**
- * gcov_info_add - add up profiling data
- * @dest: profiling data set to which data is added
- * @source: profiling data set which is added
- *
- * Adds profiling counts of @source to @dest.
- */
-void gcov_info_add(struct gcov_info *dest, struct gcov_info *source)
-{
-	unsigned int i;
-	unsigned int j;
-
-	for (i = 0; i < num_counter_active(dest); i++) {
-		for (j = 0; j < dest->counts[i].num; j++) {
-			dest->counts[i].values[j] +=
-				source->counts[i].values[j];
-		}
-	}
-}
-
-/* Get size of function info entry. Based on gcc magic. */
-static size_t get_fn_size(struct gcov_info *info)
-{
-	size_t size;
-
-	size = sizeof(struct gcov_fn_info) + num_counter_active(info) *
-	       sizeof(unsigned int);
-	if (__alignof__(struct gcov_fn_info) > sizeof(unsigned int))
-		size = ALIGN(size, __alignof__(struct gcov_fn_info));
-	return size;
-}
-
-/* Get address of function info entry. Based on gcc magic. */
-static struct gcov_fn_info *get_fn_info(struct gcov_info *info, unsigned int fn)
-{
-	return (struct gcov_fn_info *)
-		((char *) info->functions + fn * get_fn_size(info));
-}
-
-/**
- * gcov_info_dup - duplicate profiling data set
- * @info: profiling data set to duplicate
- *
- * Return newly allocated duplicate on success, %NULL on error.
- */
-struct gcov_info *gcov_info_dup(struct gcov_info *info)
-{
-	struct gcov_info *dup;
-	unsigned int i;
-	unsigned int active;
-
-	/* Duplicate gcov_info. */
-	active = num_counter_active(info);
-	dup = kzalloc(struct_size(dup, counts, active), GFP_KERNEL);
-	if (!dup)
-		return NULL;
-	dup->version		= info->version;
-	dup->stamp		= info->stamp;
-	dup->n_functions	= info->n_functions;
-	dup->ctr_mask		= info->ctr_mask;
-	/* Duplicate filename. */
-	dup->filename		= kstrdup(info->filename, GFP_KERNEL);
-	if (!dup->filename)
-		goto err_free;
-	/* Duplicate table of functions. */
-	dup->functions = kmemdup(info->functions, info->n_functions *
-				 get_fn_size(info), GFP_KERNEL);
-	if (!dup->functions)
-		goto err_free;
-	/* Duplicate counter arrays. */
-	for (i = 0; i < active ; i++) {
-		struct gcov_ctr_info *ctr = &info->counts[i];
-		size_t size = ctr->num * sizeof(gcov_type);
-
-		dup->counts[i].num = ctr->num;
-		dup->counts[i].merge = ctr->merge;
-		dup->counts[i].values = vmalloc(size);
-		if (!dup->counts[i].values)
-			goto err_free;
-		memcpy(dup->counts[i].values, ctr->values, size);
-	}
-	return dup;
-
-err_free:
-	gcov_info_free(dup);
-	return NULL;
-}
-
-/**
- * gcov_info_free - release memory for profiling data set duplicate
- * @info: profiling data set duplicate to free
- */
-void gcov_info_free(struct gcov_info *info)
-{
-	unsigned int active = num_counter_active(info);
-	unsigned int i;
-
-	for (i = 0; i < active ; i++)
-		vfree(info->counts[i].values);
-	kfree(info->functions);
-	kfree(info->filename);
-	kfree(info);
-}
-
-/**
- * struct type_info - iterator helper array
- * @ctr_type: counter type
- * @offset: index of the first value of the current function for this type
- *
- * This array is needed to convert the in-memory data format into the in-file
- * data format:
- *
- * In-memory:
- *   for each counter type
- *     for each function
- *       values
- *
- * In-file:
- *   for each function
- *     for each counter type
- *       values
- *
- * See gcc source gcc/gcov-io.h for more information on data organization.
- */
-struct type_info {
-	int ctr_type;
-	unsigned int offset;
-};
-
-/**
- * struct gcov_iterator - specifies current file position in logical records
- * @info: associated profiling data
- * @record: record type
- * @function: function number
- * @type: counter type
- * @count: index into values array
- * @num_types: number of counter types
- * @type_info: helper array to get values-array offset for current function
- */
-struct gcov_iterator {
-	struct gcov_info *info;
-
-	int record;
-	unsigned int function;
-	unsigned int type;
-	unsigned int count;
-
-	int num_types;
-	struct type_info type_info[];
-};
-
-static struct gcov_fn_info *get_func(struct gcov_iterator *iter)
-{
-	return get_fn_info(iter->info, iter->function);
-}
-
-static struct type_info *get_type(struct gcov_iterator *iter)
-{
-	return &iter->type_info[iter->type];
-}
-
-/**
- * gcov_iter_new - allocate and initialize profiling data iterator
- * @info: profiling data set to be iterated
- *
- * Return file iterator on success, %NULL otherwise.
- */
-struct gcov_iterator *gcov_iter_new(struct gcov_info *info)
-{
-	struct gcov_iterator *iter;
-
-	iter = kzalloc(struct_size(iter, type_info, num_counter_active(info)),
-		       GFP_KERNEL);
-	if (iter)
-		iter->info = info;
-
-	return iter;
-}
-
-/**
- * gcov_iter_free - release memory for iterator
- * @iter: file iterator to free
- */
-void gcov_iter_free(struct gcov_iterator *iter)
-{
-	kfree(iter);
-}
-
-/**
- * gcov_iter_get_info - return profiling data set for given file iterator
- * @iter: file iterator
- */
-struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)
-{
-	return iter->info;
-}
-
-/**
- * gcov_iter_start - reset file iterator to starting position
- * @iter: file iterator
- */
-void gcov_iter_start(struct gcov_iterator *iter)
-{
-	int i;
-
-	iter->record = 0;
-	iter->function = 0;
-	iter->type = 0;
-	iter->count = 0;
-	iter->num_types = 0;
-	for (i = 0; i < GCOV_COUNTERS; i++) {
-		if (counter_active(iter->info, i)) {
-			iter->type_info[iter->num_types].ctr_type = i;
-			iter->type_info[iter->num_types++].offset = 0;
-		}
-	}
-}
-
-/* Mapping of logical record number to actual file content. */
-#define RECORD_FILE_MAGIC	0
-#define RECORD_GCOV_VERSION	1
-#define RECORD_TIME_STAMP	2
-#define RECORD_FUNCTION_TAG	3
-#define RECORD_FUNCTON_TAG_LEN	4
-#define RECORD_FUNCTION_IDENT	5
-#define RECORD_FUNCTION_CHECK	6
-#define RECORD_COUNT_TAG	7
-#define RECORD_COUNT_LEN	8
-#define RECORD_COUNT		9
-
-/**
- * gcov_iter_next - advance file iterator to next logical record
- * @iter: file iterator
- *
- * Return zero if new position is valid, non-zero if iterator has reached end.
- */
-int gcov_iter_next(struct gcov_iterator *iter)
-{
-	switch (iter->record) {
-	case RECORD_FILE_MAGIC:
-	case RECORD_GCOV_VERSION:
-	case RECORD_FUNCTION_TAG:
-	case RECORD_FUNCTON_TAG_LEN:
-	case RECORD_FUNCTION_IDENT:
-	case RECORD_COUNT_TAG:
-		/* Advance to next record */
-		iter->record++;
-		break;
-	case RECORD_COUNT:
-		/* Advance to next count */
-		iter->count++;
-		/* fall through */
-	case RECORD_COUNT_LEN:
-		if (iter->count < get_func(iter)->n_ctrs[iter->type]) {
-			iter->record = 9;
-			break;
-		}
-		/* Advance to next counter type */
-		get_type(iter)->offset += iter->count;
-		iter->count = 0;
-		iter->type++;
-		/* fall through */
-	case RECORD_FUNCTION_CHECK:
-		if (iter->type < iter->num_types) {
-			iter->record = 7;
-			break;
-		}
-		/* Advance to next function */
-		iter->type = 0;
-		iter->function++;
-		/* fall through */
-	case RECORD_TIME_STAMP:
-		if (iter->function < iter->info->n_functions)
-			iter->record = 3;
-		else
-			iter->record = -1;
-		break;
-	}
-	/* Check for EOF. */
-	if (iter->record == -1)
-		return -EINVAL;
-	else
-		return 0;
-}
-
-/**
- * seq_write_gcov_u32 - write 32 bit number in gcov format to seq_file
- * @seq: seq_file handle
- * @v: value to be stored
- *
- * Number format defined by gcc: numbers are recorded in the 32 bit
- * unsigned binary form of the endianness of the machine generating the
- * file.
- */
-static int seq_write_gcov_u32(struct seq_file *seq, u32 v)
-{
-	return seq_write(seq, &v, sizeof(v));
-}
-
-/**
- * seq_write_gcov_u64 - write 64 bit number in gcov format to seq_file
- * @seq: seq_file handle
- * @v: value to be stored
- *
- * Number format defined by gcc: numbers are recorded in the 32 bit
- * unsigned binary form of the endianness of the machine generating the
- * file. 64 bit numbers are stored as two 32 bit numbers, the low part
- * first.
- */
-static int seq_write_gcov_u64(struct seq_file *seq, u64 v)
-{
-	u32 data[2];
-
-	data[0] = (v & 0xffffffffUL);
-	data[1] = (v >> 32);
-	return seq_write(seq, data, sizeof(data));
-}
-
-/**
- * gcov_iter_write - write data for current pos to seq_file
- * @iter: file iterator
- * @seq: seq_file handle
- *
- * Return zero on success, non-zero otherwise.
- */
-int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)
-{
-	int rc = -EINVAL;
-
-	switch (iter->record) {
-	case RECORD_FILE_MAGIC:
-		rc = seq_write_gcov_u32(seq, GCOV_DATA_MAGIC);
-		break;
-	case RECORD_GCOV_VERSION:
-		rc = seq_write_gcov_u32(seq, iter->info->version);
-		break;
-	case RECORD_TIME_STAMP:
-		rc = seq_write_gcov_u32(seq, iter->info->stamp);
-		break;
-	case RECORD_FUNCTION_TAG:
-		rc = seq_write_gcov_u32(seq, GCOV_TAG_FUNCTION);
-		break;
-	case RECORD_FUNCTON_TAG_LEN:
-		rc = seq_write_gcov_u32(seq, 2);
-		break;
-	case RECORD_FUNCTION_IDENT:
-		rc = seq_write_gcov_u32(seq, get_func(iter)->ident);
-		break;
-	case RECORD_FUNCTION_CHECK:
-		rc = seq_write_gcov_u32(seq, get_func(iter)->checksum);
-		break;
-	case RECORD_COUNT_TAG:
-		rc = seq_write_gcov_u32(seq,
-			GCOV_TAG_FOR_COUNTER(get_type(iter)->ctr_type));
-		break;
-	case RECORD_COUNT_LEN:
-		rc = seq_write_gcov_u32(seq,
-				get_func(iter)->n_ctrs[iter->type] * 2);
-		break;
-	case RECORD_COUNT:
-		rc = seq_write_gcov_u64(seq,
-			iter->info->counts[iter->type].
-				values[iter->count + get_type(iter)->offset]);
-		break;
-	}
-	return rc;
-}
-- 
2.26.0.110.g2183baf09c-goog


^ permalink raw reply related	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 01/12] compiler/gcc: Emit build-time warning for GCC prior to version 4.8
  2020-04-15 16:52 ` [PATCH v3 01/12] compiler/gcc: Emit build-time warning for GCC prior to version 4.8 Will Deacon
@ 2020-04-15 17:20   ` Masahiro Yamada
  0 siblings, 0 replies; 26+ messages in thread
From: Masahiro Yamada @ 2020-04-15 17:20 UTC (permalink / raw)
  To: Will Deacon
  Cc: Linux Kernel Mailing List, linux-arch, Cc: Android Kernel,
	Michael Ellerman, Peter Zijlstra, Linus Torvalds,
	Segher Boessenkool, Christian Borntraeger, Luc Van Oostenryck,
	Arnd Bergmann, Peter Oberparleiter, Nick Desaulniers

On Thu, Apr 16, 2020 at 1:52 AM Will Deacon <will@kernel.org> wrote:
>
> Prior to version 4.8, GCC may miscompile READ_ONCE() by erroneously
> discarding the 'volatile' qualifier:
>
> https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145
>
> We've been working around this using some nasty hacks which make
> READ_ONCE() both horribly complicated and also prevent us from enforcing
> that it is only used on scalar types. Since GCC 4.8 is pretty old for
> kernel builds now, emit a warning if we detect it during the build.


This patch is unneeded since you will remove GCC 4.8 support
in 11/12.

Please move 11/12 to the head of this series,
and remove all noise changes.

Thanks.






> Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
> Cc: Peter Zijlstra <peterz@infradead.org>
> Cc: Michael Ellerman <mpe@ellerman.id.au>
> Cc: Arnd Bergmann <arnd@arndb.de>
> Cc: Christian Borntraeger <borntraeger@de.ibm.com>
> Cc: Masahiro Yamada <masahiroy@kernel.org>
> Signed-off-by: Will Deacon <will@kernel.org>
> ---
>  init/Kconfig            | 4 ++--
>  scripts/Kconfig.include | 9 +++++++++
>  2 files changed, 11 insertions(+), 2 deletions(-)
>
> diff --git a/init/Kconfig b/init/Kconfig
> index 9e22ee8fbd75..816b8b4a5e9e 100644
> --- a/init/Kconfig
> +++ b/init/Kconfig
> @@ -9,11 +9,11 @@ config DEFCONFIG_LIST
>         default "arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG)"
>
>  config CC_IS_GCC
> -       def_bool $(success,$(CC) --version | head -n 1 | grep -q gcc)
> +       def_bool $(cc-is-gcc)
>
>  config GCC_VERSION
>         int
> -       default $(shell,$(srctree)/scripts/gcc-version.sh $(CC)) if CC_IS_GCC
> +       default $(gcc-version) if CC_IS_GCC
>         default 0
>
>  config LD_VERSION
> diff --git a/scripts/Kconfig.include b/scripts/Kconfig.include
> index c264da2b9b30..5261e9d6b50b 100644
> --- a/scripts/Kconfig.include
> +++ b/scripts/Kconfig.include
> @@ -54,3 +54,12 @@ $(error-if,$(success, $(LD) -v | grep -q gold), gold linker '$(LD)' not supporte
>  cc-option-bit = $(if-success,$(CC) -Werror $(1) -E -x c /dev/null -o /dev/null,$(1))
>  m32-flag := $(cc-option-bit,-m32)
>  m64-flag := $(cc-option-bit,-m64)
> +
> +# gcc version including patch level
> +gcc-version := $(shell,$(srctree)/scripts/gcc-version.sh $(CC))
> +
> +# Return y if the compiler is GCC, n otherwise
> +cc-is-gcc := $(success,$(CC) --version | head -n 1 | grep -q gcc)
> +
> +# Warn if the compiler is GCC prior to 4.8
> +$(warning-if,$(if-success,[ $(gcc-version) -lt 40800 ],$(cc-is-gcc),n),"Your compiler is old and may miscompile the kernel due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145 - please upgrade it.")
> --
> 2.26.0.110.g2183baf09c-goog
>


-- 
Best Regards
Masahiro Yamada

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-15 16:52 ` [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum() Will Deacon
@ 2020-04-15 17:28   ` Mark Rutland
  2020-04-15 18:42     ` Arnd Bergmann
  2020-04-15 19:26     ` Will Deacon
  2020-04-15 19:26   ` Robin Murphy
  1 sibling, 2 replies; 26+ messages in thread
From: Mark Rutland @ 2020-04-15 17:28 UTC (permalink / raw)
  To: Will Deacon
  Cc: linux-kernel, linux-arch, kernel-team, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Robin Murphy

Hi Will,

On Wed, Apr 15, 2020 at 05:52:11PM +0100, Will Deacon wrote:
> do_csum() over-reads the source buffer and therefore abuses
> READ_ONCE_NOCHECK() to avoid tripping up KASAN. In preparation for
> READ_ONCE_NOCHECK() becoming a macro, and therefore losing its
> '__no_sanitize_address' annotation, just annotate do_csum() explicitly
> and fall back to normal loads.

I'm confused by this. The whole point of READ_ONCE_NOCHECK() is that it
isn't checked by KASAN, so if that semantic is removed it has no reason
to exist.

Changing that will break the unwind/stacktrace code across multiple
architectures. IIRC they use READ_ONCE_NOCHECK() for two reasons:

1. Races with concurrent modification, as might happen when a thread's
   stack is corrupted. Allowing the unwinder to bail out after a sanity
   check means the resulting report is more useful than a KASAN splat in
   the unwinder. I made the arm64 unwinder robust to this case.

2. I believe that the frame record itself /might/ be poisoned by KASAN,
   since it's not meant to be an accessible object at the C langauge
   level. I could be wrong about this, and would have to check.
 
I would like to keep the unwinding robust in the first case, even if the
second case doesn't apply, and I'd prefer to not mark the entirety of
the unwinding code as unchecked as that's sufficiently large an subtle
that it could have nasty bugs.

Is there any way we keep something like READ_ONCE_NOCHECK() around even
if we have to give it reduced functionality relative to READ_ONCE()?

I'm not enirely sure why READ_ONCE_NOCHECK() had to go, so if there's a
particular pain point I'm happy to take a look.

Thanks,
Mark.

> 
> Cc: Mark Rutland <mark.rutland@arm.com>
> Cc: Robin Murphy <robin.murphy@arm.com>
> Signed-off-by: Will Deacon <will@kernel.org>
> ---
>  arch/arm64/lib/csum.c | 20 ++++++++++++--------
>  1 file changed, 12 insertions(+), 8 deletions(-)
> 
> diff --git a/arch/arm64/lib/csum.c b/arch/arm64/lib/csum.c
> index 60eccae2abad..78b87a64ca0a 100644
> --- a/arch/arm64/lib/csum.c
> +++ b/arch/arm64/lib/csum.c
> @@ -14,7 +14,11 @@ static u64 accumulate(u64 sum, u64 data)
>  	return tmp + (tmp >> 64);
>  }
>  
> -unsigned int do_csum(const unsigned char *buff, int len)
> +/*
> + * We over-read the buffer and this makes KASAN unhappy. Instead, disable
> + * instrumentation and call kasan explicitly.
> + */
> +unsigned int __no_sanitize_address do_csum(const unsigned char *buff, int len)
>  {
>  	unsigned int offset, shift, sum;
>  	const u64 *ptr;
> @@ -42,7 +46,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
>  	 * odd/even alignment, and means we can ignore it until the very end.
>  	 */
>  	shift = offset * 8;
> -	data = READ_ONCE_NOCHECK(*ptr++);
> +	data = *ptr++;
>  #ifdef __LITTLE_ENDIAN
>  	data = (data >> shift) << shift;
>  #else
> @@ -58,10 +62,10 @@ unsigned int do_csum(const unsigned char *buff, int len)
>  	while (unlikely(len > 64)) {
>  		__uint128_t tmp1, tmp2, tmp3, tmp4;
>  
> -		tmp1 = READ_ONCE_NOCHECK(*(__uint128_t *)ptr);
> -		tmp2 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 2));
> -		tmp3 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 4));
> -		tmp4 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 6));
> +		tmp1 = *(__uint128_t *)ptr;
> +		tmp2 = *(__uint128_t *)(ptr + 2);
> +		tmp3 = *(__uint128_t *)(ptr + 4);
> +		tmp4 = *(__uint128_t *)(ptr + 6);
>  
>  		len -= 64;
>  		ptr += 8;
> @@ -85,7 +89,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
>  		__uint128_t tmp;
>  
>  		sum64 = accumulate(sum64, data);
> -		tmp = READ_ONCE_NOCHECK(*(__uint128_t *)ptr);
> +		tmp = *(__uint128_t *)ptr;
>  
>  		len -= 16;
>  		ptr += 2;
> @@ -100,7 +104,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
>  	}
>  	if (len > 0) {
>  		sum64 = accumulate(sum64, data);
> -		data = READ_ONCE_NOCHECK(*ptr);
> +		data = *ptr;
>  		len -= 8;
>  	}
>  	/*
> -- 
> 2.26.0.110.g2183baf09c-goog
> 

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 11/12] compiler/gcc: Raise minimum GCC version for kernel builds to 4.8
  2020-04-15 16:52 ` [PATCH v3 11/12] compiler/gcc: Raise minimum GCC version for kernel builds to 4.8 Will Deacon
@ 2020-04-15 18:37   ` Arnd Bergmann
  0 siblings, 0 replies; 26+ messages in thread
From: Arnd Bergmann @ 2020-04-15 18:37 UTC (permalink / raw)
  To: Will Deacon
  Cc: linux-kernel, linux-arch, Android Kernel Team, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Peter Oberparleiter,
	Masahiro Yamada, Nick Desaulniers

On Wed, Apr 15, 2020 at 6:53 PM Will Deacon <will@kernel.org> wrote:
>
> It is very rare to see versions of GCC prior to 4.8 being used to build
> the mainline kernel. These old compilers are also know to have codegen
> issues which can lead to silent miscompilation:
>
> https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145
>
> Raise the minimum GCC version for kernel build to 4.8 and remove some
> tautological Kconfig dependencies as a consequence.
>
> Cc: Arnd Bergmann <arnd@arndb.de>
> Cc: Masahiro Yamada <masahiroy@kernel.org>
> Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
> Signed-off-by: Will Deacon <will@kernel.org>

Acked-by: Arnd Bergmann <arnd@arndb.de>

On a related note, I've updated the cross-compilers on kernel.org and
done some randconfig testing on all major versions from v4.8 to 9.3.
There were a couple of minor regressions with 4.8 (mostly harmless
warnings), but overall gcc-4.8 is still working well. I did not try older
compilers.

       Arnd

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-15 17:28   ` Mark Rutland
@ 2020-04-15 18:42     ` Arnd Bergmann
  2020-04-15 19:43       ` Will Deacon
  2020-04-15 19:26     ` Will Deacon
  1 sibling, 1 reply; 26+ messages in thread
From: Arnd Bergmann @ 2020-04-15 18:42 UTC (permalink / raw)
  To: Mark Rutland
  Cc: Will Deacon, linux-kernel, linux-arch, Android Kernel Team,
	Michael Ellerman, Peter Zijlstra, Linus Torvalds,
	Segher Boessenkool, Christian Borntraeger, Luc Van Oostenryck,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Robin Murphy

On Wed, Apr 15, 2020 at 7:28 PM Mark Rutland <mark.rutland@arm.com> wrote:
>
> Hi Will,
>
> On Wed, Apr 15, 2020 at 05:52:11PM +0100, Will Deacon wrote:
> > do_csum() over-reads the source buffer and therefore abuses
> > READ_ONCE_NOCHECK() to avoid tripping up KASAN. In preparation for
> > READ_ONCE_NOCHECK() becoming a macro, and therefore losing its
> > '__no_sanitize_address' annotation, just annotate do_csum() explicitly
> > and fall back to normal loads.
>
> I'm confused by this. The whole point of READ_ONCE_NOCHECK() is that it
> isn't checked by KASAN, so if that semantic is removed it has no reason
> to exist.
>
> Changing that will break the unwind/stacktrace code across multiple
> architectures. IIRC they use READ_ONCE_NOCHECK() for two reasons:
>
> 1. Races with concurrent modification, as might happen when a thread's
>    stack is corrupted. Allowing the unwinder to bail out after a sanity
>    check means the resulting report is more useful than a KASAN splat in
>    the unwinder. I made the arm64 unwinder robust to this case.
>
> 2. I believe that the frame record itself /might/ be poisoned by KASAN,
>    since it's not meant to be an accessible object at the C langauge
>    level. I could be wrong about this, and would have to check.

I thought the main reason was deadlocks when a READ_ONCE()
is called inside of code that is part of the KASAN handling. If
READ_ONCE() ends up recursively calling itself, the kernel
tends to crash once it overflows its stack.

> I would like to keep the unwinding robust in the first case, even if the
> second case doesn't apply, and I'd prefer to not mark the entirety of
> the unwinding code as unchecked as that's sufficiently large an subtle
> that it could have nasty bugs.
>
> Is there any way we keep something like READ_ONCE_NOCHECK() around even
> if we have to give it reduced functionality relative to READ_ONCE()?
>
> I'm not enirely sure why READ_ONCE_NOCHECK() had to go, so if there's a
> particular pain point I'm happy to take a look.

As I understood, only this particular instance was removed, not all of them.

         Arnd

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-15 17:28   ` Mark Rutland
  2020-04-15 18:42     ` Arnd Bergmann
@ 2020-04-15 19:26     ` Will Deacon
  2020-04-16  9:31       ` Mark Rutland
  1 sibling, 1 reply; 26+ messages in thread
From: Will Deacon @ 2020-04-15 19:26 UTC (permalink / raw)
  To: Mark Rutland
  Cc: linux-kernel, linux-arch, kernel-team, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Robin Murphy

On Wed, Apr 15, 2020 at 06:28:14PM +0100, Mark Rutland wrote:
> On Wed, Apr 15, 2020 at 05:52:11PM +0100, Will Deacon wrote:
> > do_csum() over-reads the source buffer and therefore abuses
> > READ_ONCE_NOCHECK() to avoid tripping up KASAN. In preparation for
> > READ_ONCE_NOCHECK() becoming a macro, and therefore losing its
> > '__no_sanitize_address' annotation, just annotate do_csum() explicitly
> > and fall back to normal loads.
> 
> I'm confused by this. The whole point of READ_ONCE_NOCHECK() is that it
> isn't checked by KASAN, so if that semantic is removed it has no reason
> to exist.

Oh, I thought it was there to be used by things like KASAN itself and
because READ_ONCE() was implemented using a static function, then that
function had to be marked as __no_sanitize_address when used in these
cases. Now that it's just a macro, that's not necessary so it's just
the same as normal READ_ONCE().

Do we have a "nocheck" version where we don't require the READ_ONCE()
semantics? I think abusing a relaxed concurrency primitive for this is
not the right thing to do, particularly when the __no_sanitize_address
annotation is available. I fact, it's almost an argument in favour
of removing READ_ONCE_NOCHECK() so that people use the annotation instead!

> Changing that will break the unwind/stacktrace code across multiple
> architectures. IIRC they use READ_ONCE_NOCHECK() for two reasons:
> 
> 1. Races with concurrent modification, as might happen when a thread's
>    stack is corrupted. Allowing the unwinder to bail out after a sanity
>    check means the resulting report is more useful than a KASAN splat in
>    the unwinder. I made the arm64 unwinder robust to this case.
> 
> 2. I believe that the frame record itself /might/ be poisoned by KASAN,
>    since it's not meant to be an accessible object at the C langauge
>    level. I could be wrong about this, and would have to check.

Ok.

> I would like to keep the unwinding robust in the first case, even if the
> second case doesn't apply, and I'd prefer to not mark the entirety of
> the unwinding code as unchecked as that's sufficiently large an subtle
> that it could have nasty bugs.

Hmm, maybe. I don't really see what's wrong with annotating the unwinding
code, though. You can still tell kasan about the accesses you're making,
like we do in the checksumming code here, and it's not hard to move the
frame-pointer chasing code into a separate function.

> Is there any way we keep something like READ_ONCE_NOCHECK() around even
> if we have to give it reduced functionality relative to READ_ONCE()?
> 
> I'm not enirely sure why READ_ONCE_NOCHECK() had to go, so if there's a
> particular pain point I'm happy to take a look.

I got rid if it because I thought it wasn't required now that it's
implemented entirely as a macro. I'd be reluctant to bring it back if
there isn't a non-ONCE version of the helper.

Will

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-15 16:52 ` [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum() Will Deacon
  2020-04-15 17:28   ` Mark Rutland
@ 2020-04-15 19:26   ` Robin Murphy
  1 sibling, 0 replies; 26+ messages in thread
From: Robin Murphy @ 2020-04-15 19:26 UTC (permalink / raw)
  To: Will Deacon, linux-kernel
  Cc: linux-arch, kernel-team, Michael Ellerman, Peter Zijlstra,
	Linus Torvalds, Segher Boessenkool, Christian Borntraeger,
	Luc Van Oostenryck, Arnd Bergmann, Peter Oberparleiter,
	Masahiro Yamada, Nick Desaulniers, Mark Rutland

On 2020-04-15 5:52 pm, Will Deacon wrote:
> do_csum() over-reads the source buffer and therefore abuses
> READ_ONCE_NOCHECK() to avoid tripping up KASAN. In preparation for
> READ_ONCE_NOCHECK() becoming a macro, and therefore losing its
> '__no_sanitize_address' annotation, just annotate do_csum() explicitly
> and fall back to normal loads.

FWIW with most compilers I played with, the read-once-ness *was* also 
important to ensure the uint128_t accesses compose to nice efficient 
LDPs rather than being split into a motley mess of individual LDRs.

The buffer loads that aren't the first or potentially the last didn't 
strictly need to be nocheck, however since the whole range gets 
explicitly checked up-front they may as well avoid further unnecessary 
KASAN penalty, plus it made things look nice and consistent :)

Robin.

> Cc: Mark Rutland <mark.rutland@arm.com>
> Cc: Robin Murphy <robin.murphy@arm.com>
> Signed-off-by: Will Deacon <will@kernel.org>
> ---
>   arch/arm64/lib/csum.c | 20 ++++++++++++--------
>   1 file changed, 12 insertions(+), 8 deletions(-)
> 
> diff --git a/arch/arm64/lib/csum.c b/arch/arm64/lib/csum.c
> index 60eccae2abad..78b87a64ca0a 100644
> --- a/arch/arm64/lib/csum.c
> +++ b/arch/arm64/lib/csum.c
> @@ -14,7 +14,11 @@ static u64 accumulate(u64 sum, u64 data)
>   	return tmp + (tmp >> 64);
>   }
>   
> -unsigned int do_csum(const unsigned char *buff, int len)
> +/*
> + * We over-read the buffer and this makes KASAN unhappy. Instead, disable
> + * instrumentation and call kasan explicitly.
> + */
> +unsigned int __no_sanitize_address do_csum(const unsigned char *buff, int len)
>   {
>   	unsigned int offset, shift, sum;
>   	const u64 *ptr;
> @@ -42,7 +46,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
>   	 * odd/even alignment, and means we can ignore it until the very end.
>   	 */
>   	shift = offset * 8;
> -	data = READ_ONCE_NOCHECK(*ptr++);
> +	data = *ptr++;
>   #ifdef __LITTLE_ENDIAN
>   	data = (data >> shift) << shift;
>   #else
> @@ -58,10 +62,10 @@ unsigned int do_csum(const unsigned char *buff, int len)
>   	while (unlikely(len > 64)) {
>   		__uint128_t tmp1, tmp2, tmp3, tmp4;
>   
> -		tmp1 = READ_ONCE_NOCHECK(*(__uint128_t *)ptr);
> -		tmp2 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 2));
> -		tmp3 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 4));
> -		tmp4 = READ_ONCE_NOCHECK(*(__uint128_t *)(ptr + 6));
> +		tmp1 = *(__uint128_t *)ptr;
> +		tmp2 = *(__uint128_t *)(ptr + 2);
> +		tmp3 = *(__uint128_t *)(ptr + 4);
> +		tmp4 = *(__uint128_t *)(ptr + 6);
>   
>   		len -= 64;
>   		ptr += 8;
> @@ -85,7 +89,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
>   		__uint128_t tmp;
>   
>   		sum64 = accumulate(sum64, data);
> -		tmp = READ_ONCE_NOCHECK(*(__uint128_t *)ptr);
> +		tmp = *(__uint128_t *)ptr;
>   
>   		len -= 16;
>   		ptr += 2;
> @@ -100,7 +104,7 @@ unsigned int do_csum(const unsigned char *buff, int len)
>   	}
>   	if (len > 0) {
>   		sum64 = accumulate(sum64, data);
> -		data = READ_ONCE_NOCHECK(*ptr);
> +		data = *ptr;
>   		len -= 8;
>   	}
>   	/*
> 

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-15 18:42     ` Arnd Bergmann
@ 2020-04-15 19:43       ` Will Deacon
  2020-04-15 20:10         ` Will Deacon
  0 siblings, 1 reply; 26+ messages in thread
From: Will Deacon @ 2020-04-15 19:43 UTC (permalink / raw)
  To: Arnd Bergmann
  Cc: Mark Rutland, linux-kernel, linux-arch, Android Kernel Team,
	Michael Ellerman, Peter Zijlstra, Linus Torvalds,
	Segher Boessenkool, Christian Borntraeger, Luc Van Oostenryck,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Robin Murphy

On Wed, Apr 15, 2020 at 08:42:16PM +0200, Arnd Bergmann wrote:
> On Wed, Apr 15, 2020 at 7:28 PM Mark Rutland <mark.rutland@arm.com> wrote:
> > On Wed, Apr 15, 2020 at 05:52:11PM +0100, Will Deacon wrote:
> > > do_csum() over-reads the source buffer and therefore abuses
> > > READ_ONCE_NOCHECK() to avoid tripping up KASAN. In preparation for
> > > READ_ONCE_NOCHECK() becoming a macro, and therefore losing its
> > > '__no_sanitize_address' annotation, just annotate do_csum() explicitly
> > > and fall back to normal loads.
> >
> > I'm confused by this. The whole point of READ_ONCE_NOCHECK() is that it
> > isn't checked by KASAN, so if that semantic is removed it has no reason
> > to exist.
> >
> > Changing that will break the unwind/stacktrace code across multiple
> > architectures. IIRC they use READ_ONCE_NOCHECK() for two reasons:
> >
> > 1. Races with concurrent modification, as might happen when a thread's
> >    stack is corrupted. Allowing the unwinder to bail out after a sanity
> >    check means the resulting report is more useful than a KASAN splat in
> >    the unwinder. I made the arm64 unwinder robust to this case.
> >
> > 2. I believe that the frame record itself /might/ be poisoned by KASAN,
> >    since it's not meant to be an accessible object at the C langauge
> >    level. I could be wrong about this, and would have to check.
> 
> I thought the main reason was deadlocks when a READ_ONCE()
> is called inside of code that is part of the KASAN handling. If
> READ_ONCE() ends up recursively calling itself, the kernel
> tends to crash once it overflows its stack.

That was also my understanding.

> > I would like to keep the unwinding robust in the first case, even if the
> > second case doesn't apply, and I'd prefer to not mark the entirety of
> > the unwinding code as unchecked as that's sufficiently large an subtle
> > that it could have nasty bugs.
> >
> > Is there any way we keep something like READ_ONCE_NOCHECK() around even
> > if we have to give it reduced functionality relative to READ_ONCE()?
> >
> > I'm not enirely sure why READ_ONCE_NOCHECK() had to go, so if there's a
> > particular pain point I'm happy to take a look.
> 
> As I understood, only this particular instance was removed, not all of
> them.

Right, but the problem is that whether the NOCHECK version gets checked
or not now depends on the caller, since it's all just a macro. If we want
to fix this, then we could force the nocheck variant to return unsigned
long, which simplifies things a lot (completely untested):


#define READ_ONCE(x)							\
({									\
	compiletime_assert_rwonce_type(x);				\
	__READ_ONCE_SCALAR(x);						\
})

unsigned long __no_sanitise_address
kasan_nocheck_read_once_ul(const volatile void *p)
{
	return READ_ONCE(*p);
}

/* Please don't use this */
#define READ_ONCE_NOCHECK(x)	kasan_nocheck_read_once_ul(&x)


which would make sense for the unwinders, where there is concurrency
involved, but I'd be inclined to have them call kasan_nocheck_read_once_ul()
directly and ditch READ_ONCE_NOCHECK() so that it doesn't get used for
single-threaded code as a convenience to avoid annotation.

What do you think?

Will

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-15 19:43       ` Will Deacon
@ 2020-04-15 20:10         ` Will Deacon
  0 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-15 20:10 UTC (permalink / raw)
  To: Arnd Bergmann
  Cc: Mark Rutland, linux-kernel, linux-arch, Android Kernel Team,
	Michael Ellerman, Peter Zijlstra, Linus Torvalds,
	Segher Boessenkool, Christian Borntraeger, Luc Van Oostenryck,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Robin Murphy

On Wed, Apr 15, 2020 at 08:43:05PM +0100, Will Deacon wrote:
> On Wed, Apr 15, 2020 at 08:42:16PM +0200, Arnd Bergmann wrote:
> > On Wed, Apr 15, 2020 at 7:28 PM Mark Rutland <mark.rutland@arm.com> wrote:
> > > On Wed, Apr 15, 2020 at 05:52:11PM +0100, Will Deacon wrote:
> > > > do_csum() over-reads the source buffer and therefore abuses
> > > > READ_ONCE_NOCHECK() to avoid tripping up KASAN. In preparation for
> > > > READ_ONCE_NOCHECK() becoming a macro, and therefore losing its
> > > > '__no_sanitize_address' annotation, just annotate do_csum() explicitly
> > > > and fall back to normal loads.
> > >
> > > I'm confused by this. The whole point of READ_ONCE_NOCHECK() is that it
> > > isn't checked by KASAN, so if that semantic is removed it has no reason
> > > to exist.
> > >
> > > Changing that will break the unwind/stacktrace code across multiple
> > > architectures. IIRC they use READ_ONCE_NOCHECK() for two reasons:
> > >
> > > 1. Races with concurrent modification, as might happen when a thread's
> > >    stack is corrupted. Allowing the unwinder to bail out after a sanity
> > >    check means the resulting report is more useful than a KASAN splat in
> > >    the unwinder. I made the arm64 unwinder robust to this case.
> > >
> > > 2. I believe that the frame record itself /might/ be poisoned by KASAN,
> > >    since it's not meant to be an accessible object at the C langauge
> > >    level. I could be wrong about this, and would have to check.
> > 
> > I thought the main reason was deadlocks when a READ_ONCE()
> > is called inside of code that is part of the KASAN handling. If
> > READ_ONCE() ends up recursively calling itself, the kernel
> > tends to crash once it overflows its stack.
> 
> That was also my understanding.
> 
> > > I would like to keep the unwinding robust in the first case, even if the
> > > second case doesn't apply, and I'd prefer to not mark the entirety of
> > > the unwinding code as unchecked as that's sufficiently large an subtle
> > > that it could have nasty bugs.
> > >
> > > Is there any way we keep something like READ_ONCE_NOCHECK() around even
> > > if we have to give it reduced functionality relative to READ_ONCE()?
> > >
> > > I'm not enirely sure why READ_ONCE_NOCHECK() had to go, so if there's a
> > > particular pain point I'm happy to take a look.
> > 
> > As I understood, only this particular instance was removed, not all of
> > them.
> 
> Right, but the problem is that whether the NOCHECK version gets checked
> or not now depends on the caller, since it's all just a macro. If we want
> to fix this, then we could force the nocheck variant to return unsigned
> long, which simplifies things a lot (completely untested):
> 
> 
> #define READ_ONCE(x)							\
> ({									\
> 	compiletime_assert_rwonce_type(x);				\
> 	__READ_ONCE_SCALAR(x);						\
> })
> 
> unsigned long __no_sanitise_address
> kasan_nocheck_read_once_ul(const volatile void *p)
> {
> 	return READ_ONCE(*p);
> }
> 
> /* Please don't use this */
> #define READ_ONCE_NOCHECK(x)	kasan_nocheck_read_once_ul(&x)
> 

Urgh, scratch that. Trying to instantiate READ_ONCE() in compiler.h
causes a circular header-file dependency between linux/compiler.h
and asm-generic/barrier.h thanks to smp_read_barrier_depends().

Time to dust off that patch I had splitting up compiler.h.

Will

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-15 19:26     ` Will Deacon
@ 2020-04-16  9:31       ` Mark Rutland
  2020-04-16 11:53         ` Will Deacon
  0 siblings, 1 reply; 26+ messages in thread
From: Mark Rutland @ 2020-04-16  9:31 UTC (permalink / raw)
  To: Will Deacon
  Cc: linux-kernel, linux-arch, kernel-team, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Robin Murphy

On Wed, Apr 15, 2020 at 08:26:05PM +0100, Will Deacon wrote:
> On Wed, Apr 15, 2020 at 06:28:14PM +0100, Mark Rutland wrote:
> > On Wed, Apr 15, 2020 at 05:52:11PM +0100, Will Deacon wrote:
> > > do_csum() over-reads the source buffer and therefore abuses
> > > READ_ONCE_NOCHECK() to avoid tripping up KASAN. In preparation for
> > > READ_ONCE_NOCHECK() becoming a macro, and therefore losing its
> > > '__no_sanitize_address' annotation, just annotate do_csum() explicitly
> > > and fall back to normal loads.
> > 
> > I'm confused by this. The whole point of READ_ONCE_NOCHECK() is that it
> > isn't checked by KASAN, so if that semantic is removed it has no reason
> > to exist.
> 
> Oh, I thought it was there to be used by things like KASAN itself and
> because READ_ONCE() was implemented using a static function, then that
> function had to be marked as __no_sanitize_address when used in these
> cases. Now that it's just a macro, that's not necessary so it's just
> the same as normal READ_ONCE().

I believe that the KASAN core files are compiled without
instrumentation, so they can use either without issue.

> Do we have a "nocheck" version where we don't require the READ_ONCE()
> semantics? 

For the unwind code we rely on the ONCE semantic (but arguably don't
need single-copy-atomicity) so that we operate on a consistent snapshot.

> I think abusing a relaxed concurrency primitive for this is
> not the right thing to do, particularly when the __no_sanitize_address
> annotation is available. I fact, it's almost an argument in favour
> of removing READ_ONCE_NOCHECK() so that people use the annotation instead!

Arguably we *are* using it as a relaxed concurrency primitive, to get a
snapshot of a varaible undergoing concurrent modification.

FWIW, for the arm64 unwind code we could add a helper to snapshot the
frame record, and mark that as __no_sanitize_address, e.g.

/*
 * Get a snapshot of a frame record that might be undergoing concurrent
 * modification (and hence we must also avoid a KASAN splat).
 */
static __no_sanitize_address snapshot_frame(struct stackframe *frame,
					    unsigned long fp)
{
	frame->fp = READ_ONCE(*(unsigned long *)(fp));
	frame->pc = READ_ONCE(*(unsigned long *)(fp + 8));
}

... we'd need to do likewied in a few bits of unwind code:

arch/s390/kernel/unwind_bc.c:	       READ_ONCE_NOCHECK(regs->psw.mask) & PSW_MASK_PSTATE;
arch/s390/kernel/unwind_bc.c:		ip = READ_ONCE_NOCHECK(sf->gprs[8]);
arch/s390/kernel/unwind_bc.c:		sp = READ_ONCE_NOCHECK(sf->back_chain);
arch/s390/kernel/unwind_bc.c:			ip = READ_ONCE_NOCHECK(sf->gprs[8]);
arch/s390/kernel/unwind_bc.c:			ip = READ_ONCE_NOCHECK(regs->psw.addr);
arch/s390/kernel/unwind_bc.c:			sp = READ_ONCE_NOCHECK(regs->gprs[15]);
arch/s390/kernel/unwind_bc.c:		ip = READ_ONCE_NOCHECK(sf->gprs[8]);
arch/x86/include/asm/atomic.h:	 * Note for KASAN: we deliberately don't use READ_ONCE_NOCHECK() here,
arch/x86/include/asm/unwind.h:		val = READ_ONCE_NOCHECK(x);		\
arch/x86/kernel/dumpstack.c:			unsigned long addr = READ_ONCE_NOCHECK(*stack);
arch/x86/kernel/process.c:	fp = READ_ONCE_NOCHECK(((struct inactive_task_frame *)sp)->bp);
arch/x86/kernel/process.c:		ip = READ_ONCE_NOCHECK(*(unsigned long *)(fp + sizeof(unsigned long)));
arch/x86/kernel/process.c:		fp = READ_ONCE_NOCHECK(*(unsigned long *)fp);
arch/x86/kernel/unwind_frame.c:			word = READ_ONCE_NOCHECK(*sp);
arch/x86/kernel/unwind_guess.c:	addr = READ_ONCE_NOCHECK(*state->sp);
arch/x86/kernel/unwind_guess.c:			unsigned long addr = READ_ONCE_NOCHECK(*state->sp);
arch/x86/kernel/unwind_orc.c:	*val = READ_ONCE_NOCHECK(*(unsigned long *)addr);
arch/x86/kernel/unwind_orc.c:		state->bp = READ_ONCE_NOCHECK(frame->bp);
arch/x86/kernel/unwind_orc.c:		state->ip = READ_ONCE_NOCHECK(frame->ret_addr);
include/linux/compiler.h: * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
include/linux/compiler.h:#define READ_ONCE_NOCHECK(x) __READ_ONCE(x, 0)
kernel/trace/trace_stack.c:			 * The READ_ONCE_NOCHECK is used to let KASAN know that
kernel/trace/trace_stack.c:			if ((READ_ONCE_NOCHECK(*p)) == stack_dump_trace[i]) {

> > I would like to keep the unwinding robust in the first case, even if the
> > second case doesn't apply, and I'd prefer to not mark the entirety of
> > the unwinding code as unchecked as that's sufficiently large an subtle
> > that it could have nasty bugs.
> 
> Hmm, maybe. I don't really see what's wrong with annotating the unwinding
> code, though. You can still tell kasan about the accesses you're making,
> like we do in the checksumming code here, and it's not hard to move the
> frame-pointer chasing code into a separate function.

Sure; agreed as above. We just need to fix up a number of places.

> > Is there any way we keep something like READ_ONCE_NOCHECK() around even
> > if we have to give it reduced functionality relative to READ_ONCE()?
> > 
> > I'm not enirely sure why READ_ONCE_NOCHECK() had to go, so if there's a
> > particular pain point I'm happy to take a look.
> 
> I got rid if it because I thought it wasn't required now that it's
> implemented entirely as a macro. I'd be reluctant to bring it back if
> there isn't a non-ONCE version of the helper.

As above, I think that we *do* care about the ONCE-ness for the unwind
code, but I'm happy for those to be dealt with by special helpers.

Thanks,
Mark.

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-16  9:31       ` Mark Rutland
@ 2020-04-16 11:53         ` Will Deacon
  2020-04-16 12:11           ` Mark Rutland
  0 siblings, 1 reply; 26+ messages in thread
From: Will Deacon @ 2020-04-16 11:53 UTC (permalink / raw)
  To: Mark Rutland
  Cc: linux-kernel, linux-arch, kernel-team, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Robin Murphy

On Thu, Apr 16, 2020 at 10:31:06AM +0100, Mark Rutland wrote:
> On Wed, Apr 15, 2020 at 08:26:05PM +0100, Will Deacon wrote:
> > I think abusing a relaxed concurrency primitive for this is
> > not the right thing to do, particularly when the __no_sanitize_address
> > annotation is available. I fact, it's almost an argument in favour
> > of removing READ_ONCE_NOCHECK() so that people use the annotation instead!
> 
> Arguably we *are* using it as a relaxed concurrency primitive, to get a
> snapshot of a varaible undergoing concurrent modification.

That's fair, so it's only the checksum code that was abusing this, which
I've fixed.

> FWIW, for the arm64 unwind code we could add a helper to snapshot the
> frame record, and mark that as __no_sanitize_address, e.g.
> 
> /*
>  * Get a snapshot of a frame record that might be undergoing concurrent
>  * modification (and hence we must also avoid a KASAN splat).
>  */
> static __no_sanitize_address snapshot_frame(struct stackframe *frame,
> 					    unsigned long fp)
> {
> 	frame->fp = READ_ONCE(*(unsigned long *)(fp));
> 	frame->pc = READ_ONCE(*(unsigned long *)(fp + 8));
> }
> 
> ... we'd need to do likewied in a few bits of unwind code:
> 
> arch/s390/kernel/unwind_bc.c:	       READ_ONCE_NOCHECK(regs->psw.mask) & PSW_MASK_PSTATE;
> arch/s390/kernel/unwind_bc.c:		ip = READ_ONCE_NOCHECK(sf->gprs[8]);
> arch/s390/kernel/unwind_bc.c:		sp = READ_ONCE_NOCHECK(sf->back_chain);
> arch/s390/kernel/unwind_bc.c:			ip = READ_ONCE_NOCHECK(sf->gprs[8]);
> arch/s390/kernel/unwind_bc.c:			ip = READ_ONCE_NOCHECK(regs->psw.addr);
> arch/s390/kernel/unwind_bc.c:			sp = READ_ONCE_NOCHECK(regs->gprs[15]);
> arch/s390/kernel/unwind_bc.c:		ip = READ_ONCE_NOCHECK(sf->gprs[8]);
> arch/x86/include/asm/atomic.h:	 * Note for KASAN: we deliberately don't use READ_ONCE_NOCHECK() here,
> arch/x86/include/asm/unwind.h:		val = READ_ONCE_NOCHECK(x);		\
> arch/x86/kernel/dumpstack.c:			unsigned long addr = READ_ONCE_NOCHECK(*stack);
> arch/x86/kernel/process.c:	fp = READ_ONCE_NOCHECK(((struct inactive_task_frame *)sp)->bp);
> arch/x86/kernel/process.c:		ip = READ_ONCE_NOCHECK(*(unsigned long *)(fp + sizeof(unsigned long)));
> arch/x86/kernel/process.c:		fp = READ_ONCE_NOCHECK(*(unsigned long *)fp);
> arch/x86/kernel/unwind_frame.c:			word = READ_ONCE_NOCHECK(*sp);
> arch/x86/kernel/unwind_guess.c:	addr = READ_ONCE_NOCHECK(*state->sp);
> arch/x86/kernel/unwind_guess.c:			unsigned long addr = READ_ONCE_NOCHECK(*state->sp);
> arch/x86/kernel/unwind_orc.c:	*val = READ_ONCE_NOCHECK(*(unsigned long *)addr);
> arch/x86/kernel/unwind_orc.c:		state->bp = READ_ONCE_NOCHECK(frame->bp);
> arch/x86/kernel/unwind_orc.c:		state->ip = READ_ONCE_NOCHECK(frame->ret_addr);
> include/linux/compiler.h: * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
> include/linux/compiler.h:#define READ_ONCE_NOCHECK(x) __READ_ONCE(x, 0)
> kernel/trace/trace_stack.c:			 * The READ_ONCE_NOCHECK is used to let KASAN know that
> kernel/trace/trace_stack.c:			if ((READ_ONCE_NOCHECK(*p)) == stack_dump_trace[i]) {

Indeed. For now, I'm going to keep this simple with the change below, but
I'll revisit this later on because I have another series removing
smp_read_barrier_depends() which makes this a lot simpler.

Will

--->8

diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 00a68063d9d5..c363d8debc43 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -212,18 +212,12 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,
 	(typeof(x))__x;							\
 })
 
-/*
- * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
- * to hide memory access from KASAN.
- */
-#define READ_ONCE_NOCHECK(x)						\
+#define READ_ONCE(x)							\
 ({									\
 	compiletime_assert_rwonce_type(x);				\
 	__READ_ONCE_SCALAR(x);						\
 })
 
-#define READ_ONCE(x)	READ_ONCE_NOCHECK(x)
-
 #define __WRITE_ONCE(x, val)				\
 do {							\
 	*(volatile typeof(x) *)&(x) = (val);		\
@@ -247,6 +241,24 @@ do {							\
 # define __no_kasan_or_inline __always_inline
 #endif
 
+static __no_kasan_or_inline
+unsigned long __read_once_word_nocheck(const void *addr)
+{
+	return __READ_ONCE(*(unsigned long *)addr);
+}
+
+/*
+ * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need to load a
+ * word from memory atomically but without telling KASAN. This is usually
+ * used by unwinding code when walking the stack of a running process.
+ */
+#define READ_ONCE_NOCHECK(x)						\
+({									\
+	unsigned long __x = __read_once_word_nocheck(&(x));		\
+	smp_read_barrier_depends();					\
+	__x;								\
+})
+
 static __no_kasan_or_inline
 unsigned long read_word_at_a_time(const void *addr)
 {

^ permalink raw reply related	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum()
  2020-04-16 11:53         ` Will Deacon
@ 2020-04-16 12:11           ` Mark Rutland
  0 siblings, 0 replies; 26+ messages in thread
From: Mark Rutland @ 2020-04-16 12:11 UTC (permalink / raw)
  To: Will Deacon
  Cc: linux-kernel, linux-arch, kernel-team, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Christian Borntraeger, Luc Van Oostenryck, Arnd Bergmann,
	Peter Oberparleiter, Masahiro Yamada, Nick Desaulniers,
	Robin Murphy

On Thu, Apr 16, 2020 at 12:53:46PM +0100, Will Deacon wrote:
> On Thu, Apr 16, 2020 at 10:31:06AM +0100, Mark Rutland wrote:
> > FWIW, for the arm64 unwind code we could add a helper to snapshot the
> > frame record, and mark that as __no_sanitize_address, e.g.

[...]

> > ... we'd need to do likewied in a few bits of unwind code:

[...]

> Indeed. For now, I'm going to keep this simple with the change below, but
> I'll revisit this later on because I have another series removing
> smp_read_barrier_depends() which makes this a lot simpler.
> 
> Will

The below looks good to me; thanks for putting that together!

Mark.

> 
> --->8
> 
> diff --git a/include/linux/compiler.h b/include/linux/compiler.h
> index 00a68063d9d5..c363d8debc43 100644
> --- a/include/linux/compiler.h
> +++ b/include/linux/compiler.h
> @@ -212,18 +212,12 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,
>  	(typeof(x))__x;							\
>  })
>  
> -/*
> - * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
> - * to hide memory access from KASAN.
> - */
> -#define READ_ONCE_NOCHECK(x)						\
> +#define READ_ONCE(x)							\
>  ({									\
>  	compiletime_assert_rwonce_type(x);				\
>  	__READ_ONCE_SCALAR(x);						\
>  })
>  
> -#define READ_ONCE(x)	READ_ONCE_NOCHECK(x)
> -
>  #define __WRITE_ONCE(x, val)				\
>  do {							\
>  	*(volatile typeof(x) *)&(x) = (val);		\
> @@ -247,6 +241,24 @@ do {							\
>  # define __no_kasan_or_inline __always_inline
>  #endif
>  
> +static __no_kasan_or_inline
> +unsigned long __read_once_word_nocheck(const void *addr)
> +{
> +	return __READ_ONCE(*(unsigned long *)addr);
> +}
> +
> +/*
> + * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need to load a
> + * word from memory atomically but without telling KASAN. This is usually
> + * used by unwinding code when walking the stack of a running process.
> + */
> +#define READ_ONCE_NOCHECK(x)						\
> +({									\
> +	unsigned long __x = __read_once_word_nocheck(&(x));		\
> +	smp_read_barrier_depends();					\
> +	__x;								\
> +})
> +
>  static __no_kasan_or_inline
>  unsigned long read_word_at_a_time(const void *addr)
>  {

^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 00/12] Rework READ_ONCE() to improve codegen
  2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
                   ` (11 preceding siblings ...)
  2020-04-15 16:52 ` [PATCH v3 12/12] gcov: Remove old GCC 3.4 support Will Deacon
@ 2020-04-16 12:30 ` Christian Borntraeger
  2020-04-16 12:48   ` Will Deacon
  12 siblings, 1 reply; 26+ messages in thread
From: Christian Borntraeger @ 2020-04-16 12:30 UTC (permalink / raw)
  To: Will Deacon, linux-kernel
  Cc: linux-arch, kernel-team, Michael Ellerman, Peter Zijlstra,
	Linus Torvalds, Segher Boessenkool, Luc Van Oostenryck,
	Arnd Bergmann, Peter Oberparleiter, Masahiro Yamada,
	Nick Desaulniers


On 15.04.20 18:52, Will Deacon wrote:
> Hi everyone,
> 
> This is version three of the patches I previously posted for improving
> the code generation of READ_ONCE() and moving the minimum GCC version
> to 4.8:
> 
> RFC: https://lore.kernel.org/lkml/20200110165636.28035-1-will@kernel.org
> v2:  https://lore.kernel.org/lkml/20200123153341.19947-1-will@kernel.org
> 
> Although v2 was queued up by Peter in -tip, it was found to break the
> build for m68k and sparc32. We fixed m68k during the merge window and
> I've since posted patches to fix sparc32 here:
> 
>   https://lore.kernel.org/lkml/20200414214011.2699-1-will@kernel.org
> 
> This series is a refresh on top of 5.7-rc1, the main changes being:
> 
>   * Fix another issue where 'const' is assigned to non-const via
>     WRITE_ONCE(), this time in the tls code
> 
>   * Fix READ_ONCE_NOCHECK() abuse in arm64 checksum code
> 
>   * Added Reviewed-bys and Acks from v2
> 
> Hopefully this can be considered for 5.8, along with the sparc32 changes.
> 
> Cheers,
> 
> Will
> 
> Cc: Michael Ellerman <mpe@ellerman.id.au>
> Cc: Peter Zijlstra <peterz@infradead.org>
> Cc: Linus Torvalds <torvalds@linux-foundation.org>
> Cc: Segher Boessenkool <segher@kernel.crashing.org>
> Cc: Christian Borntraeger <borntraeger@de.ibm.com>
> Cc: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
> Cc: Arnd Bergmann <arnd@arndb.de>
> Cc: Peter Oberparleiter <oberpar@linux.ibm.com>
> Cc: Masahiro Yamada <masahiroy@kernel.org>
> Cc: Nick Desaulniers <ndesaulniers@google.com>
> 

I gave this series a try and s390 seems to compile fine and it also seems to
properly compile the the ipte_unlock_siif function in arch/s390/kvm/gaccess.c
This function was miscompiled with gcc4.6 and the trigger for replacing
ACCESS_ONCE with READ_ONCE


^ permalink raw reply	[flat|nested] 26+ messages in thread

* Re: [PATCH v3 00/12] Rework READ_ONCE() to improve codegen
  2020-04-16 12:30 ` [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Christian Borntraeger
@ 2020-04-16 12:48   ` Will Deacon
  0 siblings, 0 replies; 26+ messages in thread
From: Will Deacon @ 2020-04-16 12:48 UTC (permalink / raw)
  To: Christian Borntraeger
  Cc: linux-kernel, linux-arch, kernel-team, Michael Ellerman,
	Peter Zijlstra, Linus Torvalds, Segher Boessenkool,
	Luc Van Oostenryck, Arnd Bergmann, Peter Oberparleiter,
	Masahiro Yamada, Nick Desaulniers

On Thu, Apr 16, 2020 at 02:30:36PM +0200, Christian Borntraeger wrote:
> 
> On 15.04.20 18:52, Will Deacon wrote:
> > Hi everyone,
> > 
> > This is version three of the patches I previously posted for improving
> > the code generation of READ_ONCE() and moving the minimum GCC version
> > to 4.8:
> > 
> > RFC: https://lore.kernel.org/lkml/20200110165636.28035-1-will@kernel.org
> > v2:  https://lore.kernel.org/lkml/20200123153341.19947-1-will@kernel.org
> > 
> > Although v2 was queued up by Peter in -tip, it was found to break the
> > build for m68k and sparc32. We fixed m68k during the merge window and
> > I've since posted patches to fix sparc32 here:
> > 
> >   https://lore.kernel.org/lkml/20200414214011.2699-1-will@kernel.org
> > 
> > This series is a refresh on top of 5.7-rc1, the main changes being:
> > 
> >   * Fix another issue where 'const' is assigned to non-const via
> >     WRITE_ONCE(), this time in the tls code
> > 
> >   * Fix READ_ONCE_NOCHECK() abuse in arm64 checksum code
> > 
> >   * Added Reviewed-bys and Acks from v2
> > 
> > Hopefully this can be considered for 5.8, along with the sparc32 changes.
> > 
> > Cheers,
> > 
> > Will
> > 
> > Cc: Michael Ellerman <mpe@ellerman.id.au>
> > Cc: Peter Zijlstra <peterz@infradead.org>
> > Cc: Linus Torvalds <torvalds@linux-foundation.org>
> > Cc: Segher Boessenkool <segher@kernel.crashing.org>
> > Cc: Christian Borntraeger <borntraeger@de.ibm.com>
> > Cc: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>
> > Cc: Arnd Bergmann <arnd@arndb.de>
> > Cc: Peter Oberparleiter <oberpar@linux.ibm.com>
> > Cc: Masahiro Yamada <masahiroy@kernel.org>
> > Cc: Nick Desaulniers <ndesaulniers@google.com>
> > 
> 
> I gave this series a try and s390 seems to compile fine and it also seems to
> properly compile the the ipte_unlock_siif function in arch/s390/kvm/gaccess.c
> This function was miscompiled with gcc4.6 and the trigger for replacing
> ACCESS_ONCE with READ_ONCE

That's good to hear, thanks Christian!

Will

^ permalink raw reply	[flat|nested] 26+ messages in thread

end of thread, other threads:[~2020-04-16 12:49 UTC | newest]

Thread overview: 26+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-04-15 16:52 [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Will Deacon
2020-04-15 16:52 ` [PATCH v3 01/12] compiler/gcc: Emit build-time warning for GCC prior to version 4.8 Will Deacon
2020-04-15 17:20   ` Masahiro Yamada
2020-04-15 16:52 ` [PATCH v3 02/12] netfilter: Avoid assigning 'const' pointer to non-const pointer Will Deacon
2020-04-15 16:52 ` [PATCH v3 03/12] net: tls: " Will Deacon
2020-04-15 16:52 ` [PATCH v3 04/12] fault_inject: Don't rely on "return value" from WRITE_ONCE() Will Deacon
2020-04-15 16:52 ` [PATCH v3 05/12] arm64: csum: Disable KASAN for do_csum() Will Deacon
2020-04-15 17:28   ` Mark Rutland
2020-04-15 18:42     ` Arnd Bergmann
2020-04-15 19:43       ` Will Deacon
2020-04-15 20:10         ` Will Deacon
2020-04-15 19:26     ` Will Deacon
2020-04-16  9:31       ` Mark Rutland
2020-04-16 11:53         ` Will Deacon
2020-04-16 12:11           ` Mark Rutland
2020-04-15 19:26   ` Robin Murphy
2020-04-15 16:52 ` [PATCH v3 06/12] READ_ONCE: Simplify implementations of {READ,WRITE}_ONCE() Will Deacon
2020-04-15 16:52 ` [PATCH v3 07/12] READ_ONCE: Enforce atomicity for {READ,WRITE}_ONCE() memory accesses Will Deacon
2020-04-15 16:52 ` [PATCH v3 08/12] READ_ONCE: Drop pointer qualifiers when reading from scalar types Will Deacon
2020-04-15 16:52 ` [PATCH v3 09/12] locking/barriers: Use '__unqual_scalar_typeof' for load-acquire macros Will Deacon
2020-04-15 16:52 ` [PATCH v3 10/12] arm64: barrier: Use '__unqual_scalar_typeof' for acquire/release macros Will Deacon
2020-04-15 16:52 ` [PATCH v3 11/12] compiler/gcc: Raise minimum GCC version for kernel builds to 4.8 Will Deacon
2020-04-15 18:37   ` Arnd Bergmann
2020-04-15 16:52 ` [PATCH v3 12/12] gcov: Remove old GCC 3.4 support Will Deacon
2020-04-16 12:30 ` [PATCH v3 00/12] Rework READ_ONCE() to improve codegen Christian Borntraeger
2020-04-16 12:48   ` Will Deacon

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).