Commit ec7714e4 authored by Linus Torvalds's avatar Linus Torvalds
Browse files
Pull Rust updates from Miguel Ojeda:
 "Toolchain and infrastructure:

   - KUnit '#[test]'s:

      - Support KUnit-mapped 'assert!' macros.

        The support that landed last cycle was very basic, and the
        'assert!' macros panicked since they were the standard library
        ones. Now, they are mapped to the KUnit ones in a similar way to
        how is done for doctests, reusing the infrastructure there.

        With this, a failing test like:

            #[test]
            fn my_first_test() {
                assert_eq!(42, 43);
            }

        will report:

            # my_first_test: ASSERTION FAILED at rust/kernel/lib.rs:251
            Expected 42 == 43 to be true, but is false
            # my_first_test.speed: normal
            not ok 1 my_first_test

      - Support tests with checked 'Result' return types.

        The return value of test functions that return a 'Result' will
        be checked, thus one can now easily catch errors when e.g. using
        the '?' operator in tests.

        With this, a failing test like:

            #[test]
            fn my_test() -> Result {
                f()?;
                Ok(())
            }

        will report:

            # my_test: ASSERTION FAILED at rust/kernel/lib.rs:321
            Expected is_test_result_ok(my_test()) to be true, but is false
            # my_test.speed: normal
            not ok 1 my_test

      - Add 'kunit_tests' to the prelude.

   - Clarify the remaining language unstable features in use.

   - Compile 'core' with edition 2024 for Rust >= 1.87.

   - Workaround 'bindgen' issue with forward references to 'enum' types.

   - objtool: relax slice condition to cover more 'noreturn' functions.

   - Use absolute paths in macros referencing 'core' and 'kernel'
     crates.

   - Skip '-mno-fdpic' flag for bindgen in GCC 32-bit arm builds.

   - Clean some 'doc_markdown' lint hits -- we may enable it later on.

  'kernel' crate:

   - 'alloc' module:

      - 'Box': support for type coercion, e.g. 'Box<T>' to 'Box<dyn U>'
        if 'T' implements 'U'.

      - 'Vec': implement new methods (prerequisites for nova-core and
        binder): 'truncate', 'resize', 'clear', 'pop',
        'push_within_capacity' (with new error type 'PushError'),
        'drain_all', 'retain', 'remove' (with new error type
        'RemoveError'), insert_within_capacity' (with new error type
        'InsertError').

        In addition, simplify 'push' using 'spare_capacity_mut', split
        'set_len' into 'inc_len' and 'dec_len', add type invariant 'len
        <= capacity' and simplify 'truncate' using 'dec_len'.

   - 'time' module:

      - Morph the Rust hrtimer subsystem into the Rust timekeeping
        subsystem, covering delay, sleep, timekeeping, timers. This new
        subsystem has all the relevant timekeeping C maintainers listed
        in the entry.

      - Replace 'Ktime' with 'Delta' and 'Instant' types to represent a
        duration of time and a point in time.

      - Temporarily add 'Ktime' to 'hrtimer' module to allow 'hrtimer'
        to delay converting to 'Instant' and 'Delta'.

   - 'xarray' module:

      - Add a Rust abstraction for the 'xarray' data structure. This
        abstraction allows Rust code to leverage the 'xarray' to store
        types that implement 'ForeignOwnable'. This support is a
        dependency for memory backing feature of the Rust null block
        driver, which is waiting to be merged.

      - Set up an entry in 'MAINTAINERS' for the XArray Rust support.
        Patches will go to the new Rust XArray tree and then via the
        Rust subsystem tree for now.

      - Allow 'ForeignOwnable' to carry information about the pointed-to
        type. This helps asserting alignment requirements for the
        pointer passed to the foreign language.

   - 'container_of!': retain pointer mut-ness and add a compile-time
     check of the type of the first parameter ('$field_ptr').

   - Support optional message in 'static_assert!'.

   - Add C FFI types (e.g. 'c_int') to the prelude.

   - 'str' module: simplify KUnit tests 'format!' macro, convert
     'rusttest' tests into KUnit, take advantage of the '-> Result'
     support in KUnit '#[test]'s.

   - 'list' module: add examples for 'List', fix path of
     'assert_pinned!' (so far unused macro rule).

   - 'workqueue' module: remove 'HasWork::OFFSET'.

   - 'page' module: add 'inline' attribute.

  'macros' crate:

   - 'module' macro: place 'cleanup_module()' in '.exit.text' section.

  'pin-init' crate:

   - Add 'Wrapper<T>' trait for creating pin-initializers for wrapper
     structs with a structurally pinned value such as 'UnsafeCell<T>' or
     'MaybeUninit<T>'.

   - Add 'MaybeZeroable' derive macro to try to derive 'Zeroable', but
     not error if not all fields implement it. This is needed to derive
     'Zeroable' for all bindgen-generated structs.

   - Add 'unsafe fn cast_[pin_]init()' functions to unsafely change the
     initialized type of an initializer. These are utilized by the
     'Wrapper<T>' implementations.

   - Add support for visibility in 'Zeroable' derive macro.

   - Add support for 'union's in 'Zeroable' derive macro.

   - Upstream dev news: streamline CI, fix some bugs. Add new workflows
     to check if the user-space version and the one in the kernel tree
     have diverged. Use the issues tab [1] to track them, which should
     help folks report and diagnose issues w.r.t. 'pin-init' better.

       [1] https://github.com/rust-for-linux/pin-init/issues

  Documentation:

   - Testing: add docs on the new KUnit '#[test]' tests.

   - Coding guidelines: explain that '///' vs. '//' applies to private
     items too. Add section on C FFI types.

   - Quick Start guide: update Ubuntu instructions and split them into
     "25.04" and "24.04 LTS and older".

  And a few other cleanups and improvements"

