rust: add `rustcheck` make target for check-only builds
Onur Özkan
reviewerPATCH 1/1 rust: add `rustcheck` make target for check-only builds
Adds a new rustcheck make target to run a check-only build similar to cargo check. This allows us to verify that the Rust sources can build without building/linking final artifacts, which speeds up the iteration (a lot) during development.
The target supports the same flags as other Rust build rules, so it can also be used with CLIPPY=1 (e.g., `make LLVM=1 rustcheck CLIPPY=1) to run Clippy in a faster way.
Also, unlike make LLVM=1, it doesn't compile large amounts of C code (on a fresh checkout) when the goal is only to check that Rust builds are not broken after some changes.
--- Makefile | 7 +++++ rust/Makefile | 73 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+)
Makefile +7 -0
@@ -1716,6 +1716,8 @@ help: @echo ' is formatted, printing a diff otherwise.' @echo ' rustdoc - Generate Rust documentation' @echo ' (requires kernel .config)' + @echo ' rustcheck - Check that the Rust code builds' + @echo ' (requires kernel .config)' @echo ' rusttest - Runs the Rust tests' @echo ' (requires kernel .config; downloads external repos)' @echo ' rust-analyzer - Generate rust-project.json rust-analyzer support file'
@@ -1821,6 +1823,11 @@ PHONY += rustdoc rustdoc: prepare $(Q)$(MAKE) $(build)=rust $@ +# Checking Rust sources. +PHONY += rustcheck +rustcheck: prepare0 + $(Q)$(MAKE) $(build)=rust $@ + # Testing target PHONY += rusttest rusttest: prepare
rust/Makefile +73 -0
79 lines not on this page · raw message
Signature · 1 line
2.51.0
Onur
reviewerQuoted 140 lines · On Sat, 13 Sep 2025 13:08:47 +0300 Onur Özkan <[email protected]> wrote:
Adds a new
rustcheckmake target to run a check-only build similar tocargo check. This allows us to verify that the Rust sources can build without building/linking final artifacts, which speeds up the iteration (a lot) during development.The target supports the same flags as other Rust build rules, so it can also be used with
CLIPPY=1(e.g., `make LLVM=1 rustcheck CLIPPY=1) to run Clippy in a faster way.Also, unlike
make LLVM=1, it doesn't compile large amounts of C code (on a fresh checkout) when the goal is only to check that Rust builds are not broken after some changes.Suggested-by Benno Losin <[email protected]>Link:
https://rust-for-linux.zulipchat.com/#narrow/channel/288089/topic/x/near/539103602Signed-off-by Onur Özkan <[email protected]> ---Makefile | 7 +++++ rust/Makefile | 73+++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+)
Makefile +0
-0@@ -1716,6 +1716,8 @@ help: @echo ' is formatted, printing a diffotherwise.' @echo ' rustdoc - Generate Rust documentation'
Makefile +2
-0@echo ' (requires kernel .config)' + @echo ' rustcheck - Check that the Rust code builds' + @echo ' (requires kernel .config)' @echo ' rusttest - Runs the Rust tests' @echo ' (requires kernel .config;downloads external repos)' @echo ' rust-analyzer -
Generate rust-project.json rust-analyzer support file' @@ -1821,6 +1823,11 @@ PHONY += rustdoc rustdoc: prepareMakefile +5
-0$(Q)$(MAKE) $(build)=rust $@ +# Checking Rust sources. +PHONY += rustcheck +rustcheck: prepare0 + $(Q)$(MAKE) $(build)=rust $@ + # Testing target PHONY += rusttest rusttest: preparerust/Makefile +0
-0@@ -265,6 +265,79 @@ rusttest-kernel: $(src)/kernel/lib.rsrusttestlib-ffi rusttestlib-kernel \ rusttestlib-uapi rusttestlib-pin_init FORCE +$(call if_changed,rustc_test)
rust/Makefile +6
-0+## Check-only compilation (similar to `cargo check`) +quiet_cmd_rustc_check_library = $(RUSTC_OR_CLIPPY_QUIET) CHECK $< + cmd_rustc_check_library = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTC_OR_CLIPPY) $(rust_common_flags) \ + @$(objtree)/include/generated/rustc_cfg$(rustc_target_flags) \
+ --crate-type $(if
$(rustc_check_library_proc),proc-macro,rlib) \rust/Makefile +3
-1+ $(if $(rustc_check_library_proc),,--emit=metadata) \ + --out-dir $(objtree)/$(obj)/check -L$(objtree)/$(obj)/check \ + --crate-name $(if$(rustc_check_crate_name),$(rustc_check_crate_name), \
rust/Makefile +1
-0+ $(subst rustcheck-,,$(substrustchecklib-,,$@))) $< +
+rustcheck: rustchecklib-build_error rustchecklib-ffi rustchecklib-macros \rust/Makefile +1
-0+ rustchecklib-compiler_builtinsrustchecklib-pin_init_internal \
rust/Makefile +1
-0+ rustchecklib-pin_init rustchecklib-bindingsrustchecklib-uapi \
rust/Makefile +14
-0+ rustchecklib-kernel + +rustchecklib-build_error: $(src)/build_error.rs FORCE + +$(call if_changed,rustc_check_library) + +rustchecklib-ffi: $(src)/ffi.rs FORCE + +$(call if_changed,rustc_check_library) + +rustchecklib-macros: private rustc_target_flags = --extern proc_macro +rustchecklib-macros: private rustc_check_library_proc = yes +rustchecklib-macros: $(src)/macros/lib.rs FORCE + +$(call if_changed,rustc_check_library) + +rustchecklib-compiler_builtins: private rustc_check_crate_name =
compiler_builtins_kernel+rustchecklib-compiler_builtins:
$(src)/compiler_builtins.rs FORCErust/Makefile +3
-0+ +$(call if_changed,rustc_check_library) + +rustchecklib-pin_init_internal: private rustc_target_flags = --cfgkernel \
rust/Makefile +2
-0+ --extern proc_macro +rustchecklib-pin_init_internal: private rustc_check_library_proc =yes +rustchecklib-pin_init_internal:
$(src)/pin-init/internal/src/lib.rs FORCErust/Makefile +3
-0+ +$(call if_changed,rustc_check_library) + +rustchecklib-pin_init: private rustc_target_flags = --extern
pin_init_internal\rust/Makefile +2
-0+ --extern macros --cfg kernel +rustchecklib-pin_init: $(src)/pin-init/src/lib.rsrustchecklib-macros \
rust/Makefile +17
-0+ rustchecklib-pin_init_internal FORCE + +$(call if_changed,rustc_check_library) + +rustchecklib-bindings: private rustc_target_flags = --extern ffi +rustchecklib-bindings: $(src)/bindings/lib.rs \ + $(obj)/bindings/bindings_generated.rs \ + $(obj)/bindings/bindings_helpers_generated.rs \ + rustchecklib-ffi FORCE + +$(call if_changed,rustc_check_library) + +rustchecklib-uapi: private rustc_target_flags = --extern ffi +rustchecklib-uapi: $(src)/uapi/lib.rs $(obj)/uapi/uapi_generated.rs \ + rustchecklib-ffi FORCE + +$(call if_changed,rustc_check_library) + +ifdef CONFIG_JUMP_LABEL +rustchecklib-kernel:$(obj)/kernel/generated_arch_static_branch_asm.rs FORCE +endif
rust/Makefile +9
-2+ifndef CONFIG_UML +ifdef CONFIG_BUG +rustchecklib-kernel: $(obj)/kernel/generated_arch_warn_asm.rs \ + $(obj)/kernel/generated_arch_reachable_asm.rs FORCE +endif +endif + +rustchecklib-kernel: private rustc_target_flags = --extern ffi --extern pin_init \ + --extern build_error --extern macros --extern bindings --extern uapi +rustchecklib-kernel: $(src)/kernel/lib.rsrustchecklib-ffi rustchecklib-pin_init \
rust/Makefile +1
-0+ rustchecklib-build_error rustchecklib-macrosrustchecklib-bindings \
rust/Makefile rusttest-kernel: $(src)/kernel/lib.rs rusttestlib-ffi rusttestlib-kernel \ · line 343
Quoted 6 lines
rust/Makefile +3
-0+ rustchecklib-uapi FORCE + +$(call if_changed,rustc_check_library) + ifdef CONFIG_CC_IS_CLANG bindgen_c_flags = $(c_flags) else
Seems like I got some indentation issues, will handle in in the next version after some feedbacks.
-Onur
Andreas Hindborg
reviewerQuoted 5 lines · Onur Özkan
Adds a new
rustcheckmake target to run a check-only build similar tocargo check. This allows us to verify that the Rust sources can build without building/linking final artifacts, which speeds up the iteration (a lot) during development.
Quoted 8 lines
The target supports the same flags as other Rust build rules, so it can also be used with
CLIPPY=1(e.g., `make LLVM=1 rustcheck CLIPPY=1) to run Clippy in a faster way.Also, unlike
make LLVM=1, it doesn't compile large amounts of C code (on a fresh checkout) when the goal is only to check that Rust builds are not broken after some changes.
I think this is a good idea! However, it looks like this target only checks rust code that live in rust/. Can we also check code that lives elsewhere, like drivers?
Best regards,
Andreas Hindborg
Quoted 4 lines · Andreas Hindborg
I think this is a good idea! However, it looks like this target only checks rust code that live in
rust/. Can we also check code that lives elsewhere, like drivers?
That is more involved, and I don't plan to add features to the current system, sorry.
Cheers,
Miguel
Andreas Hindborg
reviewerQuoted 8 lines · Miguel Ojeda
Quoted 4 lines · Andreas Hindborg
I think this is a good idea! However, it looks like this target only checks rust code that live in
rust/. Can we also check code that lives elsewhere, like drivers?That is more involved, and I don't plan to add features to the current system, sorry.
I assume you are referring to the upcoming rust build system changes. Any idea when these will land? Will it be possible to implement a check feature when the changes land?
Best regards,
Andreas Hindborg
Onur
reviewerQuoted 11 lines · On Sat, 13 Sep 2025 19:46:28 +0200 Andreas Hindborg <[email protected]>…
Quoted 9 lines · Onur Özkan
Adds a new
rustcheckmake target to run a check-only build similar tocargo check. This allows us to verify that the Rust sources can build without building/linking final artifacts, which speeds up the iteration (a lot) during development.The target supports the same flags as other Rust build rules, so it can also be used with
CLIPPY=1(e.g., `make LLVM=1 rustcheck CLIPPY=1) to run Clippy in a faster way.
Quoted 9 lines
Quoted 4 lines
Also, unlike
make LLVM=1, it doesn't compile large amounts of C code (on a fresh checkout) when the goal is only to check that Rust builds are not broken after some changes.I think this is a good idea! However, it looks like this target only checks rust code that live in
rust/. Can we also check code that lives elsewhere, like drivers?
My work depends on the existing build system and that system doesn't allow me to do that (yet).
Regards,
Onur
Quoted 5 lines
Best regards,
Andreas Hindborg