Skip to contentSkip to conversation

rust: add `rustcheck` make target for check-only builds

PATCH Superseded Onur Özkan 3 participants 6 messages Sep 13, 2025 – Sep 15, 2025

Subsystems (2)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Onur Özkan

author reviewer
#0 lore raw

PATCH 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
index cf37b9407821..7812cdc72938 100644
@@ -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
author reviewer
#1 lore raw
Quoted 140 lines · On Sat, 13 Sep 2025 13:08:47 +0300 Onur Özkan <[email protected]> wrote:

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.

Link:
https://rust-for-linux.zulipchat.com/#narrow/channel/288089/topic/x/near/539103602

 Makefile      |  7 +++++
 rust/Makefile | 73

+++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+)

Makefile +0 -0
index cf37b9407821..7812cdc72938 100644
@@ -1716,6 +1716,8 @@ help:
 	@echo  '		    is formatted, printing a diff

otherwise.' @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: prepare

Makefile +5 -0
 	$(Q)$(MAKE) $(build)=rust $@
 
+# Checking Rust sources.
+PHONY += rustcheck
+rustcheck: prepare0
+	$(Q)$(MAKE) $(build)=rust $@
+
 # Testing target
 PHONY += rusttest
 rusttest: prepare
rust/Makefile +0 -0
index bfa915b0e588..c148ef4a8c08 100644
@@ -265,6 +265,79 @@ rusttest-kernel: $(src)/kernel/lib.rs

rusttestlib-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-,,$(subst

rustchecklib-,,$@))) $< +
+rustcheck: rustchecklib-build_error rustchecklib-ffi rustchecklib-macros \

rust/Makefile +1 -0
+	rustchecklib-compiler_builtins

rustchecklib-pin_init_internal \

rust/Makefile +1 -0
+	rustchecklib-pin_init rustchecklib-bindings

rustchecklib-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 FORCE

rust/Makefile +3 -0
+	+$(call if_changed,rustc_check_library)
+
+rustchecklib-pin_init_internal: private rustc_target_flags = --cfg

kernel \

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 FORCE

rust/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.rs

rustchecklib-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.rs

rustchecklib-ffi rustchecklib-pin_init \

rust/Makefile +1 -0
+	rustchecklib-build_error rustchecklib-macros

rustchecklib-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

#2 lore raw
In reply to Onur Özkan
Quoted 5 lines · Onur Özkan

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.

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

#3 lore raw
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

#4 lore raw
Quoted 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

author reviewer
#5 lore raw
In reply to Andreas Hindborg
Quoted 11 lines · On Sat, 13 Sep 2025 19:46:28 +0200 Andreas Hindborg <[email protected]>…
Quoted 9 lines · Onur Özkan

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.

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