* tag 'rust-6.16' of git://git.kernel.org/pub/scm/linux/kernel/git/ojeda/linux: (78 commits)
  rust: list: Fix typo `much` in arc.rs
  rust: check type of `$ptr` in `container_of!`
  rust: workqueue: remove HasWork::OFFSET
  rust: retain pointer mut-ness in `container_of!`
  Documentation: rust: testing: add docs on the new KUnit `#[test]` tests
  Documentation: rust: rename `#[test]`s to "`rusttest` host tests"
  rust: str: take advantage of the `-> Result` support in KUnit `#[test]`'s
  rust: str: simplify KUnit tests `format!` macro
  rust: str: convert `rusttest` tests into KUnit
  rust: add `kunit_tests` to the prelude
  rust: kunit: support checked `-> Result`s in KUnit `#[test]`s
  rust: kunit: support KUnit-mapped `assert!` macros in `#[test]`s
  rust: make section names plural
  rust: list: fix path of `assert_pinned!`
  rust: compile libcore with edition 2024 for 1.87+
  rust: dma: add missing Markdown code span
  rust: task: add missing Markdown code spans and intra-doc links
  rust: pci: fix docs related to missing Markdown code spans
  rust: alloc: add missing Markdown code span
  rust: alloc: add missing Markdown code spans
  ...
parents 64980441 7a17bbc1
Loading
Loading
Loading
Loading
+1 −0
Original line number Diff line number Diff line
@@ -135,6 +135,7 @@ Ben Widawsky <bwidawsk@kernel.org> <benjamin.widawsky@intel.com>
Benjamin Poirier <benjamin.poirier@gmail.com> <bpoirier@suse.de>
Benjamin Tissoires <bentiss@kernel.org> <benjamin.tissoires@gmail.com>
Benjamin Tissoires <bentiss@kernel.org> <benjamin.tissoires@redhat.com>
Benno Lossin <lossin@kernel.org> <benno.lossin@proton.me>
Bingwu Zhang <xtex@aosc.io> <xtexchooser@duck.com>
Bingwu Zhang <xtex@aosc.io> <xtex@xtexx.eu.org>
Bjorn Andersson <andersson@kernel.org> <bjorn@kryo.se>
+29 −0
Original line number Diff line number Diff line
@@ -85,6 +85,18 @@ written after the documentation, e.g.:
	    // ...
	}

This applies to both public and private items. This increases consistency with
public items, allows changes to visibility with less changes involved and will
allow us to potentially generate the documentation for private items as well.
In other words, if documentation is written for a private item, then ``///``
should still be used. For instance:

.. code-block:: rust

	/// My private function.
	// TODO: ...
	fn f() {}

One special kind of comments are the ``// SAFETY:`` comments. These must appear
before every ``unsafe`` block, and they explain why the code inside the block is
correct/sound, i.e. why it cannot trigger undefined behavior in any case, e.g.:
@@ -191,6 +203,23 @@ or:
	/// [`struct mutex`]: srctree/include/linux/mutex.h


C FFI types
-----------

Rust kernel code refers to C types, such as ``int``, using type aliases such as
``c_int``, which are readily available from the ``kernel`` prelude. Please do
not use the aliases from ``core::ffi`` -- they may not map to the correct types.

