compiler_types: Introduce the Clang __preserve_most function attribute
Subsystems (7)
PATCH v4 1/4 compiler_types: Introduce the Clang __preserve_most function attribute
[1]: "On X86-64 and AArch64 targets, this attribute changes the calling convention of a function. The preserve_most calling convention attempts to make the code in the caller as unintrusive as possible. This convention behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. This alleviates the burden of saving and recovering a large register set before and after the call in the caller. If the arguments are passed in callee-saved registers, then they will be preserved by the callee across the call. This doesn't apply for values returned in callee-saved registers.
* On X86-64 the callee preserves all general purpose registers, except for R11. R11 can be used as a scratch register. Floating-point registers (XMMs/YMMs) are not preserved and need to be saved by the caller.
* On AArch64 the callee preserve all general purpose registers, except x0-X8 and X16-X18."
[1] https://clang.llvm.org/docs/AttributeReference.html#preserve-most
Introduce the attribute to compiler_types.h as __preserve_most.
Use of this attribute results in better code generation for calls to very rarely called functions, such as error-reporting functions, or rarely executed slow paths.
Beware that the attribute conflicts with instrumentation calls inserted on function entry which do not use __preserve_most themselves. Notably, function tracing which assumes the normal C calling convention for the given architecture. Where the attribute is supported, __preserve_most will imply notrace. It is recommended to restrict use of the attribute to functions that should or already disable tracing.
Note: The additional preprocessor check against architecture should not be necessary if __has_attribute() only returns true where supported; also see https://github.com/ClangBuiltLinux/linux/issues/1908. But until __has_attribute() does the right thing, we also guard by known-supported architectures to avoid build warnings on other architectures.
The attribute may be supported by a future GCC version (see
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110899).
---
v4:
* Guard attribute based on known-supported architectures to avoid compiler warnings about the attribute being ignored.
v3:
* Quote more from LLVM documentation about which registers are callee/caller with preserve_most.
* Code comment to restrict use where tracing is meant to be disabled.
v2:
* Imply notrace, to avoid any conflicts with tracing which is inserted on function entry. See added comments.
--- include/linux/compiler_types.h | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
include/linux/compiler_types.h +28 -0
@@ -106,6 +106,34 @@ static inline void __chk_io_ptr(const volatile void __iomem *ptr) { }#define __cold#endif +/* +* On x86-64 and arm64 targets, __preserve_most changes the calling convention +* of a function to make the code in the caller as unintrusive as possible. This +* convention behaves identically to the C calling convention on how arguments +* and return values are passed, but uses a different set of caller- and callee- +* saved registers. +* +* The purpose is to alleviates the burden of saving and recovering a large +* register set before and after the call in the caller. This is beneficial for +* rarely taken slow paths, such as error-reporting functions that may be called +* from hot paths. +* +* Note: This may conflict with instrumentation inserted on function entry which +* does not use __preserve_most or equivalent convention (if in assembly). Since +* function tracing assumes the normal C calling convention, where the attribute +* is supported, __preserve_most implies notrace. It is recommended to restrict +* use of the attribute to functions that should or already disable tracing. +* +* Optional: not supported by gcc. +* +* clang: https://clang.llvm.org/docs/AttributeReference.html#preserve-most +*/ +#if __has_attribute (__preserve_most__) && (defined(CONFIG_X86_64 ) || defined(CONFIG_ARM64 )) +# define __preserve_most notrace __attribute__((__preserve_most__)) +#else +# define __preserve_most +#endif +/* Builtins */ /*
Signature · 1 line
2.41.0.694.ge786442a9b-goog
PATCH v4 2/4 list_debug: Introduce inline wrappers for debug checks
Turn the list debug checking functions __list_*_valid() into inline functions that wrap the out-of-line functions. Care is taken to ensure the inline wrappers are always inlined, so that additional compiler instrumentation (such as sanitizers) does not result in redundant outlining.
This change is preparation for performing checks in the inline wrappers.
No functional change intended.
---
v3:
* Rename ___list_*_valid() to __list_*_valid_or_report().
* Some documentation.
--- arch/arm64/kvm/hyp/nvhe/list_debug.c | 6 ++--- include/linux/list.h | 37 +++++++++++++++++++++++++--- lib/list_debug.c | 11 ++++----- 3 files changed, 41 insertions(+), 13 deletions(-)
arch/arm64/kvm/hyp/nvhe/list_debug.c +3 -3
@@ -26,8 +26,8 @@ static inline __must_check bool nvhe_check_data_corruption(bool v)/* The predicates checked here are taken from lib/list_debug.c. */ -bool __list_add_valid (struct list_head *new,struct list_head *prev, -struct list_head *next) +bool __list_add_valid_or_report (struct list_head *new,struct list_head *prev, +struct list_head *next) { if (NVHE_CHECK_DATA_CORRUPTION(next->prev != prev) || NVHE_CHECK_DATA_CORRUPTION(prev->next != next) ||
@@ -37,7 +37,7 @@ bool __list_add_valid(struct list_head *new, struct list_head *prev,return true; } -bool __list_del_entry_valid (struct list_head *entry) +bool __list_del_entry_valid_or_report (struct list_head *entry) {struct list_head *prev, *next;
include/linux/list.h +33 -4
@@ -39,10 +39,39 @@ static inline void INIT_LIST_HEAD(struct list_head *list) }#ifdef CONFIG_DEBUG_LIST -extern bool __list_add_valid (struct list_head *new, -struct list_head *prev, -struct list_head *next); -extern bool __list_del_entry_valid (struct list_head *entry); +/* +* Performs the full set of list corruption checks before __list_add(). +* On list corruption reports a warning, and returns false. +*/ +extern bool __list_add_valid_or_report (struct list_head *new, +struct list_head *prev, +struct list_head *next); + +/* +* Performs list corruption checks before __list_add(). Returns false if a +* corruption is detected, true otherwise. +*/ +static __always_inline bool __list_add_valid(struct list_head *new, +struct list_head *prev, +struct list_head *next) +{ +return __list_add_valid_or_report (new, prev, next); +} + +/* +* Performs the full set of list corruption checks before __list_del_entry(). +* On list corruption reports a warning, and returns false. +*/ +extern bool __list_del_entry_valid_or_report (struct list_head *entry); + +/* +* Performs list corruption checks before __list_del_entry(). Returns false if a +* corruption is detected, true otherwise. +*/ +static __always_inline bool __list_del_entry_valid(struct list_head *entry) +{ +return __list_del_entry_valid_or_report (entry); +}#else static inline bool __list_add_valid(struct list_head *new, struct list_head *prev,
lib/list_debug.c +5 -6
@@ -17,8 +17,8 @@* attempt). */ -bool __list_add_valid (struct list_head *new,struct list_head *prev, -struct list_head *next) +bool __list_add_valid_or_report (struct list_head *new,struct list_head *prev, +struct list_head *next) { if (CHECK_DATA_CORRUPTION(prev == NULL, "list_add corruption. prev is NULL.\n") ||
@@ -37,9 +37,9 @@ bool __list_add_valid(struct list_head *new, struct list_head *prev,return true; } -EXPORT_SYMBOL (__list_add_valid); +EXPORT_SYMBOL (__list_add_valid_or_report); -bool __list_del_entry_valid (struct list_head *entry) +bool __list_del_entry_valid_or_report (struct list_head *entry) {struct list_head *prev, *next;
@@ -65,6 +65,5 @@ bool __list_del_entry_valid(struct list_head *entry)return false;return true; - } -EXPORT_SYMBOL (__list_del_entry_valid); +EXPORT_SYMBOL (__list_del_entry_valid_or_report);
Signature · 1 line
2.41.0.694.ge786442a9b-goog
PATCH v4 3/4 list: Introduce CONFIG_LIST_HARDENED
In reply to Marco ElverNumerous production kernel configs (see [1, 2]) are choosing to enable CONFIG_DEBUG_LIST, which is also being recommended by KSPP for hardened configs [3]. The motivation behind this is that the option can be used as a security hardening feature (e.g. CVE-2019-2215 and CVE-2019-2025 are mitigated by the option [4]).
The feature has never been designed with performance in mind, yet common list manipulation is happening across hot paths all over the kernel.
Introduce CONFIG_LIST_HARDENED, which performs list pointer checking inline, and only upon list corruption calls the reporting slow path.
To generate optimal machine code with CONFIG_LIST_HARDENED:
1. Elide checking for pointer values which upon dereference would result in an immediate access fault (i.e. minimal hardening checks). The trade-off is lower-quality error reports.
2. Use the __preserve_most function attribute (available with Clang, but not yet with GCC) to minimize the code footprint for calling the reporting slow path. As a result, function size of callers is reduced by avoiding saving registers before calling the rarely called reporting slow path.
Note that all TUs in lib/Makefile already disable function tracing, including list_debug.c, and __preserve_most's implied notrace has no effect in this case.
3. Because the inline checks are a subset of the full set of checks in __list_*_valid_or_report(), always return false if the inline checks failed. This avoids redundant compare and conditional branch right after return from the slow path.
As a side-effect of the checks being inline, if the compiler can prove some condition to always be true, it can completely elide some checks.
Since DEBUG_LIST is functionally a superset of LIST_HARDENED, the Kconfig variables are changed to reflect that: DEBUG_LIST selects LIST_HARDENED, whereas LIST_HARDENED itself has no dependency on DEBUG_LIST.
Running netperf with CONFIG_LIST_HARDENED (using a Clang compiler with "preserve_most") shows throughput improvements, in my case of ~7% on average (up to 20-30% on some test cases).
---
v4:
* Rename to CONFIG_LIST_HARDENED, which can independently be selected from CONFIG_DEBUG_LIST.
* LKDTM test should just check CONFIG_LIST_HARDENED (which is also implied by DEBUG_LIST).
* Comment word smithing.
v3:
* Rename ___list_*_valid() to __list_*_valid_or_report().
* More comments.
v2:
* Note that lib/Makefile disables function tracing for everything and __preserve_most's implied notrace is a noop here.
--- arch/arm64/kvm/hyp/nvhe/Makefile | 2 +- arch/arm64/kvm/hyp/nvhe/list_debug.c | 2 + drivers/misc/lkdtm/bugs.c | 4 +- include/linux/list.h | 64 +++++++++++++++++++++++++--- lib/Kconfig.debug | 9 +++- lib/Makefile | 2 +- lib/list_debug.c | 5 ++- security/Kconfig.hardening | 13 ++++++ 8 files changed, 88 insertions(+), 13 deletions(-)
arch/arm64/kvm/hyp/nvhe/Makefile +1 -1
@@ -25,7 +25,7 @@ hyp-obj-y := timer-sr.o sysreg-sr.o debug-sr.o switch.o tlb.o hyp-init.o host.o cache.o setup.o mm.o mem_protect.o sys_regs.o pkvm.o stacktrace.o ffa.o hyp-obj-y += ../vgic-v3-sr.o ../aarch32.o ../vgic-v2-cpuif-proxy.o ../entry.o \ ../fpsimd.o ../hyp-entry.o ../exception.o ../pgtable.o -hyp-obj-$(CONFIG_DEBUG_LIST) += list_debug.o +hyp-obj-$(CONFIG_LIST_HARDENED) += list_debug.o hyp-obj-y += $(lib-objs) ##
arch/arm64/kvm/hyp/nvhe/list_debug.c +2 -0
@@ -26,6 +26,7 @@ static inline __must_check bool nvhe_check_data_corruption(bool v)/* The predicates checked here are taken from lib/list_debug.c. */ +__list_valid_slowpath bool __list_add_valid_or_report(struct list_head *new, struct list_head *prev,struct list_head *next) {
@@ -37,6 +38,7 @@ bool __list_add_valid_or_report(struct list_head *new, struct list_head *prev,return true; } +__list_valid_slowpath bool __list_del_entry_valid_or_report(struct list_head *entry) {struct list_head *prev, *next;
drivers/misc/lkdtm/bugs.c +2 -2
@@ -393,7 +393,7 @@ static void lkdtm_CORRUPT_LIST_ADD(void)pr_err ("Overwrite did not happen, but no BUG?!\n" ); else {pr_err ("list_add() corruption not detected!\n" ); -pr_expected_config (CONFIG_DEBUG_LIST ); +pr_expected_config (CONFIG_LIST_HARDENED ); } }
@@ -420,7 +420,7 @@ static void lkdtm_CORRUPT_LIST_DEL(void)pr_err ("Overwrite did not happen, but no BUG?!\n" ); else {pr_err ("list_del() corruption not detected!\n" ); -pr_expected_config (CONFIG_DEBUG_LIST ); +pr_expected_config (CONFIG_LIST_HARDENED ); } }
include/linux/list.h +58 -6
97 lines not on this page · raw message
lib/Kconfig.debug +7 -2
@@ -1674,9 +1674,14 @@ menu "Debug kernel data structures" config DEBUG_LIST bool "Debug linked list manipulation" depends on DEBUG_KERNEL || BUG_ON_DATA_CORRUPTION + select LIST_HARDENED help - Enable this to turn on extended checks in the linked-list - walking routines. + Enable this to turn on extended checks in the linked-list walking + routines. + + This option trades better quality error reports for performance, and + is more suitable for kernel debugging. If you care about performance, + you should only enable CONFIG_LIST_HARDENED instead. If unsure, say N.
lib/Makefile +1 -1
@@ -167,7 +167,7 @@ obj-$(CONFIG_BTREE) += btree.o obj-$(CONFIG_INTERVAL_TREE) += interval_tree.o obj-$(CONFIG_ASSOCIATIVE_ARRAY) += assoc_array.o obj-$(CONFIG_DEBUG_PREEMPT) += smp_processor_id.o -obj-$(CONFIG_DEBUG_LIST) += list_debug.o +obj-$(CONFIG_LIST_HARDENED) += list_debug.o obj-$(CONFIG_DEBUG_OBJECTS) += debugobjects.o obj-$(CONFIG_BITREVERSE) += bitrev.o
lib/list_debug.c +4 -1
@@ -2,7 +2,8 @@* Copyright 2006, Red Hat, Inc., Dave Jones * Released under the General Public License (GPL). * -* This file contains the linked list validation for DEBUG_LIST. +* This file contains the linked list validation and error reporting for +* LIST_HARDENED and DEBUG_LIST. */ #include <linux/export.h>
@@ -17,6 +18,7 @@* attempt). */ +__list_valid_slowpath bool __list_add_valid_or_report(struct list_head *new, struct list_head *prev,struct list_head *next) {
@@ -39,6 +41,7 @@ bool __list_add_valid_or_report(struct list_head *new, struct list_head *prev, }EXPORT_SYMBOL (__list_add_valid_or_report); +__list_valid_slowpath bool __list_del_entry_valid_or_report(struct list_head *entry) {struct list_head *prev, *next;
security/Kconfig.hardening +13 -0
@@ -279,6 +279,19 @@ config ZERO_CALL_USED_REGS endmenu +menu "Hardening of kernel data structures" + +config LIST_HARDENED + bool "Check integrity of linked list manipulation" + help + Minimal integrity checking in the linked-list manipulation routines + to catch memory corruptions that are not guaranteed to result in an + immediate access fault. + + If unsure, say N. + +endmenu + config CC_HAS_RANDSTRUCT def_bool $(cc-option,-frandomize-layout-seed-file=/dev/null) # Randstruct was first added in Clang 15, but it isn't safe to use until
Signature · 1 line
2.41.0.694.ge786442a9b-goog
PATCH v4 4/4 hardening: Move BUG_ON_DATA_CORRUPTION to hardening options
In reply to Marco ElverBUG_ON_DATA_CORRUPTION is turning detected corruptions of list data structures from WARNings into BUGs. This can be useful to stop further corruptions or even exploitation attempts.
However, the option has less to do with debugging than with hardening. With the introduction of LIST_HARDENED, it makes more sense to move it to the hardening options, where it selects LIST_HARDENED instead.
Without this change, combining BUG_ON_DATA_CORRUPTION with LIST_HARDENED alone wouldn't be possible, because DEBUG_LIST would always be selected by BUG_ON_DATA_CORRUPTION.
---
v4:
* New patch, after LIST_HARDENED was made independent of DEBUG_LIST, and now DEBUG_LIST depends on LIST_HARDENED.
--- lib/Kconfig.debug | 12 +----------- security/Kconfig.hardening | 10 ++++++++++ 2 files changed, 11 insertions(+), 11 deletions(-)
lib/Kconfig.debug +1 -11
@@ -1673,7 +1673,7 @@ menu "Debug kernel data structures" config DEBUG_LIST bool "Debug linked list manipulation" - depends on DEBUG_KERNEL || BUG_ON_DATA_CORRUPTION + depends on DEBUG_KERNEL select LIST_HARDENED help Enable this to turn on extended checks in the linked-list walking
@@ -1715,16 +1715,6 @@ config DEBUG_NOTIFIERS This is a relatively cheap check but if you care about maximum performance, say N. -config BUG_ON_DATA_CORRUPTION - bool "Trigger a BUG when data corruption is detected" - select DEBUG_LIST - help - Select this option if the kernel should BUG when it encounters - data corruption in kernel memory structures when they get checked - for validity. - - If unsure, say N. - config DEBUG_MAPLE_TREE bool "Debug maple trees" depends on DEBUG_KERNEL
security/Kconfig.hardening +10 -0
@@ -290,6 +290,16 @@ config LIST_HARDENED If unsure, say N. +config BUG_ON_DATA_CORRUPTION + bool "Trigger a BUG when data corruption is detected" + select LIST_HARDENED + help + Select this option if the kernel should BUG when it encounters + data corruption in kernel memory structures when they get checked + for validity. + + If unsure, say N. + endmenu config CC_HAS_RANDSTRUCT
Signature · 1 line
2.41.0.694.ge786442a9b-goog
Quoted 40 lines · Marco Elver
[1]: "On X86-64 and AArch64 targets, this attribute changes the calling convention of a function. The
preserve_mostcalling convention attempts to make the code in the caller as unintrusive as possible. This convention behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. This alleviates the burden of saving and recovering a large register set before and after the call in the caller. If the arguments are passed in callee-saved registers, then they will be preserved by the callee across the call. This doesn't apply for values returned in callee-saved registers.* On X86-64 the callee preserves all general purpose registers, except for R11. R11 can be used as a scratch register. Floating-point registers (XMMs/YMMs) are not preserved and need to be saved by the caller.
* On AArch64 the callee preserve all general purpose registers, except x0-X8 and X16-X18."
[1] https://clang.llvm.org/docs/AttributeReference.html#preserve-most
Introduce the attribute to
compiler_types.has__preserve_most.Use of this attribute results in better code generation for calls to very rarely called functions, such as error-reporting functions, or rarely executed slow paths.
Beware that the attribute conflicts with instrumentation calls inserted on function entry which do not use
__preserve_mostthemselves. Notably, function tracing which assumes the normal C calling convention for the given architecture. Where the attribute is supported,__preserve_mostwill imply notrace. It is recommended to restrict use of the attribute to functions that should or already disable tracing.Note: The additional preprocessor check against architecture should not be necessary if
__has_attribute()only returns true where supported; also see https://github.com/ClangBuiltLinux/linux/issues/1908. But until__has_attribute()does the right thing, we also guard by known-supported architectures to avoid build warnings on other architectures.
Quoted 8 lines
The attribute may be supported by a future GCC version (see
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110899).Signed-off-by Marco Elver <[email protected]>Reviewed-by Miguel Ojeda <[email protected]>Reviewed-by Nick Desaulniers <[email protected]>Acked-by Mark Rutland <[email protected]>
Should this go via -mm, the hardening tree, or something else? I'm happy to carry it if no one else wants it?
-Kees
Signature · 1 line
Kees Cook
Quoted 45 lines · Kees Cook
Quoted 43 lines · Marco Elver
[1]: "On X86-64 and AArch64 targets, this attribute changes the calling convention of a function. The
preserve_mostcalling convention attempts to make the code in the caller as unintrusive as possible. This convention behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. This alleviates the burden of saving and recovering a large register set before and after the call in the caller. If the arguments are passed in callee-saved registers, then they will be preserved by the callee across the call. This doesn't apply for values returned in callee-saved registers.* On X86-64 the callee preserves all general purpose registers, except for R11. R11 can be used as a scratch register. Floating-point registers (XMMs/YMMs) are not preserved and need to be saved by the caller.
* On AArch64 the callee preserve all general purpose registers, except x0-X8 and X16-X18."
[1] https://clang.llvm.org/docs/AttributeReference.html#preserve-most
Introduce the attribute to
compiler_types.has__preserve_most.Use of this attribute results in better code generation for calls to very rarely called functions, such as error-reporting functions, or rarely executed slow paths.
Beware that the attribute conflicts with instrumentation calls inserted on function entry which do not use
__preserve_mostthemselves. Notably, function tracing which assumes the normal C calling convention for the given architecture. Where the attribute is supported,__preserve_mostwill imply notrace. It is recommended to restrict use of the attribute to functions that should or already disable tracing.Note: The additional preprocessor check against architecture should not be necessary if
__has_attribute()only returns true where supported; also see https://github.com/ClangBuiltLinux/linux/issues/1908. But until__has_attribute()does the right thing, we also guard by known-supported architectures to avoid build warnings on other architectures.The attribute may be supported by a future GCC version (see
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=110899).
Quoted 8 lines
Quoted 5 lines
Signed-off-by Marco Elver <[email protected]>Reviewed-by Miguel Ojeda <[email protected]>Reviewed-by Nick Desaulniers <[email protected]>Acked-by Mark Rutland <[email protected]>Should this go via -mm, the hardening tree, or something else? I'm happy to carry it if no one else wants it?
v3 of this series is already in mm-unstable, and has had some -next exposure (which was helpful in uncovering some additional issues). Therefore, I think it's appropriate that it continues in mm and Andrew picks up the latest v4 here.
Your official Ack would nevertheless be much appreciated!
Thanks,
-- Marco
Andrew Morton
maintainerQuoted 2 lines · On Mon, 14 Aug 2023 16:21:43 -0700 Kees Cook <[email protected]> wrote:
Should this go via -mm, the hardening tree, or something else? I'm happy to carry it if no one else wants it?
Please do so.
Kees Cook
AppliedQuoted 11 lines · Marco Elver
[1]: "On X86-64 and AArch64 targets, this attribute changes the calling convention of a function. The
preserve_mostcalling convention attempts to make the code in the caller as unintrusive as possible. This convention behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. This alleviates the burden of saving and recovering a large register set before and after the call in the caller. If the arguments are passed in callee-saved registers, then they will be preserved by the callee across the call. This doesn't apply for values returned in callee-saved registers.
Quoted 1 line
[...]
Applied to for-next/hardening, thanks!
[1/4] compiler_types: Introduce the Clang __preserve_most function attribute
https://git.kernel.org/kees/c/7a0fd5e16785 [2/4] list_debug: Introduce inline wrappers for debug checks https://git.kernel.org/kees/c/b16c42c8fde8 [3/4] list: Introduce CONFIG_LIST_HARDENED https://git.kernel.org/kees/c/aebc7b0d8d91 [4/4] hardening: Move BUG_ON_DATA_CORRUPTION to hardening options https://git.kernel.org/kees/c/aa9f10d57056
Take care,
Signature · 1 line
Kees Cook