linux-stable.git/rust, branch linux-6.2.y

rust: kernel: Mark rust_fmt_argument as extern "C"

2023-04-26T12:30:02+00:00

commit c682e4c37d2b8ba3bde1125cbbea4ee88824b4e2 upstream.

The rust_fmt_argument function is called from printk() to handle the %pA
format specifier.

Since it's called from C, we should mark it extern "C" to make sure it's
ABI compatible.

Cc: stable@vger.kernel.org
Fixes: 247b365dc8dc ("rust: add `kernel` crate")
Signed-off-by: David Gow 
Reviewed-by: Gary Guo 
Reviewed-by: Björn Roy Baron 
Reviewed-by: Vincenzo Palazzo 
[Applied `rustfmt`]
Signed-off-by: Miguel Ojeda 
Signed-off-by: Greg Kroah-Hartman

rust: str: fix requierments->requirements typo

2023-04-26T12:29:55+00:00

[ Upstream commit 88e8c2ec4ab84f9f05ed5af9693a3972baf386c4 ]

Fix a trivial spelling error in the `rust/kernel/str.rs` file.

Fixes: 247b365dc8dc ("rust: add `kernel` crate")
Reported-by: Miguel Ojeda 
Link: https://github.com/Rust-for-Linux/linux/issues/978
Signed-off-by: Patrick Blass 
Reviewed-by: Vincenzo Palazzo 
[Reworded slightly]
Signed-off-by: Miguel Ojeda 
Signed-off-by: Sasha Levin

rust: print: avoid evaluating arguments in `pr_*` macros in `unsafe` blocks

2023-01-15T23:54:35+00:00

At the moment it is possible to perform unsafe operations in
the arguments of `pr_*` macros since they are evaluated inside
an `unsafe` block:

    let x = &10u32 as *const u32;
    pr_info!("{}", *x);

In other words, this is a soundness issue.

Fix it so that it requires an explicit `unsafe` block.

Reported-by: Wedson Almeida Filho 
Reported-by: Domen Puncer Kugler 
Link: https://github.com/Rust-for-Linux/linux/issues/479
Signed-off-by: Miguel Ojeda 
Reviewed-by: Boqun Feng 
Reviewed-by: Gary Guo 
Reviewed-by: Björn Roy Baron 
Reviewed-by: Vincenzo Palazzo

rust: types: add `Opaque` type

2022-12-04T00:59:16+00:00

Add the `Opaque` type, which is meant to be used with FFI objects
that are never interpreted by Rust code, e.g.:

    struct Waiter {
        completion: Opaque,
        next: *mut Waiter,
    }

It has the advantage that the objects don't have to be
zero-initialised before calling their init functions, making
the code performance closer to C.

Signed-off-by: Wedson Almeida Filho 
[Reworded, adapted for upstream and applied latest changes]
Signed-off-by: Miguel Ojeda

rust: types: add `Either` type

2022-12-04T00:59:16+00:00

Introduce the new `types` module of the `kernel` crate with
`Either` as its first type.

`Either` is a sum type that always holds either a value
of type `L` (`Left` variant) or `R` (`Right` variant).

For instance:

    struct Executor {
        queue: Either,
    }

Signed-off-by: Wedson Almeida Filho 
Reviewed-by: Wei Liu 
[Reworded, adapted for upstream and applied latest changes]
Signed-off-by: Miguel Ojeda

rust: build_assert: add `build_{error,assert}!` macros

2022-12-04T00:59:16+00:00

Add the `build_error!` and `build_assert!` macros which leverage
the previously introduced `build_error` crate. Do so in a new
module, called `build_assert`.

The former fails the build if the code path calling it can possibly
be executed. The latter asserts that a boolean expression is `true`
at compile time.