These aliases should generally be referred directly by their identifier, i.e.
as a single segment path. For instance:

.. code-block:: rust

	fn f(p: *const c_char) -> c_int {
	    // ...
	}


Naming
------

+41 −3
Original line number Diff line number Diff line
@@ -90,15 +90,53 @@ they should generally work out of the box, e.g.::
Ubuntu
******

Ubuntu LTS and non-LTS (interim) releases provide recent Rust releases and thus
they should generally work out of the box, e.g.::
25.04
~~~~~

The latest Ubuntu releases provide recent Rust releases and thus they should
generally work out of the box, e.g.::

	apt install rustc rust-src bindgen rustfmt rust-clippy

In addition, ``RUST_LIB_SRC`` needs to be set, e.g.::

	RUST_LIB_SRC=/usr/src/rustc-$(rustc --version | cut -d' ' -f2)/library

For convenience, ``RUST_LIB_SRC`` can be exported to the global environment.

	apt install rustc-1.80 rust-1.80-src bindgen-0.65 rustfmt-1.80 rust-1.80-clippy

24.04 LTS and older
~~~~~~~~~~~~~~~~~~~

Though Ubuntu 24.04 LTS and older versions still provide recent Rust
releases, they require some additional configuration to be set, using
the versioned packages, e.g.::

	apt install rustc-1.80 rust-1.80-src bindgen-0.65 rustfmt-1.80 \
		rust-1.80-clippy
	ln -s /usr/lib/rust-1.80/bin/rustfmt /usr/bin/rustfmt-1.80
	ln -s /usr/lib/rust-1.80/bin/clippy-driver /usr/bin/clippy-driver-1.80

None of these packages set their tools as defaults; therefore they should be
specified explicitly, e.g.::

	make LLVM=1 RUSTC=rustc-1.80 RUSTDOC=rustdoc-1.80 RUSTFMT=rustfmt-1.80 \
		CLIPPY_DRIVER=clippy-driver-1.80 BINDGEN=bindgen-0.65

Alternatively, modify the ``PATH`` variable to place the Rust 1.80 binaries
first and set ``bindgen`` as the default, e.g.::

	PATH=/usr/lib/rust-1.80/bin:$PATH
	update-alternatives --install /usr/bin/bindgen bindgen \
		/usr/bin/bindgen-0.65 100
	update-alternatives --set bindgen /usr/bin/bindgen-0.65

``RUST_LIB_SRC`` needs to be set when using the versioned packages, e.g.::

	RUST_LIB_SRC=/usr/src/rustc-$(rustc-1.80 --version | cut -d' ' -f2)/library

For convenience, ``RUST_LIB_SRC`` can be exported to the global environment.

In addition, ``bindgen-0.65`` is available in newer releases (24.04 LTS and
24.10), but it may not be available in older ones (20.04 LTS and 22.04 LTS),
thus ``bindgen`` may need to be built manually (please see below).
+76 −4
Original line number Diff line number Diff line
@@ -133,13 +133,85 @@ please see:
The ``#[test]`` tests
---------------------

Additionally, there are the ``#[test]`` tests. These can be run using the
``rusttest`` Make target::
Additionally, there are the ``#[test]`` tests. Like for documentation tests,
these are also fairly similar to what you would expect from userspace, and they
are also mapped to KUnit.

These tests are introduced by the ``kunit_tests`` procedural macro, which takes
the name of the test suite as an argument.

For instance, assume we want to test the function ``f`` from the documentation
tests section. We could write, in the same file where we have our function:

.. code-block:: rust

	#[kunit_tests(rust_kernel_mymod)]
	mod tests {
	    use super::*;

	    #[test]
	    fn test_f() {
	        assert_eq!(f(10, 20), 30);
	    }
	}

And if we run it, the kernel log would look like::

	    KTAP version 1
	    # Subtest: rust_kernel_mymod
	    # speed: normal
	    1..1
	    # test_f.speed: normal
	    ok 1 test_f
	ok 1 rust_kernel_mymod

Like documentation tests, the ``assert!`` and ``assert_eq!`` macros are mapped
back to KUnit and do not panic. Similarly, the
`? <https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator>`_
operator is supported, i.e. the test functions may return either nothing (i.e.
the unit type ``()``) or ``Result`` (i.e. any ``Result<T, E>``). For instance:

.. code-block:: rust

	#[kunit_tests(rust_kernel_mymod)]
	mod tests {
	    use super::*;

	    #[test]
	    fn test_g() -> Result {
	        let x = g()?;
	        assert_eq!(x, 30);
	        Ok(())
	    }
	}

