* [PATCH v2 6/6] objtool/kbuild/rust: enable objtool for Rust
2024-07-24 16:14 [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool` Miguel Ojeda
@ 2024-07-24 16:14 ` Miguel Ojeda
2024-07-24 21:51 ` [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool` Benno Lossin
` (2 subsequent siblings)
3 siblings, 0 replies; 6+ messages in thread
From: Miguel Ojeda @ 2024-07-24 16:14 UTC (permalink / raw)
To: Josh Poimboeuf, Peter Zijlstra, Thomas Gleixner, Ingo Molnar,
Borislav Petkov, Dave Hansen, Masahiro Yamada
Cc: x86, H. Peter Anvin, Nathan Chancellor, Nicolas Schier,
Miguel Ojeda, Wedson Almeida Filho, Alex Gaynor, Boqun Feng,
Gary Guo, Björn Roy Baron, Benno Lossin, Andreas Hindborg,
Alice Ryhl, rust-for-linux, linux-kernel, patches, linux-kbuild
Now that we should be `objtool`-warning free, enable `objtool` for
Rust too.
Before this patch series, we were already getting warnings under e.g. IBT
builds, since those would see Rust code via `vmlinux`.
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
---
rust/Makefile | 22 ++++++++++++++--------
scripts/Makefile.build | 9 +++++++--
2 files changed, 21 insertions(+), 10 deletions(-)
diff --git a/rust/Makefile b/rust/Makefile
index bf05e65365da..1756238b641d 100644
--- a/rust/Makefile
+++ b/rust/Makefile
@@ -344,7 +344,8 @@ quiet_cmd_rustc_library = $(if $(skip_clippy),RUSTC,$(RUSTC_OR_CLIPPY_QUIET)) L
--crate-type rlib -L$(objtree)/$(obj) \
--crate-name $(patsubst %.o,%,$(notdir $@)) $< \
--sysroot=/dev/null \
- $(if $(rustc_objcopy),;$(OBJCOPY) $(rustc_objcopy) $@)
+ $(if $(rustc_objcopy),;$(OBJCOPY) $(rustc_objcopy) $@) \
+ $(cmd_objtool)
rust-analyzer:
$(Q)$(srctree)/scripts/generate_rust_analyzer.py \
@@ -366,44 +367,49 @@ ifneq ($(or $(CONFIG_ARM64),$(and $(CONFIG_RISCV),$(CONFIG_64BIT))),)
__ashlti3 __lshrti3
endif
+define rule_rustc_library
+ $(call cmd_and_fixdep,rustc_library)
+ $(call cmd,gen_objtooldep)
+endef
+
$(obj)/core.o: private skip_clippy = 1
$(obj)/core.o: private skip_flags = -Wunreachable_pub
$(obj)/core.o: private rustc_objcopy = $(foreach sym,$(redirect-intrinsics),--redefine-sym $(sym)=__rust$(sym))
$(obj)/core.o: private rustc_target_flags = $(core-cfgs)
$(obj)/core.o: $(RUST_LIB_SRC)/core/src/lib.rs FORCE
- +$(call if_changed_dep,rustc_library)
+ +$(call if_changed_rule,rustc_library)
ifdef CONFIG_X86_64
$(obj)/core.o: scripts/target.json
endif
$(obj)/compiler_builtins.o: private rustc_objcopy = -w -W '__*'
$(obj)/compiler_builtins.o: $(src)/compiler_builtins.rs $(obj)/core.o FORCE
- +$(call if_changed_dep,rustc_library)
+ +$(call if_changed_rule,rustc_library)
$(obj)/alloc.o: private skip_clippy = 1
$(obj)/alloc.o: private skip_flags = -Wunreachable_pub
$(obj)/alloc.o: private rustc_target_flags = $(alloc-cfgs)
$(obj)/alloc.o: $(RUST_LIB_SRC)/alloc/src/lib.rs $(obj)/compiler_builtins.o FORCE
- +$(call if_changed_dep,rustc_library)
+ +$(call if_changed_rule,rustc_library)
$(obj)/build_error.o: $(src)/build_error.rs $(obj)/compiler_builtins.o FORCE
- +$(call if_changed_dep,rustc_library)
+ +$(call if_changed_rule,rustc_library)
$(obj)/bindings.o: $(src)/bindings/lib.rs \
$(obj)/compiler_builtins.o \
$(obj)/bindings/bindings_generated.rs \
$(obj)/bindings/bindings_helpers_generated.rs FORCE
- +$(call if_changed_dep,rustc_library)
+ +$(call if_changed_rule,rustc_library)
$(obj)/uapi.o: $(src)/uapi/lib.rs \
$(obj)/compiler_builtins.o \
$(obj)/uapi/uapi_generated.rs FORCE
- +$(call if_changed_dep,rustc_library)
+ +$(call if_changed_rule,rustc_library)
$(obj)/kernel.o: private rustc_target_flags = --extern alloc \
--extern build_error --extern macros --extern bindings --extern uapi
$(obj)/kernel.o: $(src)/kernel/lib.rs $(obj)/alloc.o $(obj)/build_error.o \
$(obj)/libmacros.so $(obj)/bindings.o $(obj)/uapi.o FORCE
- +$(call if_changed_dep,rustc_library)
+ +$(call if_changed_rule,rustc_library)
endif # CONFIG_RUST
diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index efacca63c897..72b1232b1f7d 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -288,10 +288,15 @@ rust_common_cmd = \
# would not match each other.
quiet_cmd_rustc_o_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@
- cmd_rustc_o_rs = $(rust_common_cmd) --emit=obj=$@ $<
+ cmd_rustc_o_rs = $(rust_common_cmd) --emit=obj=$@ $< $(cmd_objtool)
+
+define rule_rustc_o_rs
+ $(call cmd_and_fixdep,rustc_o_rs)
+ $(call cmd,gen_objtooldep)
+endef
$(obj)/%.o: $(obj)/%.rs FORCE
- +$(call if_changed_dep,rustc_o_rs)
+ +$(call if_changed_rule,rustc_o_rs)
quiet_cmd_rustc_rsi_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@
cmd_rustc_rsi_rs = \
--
2.45.2
^ permalink raw reply related [flat|nested] 6+ messages in thread* Re: [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool`
2024-07-24 16:14 [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool` Miguel Ojeda
2024-07-24 16:14 ` [PATCH v2 6/6] objtool/kbuild/rust: enable objtool for Rust Miguel Ojeda
@ 2024-07-24 21:51 ` Benno Lossin
2024-07-25 8:38 ` Peter Zijlstra
2024-07-25 9:43 ` Alice Ryhl
3 siblings, 0 replies; 6+ messages in thread
From: Benno Lossin @ 2024-07-24 21:51 UTC (permalink / raw)
To: Miguel Ojeda, Josh Poimboeuf, Peter Zijlstra, Thomas Gleixner,
Ingo Molnar, Borislav Petkov, Dave Hansen, Masahiro Yamada
Cc: x86, H. Peter Anvin, Nathan Chancellor, Nicolas Schier,
Wedson Almeida Filho, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Andreas Hindborg, Alice Ryhl,
rust-for-linux, linux-kernel, patches, linux-kbuild
On 24.07.24 18:14, Miguel Ojeda wrote:
> Hi,
>
> This is an updated series to the CPU mitigations support for Rust. It
> also has the patch to enable `objtool`, so that we can start running it
> for Rust.
>
> It would be nice to get this applied soon, so that we start being
> warning-free (since we already get warnings under IBT builds via
> `vmlinux.o`). I am happy to take it through the Rust tree if the x86 and
> objtool maintainers give an Acked-by, or through any of the other trees,
> as you prefer. Otherwise, I think at this point we would need to make
> Rust exclusive to the mitigations, which isn't great.
>
> With this series, again, x86_64 is warning-free with `objtool` enabled. I
> tested `-O2`/`-Os` and the Rust versions we support under `-O2` (mainly
> for the `noreturn` patch, which uses heuristics), as well as IBT vs. no
> IBT (i.e. running on individual object files vs. in `vmlinux`). I also
> did an arm64 build.
>
> Testing is very welcome for this one!
>
> Cheers,
> Miguel
>
> v2:
> - Add patch to enable `objtool` for Rust.
>
> - Add patch to list `noreturn` Rust functions (via heuristics) to avoid
> warnings related to that.
>
> - Make the `RETHUNK` patch not an RFC since the Rust compiler has
> support for
> it now.
>
> - Update the names of the migitation config symbols, given the changes
> at e.g.
> commit 7b75782ffd82 ("x86/bugs: Rename CONFIG_MITIGATION_SLS =>
> CONFIG_MITIGATION_SLS").
>
> Miguel Ojeda (6):
> rust: module: add static pointer to `{init,cleanup}_module()`
> x86/rust: support MITIGATION_RETPOLINE
> x86/rust: support MITIGATION_RETHUNK
> x86/rust: support MITIGATION_SLS
> objtool: list `noreturn` Rust functions
> objtool/kbuild/rust: enable objtool for Rust
>
> arch/x86/Makefile | 7 ++++++-
> rust/Makefile | 22 ++++++++++++--------
> rust/macros/module.rs | 12 +++++++++++
> scripts/Makefile.build | 9 +++++++--
> scripts/generate_rust_target.rs | 15 ++++++++++++++
> tools/objtool/check.c | 36 ++++++++++++++++++++++++++++++++-
> tools/objtool/noreturns.h | 2 ++
> 7 files changed, 91 insertions(+), 12 deletions(-)
>
>
> base-commit: b1263411112305acf2af728728591465becb45b0
> --
> 2.45.2
>
I tested this series with a config that produces the objtool warnings on
b126341 and it worked flawlessly. I also tried `-O2` and `-Os`:
Tested-by: Benno Lossin <benno.lossin@proton.me>
---
Cheers,
Benno
^ permalink raw reply [flat|nested] 6+ messages in thread* Re: [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool`
2024-07-24 16:14 [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool` Miguel Ojeda
2024-07-24 16:14 ` [PATCH v2 6/6] objtool/kbuild/rust: enable objtool for Rust Miguel Ojeda
2024-07-24 21:51 ` [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool` Benno Lossin
@ 2024-07-25 8:38 ` Peter Zijlstra
2024-07-25 9:53 ` Miguel Ojeda
2024-07-25 9:43 ` Alice Ryhl
3 siblings, 1 reply; 6+ messages in thread
From: Peter Zijlstra @ 2024-07-25 8:38 UTC (permalink / raw)
To: Miguel Ojeda
Cc: Josh Poimboeuf, Thomas Gleixner, Ingo Molnar, Borislav Petkov,
Dave Hansen, Masahiro Yamada, x86, H. Peter Anvin,
Nathan Chancellor, Nicolas Schier, Wedson Almeida Filho,
Alex Gaynor, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, rust-for-linux,
linux-kernel, patches, linux-kbuild
On Wed, Jul 24, 2024 at 06:14:53PM +0200, Miguel Ojeda wrote:
> Hi,
>
> This is an updated series to the CPU mitigations support for Rust. It
> also has the patch to enable `objtool`, so that we can start running it
> for Rust.
>
> It would be nice to get this applied soon, so that we start being
> warning-free (since we already get warnings under IBT builds via
> `vmlinux.o`). I am happy to take it through the Rust tree if the x86 and
> objtool maintainers give an Acked-by, or through any of the other trees,
> as you prefer. Otherwise, I think at this point we would need to make
> Rust exclusive to the mitigations, which isn't great.
>
> With this series, again, x86_64 is warning-free with `objtool` enabled. I
> tested `-O2`/`-Os` and the Rust versions we support under `-O2` (mainly
> for the `noreturn` patch, which uses heuristics), as well as IBT vs. no
> IBT (i.e. running on individual object files vs. in `vmlinux`). I also
> did an arm64 build.
W00t :-)
Aside from a small niggle about maybe doing a helper function for those
Rust runtime things, I don't see anything objectionable here.
Thanks!
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool`
2024-07-25 8:38 ` Peter Zijlstra
@ 2024-07-25 9:53 ` Miguel Ojeda
0 siblings, 0 replies; 6+ messages in thread
From: Miguel Ojeda @ 2024-07-25 9:53 UTC (permalink / raw)
To: Peter Zijlstra
Cc: Miguel Ojeda, Josh Poimboeuf, Thomas Gleixner, Ingo Molnar,
Borislav Petkov, Dave Hansen, Masahiro Yamada, x86,
H. Peter Anvin, Nathan Chancellor, Nicolas Schier,
Wedson Almeida Filho, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg, Alice Ryhl,
rust-for-linux, linux-kernel, patches, linux-kbuild
On Thu, Jul 25, 2024 at 10:38 AM Peter Zijlstra <peterz@infradead.org> wrote:
>
> W00t :-)
>
> Aside from a small niggle about maybe doing a helper function for those
> Rust runtime things, I don't see anything objectionable here.
>
> Thanks!
Thanks for taking a look that quick, Peter, I appreciate it.
Happy to move that to a helper.
Cheers,
Miguel
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool`
2024-07-24 16:14 [PATCH v2 0/6] Rust: support `CPU_MITIGATIONS` and enable `objtool` Miguel Ojeda
` (2 preceding siblings ...)
2024-07-25 8:38 ` Peter Zijlstra
@ 2024-07-25 9:43 ` Alice Ryhl
3 siblings, 0 replies; 6+ messages in thread
From: Alice Ryhl @ 2024-07-25 9:43 UTC (permalink / raw)
To: Miguel Ojeda
Cc: Josh Poimboeuf, Peter Zijlstra, Thomas Gleixner, Ingo Molnar,
Borislav Petkov, Dave Hansen, Masahiro Yamada, x86,
H. Peter Anvin, Nathan Chancellor, Nicolas Schier,
Wedson Almeida Filho, Alex Gaynor, Boqun Feng, Gary Guo,
Björn Roy Baron, Benno Lossin, Andreas Hindborg,
rust-for-linux, linux-kernel, patches, linux-kbuild
On Wed, Jul 24, 2024 at 6:15 PM Miguel Ojeda <ojeda@kernel.org> wrote:
>
> Hi,
>
> This is an updated series to the CPU mitigations support for Rust. It
> also has the patch to enable `objtool`, so that we can start running it
> for Rust.
>
> It would be nice to get this applied soon, so that we start being
> warning-free (since we already get warnings under IBT builds via
> `vmlinux.o`). I am happy to take it through the Rust tree if the x86 and
> objtool maintainers give an Acked-by, or through any of the other trees,
> as you prefer. Otherwise, I think at this point we would need to make
> Rust exclusive to the mitigations, which isn't great.
>
> With this series, again, x86_64 is warning-free with `objtool` enabled. I
> tested `-O2`/`-Os` and the Rust versions we support under `-O2` (mainly
> for the `noreturn` patch, which uses heuristics), as well as IBT vs. no
> IBT (i.e. running on individual object files vs. in `vmlinux`). I also
> did an arm64 build.
>
> Testing is very welcome for this one!
Verified that this eliminates the relevant warnings in an x86 build of
the android-mainline kernel.
Tested-by: Alice Ryhl <aliceryhl@google.com>
^ permalink raw reply [flat|nested] 6+ messages in thread