x86/livepatch: align functions to ensure minimal distance between entry points
PATCH v5 1/1 x86/livepatch: align functions to ensure minimal distance between entry points
The minimal function size requirements for an x86 livepatch are either 5 bytes (for jmp) or 9 bytes (for endbr + jmp), and always 4 bytes on Arm. Ensure that distance between functions entry points is always at least of the minimal required size for livepatch instruction replacement to be successful.
Add an additional align directive to the linker script, in order to ensure that the next section placed after the .text.* (per-function sections) is also aligned to the required boundary, so that the distance of the last function entry point with the next symbol is also of minimal size.
Note that it's possible for the compiler to end up using a higher function alignment regardless of the passed value, so this change just make sure that the minimum required for livepatch to work is present. Different compilers handle the option differently, as clang will ignore -falign-functions value if it's smaller than the one that would be set by the optimization level, while gcc seems to always honor the function alignment passed in -falign-functions. In order to cope with this behavior and avoid that setting -falign-functions results in an alignment inferior to what the optimization level would have selected force x86 release builds to use a function alignment of 16 bytes. For Arm the default compiler selection of function alignment matches the requirements of livepatch, which are 4 bytes.
The compiler option -falign-functions is not available on at least clang 3.8, so introduce a Kconfig check for it and make the livepatch option depend on the compiler supporting the option.
The naming of the option(s) CONFIG_FUNCTION_ALIGNMENT is explicitly not mentioning CC in preparation for the option also being used by assembly code.
---
Changes since v4:
- Split from the rest of the livepatch testing series.
- Reword and expand a bit the commit message.
- Add a comment about falign-functions clang version requirement.
Changes since v3:
- Test for compiler option with -falign-functions.
- Make FUNCTION_ALIGNMENT depend on CC_HAS_FUNCTION_ALIGNMENT.
- Set 16byte function alignment for x86 release builds.
Changes since v2:
- Add Arm side.
- Align end of section in the linker script to ensure enough padding for the last function.
- Expand commit message and subject.
- Rework Kconfig options.
- Check that the compiler supports the option.
Changes since v1:
- New in this version.
--- xen/Kconfig | 21 +++++++++++++++++++++ xen/Makefile | 3 +++ xen/arch/arm/livepatch.c | 2 ++ xen/arch/arm/xen.lds.S | 4 ++++ xen/arch/x86/Kconfig | 1 + xen/arch/x86/livepatch.c | 4 ++++ xen/arch/x86/xen.lds.S | 4 ++++ xen/common/Kconfig | 5 ++++- 8 files changed, 43 insertions(+), 1 deletion(-)
xen/Kconfig +21 -0
@@ -37,6 +37,27 @@ config CC_HAS_VISIBILITY_ATTRIBUTE config CC_SPLIT_SECTIONS bool +# Set function alignment. +# +# Allow setting on a boolean basis, and then convert such selection to an +# integer for the build system and code to consume more easily. +# +# Requires clang >= 7.0.0 +config CC_HAS_FUNCTION_ALIGNMENT + def_bool $(cc-option,-falign-functions) +config FUNCTION_ALIGNMENT_4B + bool +config FUNCTION_ALIGNMENT_8B + bool +config FUNCTION_ALIGNMENT_16B + bool +config FUNCTION_ALIGNMENT + int + depends on CC_HAS_FUNCTION_ALIGNMENT + default 16 if FUNCTION_ALIGNMENT_16B + default 8 if FUNCTION_ALIGNMENT_8B + default 4 if FUNCTION_ALIGNMENT_4B + source "arch/$(SRCARCH)/Kconfig" config DEFCONFIG_LIST
xen/Makefile +3 -0
@@ -390,6 +390,9 @@ CFLAGS += -fomit-frame-pointer endif CFLAGS-$(CONFIG_CC_SPLIT_SECTIONS) += -ffunction-sections -fdata-sections +ifdef CONFIG_FUNCTION_ALIGNMENT +CFLAGS += -falign-functions=$(CONFIG_FUNCTION_ALIGNMENT) +endif CFLAGS += -nostdinc -fno-builtin -fno-common CFLAGS += -Werror -Wredundant-decls -Wwrite-strings -Wno-pointer-arith
xen/arch/arm/livepatch.c +2 -0
@@ -68,6 +68,8 @@ void arch_livepatch_revive(void)int arch_livepatch_verify_func (const struct livepatch_func *func) { +BUILD_BUG_ON (ARCH_PATCH_INSN_SIZE >CONFIG_FUNCTION_ALIGNMENT ); +/* If NOPing only do up to maximum amount we can put in the ->opaque. */ if ( !func->new_addr && (func->new_size >LIVEPATCH_OPAQUE_SIZE || func->new_size %ARCH_PATCH_INSN_SIZE ) )
xen/arch/arm/xen.lds.S +4 -0
@@ -44,6 +44,10 @@ SECTIONS #ifdef CONFIG_CC_SPLIT_SECTIONS *(.text.*) #endif +#ifdef CONFIG_FUNCTION_ALIGNMENT + /* Ensure enough distance with the next placed section. */ + . = ALIGN(CONFIG_FUNCTION_ALIGNMENT); +#endif *(.fixup) *(.gnu.warning)
xen/arch/x86/Kconfig +1 -0
@@ -29,6 +29,7 @@ config X86 select HAS_UBSAN select HAS_VPCI if HVM select NEEDS_LIBELF + select FUNCTION_ALIGNMENT_16B if !DEBUG config ARCH_DEFCONFIG string
xen/arch/x86/livepatch.c +4 -0
@@ -109,6 +109,10 @@ int arch_livepatch_verify_func(const struct livepatch_func *func)*/ uint8_t needed =ARCH_PATCH_INSN_SIZE ; +BUILD_BUG_ON (ARCH_PATCH_INSN_SIZE + + (IS_ENABLED (CONIFG_XEN_IBT ) ?ENDBR64_LEN :0 ) > +CONFIG_FUNCTION_ALIGNMENT ); +if (is_endbr64 (func->old_addr) ||is_endbr64_poison (func->old_addr) ) needed +=ENDBR64_LEN ;
xen/arch/x86/xen.lds.S +4 -0
@@ -99,6 +99,10 @@ SECTIONS *(.text) #ifdef CONFIG_CC_SPLIT_SECTIONS *(.text.*) +#endif +#ifdef CONFIG_FUNCTION_ALIGNMENT + /* Ensure enough distance with the next placed section. */ + . = ALIGN(CONFIG_FUNCTION_ALIGNMENT); #endif *(.text.__x86_indirect_thunk_*)
xen/common/Kconfig +4 -1
@@ -395,8 +395,11 @@ config CRYPTO config LIVEPATCH bool "Live patching support" default X86 - depends on "$(XEN_HAS_BUILD_ID)" = "y" + depends on "$(XEN_HAS_BUILD_ID)" = "y" && CC_HAS_FUNCTION_ALIGNMENT select CC_SPLIT_SECTIONS + select FUNCTION_ALIGNMENT_16B if XEN_IBT + select FUNCTION_ALIGNMENT_8B if X86 + select FUNCTION_ALIGNMENT_4B ---help--- Allows a running Xen hypervisor to be dynamically patched using binary patches without rebooting. This is primarily used to binarily
Signature · 1 line
2.43.0
Quoted 10 lines · Roger Pau Monne
The minimal function size requirements for an x86 livepatch are either 5 bytes (for jmp) or 9 bytes (for endbr + jmp), and always 4 bytes on Arm. Ensure that distance between functions entry points is always at least of the minimal required size for livepatch instruction replacement to be successful.
Add an additional align directive to the linker script, in order to ensure that the next section placed after the .text.* (per-function sections) is also aligned to the required boundary, so that the distance of the last function entry point with the next symbol is also of minimal size.
Quoted 9 lines
Note that it's possible for the compiler to end up using a higher function alignment regardless of the passed value, so this change just make sure that the minimum required for livepatch to work is present. Different compilers handle the option differently, as clang will ignore -falign-functions value if it's smaller than the one that would be set by the optimization level, while gcc seems to always honor the function alignment passed in -falign-functions. In order to cope with this behavior and avoid that setting -falign-functions results in an alignment inferior to what the optimization level would have selected force x86 release builds to use a function alignment of 16 bytes.
Nit: A comma after "selected" may help readability.
Quoted 4 lines
xen/Kconfig +0
-0@@ -37,6 +37,27 @@ config CC_HAS_VISIBILITY_ATTRIBUTE config CC_SPLIT_SECTIONS
xen/Kconfig config CC_HAS_VISIBILITY_ATTRIBUTE · line 47
Quoted 10 lines
xen/Kconfig +8
-0bool +# Set function alignment. +# +# Allow setting on a boolean basis, and then convert such selection to an +# integer for the build system and code to consume more easily. +# +# Requires clang >= 7.0.0 +config CC_HAS_FUNCTION_ALIGNMENT + def_bool $(cc-option,-falign-functions)
Nit: Maybe better have a blank line here?
Quoted 20 lines
xen/Kconfig +13
-0+config FUNCTION_ALIGNMENT_4B + bool +config FUNCTION_ALIGNMENT_8B + bool +config FUNCTION_ALIGNMENT_16B + bool +config FUNCTION_ALIGNMENT + int + depends on CC_HAS_FUNCTION_ALIGNMENT + default 16 if FUNCTION_ALIGNMENT_16B + default 8 if FUNCTION_ALIGNMENT_8B + default 4 if FUNCTION_ALIGNMENT_4B + source "arch/$(SRCARCH)/Kconfig" config DEFCONFIG_LIST
xen/arch/x86/xen.lds.S SECTIONS · line 107
Quoted 9 lines
xen/arch/x86/xen.lds.S +4
-0@@ -99,6 +99,10 @@ SECTIONS *(.text) #ifdef CONFIG_CC_SPLIT_SECTIONS *(.text.*) +#endif +#ifdef CONFIG_FUNCTION_ALIGNMENT + /* Ensure enough distance with the next placed section. */ + . = ALIGN(CONFIG_FUNCTION_ALIGNMENT); #endif *(.text.__x86_indirect_thunk_*)
I continue to fail to see how an alignment directive can guarantee minimum distance. In the worst case such a directive inserts nothing at all. IOW at the very least there's a non-spelled-out assumption here about the last item in the earlier section having suitable alignment and thus, if small in size, being suitably padded. Personally I don't think merely spelling out such a requirement would help - it would end up being a trap for someone to fall into.
I'm further curious why .text.__x86_indirect_thunk_* is left past the inserted alignment. While pretty unlikely, isn't it in principle possible for the thunks there to also need patching? Aren't we instead requiring then that assembly functions (and thunks) all be suitably aligned as well?
Jan
Quoted 64 lines · Jan Beulich
Quoted 10 lines · Roger Pau Monne
The minimal function size requirements for an x86 livepatch are either 5 bytes (for jmp) or 9 bytes (for endbr + jmp), and always 4 bytes on Arm. Ensure that distance between functions entry points is always at least of the minimal required size for livepatch instruction replacement to be successful.
Add an additional align directive to the linker script, in order to ensure that the next section placed after the .text.* (per-function sections) is also aligned to the required boundary, so that the distance of the last function entry point with the next symbol is also of minimal size.
Quoted 9 lines
Note that it's possible for the compiler to end up using a higher function alignment regardless of the passed value, so this change just make sure that the minimum required for livepatch to work is present. Different compilers handle the option differently, as clang will ignore -falign-functions value if it's smaller than the one that would be set by the optimization level, while gcc seems to always honor the function alignment passed in -falign-functions. In order to cope with this behavior and avoid that setting -falign-functions results in an alignment inferior to what the optimization level would have selected force x86 release builds to use a function alignment of 16 bytes.
Nit: A comma after "selected" may help readability.
Quoted 4 lines
xen/Kconfig +0
-0@@ -37,6 +37,27 @@ config CC_HAS_VISIBILITY_ATTRIBUTE config CC_SPLIT_SECTIONSxen/Kconfig config CC_HAS_VISIBILITY_ATTRIBUTE · line 47
Quoted 10 lines
xen/Kconfig +8
-0bool +# Set function alignment. +# +# Allow setting on a boolean basis, and then convert such selection to an +# integer for the build system and code to consume more easily. +# +# Requires clang >= 7.0.0 +config CC_HAS_FUNCTION_ALIGNMENT + def_bool $(cc-option,-falign-functions)Nit: Maybe better have a blank line here?
Quoted 24 lines
xen/Kconfig +13
-0+config FUNCTION_ALIGNMENT_4B + bool +config FUNCTION_ALIGNMENT_8B + bool +config FUNCTION_ALIGNMENT_16B + bool +config FUNCTION_ALIGNMENT + int + depends on CC_HAS_FUNCTION_ALIGNMENT + default 16 if FUNCTION_ALIGNMENT_16B + default 8 if FUNCTION_ALIGNMENT_8B + default 4 if FUNCTION_ALIGNMENT_4B + source "arch/$(SRCARCH)/Kconfig" config DEFCONFIG_LISTxen/arch/x86/xen.lds.S +1
-0@@ -99,6 +99,10 @@ SECTIONS *(.text) #ifdef CONFIG_CC_SPLIT_SECTIONS *(.text.*) +#endif
Quoted 8 lines
xen/arch/x86/xen.lds.S SECTIONS · line 107
Quoted 5 lines
xen/arch/x86/xen.lds.S +3
-0+#ifdef CONFIG_FUNCTION_ALIGNMENT + /* Ensure enough distance with the next placed section. */ + . = ALIGN(CONFIG_FUNCTION_ALIGNMENT); #endif *(.text.__x86_indirect_thunk_*)I continue to fail to see how an alignment directive can guarantee minimum distance. In the worst case such a directive inserts nothing at all.
I'm confused, you did provide a RB for this in v4:
https://lore.kernel.org/xen-devel/[email protected]/
Which is basically the same code with a few comments and wording adjustments.
Quoted 4 lines
IOW
at the very least there's a non-spelled-out assumption here about the last item in the earlier section having suitable alignment and thus, if small in size, being suitably padded.
Please bear with me, but I'm afraid I don't understand your concerns.
For livepatch build tools (which is the only consumer of such alignments) we already have the requirement that a function in order to be suitable for being live patched must reside in it's own section.
We do want to aim for functions (even assembly ones) to live in their own sections in order to be live patched, and to be properly aligned. However it's also fine for functions to use a different (smaller) alignment, the livepatch build tools will detect this and use the alignment reported.
While we want to get to a point where everything that we care to patch lives in it's own section, and is properly padded to ensure minimal required space, I don't see why the proposed approach here should be blocked, as it's a step in the right direction of achieving the goal.
Granted, there's still assembly code that won't be suitably padded, but the livepatch build tools won't assume it to be padded. After your series to enable assembly annotations we can also make sure the assembly annotated functions live in separate sections and are suitably aligned.
Quoted 8 lines
Personally I don't think merely spelling
out such a requirement would help - it would end up being a trap for someone to fall into.I'm further curious why .text.__x86_indirect_thunk_* is left past the inserted alignment. While pretty unlikely, isn't it in principle possible for the thunks there to also need patching? Aren't we instead requiring then that assembly functions (and thunks) all be suitably aligned as well?
Those are defined in assembly, so requires CONFIG_FUNCTION_ALIGNMENT to also be applied to the function entry points in assembly files.
Thanks, Roger.
Quoted 18 lines · Roger Pau Monné
Quoted 16 lines · Jan Beulich
xen/arch/x86/xen.lds.S SECTIONS · line 107
Quoted 12 lines · Roger Pau Monne
xen/arch/x86/xen.lds.S +4
-0@@ -99,6 +99,10 @@ SECTIONS *(.text) #ifdef CONFIG_CC_SPLIT_SECTIONS *(.text.*) +#endif +#ifdef CONFIG_FUNCTION_ALIGNMENT + /* Ensure enough distance with the next placed section. */ + . = ALIGN(CONFIG_FUNCTION_ALIGNMENT); #endif *(.text.__x86_indirect_thunk_*)I continue to fail to see how an alignment directive can guarantee minimum distance. In the worst case such a directive inserts nothing at all.
Quoted 6 lines
I'm confused, you did provide a RB for this in v4:
https://lore.kernel.org/xen-devel/[email protected]/
Which is basically the same code with a few comments and wording adjustments.
Hmm, yes. I think the aspect above was raised before, but then (perhaps) kind of addressed. (I'm puzzled then too: Why did you drop the R-b, when nothing substantially changed?) Yet re-reading the description, there's nothing said to this effect. Specifically ...
Quoted 12 lines
Quoted 4 lines
IOW
at the very least there's a non-spelled-out assumption here about the last item in the earlier section having suitable alignment and thus, if small in size, being suitably padded.Please bear with me, but I'm afraid I don't understand your concerns.
For livepatch build tools (which is the only consumer of such alignments) we already have the requirement that a function in order to be suitable for being live patched must reside in it's own section.
Quoted 5 lines
We do want to aim for functions (even assembly ones) to live in their own sections in order to be live patched, and to be properly aligned. However it's also fine for functions to use a different (smaller) alignment, the livepatch build tools will detect this and use the alignment reported.
... I don't think this and ...
Quoted 8 lines
While we want to get to a point where everything that we care to patch lives in it's own section, and is properly padded to ensure minimal required space, I don't see why the proposed approach here should be blocked, as it's a step in the right direction of achieving the goal.
Granted, there's still assembly code that won't be suitably padded, but the livepatch build tools won't assume it to be padded.
... this is being pointed out. Which I think is relevant to make explicit not the least because the build tools aren't part of the main Xen tree. Plus many (like me) may not be overly familiar with how they work.
Quoted 9 lines
After
your series to enable assembly annotations we can also make sure the assembly annotated functions live in separate sections and are suitably aligned.Quoted 3 lines
Personally I don't think merely spelling
out such a requirement would help - it would end up being a trap for someone to fall into.
Quoted 7 lines
Quoted 4 lines
I'm further curious why .text.__x86_indirect_thunk_* is left past the inserted alignment. While pretty unlikely, isn't it in principle possible for the thunks there to also need patching? Aren't we instead requiring then that assembly functions (and thunks) all be suitably aligned as well?
Those are defined in assembly, so requires
CONFIG_FUNCTION_ALIGNMENTto also be applied to the function entry points in assembly files.
I see. Yet the question then remains: Why is the alignment not inserted after them? Or will the insertion need to move later on (which would feel odd)?
Jan
Quoted 21 lines · Jan Beulich
Quoted 20 lines · Roger Pau Monné
Quoted 16 lines · Jan Beulich
xen/arch/x86/xen.lds.S SECTIONS · line 107
Quoted 12 lines · Roger Pau Monne
xen/arch/x86/xen.lds.S +4
-0@@ -99,6 +99,10 @@ SECTIONS *(.text) #ifdef CONFIG_CC_SPLIT_SECTIONS *(.text.*) +#endif +#ifdef CONFIG_FUNCTION_ALIGNMENT + /* Ensure enough distance with the next placed section. */ + . = ALIGN(CONFIG_FUNCTION_ALIGNMENT); #endif *(.text.__x86_indirect_thunk_*)I continue to fail to see how an alignment directive can guarantee minimum distance. In the worst case such a directive inserts nothing at all.
I'm confused, you did provide a RB for this in v4:
Quoted 8 lines
Quoted 4 lines
https://lore.kernel.org/xen-devel/[email protected]/
Which is basically the same code with a few comments and wording adjustments.
Hmm, yes. I think the aspect above was raised before, but then (perhaps) kind of addressed. (I'm puzzled then too: Why did you drop the R-b, when nothing substantially changed?)
The RB was given quite some time ago, so I felt it was probably best to drop it in case you wanted to re-asses the patch. Specially given you have now done the work to also add support for this feature to assembly annotated functions.
Quoted 29 lines
Yet re-reading the description, there's
nothing said to this effect. Specifically ...Quoted 12 lines
Quoted 4 lines
IOW
at the very least there's a non-spelled-out assumption here about the last item in the earlier section having suitable alignment and thus, if small in size, being suitably padded.Please bear with me, but I'm afraid I don't understand your concerns.
For livepatch build tools (which is the only consumer of such alignments) we already have the requirement that a function in order to be suitable for being live patched must reside in it's own section.
Quoted 5 lines
We do want to aim for functions (even assembly ones) to live in their own sections in order to be live patched, and to be properly aligned. However it's also fine for functions to use a different (smaller) alignment, the livepatch build tools will detect this and use the alignment reported.
... I don't think this and ...
Quoted 6 lines
While we want to get to a point where everything that we care to patch lives in it's own section, and is properly padded to ensure minimal required space, I don't see why the proposed approach here should be blocked, as it's a step in the right direction of achieving the goal.
Quoted 7 lines
Quoted 2 lines
Granted, there's still assembly code that won't be suitably padded, but the livepatch build tools won't assume it to be padded.
... this is being pointed out. Which I think is relevant to make explicit not the least because the build tools aren't part of the main Xen tree. Plus many (like me) may not be overly familiar with how they work.
OK, I can integrate some of this wording in the commit message.
Quoted 14 lines
Quoted 14 lines
After
your series to enable assembly annotations we can also make sure the assembly annotated functions live in separate sections and are suitably aligned.Quoted 8 lines
Personally I don't think merely spelling
out such a requirement would help - it would end up being a trap for someone to fall into.I'm further curious why .text.__x86_indirect_thunk_* is left past the inserted alignment. While pretty unlikely, isn't it in principle possible for the thunks there to also need patching? Aren't we instead requiring then that assembly functions (and thunks) all be suitably aligned as well?
Quoted 6 lines
Quoted 2 lines
Those are defined in assembly, so requires
CONFIG_FUNCTION_ALIGNMENTto also be applied to the function entry points in assembly files.I see. Yet the question then remains: Why is the alignment not inserted after them? Or will the insertion need to move later on (which would feel odd)?
The thunk sections will currently be consumed by *(.text.*) when using split sections. Looking at the assembly for them I think they are suitable annotated to create the right symbols for livepatch tools to pick. They won't however have the right alignment just yet, as I expect that will get solved with your follow up patch to respect CONFIG_FUNCTION_ALIGNMENT in assembly annotated functions also.
Thanks, Roger.
Quoted 15 lines · Roger Pau Monné
Quoted 7 lines · Jan Beulich
Quoted 6 lines · Roger Pau Monné
Quoted 4 lines · Jan Beulich
I'm further curious why .text.__x86_indirect_thunk_* is left past the inserted alignment. While pretty unlikely, isn't it in principle possible for the thunks there to also need patching? Aren't we instead requiring then that assembly functions (and thunks) all be suitably aligned as well?
Quoted 6 lines
Quoted 2 lines
Those are defined in assembly, so requires
CONFIG_FUNCTION_ALIGNMENTto also be applied to the function entry points in assembly files.I see. Yet the question then remains: Why is the alignment not inserted after them? Or will the insertion need to move later on (which would feel odd)?
Quoted 6 lines
The thunk sections will currently be consumed by *(.text.*) when using split sections. Looking at the assembly for them I think they are suitable annotated to create the right symbols for livepatch tools to pick. They won't however have the right alignment just yet, as I expect that will get solved with your follow up patch to respect
CONFIG_FUNCTION_ALIGNMENTin assembly annotated functions also.
Not exactly, no. Those will first need converting from ENTRY() to the new annotations model. Which I certainly intend to get to.
Jan