If we run the test and the call to ``g`` fails, then the kernel log would show::

	    KTAP version 1
	    # Subtest: rust_kernel_mymod
	    # speed: normal
	    1..1
	    # test_g: ASSERTION FAILED at rust/kernel/lib.rs:335
	    Expected is_test_result_ok(test_g()) to be true, but is false
	    # test_g.speed: normal
	    not ok 1 test_g
	not ok 1 rust_kernel_mymod

If a ``#[test]`` test could be useful as an example for the user, then please
use a documentation test instead. Even edge cases of an API, e.g. error or
boundary cases, can be interesting to show in examples.

The ``rusttest`` host tests
---------------------------

These are userspace tests that can be built and run in the host (i.e. the one
that performs the kernel build) using the ``rusttest`` Make target::

	make LLVM=1 rusttest

This requires the kernel ``.config``. It runs the ``#[test]`` tests on the host
(currently) and thus is fairly limited in what these tests can test.
This requires the kernel ``.config``.

Currently, they are mostly used for testing the ``macros`` crate's examples.

The Kselftests
--------------
+20 −6
Original line number Diff line number Diff line
@@ -10719,20 +10719,23 @@ F: kernel/time/timer_list.c
F:	kernel/time/timer_migration.*
F:	tools/testing/selftests/timers/
HIGH-RESOLUTION TIMERS [RUST]
DELAY, SLEEP, TIMEKEEPING, TIMERS [RUST]
M:	Andreas Hindborg <a.hindborg@kernel.org>
R:	Boqun Feng <boqun.feng@gmail.com>
R:	FUJITA Tomonori <fujita.tomonori@gmail.com>
R:	Frederic Weisbecker <frederic@kernel.org>
R:	Lyude Paul <lyude@redhat.com>
R:	Thomas Gleixner <tglx@linutronix.de>
R:	Anna-Maria Behnsen <anna-maria@linutronix.de>
R:	John Stultz <jstultz@google.com>
R:	Stephen Boyd <sboyd@kernel.org>
L:	rust-for-linux@vger.kernel.org
S:	Supported
W:	https://rust-for-linux.com
B:	https://github.com/Rust-for-Linux/linux/issues
T:	git https://github.com/Rust-for-Linux/linux.git hrtimer-next
F:	rust/kernel/time/hrtimer.rs
F:	rust/kernel/time/hrtimer/
T:	git https://github.com/Rust-for-Linux/linux.git timekeeping-next
F:	rust/kernel/time.rs
F:	rust/kernel/time/
HIGH-SPEED SCC DRIVER FOR AX.25
L:	linux-hams@vger.kernel.org
@@ -21588,7 +21591,7 @@ M: Alex Gaynor <alex.gaynor@gmail.com>
R:	Boqun Feng <boqun.feng@gmail.com>
R:	Gary Guo <gary@garyguo.net>
R:	Björn Roy Baron <bjorn3_gh@protonmail.com>
R:	Benno Lossin <benno.lossin@proton.me>
R:	Benno Lossin <lossin@kernel.org>
R:	Andreas Hindborg <a.hindborg@kernel.org>
R:	Alice Ryhl <aliceryhl@google.com>
R:	Trevor Gross <tmgross@umich.edu>
@@ -21618,7 +21621,7 @@ F: rust/kernel/alloc.rs
F:	rust/kernel/alloc/
RUST [PIN-INIT]
M:	Benno Lossin <benno.lossin@proton.me>
M:	Benno Lossin <lossin@kernel.org>
L:	rust-for-linux@vger.kernel.org
S:	Maintained
W:	https://rust-for-linux.com/pin-init
@@ -26829,6 +26832,17 @@ F: lib/test_xarray.c
F:	lib/xarray.c
F:	tools/testing/radix-tree
XARRAY API [RUST]
M:	Tamir Duberstein <tamird@gmail.com>
M:	Andreas Hindborg <a.hindborg@kernel.org>
L:	rust-for-linux@vger.kernel.org
S:	Supported
W:	https://rust-for-linux.com
B:	https://github.com/Rust-for-Linux/linux/issues
C:	https://rust-for-linux.zulipchat.com
T:	git https://github.com/Rust-for-Linux/linux.git xarray-next
F:	rust/kernel/xarray.rs
XBOX DVD IR REMOTE
M:	Benjamin Valentin <benpicco@googlemail.com>
S:	Maintained
Loading