In particular, `build_assert!` can be used in some contexts where
`static_assert!` cannot:

    fn f1() {
        static_assert!(N > 1);` // Error.
        build_assert!(N > 1);   // Build-time check.
        assert!(N > 1);         // Run-time check.
    }

    #[inline]
    fn f2(n: usize) {
        static_assert!(n > 1);  // Error.
        build_assert!(n > 1);   // Build-time check.
        assert!(n > 1);         // Run-time check.
    }

Signed-off-by: Gary Guo 
Reviewed-by: Wei Liu 
[Reworded, adapted for upstream and applied latest changes]
Signed-off-by: Miguel Ojeda

rust: add `build_error` crate

2022-12-04T00:59:16+00:00

The `build_error` crate provides a function `build_error` which
will panic at compile-time if executed in const context and,
by default, will cause a build error if not executed at compile
time and the optimizer does not optimise away the call.

The `CONFIG_RUST_BUILD_ASSERT_ALLOW` kernel option allows to
relax the default build failure and convert it to a runtime
check. If the runtime check fails, `panic!` will be called.

Its functionality will be exposed to users as a couple macros in
the `kernel` crate in the following patch, thus some documentation
here refers to them for simplicity.

Signed-off-by: Gary Guo 
Reviewed-by: Wei Liu 
[Reworded, adapted for upstream and applied latest changes]
Signed-off-by: Miguel Ojeda

rust: static_assert: add `static_assert!` macro

2022-12-04T00:59:16+00:00

Add the `static_assert!` macro, which is a compile-time assert, similar
to the C11 `_Static_assert` and C++11 `static_assert` declarations [1,2].
Do so in a new module, called `static_assert`.

For instance:

    static_assert!(42 > 24);
    static_assert!(core::mem::size_of::() == 1);

    const X: &[u8] = b"bar";
    static_assert!(X[1] == b'a');

    const fn f(x: i32) -> i32 {
        x + 2
    }
    static_assert!(f(40) == 42);

Link: https://en.cppreference.com/w/c/language/_Static_assert [1]
Link: https://en.cppreference.com/w/cpp/language/static_assert [2]
Co-developed-by: Alex Gaynor 
Signed-off-by: Alex Gaynor 
Signed-off-by: Miguel Ojeda

rust: std_vendor: add `dbg!` macro based on `std`'s one

2022-12-04T00:59:16+00:00

The Rust standard library has a really handy macro, `dbg!` [1,2].
It prints the source location (filename and line) along with the raw
source code that is invoked with and the `Debug` representation
of the given expression, e.g.:

    let a = 2;
    let b = dbg!(a * 2) + 1;
    //      ^-- prints: [src/main.rs:2] a * 2 = 4
    assert_eq!(b, 5);

Port the macro over to the `kernel` crate inside a new module
called `std_vendor`, using `pr_info!` instead of `eprintln!` and
make the rules about committing uses of `dbg!` into version control
more concrete (i.e. tailored for the kernel).

Since the source code for the macro is taken from the standard
library source (with only minor adjustments), the new file is
licensed under `Apache 2.0 OR MIT`, just like the original [3,4].

Link: https://doc.rust-lang.org/std/macro.dbg.html [1]
Link: https://github.com/rust-lang/rust/blob/master/library/std/src/macros.rs#L212 [2]
Link: https://github.com/rust-lang/rust/blob/master/library/std/Cargo.toml [3]
Link: https://github.com/rust-lang/rust/blob/master/COPYRIGHT [4]
Signed-off-by: Niklas Mohrin 
[Reworded, adapted for upstream and applied latest changes]
Signed-off-by: Miguel Ojeda

rust: str: add `fmt!` macro

2022-12-04T00:59:16+00:00

Add the `fmt!` macro, which is a convenience alias for the Rust
`core::format_args!` macro.

For instance, it may be used to create a `CString`:

    CString::try_from_fmt(fmt!("{}{}", "abc", 42))?

Signed-off-by: Wedson Almeida Filho 
Reviewed-by: Gary Guo 
[Reworded, adapted for upstream and applied latest changes]
Signed-off-by: Miguel Ojeda