In my last blog post, I showed how to build the ArchLinux kernel with Rust support enabled and also packaging the correct build metadata to support out-of-tree kernel modules.

In the meantime I gave a presentation about it in the Rust Zürisee Meetup and kept the AUR package more or less up to date.

Also some people got interested in enabling it for the official kernel build for ArchLinux¹ but hit some issues and the change got reverted again.

Building with the distro rust-bindgen

With the release of Linux 6.11, instead of a pinned version there should be an actual minimum version for the Rust toolchain to build the Linux with Rust support. See the git pull request for 6.11 and the rust-version-policy on https://rust-for-linux.com.

Using the distro packaged Rust toolchain should make it easier to be included in the official repositories some day, since using rustup to pin the version leads to issues when building in a clean chroot environment².

So in December 2024 I started with using rust-bindgen from the Arch repositories: https://github.com/rnestler/archpkg-linux-rust/pull/11. This lead into a roadblock when I noticed, that rust-bindgen 0.71.1 breaks the build of Linux 6.11 with Rust 1.78, while it worked just fine with rust-bindgen 0.70.1.

In January 2025, when updating to to the 6.12 version of the kernel I upgraded the PKGBUILD to use Rust 1.83 and the current ArchLinux version of rust-bindgen: https://github.com/rnestler/archpkg-linux-rust/pull/12/. This seemed to work just fine.

Do to unclarities how to ensure that the Rust version used to build the kernel is the same that will be used to build out-of-tree modules, I decided to still pin the Rust version used and only support building the kernel with rustup.

Building with the whole distro Rust toolchain

In February a nice pull-request hit my archpkg-linux-rust repo: https://github.com/rnestler/archpkg-linux-rust/pull/13. The author of it fixed a bug in the PKGBUILD and adapted it as well to build with rustc and rust-src from the repos.

Since I didn't want to break building the package with rustup I decided to support both ways. This is made easy since we can just depend on rust and rust-src which are both also provided by the rustup package:

$ pacman -Qi rustup
Name            : rustup
Version         : 1.27.1-1
Description     : The Rust toolchain installer
Architecture    : x86_64
URL             : https://github.com/rust-lang/rustup.rs
Licenses        : MIT  Apache-2.0
Groups          : None
Provides        : rust  cargo  rust-nightly  cargo-nightly  rustfmt  rust-src  lib32-rust-libs  rust-musl  rust-wasm  rust-analyzer
...

If rustup is installed we ensure in the PKGBUILD that the rust-src component is also available:

  if rustup --help >/dev/null 2>&1; then
    echo "Installing rust-src"
    rustup component add rust-src
  fi

To ease debugging if something in the toolchain isn't working we call the rustavailable kernel make target, which will output if something is missing:

  echo "Verifying that Rust support is available"
  make LLVM=1 rustavailable

Since one of my main goals was to support building out-of-tree Rust kernel modules, I wanted to store the rust toolchain used, so that a user which has rustup available can simply use the same Rust version to compile a kernel module. This turned out to be a bit tricker than expected.

Just doing the most straightforward thing:

rustc --version | cut -d' ' -f 2 > "$srcdir/rust-toolchain"

failed with the following error:

error: in /home/roughl/projects/archpkg/linux-rust/src/rust-toolchain: empty toolchain override file detected. Please remove it, or else specify the desired toolchain properties in the file

The reason is, that the shell redirection of the output into a file (>"$srcdir/rust-toolchain"), will first create the file empty, then startrustc. Now therustcbinstub fromrustupwill see that there is arust-toolchainfile present when doing therustc --version` call, but since it is empty it complains.

To fix this issue we need to first determine the version and then pipe it into a file:

  rust_version=$(rustc --version | cut -d' ' -f 2)
  echo "$rust_version" > "$srcdir/rust-toolchain"

Looking forward

Since we can now build the Linux kernel with Rust support using the distro packages it should be possible to build it in a clean chroot environment and thus there shouldn't be much in the way of Rust support landing in official kernel packages.