AARCH64: Add gcc Shadow Call Stack support
PATCH 1/1 AARCH64: Add gcc Shadow Call Stack support
Shadow call stack is available in GCC > 11.2.0, this patch makes the corresponding kernel configuration available when compiling the kernel with gcc.
Note that the implementation in GCC is slightly different from Clang. With SCS enabled, functions will only pop x30 once in the epilogue, like:
str x30, [x18], #8
stp x29, x30, [sp, #-16]!
......
- ldp x29, x30, [sp], #16 //clang + ldr x29, [sp], #16 //GCC ldr x30, [x18, #-8]!
---
FYI:
This function can be used to test if the shadow call stack works:
//noinline void __noscs scs_test(void)
noinline void scs_test(void)
{
register unsigned long *sp asm("sp");
unsigned long * lr = sp + 1;
asm volatile("":::"x30");
*lr = 0;
}ffff800008012704: d503233f paciasp ffff800008012708: f800865e str x30, [x18], #8 ffff80000801270c: a9bf7bfd stp x29, x30, [sp, #-16]! ffff800008012710: 910003fd mov x29, sp ffff800008012714: 910003e0 mov x0, sp ffff800008012718: f900041f str xzr, [x0, #8] ffff80000801271c: f85f8e5e ldr x30, [x18, #-8]! ffff800008012720: f84107fd ldr x29, [sp], #16 ffff800008012724: d50323bf autiasp ffff800008012728: d65f03c0 ret
If SCS protection is enabled, this function will return normally. If the function has __noscs attribute (scs disabled), it will crash due to 0 address access.
arch/Kconfig | 6 +++--- arch/arm64/Kconfig | 2 +- include/linux/compiler-gcc.h | 4 ++++ 3 files changed, 8 insertions(+), 4 deletions(-)
arch/Kconfig +3 -3
@@ -604,11 +604,11 @@ config ARCH_SUPPORTS_SHADOW_CALL_STACK switching. config SHADOW_CALL_STACK - bool "Clang Shadow Call Stack" - depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK + bool "Shadow Call Stack" + depends on ARCH_SUPPORTS_SHADOW_CALL_STACK depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER help - This option enables Clang's Shadow Call Stack, which uses a + This option enables Clang/GCC's Shadow Call Stack, which uses a shadow stack to protect function return addresses from being overwritten by an attacker. More information can be found in Clang's documentation:
arch/arm64/Kconfig +1 -1
@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTS config ARCH_HAS_FILTER_PGPROT def_bool y -# Supported by clang >= 7.0 +# Supported by clang >= 7.0 or GCC > 11.2.0 config CC_HAVE_SHADOW_CALL_STACK def_bool $(cc-option, -fsanitize=shadow-call-stack -ffixed-x18)
include/linux/compiler-gcc.h +4 -0
@@ -97,6 +97,10 @@#define KASAN_ABI_VERSION 4#endif +#ifdef CONFIG_SHADOW_CALL_STACK +#define __noscs __attribute__((__no_sanitize__("shadow-call-stack"))) +#endif +#if __has_attribute (__no_sanitize_address__)#define __no_sanitize_address __attribute__((no_sanitize_address))#else
Signature · 1 line
2.17.1
Quoted 15 lines · Dan Li
Shadow call stack is available in GCC > 11.2.0, this patch makes the corresponding kernel configuration available when compiling the kernel with gcc.
Note that the implementation in GCC is slightly different from Clang. With SCS enabled, functions will only pop x30 once in the epilogue, like:
str x30, [x18], #8 stp x29, x30, [sp, #-16]! ......(quoted diff) +1
-1- ldp x29, x30, [sp], #16 //clang + ldr x29, [sp], #16 //GCC ldr x30, [x18, #-8]!
Quoted 3 lines
Signed-off-by Dan Li <[email protected]>
A few open-ended comments below.
Quoted 39 lines
---
FYI:
This function can be used to test if the shadow call stack works:
//noinline void__noscsscs_test(void)
noinline voidscs_test(void){ register unsigned long *sp asm("sp"); unsigned long * lr = sp + 1; asm volatile("":::"x30"); *lr = 0; }ffff800008012704: d503233f paciasp ffff800008012708: f800865e str x30, [x18], #8 ffff80000801270c: a9bf7bfd stp x29, x30, [sp, #-16]! ffff800008012710: 910003fd mov x29, sp ffff800008012714: 910003e0 mov x0, sp ffff800008012718: f900041f str xzr, [x0, #8] ffff80000801271c: f85f8e5e ldr x30, [x18, #-8]! ffff800008012720: f84107fd ldr x29, [sp], #16 ffff800008012724: d50323bf autiasp ffff800008012728: d65f03c0 retIf SCS protection is enabled, this function will return normally. If the function has
__noscsattribute (scs disabled), it will crash due to 0 address access.arch/Kconfig | 6 +++--- arch/arm64/Kconfig | 2 +- include/linux/compiler-gcc.h | 4 ++++ 3 files changed, 8 insertions(+), 4 deletions(-)arch/Kconfig +0
-0@@ -604,11 +604,11 @@ config ARCH_SUPPORTS_SHADOW_CALL_STACK switching.
arch/Kconfig config ARCH_SUPPORTS_SHADOW_CALL_STACK · line 611
Quoted 10 lines
arch/Kconfig +3
-3config SHADOW_CALL_STACK - bool "Clang Shadow Call Stack" - depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK + bool "Shadow Call Stack" + depends on ARCH_SUPPORTS_SHADOW_CALL_STACK depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER help - This option enables Clang's Shadow Call Stack, which uses a + This option enables Clang/GCC's Shadow Call Stack, which uses a
I wonder if we want to just ditch the mention of the compiler if both support it?
arch/arm64/Kconfig config HW_PERF_EVENTS · line 1258
Quoted 13 lines
arch/Kconfig +0
-0shadow stack to protect function return addresses from being overwritten by an attacker. More information can be found in Clang's documentation:arch/arm64/Kconfig +1
-1@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTS config ARCH_HAS_FILTER_PGPROT def_bool y -# Supported by clang >= 7.0 +# Supported by clang >= 7.0 or GCC > 11.2.0
Same thing here, although eventually there may be a minimum GCC version bump to something newer than 11.2.0, which would allow us to just drop CONFIG_CC_HAVE_SHADOW_CALL_STACK altogether. No strong opinion.
Quoted 21 lines
arch/arm64/Kconfig +0
-0config CC_HAVE_SHADOW_CALL_STACK def_bool $(cc-option, -fsanitize=shadow-call-stack -ffixed-x18)include/linux/compiler-gcc.h +4
-0@@ -97,6 +97,10 @@#define KASAN_ABI_VERSION 4#endif +#ifdef CONFIG_SHADOW_CALL_STACK +#define __noscs __attribute__((__no_sanitize__("shadow-call-stack"))) +#endif +#if __has_attribute (__no_sanitize_address__)#define __no_sanitize_address __attribute__((no_sanitize_address))#else Signature · 1 line
2.17.1
Quoted 2 lines · Nathan Chancellor
Quoted 1 line · Dan Li
Shadow call stack is available in GCC > 11.2.0, this patch makes
The above suggests that the option will be available with gcc 11.3.0. Information available in public suggests that it will be introduced with gcc 12.0.
Quoted 86 lines
Quoted 14 lines
the corresponding kernel configuration available when compiling the kernel with gcc.
Note that the implementation in GCC is slightly different from Clang. With SCS enabled, functions will only pop x30 once in the epilogue, like:
str x30, [x18], #8 stp x29, x30, [sp, #-16]! ......(quoted diff) +1
-1- ldp x29, x30, [sp], #16 //clang + ldr x29, [sp], #16 //GCC ldr x30, [x18, #-8]!Quoted 3 lines
Signed-off-by Dan Li <[email protected]>Reviewed-by Nathan Chancellor <[email protected]>A few open-ended comments below.
Quoted 39 lines
---
FYI:
This function can be used to test if the shadow call stack works:
//noinline void__noscsscs_test(void)
noinline voidscs_test(void){ register unsigned long *sp asm("sp"); unsigned long * lr = sp + 1; asm volatile("":::"x30"); *lr = 0; }ffff800008012704: d503233f paciasp ffff800008012708: f800865e str x30, [x18], #8 ffff80000801270c: a9bf7bfd stp x29, x30, [sp, #-16]! ffff800008012710: 910003fd mov x29, sp ffff800008012714: 910003e0 mov x0, sp ffff800008012718: f900041f str xzr, [x0, #8] ffff80000801271c: f85f8e5e ldr x30, [x18, #-8]! ffff800008012720: f84107fd ldr x29, [sp], #16 ffff800008012724: d50323bf autiasp ffff800008012728: d65f03c0 retIf SCS protection is enabled, this function will return normally. If the function has
__noscsattribute (scs disabled), it will crash due to 0 address access.arch/Kconfig | 6 +++--- arch/arm64/Kconfig | 2 +- include/linux/compiler-gcc.h | 4 ++++ 3 files changed, 8 insertions(+), 4 deletions(-)arch/Kconfig +0
-0@@ -604,11 +604,11 @@ config ARCH_SUPPORTS_SHADOW_CALL_STACK switching.arch/Kconfig config ARCH_SUPPORTS_SHADOW_CALL_STACK · line 611
Quoted 10 lines
arch/Kconfig +3
-3config SHADOW_CALL_STACK - bool "Clang Shadow Call Stack" - depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK + bool "Shadow Call Stack" + depends on ARCH_SUPPORTS_SHADOW_CALL_STACK depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER help - This option enables Clang's Shadow Call Stack, which uses a + This option enables Clang/GCC's Shadow Call Stack, which uses aI wonder if we want to just ditch the mention of the compiler if both support it?
Quoted 11 lines
arch/Kconfig +0
-0shadow stack to protect function return addresses from being overwritten by an attacker. More information can be found in Clang's documentation:arch/arm64/Kconfig +0
-0@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTS config ARCH_HAS_FILTER_PGPROT def_bool y
Quoted 4 lines
arch/arm64/Kconfig config HW_PERF_EVENTS · line 1258
Quoted 2 lines
arch/arm64/Kconfig +1
-1-# Supported by clang >= 7.0 +# Supported by clang >= 7.0 or GCC > 11.2.0Same thing here, although eventually there may be a minimum GCC version
The point here, I think, is to list the minimum gcc version. It is going to be a long time until gcc 12.0 is the minimum version, so I think it makes sense to list the minimum version number for each compiler here.
However, it may make sense to add some reference indicating that support will indeed be added with gcc 11.3.0, and not only starting with gcc 12.0 (and maybe wait with applying this patch until it is actually available in gcc and can be confirmed to work as intended).
Thanks,
Guenter
Quoted 24 lines
bump to something newer than 11.2.0, which would allow us to just drop
CONFIG_CC_HAVE_SHADOW_CALL_STACKaltogether. No strong opinion.Quoted 21 lines
arch/arm64/Kconfig +0
-0config CC_HAVE_SHADOW_CALL_STACK def_bool $(cc-option, -fsanitize=shadow-call-stack -ffixed-x18)include/linux/compiler-gcc.h +4
-0@@ -97,6 +97,10 @@#define KASAN_ABI_VERSION 4#endif +#ifdef CONFIG_SHADOW_CALL_STACK +#define __noscs __attribute__((__no_sanitize__("shadow-call-stack"))) +#endif +#if __has_attribute (__no_sanitize_address__)#define __no_sanitize_address __attribute__((no_sanitize_address))#else Signature · 1 line
2.17.1
Quoted 5 lines · Guenter Roeck
The point here, I think, is to list the minimum gcc version. It is going to be a long time until gcc 12.0 is the minimum version, so I think it makes sense to list the minimum version number for each compiler here.
Yeah, please list the minimum version (ideally >= instead of >, with the actual version where it first appeared). It makes it easy to then remove things that are not needed anymore when the minimum GCC version is upgraded.
Cheers,
Miguel
Quoted 7 lines · Miguel Ojeda
Quoted 5 lines · Guenter Roeck
The point here, I think, is to list the minimum gcc version. It is going to be a long time until gcc 12.0 is the minimum version, so I think it makes sense to list the minimum version number for each compiler here.
Quoted 5 lines
Yeah, please list the minimum version (ideally
>=instead of>, with the actual version where it first appeared). It makes it easy to then remove things that are not needed anymore when the minimum GCC version is upgraded.
Got it, I'll use "gcc >= 12.0.0" in the next patch.
Thanks,
Dan.
Quoted 8 lines · Guenter Roeck
Quoted 2 lines · Nathan Chancellor
Quoted 1 line · Dan Li
Shadow call stack is available in GCC > 11.2.0, this patch makes
The above suggests that the option will be available with gcc 11.3.0. Information available in public suggests that it will be introduced with gcc 12.0.
Ah, yes, I think we could use "gcc >= 12.0.0" here.
Quoted 7 lines
The point here, I think, is to list the minimum gcc version. It is going to be a long time until gcc 12.0 is the minimum version, so I think it makes sense to list the minimum version number for each compiler here.
However, it may make sense to add some reference indicating that support will indeed be added with gcc 11.3.0, and not only starting
I took a quick look at the gcc description, and it seems like the y in x.y.z is usually used to fix bugs, and new features should be added directly to the trunk.
Quoted 3 lines
with gcc 12.0 (and maybe wait with applying this patch until it is actually available in gcc and can be confirmed to work as intended).
It's also fine to wait for gcc 12 to be released, and I thought maybe I could submit the "final" version of this patch to the community (or mailing list) first so maybe more people would test it and if there were any issues, it could be fixed before GCC 12 is released :)
Thanks,
Dan.
Quoted 17 lines · Nathan Chancellor
arch/Kconfig config ARCH_SUPPORTS_SHADOW_CALL_STACK · line 611
Quoted 12 lines · Dan Li
Shadow call stack is available in GCC > 11.2.0, this patch makes the corresponding kernel configuration available when compiling the kernel with gcc.
configSHADOW_CALL_STACKarch/Kconfig +3
-3- bool "Clang Shadow Call Stack" - depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK + bool "Shadow Call Stack" + depends on ARCH_SUPPORTS_SHADOW_CALL_STACK depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER help - This option enables Clang's Shadow Call Stack, which uses a + This option enables Clang/GCC's Shadow Call Stack, which uses aI wonder if we want to just ditch the mention of the compiler if both support it?
My intention is to remind users that this is a compiler feature. But since there is also a hint in CC_HAVE_SHADOW_CALL_STACK:
+# Supported by clang >= 7.0 or GCC ...
Removing the specific compiler here also looks fine to me. Would this look better?
"This option enables Shadow Call Stack, which uses a ..."
or maybe:
"This option enables compiler's Shadow Call Stack, which uses a ..."
Quoted 11 lines
Quoted 11 lines
shadow stack to protect function return addresses from being overwritten by an attacker. More information can be found in Clang's documentation:
arch/arm64/Kconfig +0
-0@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTS config ARCH_HAS_FILTER_PGPROT def_bool y
Quoted 7 lines
arch/arm64/Kconfig config HW_PERF_EVENTS · line 1258
Quoted 2 lines
arch/arm64/Kconfig +1
-1-# Supported by clang >= 7.0 +# Supported by clang >= 7.0 or GCC > 11.2.0Same thing here, although eventually there may be a minimum GCC version bump to something newer than 11.2.0, which would allow us to just drop
CONFIG_CC_HAVE_SHADOW_CALL_STACKaltogether. No strong opinion.
As Guenter said, I thought maybe we could mark the minimum available version for users :)
Thanks,
Dan.
Quoted 25 lines · Dan Li
Quoted 17 lines · Nathan Chancellor
arch/Kconfig config ARCH_SUPPORTS_SHADOW_CALL_STACK · line 611
Quoted 12 lines · Dan Li
Shadow call stack is available in GCC > 11.2.0, this patch makes the corresponding kernel configuration available when compiling the kernel with gcc.
configSHADOW_CALL_STACKarch/Kconfig +3
-3- bool "Clang Shadow Call Stack" - depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK + bool "Shadow Call Stack" + depends on ARCH_SUPPORTS_SHADOW_CALL_STACK depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER help - This option enables Clang's Shadow Call Stack, which uses a + This option enables Clang/GCC's Shadow Call Stack, which uses aI wonder if we want to just ditch the mention of the compiler if both support it?
My intention is to remind users that this is a compiler feature. But since there is also a hint in
CC_HAVE_SHADOW_CALL_STACK:
+# Supported by clang >= 7.0 or GCC ...
Quoted 8 lines
Removing the specific compiler here also looks fine to me. Would this look better?
"This option enables Shadow Call Stack, which uses a ..."
or maybe:
"This option enables compiler's Shadow Call Stack, which uses a ..."
I do not honestly have a strong opinion around removing mention of the compiler so either looks fine to me (might be better to say "the compiler's Shadow ..." in the second one).
Quoted 18 lines
Quoted 8 lines
Quoted 8 lines
shadow stack to protect function return addresses from being overwritten by an attacker. More information can be found in Clang's documentation:
arch/arm64/Kconfig +0
-0@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTSQuoted 9 lines
arch/arm64/Kconfig config HW_PERF_EVENTS · line 1258
Quoted 4 lines
arch/arm64/Kconfig +1
-1config ARCH_HAS_FILTER_PGPROT def_bool y -# Supported by clang >= 7.0 +# Supported by clang >= 7.0 or GCC > 11.2.0Same thing here, although eventually there may be a minimum GCC version bump to something newer than 11.2.0, which would allow us to just drop
CONFIG_CC_HAVE_SHADOW_CALL_STACKaltogether. No strong opinion.
Quoted 2 lines
As Guenter said, I thought maybe we could mark the minimum available version for users :)
Yes, that is what I was getting at with the "minimum version" comment. It should remain around.
Cheers,
Nathan
Quoted 10 lines · Nathan Chancellor
Quoted 9 lines · Dan Li
My intention is to remind users that this is a compiler feature. But since there is also a hint in
CC_HAVE_SHADOW_CALL_STACK:
+# Supported by clang >= 7.0 or GCC ...Removing the specific compiler here also looks fine to me. Would this look better?
"This option enables Shadow Call Stack, which uses a ..."
Quoted 8 lines
Quoted 3 lines
or maybe:
"This option enables compiler's Shadow Call Stack, which uses a ..."
I do not honestly have a strong opinion around removing mention of the compiler so either looks fine to me (might be better to say "the compiler's Shadow ..." in the second one).
Ah, yes, thanks :)
Dan.
Mark Rutland
reviewerHi,
Quoted 3 lines · Dan Li
Shadow call stack is available in GCC > 11.2.0, this patch makes the corresponding kernel configuration available when compiling the kernel with gcc.
Neat!
My local GCC devs told me that means GCC 12.x.x rather than 11.2.x or 11.3.x, so as others have said it'd be clearer to say GCC >= 12.0.0.
I'd like to try this with a GCC binary before I provide an Ack or R-b; but in the mean time I have a few comments below.
Review
Quoted 10 lines
Note that the implementation in GCC is slightly different from Clang. With SCS enabled, functions will only pop x30 once in the epilogue, like:
str x30, [x18], #8 stp x29, x30, [sp, #-16]! ......(quoted diff) +1
-1- ldp x29, x30, [sp], #16 //clang + ldr x29, [sp], #16 //GCC ldr x30, [x18, #-8]!
Given the prologue still pushes both x29 and x30 (which we critically depend upon) that sounds OK to me.
Quoted 9 lines
Signed-off-by Dan Li <[email protected]>---
FYI:
This function can be used to test if the shadow call stack works:
//noinline void__noscsscs_test(void)
noinline voidscs_test(void)
Quoted 7 lines
{
register unsigned long *sp asm("sp");
unsigned long * lr = sp + 1;
asm volatile("":::"x30");
*lr = 0;
}It's probably be better to use __builtin_frame_address(0) to get the address of the frame record rather than assuming that fp==sp in the middle of the function.
Quoted 29 lines
ffff800008012704: d503233f paciasp ffff800008012708: f800865e str x30, [x18], #8 ffff80000801270c: a9bf7bfd stp x29, x30, [sp, #-16]! ffff800008012710: 910003fd mov x29, sp ffff800008012714: 910003e0 mov x0, sp ffff800008012718: f900041f str xzr, [x0, #8] ffff80000801271c: f85f8e5e ldr x30, [x18, #-8]! ffff800008012720: f84107fd ldr x29, [sp], #16 ffff800008012724: d50323bf autiasp ffff800008012728: d65f03c0 retIf SCS protection is enabled, this function will return normally. If the function has
__noscsattribute (scs disabled), it will crash due to 0 address access.arch/Kconfig | 6 +++--- arch/arm64/Kconfig | 2 +- include/linux/compiler-gcc.h | 4 ++++ 3 files changed, 8 insertions(+), 4 deletions(-)arch/Kconfig +0
-1@@ -604,11 +604,11 @@ config ARCH_SUPPORTS_SHADOW_CALL_STACK switching. config SHADOW_CALL_STACK - bool "Clang Shadow Call Stack"
arch/Kconfig config ARCH_SUPPORTS_SHADOW_CALL_STACK · line 614
Quoted 10 lines
arch/Kconfig +3
-2- depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK + bool "Shadow Call Stack" + depends on ARCH_SUPPORTS_SHADOW_CALL_STACK depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER help - This option enables Clang's Shadow Call Stack, which uses a + This option enables Clang/GCC's Shadow Call Stack, which uses a shadow stack to protect function return addresses from being overwritten by an attacker. More information can be found in Clang's documentation:
Is there any additional GCC documentation that we can refer to?
arch/arm64/Kconfig config HW_PERF_EVENTS · line 1258
Quoted 10 lines
arch/arm64/Kconfig +1
-1@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTS config ARCH_HAS_FILTER_PGPROT def_bool y -# Supported by clang >= 7.0 +# Supported by clang >= 7.0 or GCC > 11.2.0
As above, I beleive that should be GCC >= 12.0.0.
Thanks,
Mark
Quoted 21 lines
arch/arm64/Kconfig +0
-0config CC_HAVE_SHADOW_CALL_STACK def_bool $(cc-option, -fsanitize=shadow-call-stack -ffixed-x18)include/linux/compiler-gcc.h +4
-0@@ -97,6 +97,10 @@#define KASAN_ABI_VERSION 4#endif +#ifdef CONFIG_SHADOW_CALL_STACK +#define __noscs __attribute__((__no_sanitize__("shadow-call-stack"))) +#endif +#if __has_attribute (__no_sanitize_address__)#define __no_sanitize_address __attribute__((no_sanitize_address))#else Signature · 1 line
2.17.1
Quoted 12 lines · Mark Rutland
Hi,
Quoted 3 lines · Dan Li
Shadow call stack is available in GCC > 11.2.0, this patch makes the corresponding kernel configuration available when compiling the kernel with gcc.
Neat!
My local GCC devs told me that means GCC 12.x.x rather than 11.2.x or 11.3.x, so as others have said it'd be clearer to say
GCC >= 12.0.0.
Ah, yes, I just saw this flag in gcc/BASE-VER.
Quoted 3 lines
I'd like to try this with a GCC binary before I provide an Ack or R-b; but in the mean time I have a few comments below.
Thanks for your test, Mark.
Please let me know if there is any issues :)
Quoted 9 lines
Quoted 9 lines
---
FYI:
This function can be used to test if the shadow call stack works:
//noinline void__noscsscs_test(void)
noinline voidscs_test(void){ register unsigned long *sp asm("sp"); unsigned long * lr = sp + 1;
Quoted 8 lines
Quoted 3 lines
asm volatile("":::"x30"); *lr = 0; }It's probably be better to use
__builtin_frame_address(0)to get the address of the frame record rather than assuming that fp==sp in the middle of the function.
Got it.
Quoted 6 lines
Quoted 6 lines
config
SHADOW_CALL_STACKarch/Kconfig +2
-2- bool "Clang Shadow Call Stack" - depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK + bool "Shadow Call Stack" + depends on ARCH_SUPPORTS_SHADOW_CALL_STACK depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER
Quoted 9 lines
arch/Kconfig config ARCH_SUPPORTS_SHADOW_CALL_STACK · line 614
Quoted 6 lines
help
arch/Kconfig +1
-1- This option enables Clang's Shadow Call Stack, which uses a + This option enables Clang/GCC's Shadow Call Stack, which uses a shadow stack to protect function return addresses from being overwritten by an attacker. More information can be found in Clang's documentation:Is there any additional GCC documentation that we can refer to?
Currently there is only a brief description of
-fsanitize=shadow-call-stack in the user manual.
Since the description of the clang documentation is more detailed, should I add this gcc link to the configuration description?
Quoted 8 lines
Quoted 8 lines
arch/arm64/Kconfig +0
-0@@ -1255,7 +1255,7 @@ config HW_PERF_EVENTS config ARCH_HAS_FILTER_PGPROT def_bool y
Quoted 5 lines
arch/arm64/Kconfig config HW_PERF_EVENTS · line 1258
Quoted 2 lines
arch/arm64/Kconfig +1
-1-# Supported by clang >= 7.0 +# Supported by clang >= 7.0 or GCC > 11.2.0As above, I beleive that should be
GCC >= 12.0.0.
Yeah.
Thanks,
Dan.
Quoted 27 lines · Mark Rutland
Hi,
Quoted 3 lines · Dan Li
Shadow call stack is available in GCC > 11.2.0, this patch makes the corresponding kernel configuration available when compiling the kernel with gcc.
Neat!
My local GCC devs told me that means GCC 12.x.x rather than 11.2.x or 11.3.x, so as others have said it'd be clearer to say
GCC >= 12.0.0.I'd like to try this with a GCC binary before I provide an Ack or R-b; but in the mean time I have a few comments below.
Review
Quoted 10 lines
Note that the implementation in GCC is slightly different from Clang. With SCS enabled, functions will only pop x30 once in the epilogue, like:
str x30, [x18], #8 stp x29, x30, [sp, #-16]! ......(quoted diff) +1
-1- ldp x29, x30, [sp], #16 //clang + ldr x29, [sp], #16 //GCC ldr x30, [x18, #-8]!
Quoted 3 lines
Given the prologue still pushes both x29 and x30 (which we critically depend upon) that sounds OK to me.
Indeed.
What did come up in the discussion on the GCC side was runtime patching (to avoid the overhead of having both PAC and SCS), but it seems far more likely that we would patch PACIASP/AUTIASP instructions into SCS pushes/pops rather than the other way around, and so loading x30 only once should be fine.