Support several Rust toolchain versions
Subsystems (7)
Miguel Ojeda
maintainercover Support several Rust toolchain versions
Hi all,
It is time to start supporting several Rust toolchain versions and thus establish a minimum Rust compiler and bindgen version.
For the Rust compiler, we will start with a window of two stable releases, and widen it over time. This series keeps the minimum where it is (1.78.0), but adds support for the recently released 1.79.0.
This should already be enough for kernel developers in distributions that provide recent Rust compiler versions routinely, such as Arch Linux, Debian Unstable (outside the freeze period), Fedora Linux, Gentoo Linux (especially the testing channel), Nix (unstable) and openSUSE Tumbleweed. A documentation adds the instructions for each of them.
In addition, Rust for Linux is now being built-tested in Rust's pre-merge CI. That is, every change that is attempting to land into the Rust compiler is tested against the kernel, and it is merged only if it passes -- thanks to the Rust project for that!
Thus, with the pre-merge CI in place, both projects hope to avoid unintentional changes to Rust that break the kernel. This means that, in general, apart from intentional changes on their side (that we will need to workaround conditionally on our side), the upcoming Rust compiler versions should generally work.
For instance, currently, the beta (1.80.0) and nightly (1.81.0) branches work as well.
Similarly, we kept the minimum as it is for bindgen. bindgen is also adding the kernel to its CI -- thanks!
Cheers,
Miguel
Miguel Ojeda (13):
rust: macros: indent list item in paste!'s docs
rust: init: simplify from map_err to inspect_err
rust: allow dead_code for never constructed bindings
rust: relax most deny-level lints to warnings
rust: simplify Clippy warning flags set
rust: start supporting several compiler versions
rust: warn about bindgen versions 0.66.0 and 0.66.1
rust: work around bindgen 0.69.0 issue
rust: avoid assuming a particular bindgen build
rust: start supporting several bindgen versions
kbuild: rust: add rustc-version support
rust: support the new -Zub-checks flag
docs: rust: quick-start: add section on Linux distributions
Documentation/process/changes.rst | 9 +-- Documentation/rust/quick-start.rst | 118 +++++++++++++++++++++++------ Makefile | 29 +++---- init/Kconfig | 11 ++- lib/Kconfig.debug | 18 +++++ rust/Makefile | 4 +- rust/bindings/lib.rs | 1 + rust/kernel/init.rs | 12 +-- rust/macros/lib.rs | 2 +- rust/uapi/lib.rs | 1 + scripts/Kconfig.include | 6 ++ scripts/Makefile.compiler | 4 + scripts/rust_is_available.sh | 20 ++--- scripts/rust_is_available_test.py | 40 +++++----- scripts/rustc-version.sh | 52 +++++++++++++ 15 files changed, 238 insertions(+), 89 deletions(-) create mode 100755 scripts/rustc-version.sh
base-commit: f2661062f16b2de5d7b6a5c42a9a5c96326b8454
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 1/13 rust: macros: indent list item in `paste!`'s docs
A new style lint, doc_lazy_continuation [1], has been introduced in the upcoming Rust 1.80 (currently in beta), which detects missing indentation in code documentation.
We have one such case:
error: doc list item missing indentation
--> rust/macros/lib.rs:315:5
|
315 | /// default the span of the [< >] group is used.
| ^
|
= help: if this is supposed to be its own paragraph, add a blank line
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_lazy_continuation
= note: -D clippy::doc-lazy-continuation implied by -D clippy::style
= help: to override -D clippy::style add #[allow(clippy::doc_lazy_continuation)]
help: indent this line
|
315 | /// default the span of the [< >] group is used.
| ++
While the rendering of the docs by rustdoc is not affected, we apply this kind of indentation elsewhere since it looks better.
Thus clean it up.
--- rust/macros/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
rust/macros/lib.rs +1 -1
@@ -312,7 +312,7 @@ pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {/// /// Currently supported modifiers are: /// * `span`: change the span of concatenated identifier to the span of the specified token. By -/// default the span of the `[< >]` group is used. +/// default the span of the `[< >]` group is used. /// * `lower`: change the identifier to lower case. /// * `upper`: change the identifier to upper case. ///
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 2/13 rust: init: simplify from `map_err` to `inspect_err`
In reply to Miguel OjedaA new complexity lint, manual_inspect [1], has been introduced in the upcoming Rust 1.81 (currently in nightly), which checks for uses of map* which return the original item:
error:
--> rust/kernel/init.rs:846:23
|
846 | (self.1)(val).map_err(|e| {
| ^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_inspect
= note: `-D clippy::manual-inspect` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::manual_inspect)]`
help: try
|
846 ~ (self.1)(val).inspect_err(|e| {
847 | // SAFETY: `slot` was initialized above.
848 ~ unsafe { core::ptr::drop_in_place(slot) };
|Thus clean them up.
--- rust/kernel/init.rs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
rust/kernel/init.rs +4 -8
@@ -843,11 +843,9 @@ unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> {let val =unsafe { &mut *slot };// SAFETY: `slot` is considered pinned. let val =unsafe {Pin ::new_unchecked (val) }; - (self.1 )(val).map_err (|e| { + (self.1 )(val).inspect_err (|_|// SAFETY: `slot` was initialized above. -unsafe { core::ptr::drop_in_place (slot) }; - e - }) +unsafe { core::ptr::drop_in_place (slot) }) } }
@@ -941,11 +939,9 @@ unsafe fn __init(self, slot: *mut T) -> Result<(), E> {// SAFETY: All requirements fulfilled since this function is `__init`. unsafe { self.0 .__pinned_init (slot)? };// SAFETY: The above call initialized `slot` and we still have unique access. - (self.1 )(unsafe { &mut *slot }).map_err (|e| { + (self.1 )(unsafe { &mut *slot }).inspect_err (|_|// SAFETY: `slot` was initialized above. -unsafe { core::ptr::drop_in_place (slot) }; - e - }) +unsafe { core::ptr::drop_in_place (slot) }) } }
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 3/13 rust: allow `dead_code` for never constructed bindings
In reply to Miguel OjedaStarting with the upcoming Rust 1.80.0 (since upstream commit 35130d7233e9 ("Detect pub structs never constructed and unused associated constants in traits")), the dead_code pass detects more cases, which triggers in the bindings crate:
warning: struct `boot_params` is never constructed
--> rust/bindings/bindings_generated.rs:10684:12
|
10684 | pub struct boot_params {
| ^^^^^^^^^^^
|
= note: `#[warn(dead_code)]` on by defaultAs well as in the uapi one:
warning: struct `boot_params` is never constructed
--> rust/uapi/uapi_generated.rs:10392:12
|
10392 | pub struct boot_params {
| ^^^^^^^^^^^
|
= note: `#[warn(dead_code)]` on by defaultThese are all expected, since we do not use all the structs in the bindings that bindgen generates from the C headers.
Therefore, allow them.
--- rust/bindings/lib.rs | 1 + rust/uapi/lib.rs | 1 + 2 files changed, 2 insertions(+)
rust/bindings/lib.rs +1 -0
@@ -24,6 +24,7 @@ unsafe_op_in_unsafe_fn )] +#[allow(dead_code)] mod bindings_raw {// Use glob import here to expose all helpers. // Symbols defined within the module will take precedence to the glob import.
rust/uapi/lib.rs +1 -0
@@ -14,6 +14,7 @@#![cfg_attr(test, allow(unsafe_op_in_unsafe_fn))] #![allow( clippy::all, + dead_code, missing_docs, non_camel_case_types, non_upper_case_globals,
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 4/13 rust: relax most deny-level lints to warnings
In reply to Miguel OjedaSince we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints.
Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring.
To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under WERROR=y) and the set of lints is not changed.
unsafe_op_in_unsafe_fn is left unmodified, i.e. as an error, since
1) it is simple enough that it should not have false positives (unlike e.g. rust_2018_idioms's explicit_outlives_requirements) and 2) it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested.
--- Makefile | 22 +++++++++++----------- rust/Makefile | 4 ++-- 2 files changed, 13 insertions(+), 13 deletions(-)
Makefile +11 -11
@@ -461,17 +461,17 @@ KBUILD_USERLDFLAGS := $(USERLDFLAGS) # host programs. export rust_common_flags := --edition=2021 \ -Zbinary_dep_depinfo=y \ - -Dunsafe_op_in_unsafe_fn -Drust_2018_idioms \ - -Dunreachable_pub -Dnon_ascii_idents \ + -Dunsafe_op_in_unsafe_fn -Wrust_2018_idioms \ + -Wunreachable_pub -Wnon_ascii_idents \ -Wmissing_docs \ - -Drustdoc::missing_crate_level_docs \ - -Dclippy::correctness -Dclippy::style \ - -Dclippy::suspicious -Dclippy::complexity \ - -Dclippy::perf \ - -Dclippy::let_unit_value -Dclippy::mut_mut \ - -Dclippy::needless_bitwise_bool \ - -Dclippy::needless_continue \ - -Dclippy::no_mangle_with_rust_abi \ + -Wrustdoc::missing_crate_level_docs \ + -Wclippy::correctness -Wclippy::style \ + -Wclippy::suspicious -Wclippy::complexity \ + -Wclippy::perf \ + -Wclippy::let_unit_value -Wclippy::mut_mut \ + -Wclippy::needless_bitwise_bool \ + -Wclippy::needless_continue \ + -Wclippy::no_mangle_with_rust_abi \ -Wclippy::dbg_macro KBUILD_HOSTCFLAGS := $(KBUILD_USERHOSTCFLAGS) $(HOST_LFS_CFLAGS) $(HOSTCFLAGS)
@@ -573,7 +573,7 @@ KBUILD_RUSTFLAGS := $(rust_common_flags) \ -Csymbol-mangling-version=v0 \ -Crelocation-model=static \ -Zfunction-sections=n \ - -Dclippy::float_arithmetic + -Wclippy::float_arithmetic KBUILD_AFLAGS_KERNEL := KBUILD_CFLAGS_KERNEL :=
rust/Makefile +2 -2
@@ -421,7 +421,7 @@ ifneq ($(or $(CONFIG_ARM64),$(and $(CONFIG_RISCV),$(CONFIG_64BIT))),) endif $(obj)/core.o: private skip_clippy = 1 -$(obj)/core.o: private skip_flags = -Dunreachable_pub +$(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
@@ -435,7 +435,7 @@ $(obj)/compiler_builtins.o: $(src)/compiler_builtins.rs $(obj)/core.o FORCE +$(call if_changed_dep,rustc_library) $(obj)/alloc.o: private skip_clippy = 1 -$(obj)/alloc.o: private skip_flags = -Dunreachable_pub +$(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)
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 5/13 rust: simplify Clippy warning flags set
In reply to Miguel OjedaAll Clippy lint groups that we enable, except correctness, have a default warn level, thus they may be removed now that we relaxed all lints to warn.
Moreover, Clippy provides an all lint group that covers the groups we enable by default. Thus just use all instead -- the only change is that, if Clippy introduces a new lint group or splits an existing one, we will cover that one automatically.
In addition, let_unit_value is in style since Rust 1.62.0, thus it does not need to be enabled manually.
--- Makefile | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
Makefile +2 -4
@@ -465,10 +465,8 @@ export rust_common_flags := --edition=2021 \ -Wunreachable_pub -Wnon_ascii_idents \ -Wmissing_docs \ -Wrustdoc::missing_crate_level_docs \ - -Wclippy::correctness -Wclippy::style \ - -Wclippy::suspicious -Wclippy::complexity \ - -Wclippy::perf \ - -Wclippy::let_unit_value -Wclippy::mut_mut \ + -Wclippy::all \ + -Wclippy::mut_mut \ -Wclippy::needless_bitwise_bool \ -Wclippy::needless_continue \ -Wclippy::no_mangle_with_rust_abi \
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 6/13 rust: start supporting several compiler versions
In reply to Miguel OjedaIt is time to start supporting several Rust compiler versions and thus establish a minimum Rust version.
We may still want to upgrade the minimum sometimes in the beginning since there may be important features coming into the language that improve how we write code (e.g. field projections), which may or may not make sense to support conditionally.
We will start with a window of two stable releases, and widen it over time. Thus this patch does not move the current minimum (1.78.0), but instead adds support for the recently released 1.79.0.
This should already be enough for kernel developers in distributions that provide recent Rust compiler versions routinely, such as Arch Linux, Debian Unstable (outside the freeze period), Fedora Linux, Gentoo Linux (especially the testing channel), Nix (unstable) and openSUSE Tumbleweed. See the documentation patch about it later in this series.
In addition, Rust for Linux is now being built-tested in Rust's pre-merge CI [1]. That is, every change that is attempting to land into the Rust compiler is tested against the kernel, and it is merged only if it passes -- thanks to the Rust project for that!
Thus, with the pre-merge CI in place, both projects hope to avoid unintentional changes to Rust that break the kernel. This means that, in general, apart from intentional changes on their side (that we will need to workaround conditionally on our side), the upcoming Rust compiler versions should generally work.
For instance, currently, the beta (1.80.0) and nightly (1.81.0) branches work as well.
Of course, the Rust for Linux CI job in the Rust toolchain may still need to be temporarily disabled for different reasons, but the intention is to help bring Rust for Linux into stable Rust.
--- Documentation/process/changes.rst | 4 +--- Documentation/rust/quick-start.rst | 9 ++++----- scripts/rust_is_available.sh | 8 -------- scripts/rust_is_available_test.py | 5 ----- 4 files changed, 5 insertions(+), 21 deletions(-)
Documentation/process/changes.rst +1 -3
@@ -88,9 +88,7 @@ docs on :ref:`Building Linux with Clang/LLVM <kbuild_llvm>`. Rust (optional) --------------- -A particular version of the Rust toolchain is required. Newer versions may or -may not work because the kernel depends on some unstable Rust features, for -the moment. +A recent version of the Rust compiler is required. Each Rust toolchain comes with several "components", some of which are required (like ``rustc``) and some that are optional. The ``rust-src`` component (which
Documentation/rust/quick-start.rst +4 -5
@@ -29,16 +29,15 @@ if that is the case. rustc ***** -A particular version of the Rust compiler is required. Newer versions may or -may not work because, for the moment, the kernel depends on some unstable -Rust features. +A recent version of the Rust compiler is required. If ``rustup`` is being used, enter the kernel build directory (or use -``--path=<build-dir>`` argument to the ``set`` sub-command) and run:: +``--path=<build-dir>`` argument to the ``set`` sub-command) and run, +for instance:: rustup override set $(scripts/min-tool-version.sh rustc) -This will configure your working directory to use the correct version of +This will configure your working directory to use the given version of ``rustc`` without affecting your default toolchain. Note that the override applies to the current working directory (and its
scripts/rust_is_available.sh +0 -8
@@ -117,14 +117,6 @@ if [ "$rust_compiler_cversion" -lt "$rust_compiler_min_cversion" ]; then echo >&2 "***" exit 1 fi -if [ "$rust_compiler_cversion" -gt "$rust_compiler_min_cversion" ]; then - echo >&2 "***" - echo >&2 "*** Rust compiler '$RUSTC' is too new. This may or may not work." - echo >&2 "*** Your version: $rust_compiler_version" - echo >&2 "*** Expected version: $rust_compiler_min_version" - echo >&2 "***" - warning=1 -fi # Check that the Rust bindings generator is suitable. #
scripts/rust_is_available_test.py +0 -5
@@ -193,11 +193,6 @@ else: result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc }) self.assertIn(f"Rust compiler '{rustc}' is too old.", result.stderr) - def test_rustc_new_version(self): - rustc = self.generate_rustc("rustc 1.999.0 (a8314ef7d 2099-06-27)") - result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "RUSTC": rustc }) - self.assertIn(f"Rust compiler '{rustc}' is too new. This may or may not work.", result.stderr) - def test_bindgen_nonexecutable(self): result = self.run_script(self.Expected.FAILURE, { "BINDGEN": self.nonexecutable }) self.assertIn(f"Running '{self.nonexecutable}' to check the Rust bindings generator version failed with", result.stderr)
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 7/13 rust: warn about `bindgen` versions 0.66.0 and 0.66.1
In reply to Miguel Ojedabindgen versions 0.66.0 and 0.66.1 panic due to C string literals with NUL characters [1]:
panicked at .cargo/registry/src/index.crates.io-6f17d22bba15001f/bindgen-0.66.0/codegen/mod.rs:717:71:
called `Result::unwrap()` on an `Err` value: FromBytesWithNulError { kind: InteriorNul(4) }Thus, in preparation for supporting several bindgen versions, add a version check to warn the user about it.
We could make it an error, but 1) it is going to fail anyway later in the build, 2) we would disable RUST automatically, which is also painful,
3) someone could be using a patched bindgen at that version, 4) the interior NUL may go away in the headers (however unlikely). Thus just warn about it so that users know why it is failing.
In addition, add a test for the new case.
--- scripts/rust_is_available.sh | 8 ++++++++ scripts/rust_is_available_test.py | 7 +++++++ 2 files changed, 15 insertions(+)
scripts/rust_is_available.sh +8 -0
@@ -165,6 +165,14 @@ if [ "$rust_bindings_generator_cversion" -gt "$rust_bindings_generator_min_cvers echo >&2 "***" warning=1 fi +if [ "$rust_bindings_generator_cversion" -eq 6600 ] || [ "$rust_bindings_generator_cversion" -eq 6601 ]; then + echo >&2 "***" + echo >&2 "*** Rust bindings generator '$BINDGEN' versions 0.66.0 and 0.66.1 may not" + echo >&2 "*** work due to a bug (https://github.com/rust-lang/rust-bindgen/pull/2567)." + echo >&2 "*** Your version: $rust_bindings_generator_version" + echo >&2 "***" + warning=1 +fi # Check that the `libclang` used by the Rust bindings generator is suitable. #
scripts/rust_is_available_test.py +7 -0
@@ -226,6 +226,13 @@ else: result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "BINDGEN": bindgen }) self.assertIn(f"Rust bindings generator '{bindgen}' is too new. This may or may not work.", result.stderr) + def test_bindgen_bad_version_0_66_0_and_0_66_1(self): + for version in ("0.66.0", "0.66.1"): + with self.subTest(version=version): + bindgen = self.generate_bindgen_version(f"bindgen {version}") + result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "BINDGEN": bindgen }) + self.assertIn(f"Rust bindings generator '{bindgen}' versions 0.66.0 and 0.66.1 may not", result.stderr) + def test_bindgen_libclang_failure(self): for env in ( { "LLVM_CONFIG_PATH": self.missing },
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 8/13 rust: work around `bindgen` 0.69.0 issue
In reply to Miguel Ojedabindgen 0.69.0 contains a bug: --version does not work without providing a header [1]:
error: the following required arguments were not provided:
<HEADER>
Usage: bindgen <FLAGS> <OPTIONS> <HEADER> -- <CLANG_ARGS>...
Thus, in preparation for supporting several bindgen versions, work around the issue by passing a dummy argument.
Include a comment so that we can remove the workaround in the future.
--- init/Kconfig | 5 ++++- scripts/rust_is_available.sh | 6 +++++- 2 files changed, 9 insertions(+), 2 deletions(-)
init/Kconfig +4 -1
@@ -1928,7 +1928,10 @@ config RUSTC_VERSION_TEXT config BINDGEN_VERSION_TEXT string depends on RUST - default $(shell,command -v $(BINDGEN) >/dev/null 2>&1 && $(BINDGEN) --version || echo n) + # The dummy parameter `workaround-for-0.69.0` is required to support 0.69.0 + # (https://github.com/rust-lang/rust-bindgen/pull/2678). It can be removed when + # the minimum version is upgraded past that (0.69.1 already fixed the issue). + default $(shell,command -v $(BINDGEN) >/dev/null 2>&1 && $(BINDGEN) --version workaround-for-0.69.0 || echo n) # # Place an empty function call at each tracepoint site. Can be
scripts/rust_is_available.sh +5 -1
@@ -121,8 +121,12 @@ fi # Check that the Rust bindings generator is suitable. # # Non-stable and distributions' versions may have a version suffix, e.g. `-dev`. +# +# The dummy parameter `workaround-for-0.69.0` is required to support 0.69.0 +# (https://github.com/rust-lang/rust-bindgen/pull/2678). It can be removed when +# the minimum version is upgraded past that (0.69.1 already fixed the issue). rust_bindings_generator_output=$( \ - LC_ALL=C "$BINDGEN" --version 2>/dev/null + LC_ALL=C "$BINDGEN" --version workaround-for-0.69.0 2>/dev/null ) || rust_bindings_generator_code=$? if [ -n "$rust_bindings_generator_code" ]; then echo >&2 "***"
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 9/13 rust: avoid assuming a particular `bindgen` build
In reply to Miguel Ojedabindgen's logic to find libclang (via clang-sys) may change over time, and depends on how it was built (e.g. Linux distributions may decide to build it differently, and we are going to provide documentation on installing it via distributions later in this series).
Therefore, clarify that bindgen may be built in several ways and simplify the documentation by only mentioning the most prominent environment variable (LIBCLANG_PATH) as an example on how to tweak the search of the library at runtime (i.e. when bindgen is built as our documentation explains). This also avoids duplicating the documentation, like bindgen itself does (i.e. it refers to clang-sys).
Similarly, replace the test we had for this (which used the real program) with a mocked one, to avoid depending on the build as well.
--- Documentation/rust/quick-start.rst | 23 +++++++++-------------- scripts/rust_is_available_test.py | 25 +++++++++++++++---------- 2 files changed, 24 insertions(+), 24 deletions(-)
Documentation/rust/quick-start.rst +9 -14
@@ -106,20 +106,15 @@ Install it via (note that this will download and build the tool from source):: cargo install --locked --version $(scripts/min-tool-version.sh bindgen) bindgen-cli -``bindgen`` needs to find a suitable ``libclang`` in order to work. If it is -not found (or a different ``libclang`` than the one found should be used), -the process can be tweaked using the environment variables understood by -``clang-sys`` (the Rust bindings crate that ``bindgen`` uses to access -``libclang``): - -* ``LLVM_CONFIG_PATH`` can be pointed to an ``llvm-config`` executable. - -* Or ``LIBCLANG_PATH`` can be pointed to a ``libclang`` shared library - or to the directory containing it. - -* Or ``CLANG_PATH`` can be pointed to a ``clang`` executable. - -For details, please see ``clang-sys``'s documentation at: +``bindgen`` uses the ``clang-sys`` crate to find a suitable ``libclang`` (which +may be linked statically, dynamically or loaded at runtime). By default, the +``cargo`` command above will produce a ``bindgen`` binary that will load +``libclang`` at runtime. If it is not found (or a different ``libclang`` than +the one found should be used), the process can be tweaked, e.g. by using the +``LIBCLANG_PATH`` environment variable. For details, please see ``clang-sys``'s +documentation at: + + https://github.com/KyleMayes/clang-sys#linking https://github.com/KyleMayes/clang-sys#environment-variables
scripts/rust_is_available_test.py +15 -10
@@ -55,10 +55,15 @@ else: @classmethod def generate_bindgen(cls, version_stdout, libclang_stderr): + if libclang_stderr is None: + libclang_case = f"raise SystemExit({cls.bindgen_default_bindgen_libclang_failure_exit_code})" + else: + libclang_case = f"print({repr(libclang_stderr)}, file=sys.stderr)" + return cls.generate_executable(f"""#!/usr/bin/env python3 import sys if "rust_is_available_bindgen_libclang.h" in " ".join(sys.argv): - print({repr(libclang_stderr)}, file=sys.stderr) + {libclang_case} else: print({repr(version_stdout)}) """)
@@ -67,6 +72,10 @@ else: def generate_bindgen_version(cls, stdout): return cls.generate_bindgen(stdout, cls.bindgen_default_bindgen_libclang_stderr) + @classmethod + def generate_bindgen_libclang_failure(cls): + return cls.generate_bindgen(cls.bindgen_default_bindgen_version_stdout, None) + @classmethod def generate_bindgen_libclang(cls, stderr): return cls.generate_bindgen(cls.bindgen_default_bindgen_version_stdout, stderr)
@@ -89,6 +98,7 @@ else: cls.rust_default_sysroot = subprocess.check_output(("rustc", "--print", "sysroot")).decode().strip() cls.bindgen_default_bindgen_version_stdout = f"bindgen {cls.bindgen_default_version}" + cls.bindgen_default_bindgen_libclang_failure_exit_code = 42 cls.bindgen_default_bindgen_libclang_stderr = f"scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {cls.llvm_default_version} [-W#pragma-messages], err: false" cls.default_rustc = cls.generate_rustc(f"rustc {cls.rustc_default_version}")
@@ -234,15 +244,10 @@ else: self.assertIn(f"Rust bindings generator '{bindgen}' versions 0.66.0 and 0.66.1 may not", result.stderr) def test_bindgen_libclang_failure(self): - for env in ( - { "LLVM_CONFIG_PATH": self.missing }, - { "LIBCLANG_PATH": self.missing }, - { "CLANG_PATH": self.missing }, - ): - with self.subTest(env=env): - result = self.run_script(self.Expected.FAILURE, env | { "PATH": os.environ["PATH"], "BINDGEN": "bindgen" }) - self.assertIn("Running 'bindgen' to check the libclang version (used by the Rust", result.stderr) - self.assertIn("bindings generator) failed with code ", result.stderr) + bindgen = self.generate_bindgen_libclang_failure() + result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen }) + self.assertIn(f"Running '{bindgen}' to check the libclang version (used by the Rust", result.stderr) + self.assertIn(f"bindings generator) failed with code {self.bindgen_default_bindgen_libclang_failure_exit_code}. This may be caused by", result.stderr) def test_bindgen_libclang_unexpected_version(self): bindgen = self.generate_bindgen_libclang("scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version unexpected [-W#pragma-messages], err: false")
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 10/13 rust: start supporting several `bindgen` versions
In reply to Miguel OjedaWith both the workaround for bindgen 0.69.0 and the warning about 0.66.0 and 0.66.1 in place, start supporting several bindgen versions, like it was done for the Rust compiler in a previous patch.
All other versions, including the latest 0.69.4, build without errors.
The bindgen project, like Rust, has also agreed to have the kernel in their CI [1] -- thanks! This should help both projects: bindgen will be able to detect early issues like those mentioned above, and the kernel will be very likely build with new releases (at least for the basic configuration being tested).
--- Documentation/rust/quick-start.rst | 5 +++-- scripts/rust_is_available.sh | 8 -------- scripts/rust_is_available_test.py | 5 ----- 3 files changed, 3 insertions(+), 15 deletions(-)
Documentation/rust/quick-start.rst +3 -2
@@ -100,9 +100,10 @@ bindgen ******* The bindings to the C side of the kernel are generated at build time using -the ``bindgen`` tool. A particular version is required. +the ``bindgen`` tool. -Install it via (note that this will download and build the tool from source):: +Install it, for instance, via (note that this will download and build the tool +from source):: cargo install --locked --version $(scripts/min-tool-version.sh bindgen) bindgen-cli
scripts/rust_is_available.sh +0 -8
@@ -161,14 +161,6 @@ if [ "$rust_bindings_generator_cversion" -lt "$rust_bindings_generator_min_cvers echo >&2 "***" exit 1 fi -if [ "$rust_bindings_generator_cversion" -gt "$rust_bindings_generator_min_cversion" ]; then - echo >&2 "***" - echo >&2 "*** Rust bindings generator '$BINDGEN' is too new. This may or may not work." - echo >&2 "*** Your version: $rust_bindings_generator_version" - echo >&2 "*** Expected version: $rust_bindings_generator_min_version" - echo >&2 "***" - warning=1 -fi if [ "$rust_bindings_generator_cversion" -eq 6600 ] || [ "$rust_bindings_generator_cversion" -eq 6601 ]; then echo >&2 "***" echo >&2 "*** Rust bindings generator '$BINDGEN' versions 0.66.0 and 0.66.1 may not"
scripts/rust_is_available_test.py +0 -5
@@ -231,11 +231,6 @@ else: result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen }) self.assertIn(f"Rust bindings generator '{bindgen}' is too old.", result.stderr) - def test_bindgen_new_version(self): - bindgen = self.generate_bindgen_version("bindgen 0.999.0") - result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "BINDGEN": bindgen }) - self.assertIn(f"Rust bindings generator '{bindgen}' is too new. This may or may not work.", result.stderr) - def test_bindgen_bad_version_0_66_0_and_0_66_1(self): for version in ("0.66.0", "0.66.1"): with self.subTest(version=version):
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 11/13 kbuild: rust: add `rustc-version` support
In reply to Miguel OjedaNow that we are starting to support several Rust versions, introduce rustc-version support, mimicking the C side:
- scripts/rustc-version.sh, that mimics the other version scripts
(with one more digit, e.g. Rust 1.79.0 is 107900).
- rustc-{info,name,version} Kbuild macros.
- CONFIG_RUSTC_VERSION Kconfig symbol that calls rustc-version.
- rustc-min-version Kbuild macro that uses CONFIG_RUSTC_VERSION.
With these, we can easily support flags conditionally depending on rustc's version -- a user comes in the next patch.
Another user will be the -Ctarget-feature=+reserve-x18/-Zfixed-x18 arm64 flags [1].
--- init/Kconfig | 6 +++++ scripts/Kconfig.include | 6 +++++ scripts/Makefile.compiler | 4 +++ scripts/rustc-version.sh | 52 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 68 insertions(+) create mode 100755 scripts/rustc-version.sh
init/Kconfig +6 -0
@@ -1920,6 +1920,12 @@ config RUST If unsure, say N. +config RUSTC_VERSION + int + depends on RUST + default $(rustc-version) + default 0 + config RUSTC_VERSION_TEXT string depends on RUST
scripts/Kconfig.include +6 -0
@@ -45,6 +45,12 @@ $(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this C compiler is not cc-name := $(shell,set -- $(cc-info) && echo $1) cc-version := $(shell,set -- $(cc-info) && echo $2) +# Get the Rust compiler name, version, and error out if it is not supported. +rustc-info := $(shell,$(srctree)/scripts/rustc-version.sh $(RUSTC)) +$(error-if,$(success,test -z "$(rustc-info)"),Sorry$(comma) this Rust compiler is not supported.) +rustc-name := $(shell,set -- $(rustc-info) && echo $1) +rustc-version := $(shell,set -- $(rustc-info) && echo $2) + # Get the assembler name, version, and error out if it is not supported. as-info := $(shell,$(srctree)/scripts/as-version.sh $(CC) $(CLANG_FLAGS)) $(error-if,$(success,test -z "$(as-info)"),Sorry$(comma) this assembler is not supported.)
scripts/Makefile.compiler +4 -0
@@ -69,6 +69,10 @@ gcc-min-version = $(call test-ge, $(CONFIG_GCC_VERSION), $1) # Usage: cflags-$(call clang-min-version, 110000) += -foo clang-min-version = $(call test-ge, $(CONFIG_CLANG_VERSION), $1) +# rustc-min-version +# Usage: rustflags-$(call rustc-min-version, 107900) += -foo +rustc-min-version = $(call test-ge, $(CONFIG_RUSTC_VERSION), $1) + # ld-option # Usage: KBUILD_LDFLAGS += $(call ld-option, -X, -Y) ld-option = $(call try-run, $(LD) $(KBUILD_LDFLAGS) $(1) -v,$(1),$(2),$(3))
scripts/rustc-version.sh new file +52 -0
52 lines not on this page · raw message
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 12/13 rust: support the new `-Zub-checks` flag
In reply to Miguel OjedaRust 1.79.0 has introduced a new codegen flag, -Zub-checks [1], to allow to independently configure (from -Cdebug-assertions) whether the extra runtime checks for UB are emitted, in a similar fashion to -Coverflow-checks.
This allows to configure the kernel with only the UB checks enabled, but not the debug_assert!s; or vice versa, e.g. [2].
It also showcases how RUSTC_VERSION and the Kbuild macros, introduced in the previous commit, can be used.
--- Makefile | 9 +++++++-- lib/Kconfig.debug | 18 ++++++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-)
Makefile +7 -2
@@ -820,10 +820,15 @@ KBUILD_CFLAGS += -Os KBUILD_RUSTFLAGS += -Copt-level=s endif -# Always set `debug-assertions` and `overflow-checks` because their default -# depends on `opt-level` and `debug-assertions`, respectively. +# Always set `debug-assertions` because its default depends on `opt-level`. KBUILD_RUSTFLAGS += -Cdebug-assertions=$(if $(CONFIG_RUST_DEBUG_ASSERTIONS),y,n) + +# Always set `overflow-checks` and `ub-checks` because their default depends on +# `debug-assertions`. KBUILD_RUSTFLAGS += -Coverflow-checks=$(if $(CONFIG_RUST_OVERFLOW_CHECKS),y,n) +ifeq ($(call rustc-min-version, 107900),y) +KBUILD_RUSTFLAGS += -Zub-checks=$(if $(CONFIG_RUST_UNDEFINED_BEHAVIOR_CHECKS),y,n) +endif # Tell gcc to never replace conditional load with a non-conditional one ifdef CONFIG_CC_IS_GCC
lib/Kconfig.debug +18 -0
@@ -3020,6 +3020,24 @@ config RUST_OVERFLOW_CHECKS If unsure, say Y. +config RUST_UNDEFINED_BEHAVIOR_CHECKS + bool "Undefined Behavior checks" + depends on RUST && RUSTC_VERSION >= 107900 + help + Enables rustc's `-Zub-checks` codegen option. + + This flag allows you to control whether additional runtime checks that + detect some causes of Undefined Behavior at runtime will be emitted. + When enabled, a Rust panic will occur if UB is detected. + + All checks are generated on a best-effort basis; even if there is a check + implemented for some cause of Undefined Behavior, it may be possible for + the check to not fire. + + Note that this will apply to all Rust code, including `core`. + + If unsure, say N. + config RUST_BUILD_ASSERT_ALLOW bool "Allow unoptimized build-time assertions" depends on RUST
Signature · 1 line
2.45.2
Miguel Ojeda
maintainerPATCH 13/13 docs: rust: quick-start: add section on Linux distributions
In reply to Miguel OjedaNow that we are starting to support several Rust compiler and bindgen versions, there is a good chance some Linux distributions work out of the box.
Thus, provide some instructions on how to set the toolchain up for a few major Linux distributions. This simplifies the setup users need to build the kernel.
In addition, add an introduction to the document so that it is easier to understand its structure. We may want to reorganize it or split it in the future, but I wanted to focus this commit on the new information added about each particular distribution.
Finally, remove the rustup's components mention in changes.rst since users do not need it if they install the toolchain via the distributions (and anyway it was too detailed for that main document).
---
Note that openSUSE Tumbleweed is adding the Rust standard library source code, rustfmt and Clippy, so we may be able to drop that small note in their section in a few days (possibly before this gets applied) -- thanks William!
Documentation/process/changes.rst | 5 -- Documentation/rust/quick-start.rst | 83 ++++++++++++++++++++++++++++-- 2 files changed, 78 insertions(+), 10 deletions(-)
Documentation/process/changes.rst +0 -5
@@ -90,11 +90,6 @@ Rust (optional) A recent version of the Rust compiler is required. -Each Rust toolchain comes with several "components", some of which are required -(like ``rustc``) and some that are optional. The ``rust-src`` component (which -is optional) needs to be installed to build the kernel. Other components are -useful for developing. - Please see Documentation/rust/quick-start.rst for instructions on how to satisfy the build requirements of Rust support. In particular, the ``Makefile`` target ``rustavailable`` is useful to check why the Rust toolchain may not
Documentation/rust/quick-start.rst +78 -5
95 lines not on this page · raw message
Signature · 1 line
2.45.2
Björn Roy Baron
reviewerRe: [PATCH 04/13] rust: relax most deny-level lints to warnings
In reply to Miguel OjedaQuoted 30 lines · Miguel Ojeda
Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints.
Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring.
To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under
WERROR=y) and the set of lints is not changed.
unsafe_op_in_unsafe_fnis left unmodified, i.e. as an error, since
1) it is simple enough that it should not have false positives (unlike e.g.rust_2018_idioms'sexplicit_outlives_requirements) and 2) it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested.Signed-off-by Miguel Ojeda <[email protected]>--- Makefile | 22 +++++++++++----------- rust/Makefile | 4 ++-- 2 files changed, 13 insertions(+), 13 deletions(-)Makefile +0
-0
Makefile KBUILD_USERLDFLAGS := $(USERLDFLAGS) · line 465
Quoted 7 lines
Makefile +2
-2@@ -461,17 +461,17 @@ KBUILD_USERLDFLAGS := $(USERLDFLAGS) # host programs. export rust_common_flags := --edition=2021 \ -Zbinary_dep_depinfo=y \ - -Dunsafe_op_in_unsafe_fn -Drust_2018_idioms \ - -Dunreachable_pub -Dnon_ascii_idents \ + -Dunsafe_op_in_unsafe_fn -Wrust_2018_idioms \ + -Wunreachable_pub -Wnon_ascii_idents \
Maybe also keep non_ascii_idents as error? It shouldn't have any false positives.
Quoted 52 lines
Makefile +9
-9-Wmissing_docs \ - -Drustdoc::missing_crate_level_docs \ - -Dclippy::correctness -Dclippy::style \ - -Dclippy::suspicious -Dclippy::complexity \ - -Dclippy::perf \ - -Dclippy::let_unit_value -Dclippy::mut_mut \ - -Dclippy::needless_bitwise_bool \ - -Dclippy::needless_continue \ - -Dclippy::no_mangle_with_rust_abi \ + -Wrustdoc::missing_crate_level_docs \ + -Wclippy::correctness -Wclippy::style \ + -Wclippy::suspicious -Wclippy::complexity \ + -Wclippy::perf \ + -Wclippy::let_unit_value -Wclippy::mut_mut \ + -Wclippy::needless_bitwise_bool \ + -Wclippy::needless_continue \ + -Wclippy::no_mangle_with_rust_abi \ -Wclippy::dbg_macro KBUILD_HOSTCFLAGS := $(KBUILD_USERHOSTCFLAGS) $(HOST_LFS_CFLAGS) $(HOSTCFLAGS)@@ -573,7 +573,7 @@ KBUILD_RUSTFLAGS := $(rust_common_flags) \ -Csymbol-mangling-version=v0 \ -Crelocation-model=static \ -Zfunction-sections=n \ - -Dclippy::float_arithmetic + -Wclippy::float_arithmetic KBUILD_AFLAGS_KERNEL := KBUILD_CFLAGS_KERNEL :=rust/Makefile +2
-3@@ -421,7 +421,7 @@ ifneq ($(or $(CONFIG_ARM64),$(and $(CONFIG_RISCV),$(CONFIG_64BIT))),) endif $(obj)/core.o: private skip_clippy = 1 -$(obj)/core.o: private skip_flags = -Dunreachable_pub +$(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@@ -435,7 +435,7 @@ $(obj)/compiler_builtins.o: $(src)/compiler_builtins.rs $(obj)/core.o FORCE +$(call if_changed_dep,rustc_library) $(obj)/alloc.o: private skip_clippy = 1 -$(obj)/alloc.o: private skip_flags = -Dunreachable_pub +$(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) --
Quoted 1 line
2.45.2
Cheers,
Bjorn
Re: [PATCH 01/13] rust: macros: indent list item in `paste!`'s docs
In reply to Miguel OjedaQuoted 21 lines · Miguel Ojeda
A new style lint,
doc_lazy_continuation[1], has been introduced in the upcoming Rust 1.80 (currently in beta), which detects missing indentation in code documentation.We have one such case:
error: doc list item missing indentation
-->rust/macros/lib.rs:315:5
|
315 | /// default the span of the[< >]group is used.
| ^
|
= help: if this is supposed to be its own paragraph, add a blank line
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_lazy_continuation
= note:-D clippy::doc-lazy-continuationimplied by-D clippy::style
= help: to override-D clippy::styleadd#[allow(clippy::doc_lazy_continuation)]
help: indent this line
|
315 | /// default the span of the[< >]group is used.
| ++
Quoted 7 lines
While the rendering of the docs by
rustdocis not affected, we apply this kind of indentation elsewhere since it looks better.Thus clean it up.
Quoted 19 lines
--- rust/macros/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)rust/macros/lib.rs +1
-2@@ -312,7 +312,7 @@ pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {/// /// Currently supported modifiers are: /// * `span`: change the span of concatenated identifier to the span of the specified token. By -/// default the span of the `[< >]` group is used. +/// default the span of the `[< >]` group is used. /// * `lower`: change the identifier to lower case. /// * `upper`: change the identifier to upper case. /// --2.45.2
Björn Roy Baron
reviewerRe: [PATCH 02/13] rust: init: simplify from `map_err` to `inspect_err`
In reply to Miguel OjedaQuoted 33 lines · Miguel Ojeda
A new complexity lint,
manual_inspect[1], has been introduced in the upcoming Rust 1.81 (currently in nightly), which checks for uses ofmap*which return the original item:error: --> rust/kernel/init.rs:846:23 | 846 | (self.1)(val).map_err(|e| { | ^^^^^^^ | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#manual_inspect = note: `-D clippy::manual-inspect` implied by `-D warnings` = help: to override `-D warnings` add `#[allow(clippy::manual_inspect)]` help: try | 846 ~ (self.1)(val).inspect_err(|e| { 847 | // SAFETY: `slot` was initialized above. 848 ~ unsafe { core::ptr::drop_in_place(slot) }; |Thus clean them up.
Signed-off-by Miguel Ojeda <[email protected]>--- rust/kernel/init.rs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)rust/kernel/init.rs +0
-0
rust/kernel/init.rs unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> { · line 848
Quoted 10 lines
rust/kernel/init.rs +2
-4@@ -843,11 +843,9 @@ unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> {let val =unsafe { &mut *slot };// SAFETY: `slot` is considered pinned. let val =unsafe {Pin ::new_unchecked (val) }; - (self.1 )(val).map_err (|e| { + (self.1 )(val).inspect_err (|_|// SAFETY: `slot` was initialized above. -unsafe { core::ptr::drop_in_place (slot) }; - e - }) +unsafe { core::ptr::drop_in_place (slot) })
The formatting here is a bit weird. I would have expected the ) ending the inspect_err call to be placed on a new line given that the unsafe block isn't placed on the same line as the start of the inspect_err call either. This seems to be a case where rustfmt mostly gives up on formatting. If I deindent the comment and unsafe block rustfmt will keep it that way and if I add a trailing space to the inspect_err line it will keep it and emit an error that it left behind trailing whitespace. Maybe add a block around the comment and unsafe block to make rustfmt work again?
Quoted 19 lines
rust/kernel/init.rs +2
-5} }@@ -941,11 +939,9 @@ unsafe fn __init(self, slot: *mut T) -> Result<(), E> {// SAFETY: All requirements fulfilled since this function is `__init`. unsafe { self.0 .__pinned_init (slot)? };// SAFETY: The above call initialized `slot` and we still have unique access. - (self.1 )(unsafe { &mut *slot }).map_err (|e| { + (self.1 )(unsafe { &mut *slot }).inspect_err (|_|// SAFETY: `slot` was initialized above. -unsafe { core::ptr::drop_in_place (slot) }; - e - }) +unsafe { core::ptr::drop_in_place (slot) }) } } --2.45.2
Re: [PATCH 03/13] rust: allow `dead_code` for never constructed bindings
In reply to Miguel OjedaQuoted 23 lines · Miguel Ojeda
Starting with the upcoming Rust 1.80.0 (since upstream commit
35130d7233e9("Detect pub structs never constructed and unused associated constants in traits")), thedead_codepass detects more cases, which triggers in thebindingscrate:warning: struct `boot_params` is never constructed --> rust/bindings/bindings_generated.rs:10684:12 | 10684 | pub struct boot_params { | ^^^^^^^^^^^ | = note: `#[warn(dead_code)]` on by defaultAs well as in the
uapione:warning: struct `boot_params` is never constructed --> rust/uapi/uapi_generated.rs:10392:12 | 10392 | pub struct boot_params { | ^^^^^^^^^^^ | = note: `#[warn(dead_code)]` on by default
Quoted 6 lines
These are all expected, since we do not use all the structs in the bindings that
bindgengenerates from the C headers.Therefore, allow them.
Signed-off-by Miguel Ojeda <[email protected]>
Quoted 31 lines
--- rust/bindings/lib.rs | 1 + rust/uapi/lib.rs | 1 + 2 files changed, 2 insertions(+)rust/bindings/lib.rs +1
-0@@ -24,6 +24,7 @@ unsafe_op_in_unsafe_fn )] +#[allow(dead_code)] mod bindings_raw {// Use glob import here to expose all helpers. // Symbols defined within the module will take precedence to the glob import. rust/uapi/lib.rs +1
-0@@ -14,6 +14,7 @@#![cfg_attr(test, allow(unsafe_op_in_unsafe_fn))] #![allow( clippy::all, + dead_code, missing_docs, non_camel_case_types, non_upper_case_globals,Signature · 1 line
2.45.2
Re: [PATCH 04/13] rust: relax most deny-level lints to warnings
In reply to Björn Roy BaronQuoted 2 lines · Björn Roy Baron
Maybe also keep
non_ascii_identsas error? It shouldn't have any false positives.
I was on the fence for that one too. It is also unlikely that having it as -W helps "productivity", i.e. I don't expect anybody to be helped by being able to type non-ASCII identifiers during development. :)
Happy either way.
Thanks for the quick review, too!
Cheers,
Miguel
Re: [PATCH 02/13] rust: init: simplify from `map_err` to `inspect_err`
In reply to Björn Roy BaronQuoted 2 lines · Björn Roy Baron
The formatting here is a bit weird. I would have expected the ) ending the
inspect_errcall to be placed on a new line given that the unsafe block isn't placed on the same line as the start of theinspect_errcall either. This seems to be a case where rustfmt mostly gives up on formatting. If I deindent the comment and unsafe block rustfmt will keep it that way and if I add a trailing space to theinspect_errline it will keep it and emit an error that it left behind trailing whitespace. Maybe add a block around the comment and unsafe block to make rustfmt work again?
Benno: any preference here? Or even open coding it.
Thanks Björn!
Cheers,
Miguel
Quoted 70 lines · Miguel Ojeda
Hi all,
It is time to start supporting several Rust toolchain versions and thus establish a minimum Rust compiler and
bindgenversion.For the Rust compiler, we will start with a window of two stable releases, and widen it over time. This series keeps the minimum where it is (1.78.0), but adds support for the recently released 1.79.0.
This should already be enough for kernel developers in distributions that provide recent Rust compiler versions routinely, such as Arch Linux, Debian Unstable (outside the freeze period), Fedora Linux, Gentoo Linux (especially the testing channel), Nix (unstable) and openSUSE Tumbleweed. A documentation adds the instructions for each of them.
In addition, Rust for Linux is now being built-tested in Rust's pre-merge CI. That is, every change that is attempting to land into the Rust compiler is tested against the kernel, and it is merged only if it passes -- thanks to the Rust project for that!
Thus, with the pre-merge CI in place, both projects hope to avoid unintentional changes to Rust that break the kernel. This means that, in general, apart from intentional changes on their side (that we will need to workaround conditionally on our side), the upcoming Rust compiler versions should generally work.
For instance, currently, the beta (1.80.0) and nightly (1.81.0) branches work as well.
Similarly, we kept the minimum as it is for
bindgen.bindgenis also adding the kernel to its CI -- thanks!Cheers,
MiguelMiguel Ojeda (13):
rust: macros: indent list item inpaste!'s docs
rust: init: simplify frommap_errtoinspect_err
rust: allowdead_codefor never constructed bindings
rust: relax most deny-level lints to warnings
rust: simplify Clippy warning flags set
rust: start supporting several compiler versions
rust: warn aboutbindgenversions 0.66.0 and 0.66.1
rust: work aroundbindgen0.69.0 issue
rust: avoid assuming a particularbindgenbuild
rust: start supporting severalbindgenversions
kbuild: rust: addrustc-versionsupport
rust: support the new-Zub-checksflag
docs: rust: quick-start: add section on Linux distributionsDocumentation/process/changes.rst | 9 +-- Documentation/rust/quick-start.rst | 118 +++++++++++++++++++++++------ Makefile | 29 +++---- init/Kconfig | 11 ++- lib/Kconfig.debug | 18 +++++ rust/Makefile | 4 +- rust/bindings/lib.rs | 1 + rust/kernel/init.rs | 12 +-- rust/macros/lib.rs | 2 +- rust/uapi/lib.rs | 1 + scripts/Kconfig.include | 6 ++ scripts/Makefile.compiler | 4 + scripts/rust_is_available.sh | 20 ++--- scripts/rust_is_available_test.py | 40 +++++----- scripts/rustc-version.sh | 52 +++++++++++++ 15 files changed, 238 insertions(+), 89 deletions(-) create mode 100755 scripts/rustc-version.sh
Quoted 3 lines
base-commit:
f2661062f16b2de5d7b6a5c42a9a5c96326b8454--
2.45.2
I applied the series and successfully ran the kunit tests on nixos. I tried the following rust versions via fenix:
- rustc 1.78.0 (9b00956e5 2024-04-29)
- rustc 1.79.0 (129f3b996 2024-06-10)
- 1.80.0-beta.4 (64a1fe671 2024-06-21)
- 1.81.0-nightly (6868c831a 2024-06-30)
My bindgen version is 0.69.4.
Everything worked as expected :)
---
Cheers,
Benno
Re: [PATCH 02/13] rust: init: simplify from `map_err` to `inspect_err`
In reply to Miguel OjedaQuoted 6 lines · Miguel Ojeda
Quoted 2 lines · Björn Roy Baron
The formatting here is a bit weird. I would have expected the ) ending the
inspect_errcall to be placed on a new line given that the unsafe block isn't placed on the same line as the start of theinspect_errcall either. This seems to be a case where rustfmt mostly gives up on formatting. If I deindent the comment and unsafe block rustfmt will keep it that way and if I add a trailing space to theinspect_errline it will keep it and emit an error that it left behind trailing whitespace. Maybe add a block around the comment and unsafe block to make rustfmt work again?Benno: any preference here? Or even open coding it.
I would put the comment outside of the closure:
let val = unsafe { &mut *slot };
// SAFETY: `slot` is considered pinned.
let val = unsafe { Pin::new_unchecked(val) };
// SAFETY: `slot` was initialized above.
(self.1)(val).inspect_err(|_| unsafe { core::ptr::drop_in_place(slot) })---
Cheers,
Benno
Quoted 11 lines · Benno Lossin
I applied the series and successfully ran the kunit tests on nixos. I tried the following rust versions via fenix:
- rustc 1.78.0 (9b00956e52024-04-29)
- rustc 1.79.0 (129f3b9962024-06-10)
- 1.80.0-beta.4 (64a1fe6712024-06-21)
- 1.81.0-nightly (6868c831a2024-06-30)My bindgen version is 0.69.4.
Everything worked as expected :)
Thanks Benno! I tried nixpkgs' toolchain for the examples in the docs patch, but not fenix's ones, so it's good to know those work as well. :)
Cheers,
Miguel
Alice Ryhl
reviewerRe: [PATCH 02/13] rust: init: simplify from `map_err` to `inspect_err`
In reply to Miguel OjedaQuoted 7 lines · Miguel Ojeda
Quoted 2 lines · Björn Roy Baron
The formatting here is a bit weird. I would have expected the ) ending the
inspect_errcall to be placed on a new line given that the unsafe block isn't placed on the same line as the start of theinspect_errcall either. This seems to be a case where rustfmt mostly gives up on formatting. If I deindent the comment and unsafe block rustfmt will keep it that way and if I add a trailing space to theinspect_errline it will keep it and emit an error that it left behind trailing whitespace. Maybe add a block around the comment and unsafe block to make rustfmt work again?Benno: any preference here? Or even open coding it.
I would open code it with an if res.is_err() { drop }. Using inspect for a side effect other than printing seems weird to me.
Alice
Re: [PATCH 01/13] rust: macros: indent list item in `paste!`'s docs
In reply to Miguel OjedaQuoted 21 lines · Miguel Ojeda
A new style lint,
doc_lazy_continuation[1], has been introduced in the upcoming Rust 1.80 (currently in beta), which detects missing indentation in code documentation.We have one such case:
error: doc list item missing indentation
-->rust/macros/lib.rs:315:5
|
315 | /// default the span of the[< >]group is used.
| ^
|
= help: if this is supposed to be its own paragraph, add a blank line
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#doc_lazy_continuation
= note:-D clippy::doc-lazy-continuationimplied by-D clippy::style
= help: to override-D clippy::styleadd#[allow(clippy::doc_lazy_continuation)]
help: indent this line
|
315 | /// default the span of the[< >]group is used.
| ++
Quoted 7 lines
While the rendering of the docs by
rustdocis not affected, we apply this kind of indentation elsewhere since it looks better.Thus clean it up.
Quoted 19 lines
--- rust/macros/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)rust/macros/lib.rs +1
-1@@ -312,7 +312,7 @@ pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {/// /// Currently supported modifiers are: /// * `span`: change the span of concatenated identifier to the span of the specified token. By -/// default the span of the `[< >]` group is used. +/// default the span of the `[< >]` group is used. /// * `lower`: change the identifier to lower case. /// * `upper`: change the identifier to upper case. /// Signature · 1 line
2.45.2
Re: [PATCH 03/13] rust: allow `dead_code` for never constructed bindings
In reply to Miguel OjedaQuoted 23 lines · Miguel Ojeda
Starting with the upcoming Rust 1.80.0 (since upstream commit
35130d7233e9("Detect pub structs never constructed and unused associated constants in traits")), thedead_codepass detects more cases, which triggers in thebindingscrate:warning: struct `boot_params` is never constructed --> rust/bindings/bindings_generated.rs:10684:12 | 10684 | pub struct boot_params { | ^^^^^^^^^^^ | = note: `#[warn(dead_code)]` on by defaultAs well as in the
uapione:warning: struct `boot_params` is never constructed --> rust/uapi/uapi_generated.rs:10392:12 | 10392 | pub struct boot_params { | ^^^^^^^^^^^ | = note: `#[warn(dead_code)]` on by default
Quoted 6 lines
These are all expected, since we do not use all the structs in the bindings that
bindgengenerates from the C headers.Therefore, allow them.
Signed-off-by Miguel Ojeda <[email protected]>
Quoted 31 lines
--- rust/bindings/lib.rs | 1 + rust/uapi/lib.rs | 1 + 2 files changed, 2 insertions(+)rust/bindings/lib.rs +1
-0@@ -24,6 +24,7 @@ unsafe_op_in_unsafe_fn )] +#[allow(dead_code)] mod bindings_raw {// Use glob import here to expose all helpers. // Symbols defined within the module will take precedence to the glob import. rust/uapi/lib.rs +1
-0@@ -14,6 +14,7 @@#![cfg_attr(test, allow(unsafe_op_in_unsafe_fn))] #![allow( clippy::all, + dead_code, missing_docs, non_camel_case_types, non_upper_case_globals,Signature · 1 line
2.45.2
Re: [PATCH 04/13] rust: relax most deny-level lints to warnings
In reply to Miguel OjedaQuoted 12 lines · Miguel Ojeda
Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints.
Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring.
To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under
WERROR=y) and the set of lints is not changed.
Quoted 8 lines
unsafe_op_in_unsafe_fnis left unmodified, i.e. as an error, since
1) it is simple enough that it should not have false positives (unlike e.g.rust_2018_idioms'sexplicit_outlives_requirements) and 2) it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested.Signed-off-by Miguel Ojeda <[email protected]>
Also in favour of disallowing non ASCII idents. Either way
Quoted 70 lines
--- Makefile | 22 +++++++++++----------- rust/Makefile | 4 ++-- 2 files changed, 13 insertions(+), 13 deletions(-)Makefile +11
-11@@ -461,17 +461,17 @@ KBUILD_USERLDFLAGS := $(USERLDFLAGS) # host programs. export rust_common_flags := --edition=2021 \ -Zbinary_dep_depinfo=y \ - -Dunsafe_op_in_unsafe_fn -Drust_2018_idioms \ - -Dunreachable_pub -Dnon_ascii_idents \ + -Dunsafe_op_in_unsafe_fn -Wrust_2018_idioms \ + -Wunreachable_pub -Wnon_ascii_idents \ -Wmissing_docs \ - -Drustdoc::missing_crate_level_docs \ - -Dclippy::correctness -Dclippy::style \ - -Dclippy::suspicious -Dclippy::complexity \ - -Dclippy::perf \ - -Dclippy::let_unit_value -Dclippy::mut_mut \ - -Dclippy::needless_bitwise_bool \ - -Dclippy::needless_continue \ - -Dclippy::no_mangle_with_rust_abi \ + -Wrustdoc::missing_crate_level_docs \ + -Wclippy::correctness -Wclippy::style \ + -Wclippy::suspicious -Wclippy::complexity \ + -Wclippy::perf \ + -Wclippy::let_unit_value -Wclippy::mut_mut \ + -Wclippy::needless_bitwise_bool \ + -Wclippy::needless_continue \ + -Wclippy::no_mangle_with_rust_abi \ -Wclippy::dbg_macro KBUILD_HOSTCFLAGS := $(KBUILD_USERHOSTCFLAGS) $(HOST_LFS_CFLAGS) $(HOSTCFLAGS)@@ -573,7 +573,7 @@ KBUILD_RUSTFLAGS := $(rust_common_flags) \ -Csymbol-mangling-version=v0 \ -Crelocation-model=static \ -Zfunction-sections=n \ - -Dclippy::float_arithmetic + -Wclippy::float_arithmetic KBUILD_AFLAGS_KERNEL := KBUILD_CFLAGS_KERNEL :=rust/Makefile +2
-2@@ -421,7 +421,7 @@ ifneq ($(or $(CONFIG_ARM64),$(and $(CONFIG_RISCV),$(CONFIG_64BIT))),) endif $(obj)/core.o: private skip_clippy = 1 -$(obj)/core.o: private skip_flags = -Dunreachable_pub +$(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@@ -435,7 +435,7 @@ $(obj)/compiler_builtins.o: $(src)/compiler_builtins.rs $(obj)/core.o FORCE +$(call if_changed_dep,rustc_library) $(obj)/alloc.o: private skip_clippy = 1 -$(obj)/alloc.o: private skip_flags = -Dunreachable_pub +$(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)Signature · 1 line
2.45.2
Re: [PATCH 05/13] rust: simplify Clippy warning flags set
In reply to Miguel OjedaQuoted 9 lines · Miguel Ojeda
All Clippy lint groups that we enable, except
correctness, have a defaultwarnlevel, thus they may be removed now that we relaxed all lints towarn.Moreover, Clippy provides an
alllint group that covers the groups we enable by default. Thus just useallinstead -- the only change is that, if Clippy introduces a new lint group or splits an existing one, we will cover that one automatically.
Quoted 4 lines
In addition,
let_unit_valueis instylesince Rust 1.62.0, thus it does not need to be enabled manually.Signed-off-by Miguel Ojeda <[email protected]>
Quoted 23 lines
--- Makefile | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)Makefile +2
-4@@ -465,10 +465,8 @@ export rust_common_flags := --edition=2021 \ -Wunreachable_pub -Wnon_ascii_idents \ -Wmissing_docs \ -Wrustdoc::missing_crate_level_docs \ - -Wclippy::correctness -Wclippy::style \ - -Wclippy::suspicious -Wclippy::complexity \ - -Wclippy::perf \ - -Wclippy::let_unit_value -Wclippy::mut_mut \ + -Wclippy::all \ + -Wclippy::mut_mut \ -Wclippy::needless_bitwise_bool \ -Wclippy::needless_continue \ -Wclippy::no_mangle_with_rust_abi \Signature · 1 line
2.45.2
Re: [PATCH 07/13] rust: warn about `bindgen` versions 0.66.0 and 0.66.1
In reply to Miguel OjedaQuoted 15 lines · Miguel Ojeda
bindgenversions 0.66.0 and 0.66.1 panic due to C string literals with NUL characters [1]:panicked at .cargo/registry/src/index.crates.io-6f17d22bba15001f/bindgen-0.66.0/codegen/mod.rs:717:71: called `Result::unwrap()` on an `Err` value: FromBytesWithNulError { kind: InteriorNul(4) }Thus, in preparation for supporting several
bindgenversions, add a version check to warn the user about it.We could make it an error, but 1) it is going to fail anyway later in the build, 2) we would disable
RUSTautomatically, which is also painful,
3) someone could be using a patchedbindgenat that version, 4) the interior NUL may go away in the headers (however unlikely). Thus just warn about it so that users know why it is failing.
Quoted 4 lines
In addition, add a test for the new case.
Signed-off-by Miguel Ojeda <[email protected]>
Quoted 44 lines
--- scripts/rust_is_available.sh | 8 ++++++++ scripts/rust_is_available_test.py | 7 +++++++ 2 files changed, 15 insertions(+)scripts/rust_is_available.sh +8
-0@@ -165,6 +165,14 @@ if [ "$rust_bindings_generator_cversion" -gt "$rust_bindings_generator_min_cvers echo >&2 "***" warning=1 fi +if [ "$rust_bindings_generator_cversion" -eq 6600 ] || [ "$rust_bindings_generator_cversion" -eq 6601 ]; then + echo >&2 "***" + echo >&2 "*** Rust bindings generator '$BINDGEN' versions 0.66.0 and 0.66.1 may not" + echo >&2 "*** work due to a bug (https://github.com/rust-lang/rust-bindgen/pull/2567)." + echo >&2 "*** Your version: $rust_bindings_generator_version" + echo >&2 "***" + warning=1 +fi # Check that the `libclang` used by the Rust bindings generator is suitable. #scripts/rust_is_available_test.py +7
-0@@ -226,6 +226,13 @@ else: result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "BINDGEN": bindgen }) self.assertIn(f"Rust bindings generator '{bindgen}' is too new. This may or may not work.", result.stderr) + def test_bindgen_bad_version_0_66_0_and_0_66_1(self): + for version in ("0.66.0", "0.66.1"): + with self.subTest(version=version): + bindgen = self.generate_bindgen_version(f"bindgen {version}") + result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "BINDGEN": bindgen }) + self.assertIn(f"Rust bindings generator '{bindgen}' versions 0.66.0 and 0.66.1 may not", result.stderr) + def test_bindgen_libclang_failure(self): for env in ( { "LLVM_CONFIG_PATH": self.missing },Signature · 1 line
2.45.2
Re: [PATCH 08/13] rust: work around `bindgen` 0.69.0 issue
In reply to Miguel OjedaQuoted 8 lines · Miguel Ojeda
bindgen0.69.0 contains a bug:--versiondoes not work without providing a header [1]:error: the following required arguments were not provided:
<HEADER>Usage: bindgen <FLAGS> <OPTIONS> <HEADER> -- <
CLANG_ARGS>...
Quoted 7 lines
Thus, in preparation for supporting several
bindgenversions, work around the issue by passing a dummy argument.Include a comment so that we can remove the workaround in the future.
Signed-off-by Miguel Ojeda <[email protected]>
Quoted 41 lines
--- init/Kconfig | 5 ++++- scripts/rust_is_available.sh | 6 +++++- 2 files changed, 9 insertions(+), 2 deletions(-)init/Kconfig +4
-1@@ -1928,7 +1928,10 @@ config RUSTC_VERSION_TEXT config BINDGEN_VERSION_TEXT string depends on RUST - default $(shell,command -v $(BINDGEN) >/dev/null 2>&1 && $(BINDGEN) --version || echo n) + # The dummy parameter `workaround-for-0.69.0` is required to support 0.69.0 + # (https://github.com/rust-lang/rust-bindgen/pull/2678). It can be removed when + # the minimum version is upgraded past that (0.69.1 already fixed the issue). + default $(shell,command -v $(BINDGEN) >/dev/null 2>&1 && $(BINDGEN) --version workaround-for-0.69.0 || echo n) # # Place an empty function call at each tracepoint site. Can bescripts/rust_is_available.sh +5
-1@@ -121,8 +121,12 @@ fi # Check that the Rust bindings generator is suitable. # # Non-stable and distributions' versions may have a version suffix, e.g. `-dev`. +# +# The dummy parameter `workaround-for-0.69.0` is required to support 0.69.0 +# (https://github.com/rust-lang/rust-bindgen/pull/2678). It can be removed when +# the minimum version is upgraded past that (0.69.1 already fixed the issue). rust_bindings_generator_output=$( \ - LC_ALL=C "$BINDGEN" --version 2>/dev/null + LC_ALL=C "$BINDGEN" --version workaround-for-0.69.0 2>/dev/null ) || rust_bindings_generator_code=$? if [ -n "$rust_bindings_generator_code" ]; then echo >&2 "***"Signature · 1 line
2.45.2
Re: [PATCH 11/13] kbuild: rust: add `rustc-version` support
In reply to Miguel OjedaQuoted 12 lines · Miguel Ojeda
Now that we are starting to support several Rust versions, introduce
rustc-versionsupport, mimicking the C side:-
scripts/rustc-version.sh, that mimics the other version scripts(with one more digit, e.g. Rust 1.79.0 is 107900).-
rustc-{info,name,version}Kbuildmacros.-
CONFIG_RUSTC_VERSIONKconfigsymbol that callsrustc-version.-
rustc-min-versionKbuildmacro that usesCONFIG_RUSTC_VERSION.
Quoted 8 lines
With these, we can easily support flags conditionally depending on
rustc's version -- a user comes in the next patch.Another user will be the
-Ctarget-feature=+reserve-x18/-Zfixed-x18arm64 flags [1].
Quoted 117 lines
--- init/Kconfig | 6 +++++ scripts/Kconfig.include | 6 +++++ scripts/Makefile.compiler | 4 +++ scripts/rustc-version.sh | 52 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 68 insertions(+) create mode 100755 scripts/rustc-version.shinit/Kconfig +6
-0@@ -1920,6 +1920,12 @@ config RUST If unsure, say N. +config RUSTC_VERSION + int + depends on RUST + default $(rustc-version) + default 0 + config RUSTC_VERSION_TEXT string depends on RUSTscripts/Kconfig.include +6
-0@@ -45,6 +45,12 @@ $(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this C compiler is not cc-name := $(shell,set -- $(cc-info) && echo $1) cc-version := $(shell,set -- $(cc-info) && echo $2) +# Get the Rust compiler name, version, and error out if it is not supported. +rustc-info := $(shell,$(srctree)/scripts/rustc-version.sh $(RUSTC)) +$(error-if,$(success,test -z "$(rustc-info)"),Sorry$(comma) this Rust compiler is not supported.) +rustc-name := $(shell,set -- $(rustc-info) && echo $1) +rustc-version := $(shell,set -- $(rustc-info) && echo $2) + # Get the assembler name, version, and error out if it is not supported. as-info := $(shell,$(srctree)/scripts/as-version.sh $(CC) $(CLANG_FLAGS)) $(error-if,$(success,test -z "$(as-info)"),Sorry$(comma) this assembler is not supported.)scripts/Makefile.compiler +4
-0@@ -69,6 +69,10 @@ gcc-min-version = $(call test-ge, $(CONFIG_GCC_VERSION), $1) # Usage: cflags-$(call clang-min-version, 110000) += -foo clang-min-version = $(call test-ge, $(CONFIG_CLANG_VERSION), $1) +# rustc-min-version +# Usage: rustflags-$(call rustc-min-version, 107900) += -foo +rustc-min-version = $(call test-ge, $(CONFIG_RUSTC_VERSION), $1) + # ld-option # Usage: KBUILD_LDFLAGS += $(call ld-option, -X, -Y) ld-option = $(call try-run, $(LD) $(KBUILD_LDFLAGS) $(1) -v,$(1),$(2),$(3))scripts/rustc-version.sh new file +52
-0@@ -0,0 +1,52 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# +# Print the Rust compiler name and its version in a 5 or 6-digit form. +# Also, perform the minimum version check. + +set -e + +# Convert the version string x.y.z to a canonical up-to-7-digits form. +# +# Note that this function uses one more digit (compared to other +# instances in other version scripts) to give a bit more space to +# `rustc` since it will reach 1.100.0 in late 2026. +get_canonical_version() +{ + IFS=. + set -- $1 + echo $((100000 * $1 + 100 * $2 + $3)) +} + +orig_args="$@" + +set -- $("$@" --version) + +name=$1 + +min_tool_version=$(dirname $0)/min-tool-version.sh + +case "$name" in +rustc) + version=$2 + min_version=$($min_tool_version rustc) + ;; +*) + echo "$orig_args: unknown Rust compiler" >&2 + exit 1 + ;; +esac + +rustcversion=$(get_canonical_version $version) +min_rustcversion=$(get_canonical_version $min_version) + +if [ "$rustcversion" -lt "$min_rustcversion" ]; then + echo >&2 "***" + echo >&2 "*** Rust compiler is too old." + echo >&2 "*** Your $name version: $version" + echo >&2 "*** Minimum $name version: $min_version" + echo >&2 "***" + exit 1 +fi + +echo $name $rustcversionSignature · 1 line
2.45.2
Re: [PATCH 12/13] rust: support the new `-Zub-checks` flag
In reply to Miguel OjedaQuoted 8 lines · Miguel Ojeda
Rust 1.79.0 has introduced a new codegen flag,
-Zub-checks[1], to allow to independently configure (from-Cdebug-assertions) whether the extra runtime checks for UB are emitted, in a similar fashion to-Coverflow-checks.This allows to configure the kernel with only the UB checks enabled, but not the
debug_assert!s; or vice versa, e.g. [2].
Quoted 6 lines
It also showcases how
RUSTC_VERSIONand theKbuildmacros, introduced in the previous commit, can be used.Link https://godbolt.org/z/jY69ezx5K [2]Signed-off-by Miguel Ojeda <[email protected]>
Quoted 58 lines
--- Makefile | 9 +++++++-- lib/Kconfig.debug | 18 ++++++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-)Makefile +7
-2@@ -820,10 +820,15 @@ KBUILD_CFLAGS += -Os KBUILD_RUSTFLAGS += -Copt-level=s endif -# Always set `debug-assertions` and `overflow-checks` because their default -# depends on `opt-level` and `debug-assertions`, respectively. +# Always set `debug-assertions` because its default depends on `opt-level`. KBUILD_RUSTFLAGS += -Cdebug-assertions=$(if $(CONFIG_RUST_DEBUG_ASSERTIONS),y,n) + +# Always set `overflow-checks` and `ub-checks` because their default depends on +# `debug-assertions`. KBUILD_RUSTFLAGS += -Coverflow-checks=$(if $(CONFIG_RUST_OVERFLOW_CHECKS),y,n) +ifeq ($(call rustc-min-version, 107900),y) +KBUILD_RUSTFLAGS += -Zub-checks=$(if $(CONFIG_RUST_UNDEFINED_BEHAVIOR_CHECKS),y,n) +endif # Tell gcc to never replace conditional load with a non-conditional one ifdef CONFIG_CC_IS_GCClib/Kconfig.debug +18
-0@@ -3020,6 +3020,24 @@ config RUST_OVERFLOW_CHECKS If unsure, say Y. +config RUST_UNDEFINED_BEHAVIOR_CHECKS + bool "Undefined Behavior checks" + depends on RUST && RUSTC_VERSION >= 107900 + help + Enables rustc's `-Zub-checks` codegen option. + + This flag allows you to control whether additional runtime checks that + detect some causes of Undefined Behavior at runtime will be emitted. + When enabled, a Rust panic will occur if UB is detected. + + All checks are generated on a best-effort basis; even if there is a check + implemented for some cause of Undefined Behavior, it may be possible for + the check to not fire. + + Note that this will apply to all Rust code, including `core`. + + If unsure, say N. + config RUST_BUILD_ASSERT_ALLOW bool "Allow unoptimized build-time assertions" depends on RUSTSignature · 1 line
2.45.2
Re: [PATCH 06/13] rust: start supporting several compiler versions
In reply to a message not in the archiveQuoted 4 lines · Finn Behrens
One idea below, but fine with or without it.
Reviewed-by Finn Behrens <[email protected]>
Thanks Finn!
Quoted 1 line
Would it make sense to not advise the min version but the “max” or just latest stable version? Min version should work as well latest could potentially be a bit more optimised if both work either way?
Yeah, that is a good idea -- we could just say stable there.
In fact, it makes more sense, because this is using rustup, i.e. the Rust-provided binaries, and the Rust project only supports the latest version (so far -- there are proposals about LTSs there).
Cheers,
Miguel
Re: [PATCH 13/13] docs: rust: quick-start: add section on Linux distributions
In reply to Miguel OjedaOn Mon, Jul 01, 2024 at 08:36:23PM +0200, Miguel Ojeda wrote:
..
Documentation/rust/quick-start.rst Quick Start · line 39
Quoted 7 lines
Documentation/rust/quick-start.rst +7
-0+Debian +****** + +Debian Unstable (Sid), outside of the freeze period, provides recent Rust +release and thus it should generally work out of the box, e.g.:: + + apt install rustc rust-src bindgen rustfmt rust-clippy
This implicitly covers Ubuntu, since packages are sync'ed with Debian.
In addition to that Ubuntu also provides versioned packages (such as rustc-1.74, bindgen-0.65, etc.), so in case of special requirements (e.g., older kernels) users should be able to install the required version(s) using the packages provided by the distro.
Maybe it's worth mentioning as a little note, so that users are aware of these extra packages.
Thanks,
-Andrea
Re: [PATCH 13/13] docs: rust: quick-start: add section on Linux distributions
Quoted 12 lines · Andrea Righi
On Mon, Jul 01, 2024 at 08:36:23PM +0200, Miguel Ojeda wrote:
..Documentation/rust/quick-start.rst Quick Start · line 39
Quoted 7 lines
Documentation/rust/quick-start.rst +7
-0+Debian +****** + +Debian Unstable (Sid), outside of the freeze period, provides recent Rust +release and thus it should generally work out of the box, e.g.:: + + apt install rustc rust-src bindgen rustfmt rust-clippyThis implicitly covers Ubuntu, since packages are sync'ed with Debian.
Quoted 4 lines
In addition to that Ubuntu also provides versioned packages (such as rustc-1.74, bindgen-0.65, etc.), so in case of special requirements (e.g., older kernels) users should be able to install the required version(s) using the packages provided by the distro.
Debian (for building firefox and chromium), and uses a -web suffix for that:
https://tracker.debian.org/pkg/rustc-web
https://tracker.debian.org/pkg/rust-cbindgen-web
cheers,
Fabian
Re: [PATCH 13/13] docs: rust: quick-start: add section on Linux distributions
In reply to Andrea RighiQuoted 2 lines · Andrea Righi
This implicitly covers Ubuntu, since packages are sync'ed with Debian.
Do you mean the names (i.e. command) is the same, or that the newer versions from e.g. Sid can be used in Ubuntu? If the latter, that would be definitely worth adding, yeah -- is that supported / expected to work?
Quoted 7 lines
In addition to that Ubuntu also provides versioned packages (such as rustc-1.74, bindgen-0.65, etc.), so in case of special requirements (e.g., older kernels) users should be able to install the required version(s) using the packages provided by the distro.
Maybe it's worth mentioning as a little note, so that users are aware of these extra packages.
I thought about adding a section for Ubuntu to mention those -- so far I only added the distributions/commands that were likely to work with the versions supported by the kernel, with the idea of expand later as time passes. So I didn't add the versioned ones since the latest is 1.76, so it wouldn't work for the current kernel.
But it may be useful to state it nevertheless, since some people may only look at the latest docs. (Or perhaps Ubuntu can add Rust 1.79? :)
Thanks!
Cheers,
Miguel
Re: [PATCH 13/13] docs: rust: quick-start: add section on Linux distributions
In reply to Fabian GrünbichlerQuoted 5 lines · Fabian Grünbichler
Debian (for building firefox and chromium), and uses a -web suffix for that:
Like for Ubuntu's versioned ones, it seems not recent enough at the moment (i.e. for the current kernel), if I understand correctly.
Also, it is a single version, i.e. 1.70, right? We didn't use that particular version in any old kernel version (we moved from 1.68.2 to 1.71.1 in commit 89eed1ab1161 ("rust: upgrade to Rust 1.71.1") back then). So I am not sure how useful it would be, but if you think it will be in the future, perhaps it is worth mentioning.
Quoted 1 line
We may use cbindgen too in the future, but not currently.
Is something like bindgen-web also available for stable?
Thanks!
Cheers,
Miguel
Re: [PATCH 13/13] docs: rust: quick-start: add section on Linux distributions
In reply to Miguel OjedaQuoted 8 lines · Miguel Ojeda
Quoted 2 lines · Andrea Righi
This implicitly covers Ubuntu, since packages are sync'ed with Debian.
Do you mean the names (i.e. command) is the same, or that the newer versions from e.g. Sid can be used in Ubuntu? If the latter, that would be definitely worth adding, yeah -- is that supported / expected to work?
Command and package names are the same. We may also have different (newer) versions than Sid, but this is up to foundations team.
Zixing, what do you think?
Quoted 9 lines
Quoted 8 lines
In addition to that Ubuntu also provides versioned packages (such as rustc-1.74, bindgen-0.65, etc.), so in case of special requirements (e.g., older kernels) users should be able to install the required version(s) using the packages provided by the distro.
Maybe it's worth mentioning as a little note, so that users are aware of these extra packages.
Quoted 8 lines
I thought about adding a section for Ubuntu to mention those -- so far I only added the distributions/commands that were likely to work with the versions supported by the kernel, with the idea of expand later as time passes. So I didn't add the versioned ones since the latest is 1.76, so it wouldn't work for the current kernel.
But it may be useful to state it nevertheless, since some people may only look at the latest docs. (Or perhaps Ubuntu can add Rust 1.79? :)
Actually, considering that this doc will go in newer kernels, probably it's not worth to mention the *old* packages.
About Rust 1.79, calling out Zixing again... :) He may have newer Rust packages in his ppa at some point, but I don't know how much we can consider that ppa "official".
-Andrea
Re: [PATCH 13/13] docs: rust: quick-start: add section on Linux distributions
In reply to Miguel OjedaQuoted 10 lines · Miguel Ojeda
Quoted 5 lines · Fabian Grünbichler
Debian (for building firefox and chromium), and uses a -web suffix for that:
Like for Ubuntu's versioned ones, it seems not recent enough at the moment (i.e. for the current kernel), if I understand correctly.
yep.
Quoted 5 lines
Also, it is a single version, i.e. 1.70, right? We didn't use that particular version in any old kernel version (we moved from 1.68.2 to 1.71.1 in commit
89eed1ab1161("rust: upgrade to Rust 1.71.1") back then). So I am not sure how useful it would be, but if you think it will be in the future, perhaps it is worth mentioning.
right now it is updated whenever its rdeps (firefox and chromium in stable) need newer versions. once e.g. a stable Debian kernel has similar requirements, I guess the same would apply there. I am not sure upstream kernel development on Debian stable would be enough of an argument to update it (or provide similar packages), but I am not a member of the teams that would make that decision.
we currently don't provide multiple versions in parallel (like GCC or LLVM though) besides this special affordance for browsers. I am not sure this would be a good idea either given rustc's release cadence ;)
as discussed off-list, -backports might be a better place for providing more recent toolchain packages on Debian stable, and independent from this thread, I have pondered providing them there in the past already. backports would only ship one version as well though, and at most the one in testing (so it would also be affected by the freeze period, just like unstable and testing).
Quoted 3 lines
Quoted 1 line
We may use
cbindgentoo in the future, but not currently.
it's used by firefox :)
Quoted 1 line
Is something like
bindgen-webalso available for stable?
not yet, but could conceivably be provided once/iff there is a need (see above).
Re: [PATCH 13/13] docs: rust: quick-start: add section on Linux distributions
Quoted 7 lines · Fabian Grünbichler
right now it is updated whenever its rdeps (firefox and chromium in stable) need newer versions. once e.g. a stable Debian kernel has similar requirements, I guess the same would apply there. I am not sure upstream kernel development on Debian stable would be enough of an argument to update it (or provide similar packages), but I am not a member of the teams that would make that decision.
That is reasonable.
Quoted 6 lines
as discussed off-list, -backports might be a better place for providing more recent toolchain packages on Debian stable, and independent from this thread, I have pondered providing them there in the past already. backports would only ship one version as well though, and at most the one in testing (so it would also be affected by the freeze period, just like unstable and testing).
I imagine that could be useful for some (kernel or not) developers on stable, even with the freeze period.
Thanks!
Cheers,
Miguel