add `const_assert!` macro and rework documentation
Subsystems (16)
v3 cover add `const_assert!` macro and rework documentation
From: Gary Guo <[email protected]>
This adds the const_assert! macro, rework documentation of all build-time assertion macros to live under build_assert module, and make that the canonical path to refer to these macros.
The Rust documentation rendering side can be tested out with make rustdoc command.
Changes since v2:
- Rebased on top of latest linux-next to pick up register! changes
- Drop the unintended removal of #[inline(always)] doc on
build_assert! (Sashiko)
- Remove imports covered by prelude (Danilo)
- Fix references in Nova and new register! macro
- Link to v2: https://lore.kernel.org/rust-for-linux/[email protected]/
Changes since v1:
- Completely overhaul of the documentation
- Make kernel::build_assert the canonical path to refer to related macros
- Link to v1: https://lore.kernel.org/rust-for-linux/[email protected]/
Gary Guo (4):
rust: move static_assert into build_assert
rust: add const_assert! macro
rust: rework build_assert! documentation
rust: make build_assert module the home of related macros
drivers/gpu/nova-core/bitfield.rs | 4 +- drivers/gpu/nova-core/num.rs | 2 +- rust/kernel/build_assert.rs | 200 ++++++++++++++++++++++----- rust/kernel/dma.rs | 5 +- rust/kernel/io/register.rs | 19 ++- rust/kernel/io/resource.rs | 2 +- rust/kernel/ioctl.rs | 2 +- rust/kernel/lib.rs | 2 - rust/kernel/net/phy/reg.rs | 8 +- rust/kernel/num/bounded.rs | 26 ++-- rust/kernel/prelude.rs | 10 +- rust/kernel/ptr.rs | 12 +- rust/kernel/static_assert.rs | 39 ------ rust/kernel/sync/atomic/internal.rs | 9 +- rust/kernel/sync/atomic/predefine.rs | 2 +- rust/kernel/sync/locked_by.rs | 2 +- rust/kernel/sync/refcount.rs | 8 +- rust/kernel/xarray.rs | 10 +- scripts/Makefile.build | 5 +- 19 files changed, 236 insertions(+), 131 deletions(-) delete mode 100644 rust/kernel/static_assert.rs
base-commit: 8e42d2514a7e8eb8d740d0ba82339dd6c0b6463f
Signature · 1 line
2.51.2
PATCH v3 1/4 rust: move `static_assert` into `build_assert`
From: Gary Guo <[email protected]>
Conceptually, static_assert is also a build-time assertion that occurs earlier in the pipeline. Consolidate the implementation so that we can use this as the canonical place to add more useful build-time assertions.
--- rust/kernel/build_assert.rs | 40 +++++++++++++++++++++++++++++++++--- rust/kernel/lib.rs | 1 - rust/kernel/prelude.rs | 4 +--- rust/kernel/static_assert.rs | 39 ----------------------------------- 4 files changed, 38 insertions(+), 46 deletions(-) delete mode 100644 rust/kernel/static_assert.rs
rust/kernel/build_assert.rs +37 -3
@@ -1,10 +1,46 @@// SPDX-License-Identifier: GPL-2.0 -//! Build-time assert. +//! Various assertions that happen during build-time. #[doc(hidden)] pub use build_error::build_error; +/// Static assert (i.e. compile-time assert). +/// +/// Similar to C11 [`_Static_assert`] and C++11 [`static_assert`]. +/// +/// An optional panic message can be supplied after the expression. +/// Currently only a string literal without formatting is supported +/// due to constness limitations of the [`assert!`] macro. +/// +/// The feature may be added to Rust in the future: see [RFC 2790]. +/// +/// [`_Static_assert`]: https://en.cppreference.com/w/c/language/_Static_assert +/// [`static_assert`]: https://en.cppreference.com/w/cpp/language/static_assert +/// [RFC 2790]: https://github.com/rust-lang/rfcs/issues/2790 +/// +/// # Examples +/// +/// ``` +/// static_assert!(42 > 24); +/// static_assert!(core::mem::size_of::<u8>() == 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); +/// static_assert!(f(40) == 42, "f(x) must add 2 to the given input."); +/// ``` +#[macro_export] +macro_rules! static_assert { + ($condition:expr $(,$arg:literal)?) => { +const _: () = ::core::assert!($condition $(,$arg)?); + }; +} +/// Fails the build if the code path calling `build_error!` can possibly be executed. /// /// If the macro is executed in const context, `build_error!` will panic.
@@ -74,8 +110,6 @@ macro_rules! build_error {/// assert!(n > 1); // Run-time check /// } /// ``` -/// -/// [`static_assert!`]: crate::static_assert! #[macro_export] macro_rules! build_assert { ($cond:expr $(,)?) => {{
rust/kernel/lib.rs +0 -1
@@ -151,7 +151,6 @@pub mod slice;#[cfg( CONFIG_SOC_BUS )] pub mod soc; -mod static_assert;#[doc(hidden)] pub mod std_vendor;pub mod str;
rust/kernel/prelude.rs +1 -3
@@ -29,7 +29,7 @@pub use pin_init::{init, pin_data, pin_init, pinned_drop,InPlaceWrite ,Init ,PinInit ,Zeroable }; -pub use super ::{build_assert, build_error}; +pub use super ::{build_assert, build_error, static_assert};// `super::std_vendor` is hidden, which makes the macro inline for some reason. #[doc(no_inline)]
@@ -39,8 +39,6 @@pub use super ::{try_init, try_pin_init}; -pub use super ::static_assert; -pub use super ::error::{code::*,Error ,Result };pub use super ::{str::CStrExt as _,ThisModule };
rust/kernel/static_assert.rs deleted +0 -39
@@ -1,39 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0 - -//! Static assert. - -/// Static assert (i.e. compile-time assert). -/// -/// Similar to C11 [`_Static_assert`] and C++11 [`static_assert`]. -/// -/// An optional panic message can be supplied after the expression. -/// Currently only a string literal without formatting is supported -/// due to constness limitations of the [`assert!`] macro. -/// -/// The feature may be added to Rust in the future: see [RFC 2790]. -/// -/// [`_Static_assert`]: https://en.cppreference.com/w/c/language/_Static_assert -/// [`static_assert`]: https://en.cppreference.com/w/cpp/language/static_assert -/// [RFC 2790]: https://github.com/rust-lang/rfcs/issues/2790 -/// -/// # Examples -/// -/// ``` -/// static_assert!(42 > 24); -/// static_assert!(core::mem::size_of::<u8>() == 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); -/// static_assert!(f(40) == 42, "f(x) must add 2 to the given input."); -/// ``` -#[macro_export] -macro_rules! static_assert { - ($condition:expr $(,$arg:literal)?) => { -const _: () = ::core::assert!($condition $(,$arg)?); - }; -}
Signature · 1 line
2.51.2
PATCH v3 2/4 rust: add `const_assert!` macro
In reply to Gary GuoFrom: Gary Guo <[email protected]>
The macro is a more powerful version of static_assert! for use inside function contexts. This is powered by inline consts, so enable the feature for old compiler versions that does not have it stably.
While it is possible already to write const { assert!(...) }, this provides a short hand that is more uniform with other assertions. It also formats nicer with rustfmt where it will not be formatted into multiple lines.
Two users that would route via the Rust tree are converted.
--- rust/kernel/build_assert.rs | 24 ++++++++++++++++++++++++ rust/kernel/num/bounded.rs | 24 +++++++++--------------- rust/kernel/prelude.rs | 7 ++++++- rust/kernel/ptr.rs | 12 ++++++------ scripts/Makefile.build | 5 +++-- 5 files changed, 48 insertions(+), 24 deletions(-)
rust/kernel/build_assert.rs +24 -0
@@ -41,6 +41,30 @@ macro_rules! static_assert { }; } +/// Assertion during constant evaluation. +/// +/// This is a more powerful version of [`static_assert!`] that can refer to generics inside +/// functions or implementation blocks. However, it also has a limitation where it can only appear +/// in places where statements can appear; for example, you cannot use it as an item in the module. +/// +/// # Examples +/// +/// ``` +/// fn foo<const N: usize>() { +/// const_assert!(N > 1); +/// } +/// +/// fn bar<T>() { +/// const_assert!(size_of::<T>() > 0, "T cannot be ZST"); +/// } +/// ``` +#[macro_export] +macro_rules! const_assert { + ($condition:expr $(,$arg:literal)?) => { +const { ::core::assert!($condition $(,$arg)?) }; + }; +} +/// Fails the build if the code path calling `build_error!` can possibly be executed. /// /// If the macro is executed in const context, `build_error!` will panic.
rust/kernel/num/bounded.rs +9 -15
@@ -255,9 +255,7 @@ impl<const N: u32> Bounded<$type, N> {/// ``` pub const fn new <const VALUE : $type>() ->Self {// Statically assert that `VALUE` fits within the set number of bits. -const { -assert! (fits_within! (VALUE , $type ,N )); - } +const_assert! (fits_within! (VALUE , $type ,N ));// SAFETY: `fits_within` confirmed that `VALUE` can be represented within // `N` bits.
@@ -287,12 +285,10 @@ impl<T, const N: u32> Bounded<T, N>/// The caller must ensure that `value` can be represented within `N` bits. const unsafe fn __new (value:T ) ->Self {// Enforce the type invariants. -const { -// `N` cannot be zero. -assert! (N !=0 ); -// The backing type is at least as large as `N` bits. -assert! (N <=T ::BITS ); - } +// `N` cannot be zero. +const_assert! (N !=0 ); +// The backing type is at least as large as `N` bits. +const_assert! (N <=T ::BITS );// INVARIANT: The caller ensures `value` fits within `N` bits. Self (value)
@@ -409,12 +405,10 @@ pub const fn get(self) -> T {/// assert_eq!(larger_v, v); /// ``` pub const fn extend <const M :u32 >(self) ->Bounded <T ,M > { -const { -assert! ( -M >=N , -"Requested number of bits is less than the current representation." - ); - } +const_assert! ( +M >=N , +"Requested number of bits is less than the current representation." + );// SAFETY: The value did fit within `N` bits, so it will all the more fit within // the larger `M` bits.
rust/kernel/prelude.rs +6 -1
@@ -29,7 +29,12 @@pub use pin_init::{init, pin_data, pin_init, pinned_drop,InPlaceWrite ,Init ,PinInit ,Zeroable }; -pub use super ::{build_assert, build_error, static_assert}; +pub use super ::{ + build_assert, + build_error, + const_assert, + static_assert,// +};// `super::std_vendor` is hidden, which makes the macro inline for some reason. #[doc(no_inline)]
rust/kernel/ptr.rs +6 -6
@@ -11,6 +11,8 @@ };use core::num::NonZero ; +use crate ::const_assert; +/// Type representing an alignment, which is always a power of two. /// /// It is used to validate that a given value is a valid alignment, and to perform masking and
@@ -44,12 +46,10 @@ impl Alignment {/// ``` #[inline(always)] pub const fn new <const ALIGN :usize >() ->Self { -const { -assert! ( -ALIGN .is_power_of_two (), -"Provided alignment is not a power of two." - ); - } +const_assert! ( +ALIGN .is_power_of_two (), +"Provided alignment is not a power of two." + );// INVARIANT: `align` is a power of two. // SAFETY: `align` is a power of two, and thus non-zero.
scripts/Makefile.build +3 -2
@@ -310,7 +310,8 @@ $(obj)/%.lst: $(obj)/%.c FORCE # The features in this list are the ones allowed for non-`rust/` code. # -# - Stable since Rust 1.79.0: `feature(slice_ptr_len)`. +# - Stable since Rust 1.79.0: `feature(inline_const)`, +# `feature(slice_ptr_len)`, # - Stable since Rust 1.81.0: `feature(lint_reasons)`. # - Stable since Rust 1.82.0: `feature(asm_const)`, # `feature(offset_of_nested)`, `feature(raw_ref_op)`.
@@ -322,7 +323,7 @@ $(obj)/%.lst: $(obj)/%.c FORCE # # Please see https://github.com/Rust-for-Linux/linux/issues/2 for details on # the unstable features in use. -rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,generic_arg_infer,lint_reasons,offset_of_nested,raw_ref_op,slice_ptr_len,strict_provenance,used_with_arg +rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,generic_arg_infer,inline_const,lint_reasons,offset_of_nested,raw_ref_op,slice_ptr_len,strict_provenance,used_with_arg # `--out-dir` is required to avoid temporaries being created by `rustc` in the # current working directory, which may be not accessible in the out-of-tree
Signature · 1 line
2.51.2
PATCH v3 3/4 rust: rework `build_assert!` documentation
In reply to Gary GuoFrom: Gary Guo <[email protected]>
Add a detailed comparison and recommendation of the three types of build-time assertion macro as module documentation (and un-hide the module to render them).
The documentation on the macro themselves are simplified to only cover the scenarios where they should be used; links to the module documentation is added instead.
--- rust/kernel/build_assert.rs | 119 ++++++++++++++++++++++++++++-------- rust/kernel/lib.rs | 1 - 2 files changed, 92 insertions(+), 28 deletions(-)
rust/kernel/build_assert.rs +92 -27
@@ -1,6 +1,72 @@// SPDX-License-Identifier: GPL-2.0 //! Various assertions that happen during build-time. +//! +//! There are three types of build-time assertions that you can use: +//! - [`static_assert!`] +//! - [`const_assert!`] +//! - [`build_assert!`] +//! +//! The ones towards the bottom of the list are more expressive, while the ones towards the top of +//! the list are more robust and trigger earlier in the compilation pipeline. Therefore, you should +//! prefer the ones towards the top of the list wherever possible. +//! +//! # Choosing the correct assertion +//! +//! If you're asserting outside any bodies (e.g. initializers or function bodies), you should use +//! [`static_assert!`] as it is the only assertion that can be used in that context. +//! +//! Inside bodies, if your assertion condition does not depend on any variable or generics, you +//! should use [`static_assert!`]. If the condition depends on generics, but not variables +//! (including function arguments), you should use [`const_assert!`]. Otherwise, use +//! [`build_assert!`]. The same is true regardless if the function is `const fn`. +//! +//! ``` +//! // Outside any bodies +//! static_assert!(core::mem::size_of::<u8>() == 1); +//! // `const_assert!` and `build_assert!` cannot be used here, they will fail to compile. +//! +//! #[inline(always)] +//! fn foo<const N: usize>(v: usize) { +//! static_assert!(core::mem::size_of::<u8>() == 1); // Preferred +//! const_assert!(core::mem::size_of::<u8>() == 1); // Discouraged +//! build_assert!(core::mem::size_of::<u8>() == 1); // Discouraged +//! +//! // `static_assert!(N > 1);` is not allowed +//! const_assert!(N > 1); // Preferred +//! build_assert!(N > 1); // Discouraged +//! +//! // `static_assert!(v > 1);` is not allowed +//! // `const_assert!(v > 1);` is not allowed +//! build_assert!(v > 1); // Works +//! } +//! ``` +//! +//! # Detailed behavior +//! +//! `static_assert!()` is equivalent to `static_assert` in C. It requires `expr` to be a constant +//! expression. This expression cannot refer to any generics. A `static_assert!(expr)` in a program +//! is always evaluated, regardless if the function it appears in is used or not. This is also the +//! only usable assertion outside a body. +//! +//! `const_assert!()` has no direct C equivalence. It is a more powerful version of +//! `static_assert!()`, where it may refer to generics in a function. Note that due to the ability +//! to refer to generics, the assertion is tied to a specific instance of a function. So if it is +//! used in a generic function that is not instantiated, the assertion will not be checked. For this +//! reason, `static_assert!()` is preferred wherever possible. +//! +//! `build_assert!()` is equivalent to `BUILD_BUG_ON`. It is even more powerful than +//! `const_assert!()` because it can be used to check tautologies that depend on runtime value (this +//! is the same as `BUILD_BUG_ON`). However, the assertion failure mechanism can possibly be +//! undefined symbols and linker errors, it is not developer friendly to debug, so it is recommended +//! to avoid it and prefer other two assertions where possible. + +pub use crate ::{ + build_assert, + build_error, + const_assert, + static_assert,// +};#[doc(hidden)] pub use build_error::build_error;
@@ -15,6 +81,10 @@/// /// The feature may be added to Rust in the future: see [RFC 2790]. /// +/// You cannot refer to generics or variables with [`static_assert!`]. If you need to refer to +/// generics, use [`const_assert!`]; if you need to refer to variables, use [`build_assert!`]. See +/// the [module documentation](self). +/// /// [`_Static_assert`]: https://en.cppreference.com/w/c/language/_Static_assert /// [`static_assert`]: https://en.cppreference.com/w/cpp/language/static_assert /// [RFC 2790]: https://github.com/rust-lang/rfcs/issues/2790
@@ -47,6 +117,10 @@ macro_rules! static_assert {/// functions or implementation blocks. However, it also has a limitation where it can only appear /// in places where statements can appear; for example, you cannot use it as an item in the module. /// +/// [`static_assert!`] should be preferred if no generics are referred to in the condition. You +/// cannot refer to variables with [`const_assert!`] (even inside `const fn`); if you need the +/// capability, use [`build_assert!`]. See the [module documentation](self). +/// /// # Examples /// /// ```
@@ -98,41 +172,32 @@ macro_rules! build_error {/// will panic. If the compiler or optimizer cannot guarantee the condition will /// be evaluated to `true`, a build error will be triggered. /// -/// [`static_assert!`] should be preferred to `build_assert!` whenever possible. +/// When a condition depends on a function argument, the function must be annotated with +/// `#[inline(always)]`. Without this attribute, the compiler may choose to not inline the +/// function, preventing it from optimizing out the error path. +/// +/// If the assertion condition does not depend on any variables or generics, you should use +/// [`static_assert!`]. If the assertion condition does not depend on variables, but does depend on +/// generics, you should use [`const_assert!`]. See the [module documentation](self). /// /// # Examples /// -/// These examples show that different types of [`assert!`] will trigger errors -/// at different stage of compilation. It is preferred to err as early as -/// possible, so [`static_assert!`] should be used whenever possible. -/// ```ignore -/// fn foo() { -/// static_assert!(1 > 1); // Compile-time error -/// build_assert!(1 > 1); // Build-time error -/// assert!(1 > 1); // Run-time error -/// } /// ``` +/// #[inline(always)] // Important +/// fn bar(n: usize) { +/// build_assert!(n > 1); +/// } /// -/// When the condition refers to generic parameters or parameters of an inline function, -/// [`static_assert!`] cannot be used. Use `build_assert!` in this scenario. -/// ``` -/// fn foo<const N: usize>() { -/// // `static_assert!(N > 1);` is not allowed -/// build_assert!(N > 1); // Build-time check -/// assert!(N > 1); // Run-time check +/// fn foo() { +/// bar(2); /// } -/// ``` /// -/// When a condition depends on a function argument, the function must be annotated with -/// `#[inline(always)]`. Without this attribute, the compiler may choose to not inline the -/// function, preventing it from optimizing out the error path. -/// ``` -/// #[inline(always)] -/// fn bar(n: usize) { -/// // `static_assert!(n > 1);` is not allowed -/// build_assert!(n > 1); // Build-time check -/// assert!(n > 1); // Run-time check +/// #[inline(always)] // Important +/// const fn const_bar(n: usize) { +/// build_assert!(n > 1); /// } +/// +/// const _: () = const_bar(2); /// ``` #[macro_export] macro_rules! build_assert {
rust/kernel/lib.rs +0 -1
@@ -80,7 +80,6 @@#[cfg( CONFIG_BLOCK )] pub mod block;pub mod bug; -#[doc(hidden)] pub mod build_assert;pub mod clk;#[cfg( CONFIG_CONFIGFS_FS )]
Signature · 1 line
2.51.2
PATCH v3 4/4 rust: make `build_assert` module the home of related macros
In reply to Gary GuoFrom: Gary Guo <[email protected]>
Given the macro scoping rules, all macros are rendered 3 times, in the module, in the top-level of kernel crate, and in the prelude.
Add #[doc(no_inline)] to the prelude so it just shows up as re-export. Add #[doc(hidden)] to the macro definition and #[doc(inline)] to the re-export inside build_assert module so the top-level items are hidden.
--- drivers/gpu/nova-core/bitfield.rs | 4 ++-- drivers/gpu/nova-core/num.rs | 2 +- rust/kernel/build_assert.rs | 19 ++++++++++++------- rust/kernel/dma.rs | 5 +++-- rust/kernel/io/register.rs | 19 ++++++++++++------- rust/kernel/io/resource.rs | 2 +- rust/kernel/ioctl.rs | 2 +- rust/kernel/net/phy/reg.rs | 8 +++++--- rust/kernel/num/bounded.rs | 2 +- rust/kernel/prelude.rs | 3 ++- rust/kernel/sync/atomic/internal.rs | 9 ++++++--- rust/kernel/sync/atomic/predefine.rs | 2 +- rust/kernel/sync/locked_by.rs | 2 +- rust/kernel/sync/refcount.rs | 8 +++++--- rust/kernel/xarray.rs | 10 ++++++++-- 15 files changed, 61 insertions(+), 36 deletions(-)
drivers/gpu/nova-core/bitfield.rs +2 -2
@@ -170,7 +170,7 @@ impl $name { (@check_field_bounds $hi:tt:$lo:tt $field:ident as bool) => {#[allow(clippy::eq_op)] const _: () = { - ::kernel::build_assert!( + ::kernel::build_assert::build_assert!( $hi == $lo,concat! ("boolean field `" ,stringify! ($field),"` covers more than one bit" ) );
@@ -181,7 +181,7 @@ impl $name { (@check_field_bounds $hi:tt:$lo:tt $field:ident as $type:tt) => {#[allow(clippy::eq_op)] const _: () = { - ::kernel::build_assert!( + ::kernel::build_assert::build_assert!( $hi >= $lo,concat! ("field `" ,stringify! ($field),"`'s MSB is smaller than its LSB" ) );
drivers/gpu/nova-core/num.rs +1 -1
@@ -49,7 +49,7 @@ macro_rules! impl_safe_as {#[allow(unused)] #[inline(always)] pub(crate) const fn [<$from _as_ $into>](value: $from) -> $into { - kernel::static_assert!(size_of ::<$into>() >=size_of ::<$from>()); + ::kernel::build_assert::static_assert!(size_of ::<$into>() >=size_of ::<$from>()); valueas $into }
rust/kernel/build_assert.rs +12 -7
@@ -61,15 +61,16 @@//! undefined symbols and linker errors, it is not developer friendly to debug, so it is recommended //! to avoid it and prefer other two assertions where possible. +#[doc(inline)] pub use crate ::{ - build_assert, + build_assert_macroas build_assert, build_error, const_assert, static_assert,// };#[doc(hidden)] -pub use build_error::build_error; +pub use build_error::build_erroras build_error_fn;/// Static assert (i.e. compile-time assert). ///
@@ -105,6 +106,7 @@/// static_assert!(f(40) == 42, "f(x) must add 2 to the given input."); /// ``` #[macro_export] +#[doc(hidden)] macro_rules! static_assert { ($condition:expr $(,$arg:literal)?) => {const _: () = ::core::assert!($condition $(,$arg)?);
@@ -133,6 +135,7 @@ macro_rules! static_assert {/// } /// ``` #[macro_export] +#[doc(hidden)] macro_rules! const_assert { ($condition:expr $(,$arg:literal)?) => {const { ::core::assert!($condition $(,$arg)?) };
@@ -157,12 +160,13 @@ macro_rules! const_assert {/// // foo(usize::MAX); // Fails to compile. /// ``` #[macro_export] +#[doc(hidden)] macro_rules! build_error { () => {{ - $crate::build_assert::build_error ("" ) + $crate::build_assert::build_error_fn ("" ) }}; ($msg:expr) => {{ - $crate::build_assert::build_error ($msg) + $crate::build_assert::build_error_fn ($msg) }}; }
@@ -200,15 +204,16 @@ macro_rules! build_error {/// const _: () = const_bar(2); /// ``` #[macro_export] -macro_rules! build_assert { +#[doc(hidden)] +macro_rules! build_assert_macro { ($cond:expr $(,)?) => {{if !$cond { - $crate::build_assert::build_error (concat! ("assertion failed: " ,stringify! ($cond))); + $crate::build_assert::build_error_fn (concat! ("assertion failed: " ,stringify! ($cond))); } }}; ($cond:expr, $msg:expr) => {{if !$cond { - $crate::build_assert::build_error ($msg); + $crate::build_assert::build_error_fn ($msg); } }}; }
rust/kernel/dma.rs +3 -2
@@ -5,12 +5,13 @@//! C header: [`include/linux/dma-mapping.h`](srctree/include/linux/dma-mapping.h) use crate ::{ - bindings, build_assert, device, + bindings, + device, device::{Bound ,Core }, error::{to_result,Result }, prelude::*, sync::aref::ARef , - transmute::{AsBytes ,FromBytes }, + transmute::{AsBytes ,FromBytes },// };use core::ptr::NonNull ;
rust/kernel/io/register.rs +12 -7
@@ -108,9 +108,10 @@use core::marker::PhantomData ; -use crate ::io::IoLoc ; - -use kernel::build_assert; +use crate ::{ + build_assert::build_assert, + io::IoLoc ,// +};/// Trait implemented by all registers. pub trait Register :Sized {
@@ -872,7 +873,7 @@ macro_rules! register { @reg $(#[$attr:meta])* $vis:vis $name:ident ($storage:ty) [ $size:expr, stride = $stride:expr ] @ $offset:literal { $($fields:tt)* } ) => { - ::kernel::static_assert!(::core::mem::size_of ::<$storage>() <= $stride); + $crate::build_assert::static_assert!(::core::mem::size_of ::<$storage>() <= $stride); $crate::register!(@bitfield $(#[$attr] )* $visstruct $name($storage) { $($fields)* }); $crate::register!(@io_base $name($storage) @ $offset);
@@ -895,7 +896,9 @@ macro_rules! register { @reg $(#[$attr:meta])* $vis:vis $name:ident ($storage:ty) => $alias:ident [ $idx:expr ] { $($fields:tt)* } ) => { - ::kernel::static_assert!($idx < <$aliasas $crate ::io::register::RegisterArray >::SIZE ); + $crate::build_assert::static_assert!( + $idx < <$aliasas $crate ::io::register::RegisterArray >::SIZE + ); $crate::register!(@bitfield $(#[$attr] )* $visstruct $name($storage) { $($fields)* }); $crate::register!(
@@ -912,7 +915,7 @@ macro_rules! register { [ $size:expr, stride = $stride:expr ] @ $base:ident + $offset:literal { $($fields:tt)* } ) => { - ::kernel::static_assert!(::core::mem::size_of ::<$storage>() <= $stride); + $crate::build_assert::static_assert!(::core::mem::size_of ::<$storage>() <= $stride); $crate::register!(@bitfield $(#[$attr] )* $visstruct $name($storage) { $($fields)* }); $crate::register!(@io_base $name($storage) @ $offset);
@@ -938,7 +941,9 @@ macro_rules! register { @reg $(#[$attr:meta])* $vis:vis $name:ident ($storage:ty) => $base:ident + $alias:ident [ $idx:expr ] { $($fields:tt)* } ) => { - ::kernel::static_assert!($idx < <$aliasas $crate ::io::register::RegisterArray >::SIZE ); + $crate::build_assert::static_assert!( + $idx < <$aliasas $crate ::io::register::RegisterArray >::SIZE + ); $crate::register!(@bitfield $(#[$attr] )* $visstruct $name($storage) { $($fields)* }); $crate::register!(
rust/kernel/io/resource.rs +1 -1
@@ -229,7 +229,7 @@ impl Flags {// Always inline to optimize out error path of `build_assert`. #[inline(always)] const fn new (value:u32 ) ->Self { -crate ::build_assert!(valueas u64 <= c_ulong::MAX as u64 ); +build_assert! (valueas u64 <= c_ulong::MAX as u64 );Flags (valueas c_ulong ) } }
rust/kernel/ioctl.rs +1 -1
@@ -6,7 +6,7 @@#![expect(non_snake_case)] -use crate ::build_assert; +use crate ::build_assert::build_assert;/// Build an ioctl number, analogous to the C macro of the same name. #[inline(always)]
rust/kernel/net/phy/reg.rs +5 -3
@@ -9,9 +9,11 @@//! defined in IEEE 802.3. use super ::Device ; -use crate ::build_assert; -use crate ::error::*; -use crate ::uapi; +use crate ::{ + build_assert::build_assert, + error::*, + uapi,// +};mod private {/// Marker that a trait cannot be implemented outside of this crate
rust/kernel/num/bounded.rs +1 -1
@@ -364,7 +364,7 @@ pub fn try_new(value: T) -> Option<Self> {// Always inline to optimize out error path of `build_assert`. #[inline(always)] pub fn from_expr (expr:T ) ->Self { -crate ::build_assert!( +crate ::build_assert::build_assert!(fits_within (expr,N ),"Requested value larger than maximal representable value." );
rust/kernel/prelude.rs +2 -1
@@ -29,7 +29,8 @@pub use pin_init::{init, pin_data, pin_init, pinned_drop,InPlaceWrite ,Init ,PinInit ,Zeroable }; -pub use super ::{ +#[doc(no_inline)] +pub use crate ::build_assert::{ build_assert, build_error, const_assert,
rust/kernel/sync/atomic/internal.rs +6 -3
@@ -4,8 +4,11 @@//! //! Provides 1:1 mapping to the C atomic operations. -use crate ::bindings; -use crate ::macros::paste; +use crate ::{ + bindings, + build_assert::static_assert, + macros::paste,// +};use core::cell::UnsafeCell ;use ffi::c_void;
@@ -46,7 +49,7 @@ pub trait AtomicImpl: Sized + Copy + private::Sealed {// In the future when a CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=n architecture plans to support Rust, the // load/store helpers that guarantee atomicity against RmW operations (usually via a lock) need to // be added. -crate ::static_assert!( +static_assert! (cfg! (CONFIG_ARCH_SUPPORTS_ATOMIC_RMW ),"The current implementation of atomic i8/i16/ptr relies on the architecure being \ ARCH_SUPPORTS_ATOMIC_RMW"
rust/kernel/sync/atomic/predefine.rs +1 -1
@@ -2,7 +2,7 @@//! Pre-defined atomic types -use crate ::static_assert; +use crate ::prelude::*;use core::mem::{align_of, size_of};use ffi::c_void;
rust/kernel/sync/locked_by.rs +1 -1
@@ -3,7 +3,7 @@//! A wrapper for data protected by a lock that does not wrap it. use super ::{lock::Backend , lock::Lock }; -use crate ::build_assert; +use crate ::build_assert::build_assert;use core::{cell::UnsafeCell , mem::size_of, ptr};/// Allows access to some data to be serialised by a lock that does not wrap it.
rust/kernel/sync/refcount.rs +5 -3
@@ -4,9 +4,11 @@//! //! C header: [`include/linux/refcount.h`](srctree/include/linux/refcount.h) -use crate ::build_assert; -use crate ::sync::atomic::Atomic ; -use crate ::types::Opaque ; +use crate ::{ + build_assert::build_assert, + sync::atomic::Atomic , + types::Opaque ,// +};/// Atomic reference counter. ///
rust/kernel/xarray.rs +8 -2
@@ -5,10 +5,16 @@//! C header: [`include/linux/xarray.h`](srctree/include/linux/xarray.h) use crate ::{ - alloc, bindings, build_assert, + alloc, + bindings, + build_assert::build_assert, error::{Error ,Result }, ffi::c_void, - types::{ForeignOwnable ,NotThreadSafe ,Opaque }, + types::{ +ForeignOwnable , +NotThreadSafe , +Opaque ,// + },// };use core::{iter, marker::PhantomData , pin::Pin , ptr::NonNull };use pin_init::{pin_data, pin_init, pinned_drop,PinInit };
Signature · 1 line
2.51.2
Re: [PATCH v3 1/4] rust: move `static_assert` into `build_assert`
In reply to Gary GuoQuoted 8 lines · Gary Guo
From: Gary Guo <[email protected]>
Conceptually,
static_assertis also a build-time assertion that occurs earlier in the pipeline. Consolidate the implementation so that we can use this as the canonical place to add more useful build-time assertions.Reviewed-by Yury Norov <[email protected]>Signed-off-by Gary Guo <[email protected]>
Re: [PATCH v3 2/4] rust: add `const_assert!` macro
In reply to Gary GuoQuoted 11 lines · Gary Guo
From: Gary Guo <[email protected]>
The macro is a more powerful version of
static_assert!for use inside function contexts. This is powered by inline consts, so enable the feature for old compiler versions that does not have it stably.While it is possible already to write
const { assert!(...) }, this provides a short hand that is more uniform with other assertions. It also formats nicer with rustfmt where it will not be formatted into multiple lines.
Quoted 4 lines
Two users that would route via the Rust tree are converted.
Reviewed-by Yury Norov <[email protected]>Signed-off-by Gary Guo <[email protected]>
It may be worth to mention in docs that const_assert! may only be checked if the function it appears in has a caller. Whereas static_assert! is always checked no matter what.
Alice
Re: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Gary GuoQuoted 5 lines · Gary Guo
drivers/gpu/nova-core/bitfield.rs | 4 ++-- drivers/gpu/nova-core/num.rs | 2 +- rust/kernel/dma.rs | 5 +++-- rust/kernel/io/register.rs | 19 ++++++++++++------- rust/kernel/io/resource.rs | 2 +-
Quoted 5 lines · Gary Guo
Gary Guo (4):
rust: movestatic_assertintobuild_assert
rust: addconst_assert!macro
rust: reworkbuild_assert!documentation
rust: makebuild_assertmodule the home of related macros
Re: [PATCH v3 3/4] rust: rework `build_assert!` documentation
In reply to Gary GuoQuoted 6 lines · Gary Guo
From: Gary Guo <[email protected]>
Add a detailed comparison and recommendation of the three types of build-time assertion macro as module documentation (and un-hide the module to render them).
Quoted 6 lines
The documentation on the macro themselves are simplified to only cover the scenarios where they should be used; links to the module documentation is added instead.
Reviewed-by Yury Norov <[email protected]>Signed-off-by Gary Guo <[email protected]>
Gary Guo
maintainerRe: [PATCH v3 2/4] rust: add `const_assert!` macro
In reply to Alice RyhlQuoted 17 lines · Alice Ryhl
Quoted 11 lines · Gary Guo
From: Gary Guo <[email protected]>
The macro is a more powerful version of
static_assert!for use inside function contexts. This is powered by inline consts, so enable the feature for old compiler versions that does not have it stably.While it is possible already to write
const { assert!(...) }, this provides a short hand that is more uniform with other assertions. It also formats nicer with rustfmt where it will not be formatted into multiple lines.Quoted 4 lines
Two users that would route via the Rust tree are converted.
Reviewed-by Yury Norov <[email protected]>Signed-off-by Gary Guo <[email protected]>
Quoted 7 lines
Reviewed-by Alice Ryhl <[email protected]>It may be worth to mention in docs that
const_assert! may only be checked if the function it appears in has a caller. Whereasstatic_assert! is always checked no matter what.Alice
I explained this in patch 3 on why static_assert! is preferred over const_assert!. Given that we recommend const_assert! only when it refers to generics, the check is inherently tied to a specific instance anyway, so I don't think it needs to be mentioned in the item doc.
Best,
Gary
Re: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Gary GuoQuoted 10 lines · Gary Guo
From: Gary Guo <[email protected]>
Given the macro scoping rules, all macros are rendered 3 times, in the module, in the top-level of kernel crate, and in the prelude.
Add
#[doc(no_inline)]to the prelude so it just shows up as re-export. Add#[doc(hidden)]to the macro definition and#[doc(inline)]to the re-export insidebuild_assertmodule so the top-level items are hidden.Signed-off-by Gary Guo <[email protected]>
Alice Ryhl
maintainerRe: [PATCH v3 2/4] rust: add `const_assert!` macro
In reply to Gary GuoQuoted 24 lines · Gary Guo
Quoted 23 lines · Alice Ryhl
Quoted 11 lines · Gary Guo
From: Gary Guo <[email protected]>
The macro is a more powerful version of
static_assert!for use inside function contexts. This is powered by inline consts, so enable the feature for old compiler versions that does not have it stably.While it is possible already to write
const { assert!(...) }, this provides a short hand that is more uniform with other assertions. It also formats nicer with rustfmt where it will not be formatted into multiple lines.Quoted 4 lines
Two users that would route via the Rust tree are converted.
Reviewed-by Yury Norov <[email protected]>Signed-off-by Gary Guo <[email protected]>Reviewed-by Alice Ryhl <[email protected]>It may be worth to mention in docs that
const_assert! may only be checked if the function it appears in has a caller. Whereasstatic_assert! is always checked no matter what.
Quoted 6 lines
Quoted 1 line
Alice
I explained this in patch 3 on why
static_assert!is preferred overconst_assert!. Given that we recommendconst_assert!only when it refers to generics, the check is inherently tied to a specific instance anyway, so I don't think it needs to be mentioned in the item doc.
Ok.
Alexandre Courbot
maintainerRe: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Gary GuoQuoted 33 lines · Gary Guo
From: Gary Guo <[email protected]>
Given the macro scoping rules, all macros are rendered 3 times, in the module, in the top-level of kernel crate, and in the prelude.
Add
#[doc(no_inline)]to the prelude so it just shows up as re-export. Add#[doc(hidden)]to the macro definition and#[doc(inline)]to the re-export insidebuild_assertmodule so the top-level items are hidden.Signed-off-by Gary Guo <[email protected]>--- drivers/gpu/nova-core/bitfield.rs | 4 ++-- drivers/gpu/nova-core/num.rs | 2 +- rust/kernel/build_assert.rs | 19 ++++++++++++------- rust/kernel/dma.rs | 5 +++-- rust/kernel/io/register.rs | 19 ++++++++++++------- rust/kernel/io/resource.rs | 2 +- rust/kernel/ioctl.rs | 2 +- rust/kernel/net/phy/reg.rs | 8 +++++--- rust/kernel/num/bounded.rs | 2 +- rust/kernel/prelude.rs | 3 ++- rust/kernel/sync/atomic/internal.rs | 9 ++++++--- rust/kernel/sync/atomic/predefine.rs | 2 +- rust/kernel/sync/locked_by.rs | 2 +- rust/kernel/sync/refcount.rs | 8 +++++--- rust/kernel/xarray.rs | 10 ++++++++-- 15 files changed, 61 insertions(+), 36 deletions(-)drivers/gpu/nova-core/bitfield.rs +0
-0
drivers/gpu/nova-core/bitfield.rs impl $name { · line 173
Quoted 5 lines
drivers/gpu/nova-core/bitfield.rs +1
-1@@ -170,7 +170,7 @@ impl $name { (@check_field_bounds $hi:tt:$lo:tt $field:ident as bool) => { #[allow(clippy::eq_op)] const _: () = { - ::kernel::build_assert!( + ::kernel::build_assert::build_assert!(
Given that the build_assert module now hosts 3 different assert macros, have we considered renaming it to just assert? Otherwise the naming implies that it is more connected to the build_assert macro than the others, which doesn't seem to be true.
Re: [PATCH v3 2/4] rust: add `const_assert!` macro
In reply to Gary GuoQuoted 13 lines · Gary Guo
From: Gary Guo <[email protected]>
The macro is a more powerful version of
static_assert!for use inside function contexts. This is powered by inline consts, so enable the feature for old compiler versions that does not have it stably.While it is possible already to write
const { assert!(...) }, this provides a short hand that is more uniform with other assertions. It also formats nicer with rustfmt where it will not be formatted into multiple lines.Two users that would route via the Rust tree are converted.
Quoted 8 lines
Reviewed-by Yury Norov <[email protected]>Signed-off-by Gary Guo <[email protected]>--- rust/kernel/build_assert.rs | 24 ++++++++++++++++++++++++ rust/kernel/num/bounded.rs | 24 +++++++++--------------- rust/kernel/prelude.rs | 7 ++++++- rust/kernel/ptr.rs | 12 ++++++------ scripts/Makefile.build | 5 +++--
I'd split the update of users to the new version into dedicated patches, but other than that,
Re: [PATCH v3 3/4] rust: rework `build_assert!` documentation
In reply to Gary GuoQuoted 6 lines · Gary Guo
From: Gary Guo <[email protected]>
Add a detailed comparison and recommendation of the three types of build-time assertion macro as module documentation (and un-hide the module to render them).
Quoted 6 lines
The documentation on the macro themselves are simplified to only cover the scenarios where they should be used; links to the module documentation is added instead.
Reviewed-by Yury Norov <[email protected]>Signed-off-by Gary Guo <[email protected]>
That's a great improvement over the documentation, makes the use scenarios crytal-clear.
Gary Guo
maintainerRe: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Alexandre CourbotQuoted 29 lines · Alexandre Courbot
Quoted 28 lines · Gary Guo
From: Gary Guo <[email protected]>
Given the macro scoping rules, all macros are rendered 3 times, in the module, in the top-level of kernel crate, and in the prelude.
Add
#[doc(no_inline)]to the prelude so it just shows up as re-export. Add#[doc(hidden)]to the macro definition and#[doc(inline)]to the re-export insidebuild_assertmodule so the top-level items are hidden.Signed-off-by Gary Guo <[email protected]>--- drivers/gpu/nova-core/bitfield.rs | 4 ++-- drivers/gpu/nova-core/num.rs | 2 +- rust/kernel/build_assert.rs | 19 ++++++++++++------- rust/kernel/dma.rs | 5 +++-- rust/kernel/io/register.rs | 19 ++++++++++++------- rust/kernel/io/resource.rs | 2 +- rust/kernel/ioctl.rs | 2 +- rust/kernel/net/phy/reg.rs | 8 +++++--- rust/kernel/num/bounded.rs | 2 +- rust/kernel/prelude.rs | 3 ++- rust/kernel/sync/atomic/internal.rs | 9 ++++++--- rust/kernel/sync/atomic/predefine.rs | 2 +- rust/kernel/sync/locked_by.rs | 2 +- rust/kernel/sync/refcount.rs | 8 +++++--- rust/kernel/xarray.rs | 10 ++++++++-- 15 files changed, 61 insertions(+), 36 deletions(-)
Quoted 15 lines
drivers/gpu/nova-core/bitfield.rs impl $name { · line 173
Quoted 10 lines
drivers/gpu/nova-core/bitfield.rs +1
-1@@ -170,7 +170,7 @@ impl $name { (@check_field_bounds $hi:tt:$lo:tt $field:ident as bool) => { #[allow(clippy::eq_op)] const _: () = { - ::kernel::build_assert!( + ::kernel::build_assert::build_assert!(Given that the
build_assertmodule now hosts 3 different assert macros, have we considered renaming it to justassert? Otherwise the naming implies that it is more connected to thebuild_assertmacro than the others, which doesn't seem to be true.
I personally view them all as variants of BUILD_BUG_ON, hence the name is build_assert. I thought about assert, but to me that feels like it's going to host runtime assertions.
I won't be surprised if we're going to have assert module in the future to host families of
assert!()
warn_on!()
unsafe { assume!() }
ensure!()etc..
Best,
Gary
Re: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
Quoted 8 lines · Gary Guo
I personally view them all as variants of
BUILD_BUG_ON, hence the name isbuild_assert. I thought aboutassert, but to me that feels like it's going to host runtime assertions.I won't be surprised if we're going to have
assertmodule in the future to host families of
Quoted 6 lines
assert!() warn_on!() unsafe { assume!() } ensure!()etc..
We also have now unsafe_precondition_assert in the safety module which is essentially a debug_assert at least for now, which could potentially be moved too.
Most of these (both build time and runtime ones) should be in the prelude anyway, so they should be easy to reorganize.
Cheers,
Miguel
Re: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Gary GuoQuoted 2 lines · Gary Guo
rust/kernel/net/phy/reg.rs | 8 +++++---
Tomonori: are you OK with these changes?
Quoted 1 line
rust/kernel/num/bounded.rs | 2 +-
Alexandre: are you OK with these changes?
Quoted 4 lines
rust/kernel/sync/atomic/internal.rs | 9 ++++++--- rust/kernel/sync/atomic/predefine.rs | 2 +- rust/kernel/sync/locked_by.rs | 2 +- rust/kernel/sync/refcount.rs | 8 +++++---
Boqun: are you OK with these changes?
Quoted 1 line
rust/kernel/xarray.rs | 10 ++++++++--
Tamir, Andreas: are you OK with these changes?
rust/kernel/dma.rs line 14
Quoted 2 lines
rust/kernel/dma.rs +1
-1- transmute::{AsBytes, FromBytes}, + transmute::{AsBytes, FromBytes}, //
Nit: We should take the chance to expand this.
Thanks all!
Cheers,
Miguel
Re: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Gary GuoQuoted 11 lines · Gary Guo
From: Gary Guo <[email protected]>
Given the macro scoping rules, all macros are rendered 3 times, in the module, in the top-level of kernel crate, and in the prelude.
Add
#[doc(no_inline)]to the prelude so it just shows up as re-export. Add#[doc(hidden)]to the macro definition and#[doc(inline)]to the re-export insidebuild_assertmodule so the top-level items are hidden.Signed-off-by Gary Guo <[email protected]>
Quoted 16 lines
--- drivers/gpu/nova-core/bitfield.rs | 4 ++-- drivers/gpu/nova-core/num.rs | 2 +- rust/kernel/build_assert.rs | 19 ++++++++++++------- rust/kernel/dma.rs | 5 +++-- rust/kernel/io/register.rs | 19 ++++++++++++------- rust/kernel/io/resource.rs | 2 +- rust/kernel/ioctl.rs | 2 +- rust/kernel/net/phy/reg.rs | 8 +++++--- rust/kernel/num/bounded.rs | 2 +- rust/kernel/prelude.rs | 3 ++- rust/kernel/sync/atomic/internal.rs | 9 ++++++--- rust/kernel/sync/atomic/predefine.rs | 2 +- rust/kernel/sync/locked_by.rs | 2 +- rust/kernel/sync/refcount.rs | 8 +++++--- rust/kernel/xarray.rs | 10 ++++++++--
Re: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Miguel OjedaQuoted 3 lines · Miguel Ojeda
Quoted 1 line
rust/kernel/num/bounded.rs | 2 +-Alexandre: are you OK with these changes?
(sorry, assumed my Reviewed-by carried an implicit ack as well)
Re: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
Quoted 4 lines · Alexandre Courbot
(sorry, assumed my Reviewed-by carried an implicit ack as well)
Ah, I saw your tag for #2 and #3, but not #4 (nor #1).
Did I miss it/them?
Thanks!
Cheers,
Miguel
Alexandre Courbot
maintainerRe: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
Quoted 9 lines · Miguel Ojeda
Quoted 4 lines · Alexandre Courbot
(sorry, assumed my Reviewed-by carried an implicit ack as well)
Ah, I saw your tag for #2 and #3, but not #4 (nor #1).
Did I miss it/them?
You are correct and I will have some more morning caffeine. :) I had one question but the patch looks good regardless, should have acked it preemptively.
FUJITA Tomonori
Acked-byRe: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Miguel OjedaQuoted 5 lines · On Mon, 23 Mar 2026 00:36:52 +0100 Miguel Ojeda…
Quoted 2 lines · Gary Guo
rust/kernel/net/phy/reg.rs | 8 +++++---Tomonori: are you OK with these changes?
Re: [PATCH v3 4/4] rust: make `build_assert` module the home of related macros
In reply to Miguel OjedaQuoted 8 lines · Miguel Ojeda
Quoted 2 lines · Gary Guo
rust/kernel/net/phy/reg.rs | 8 +++++---Tomonori: are you OK with these changes?
Quoted 1 line
rust/kernel/num/bounded.rs | 2 +-
Quoted 9 lines
Alexandre: are you OK with these changes?
Quoted 4 lines
rust/kernel/sync/atomic/internal.rs | 9 ++++++--- rust/kernel/sync/atomic/predefine.rs | 2 +- rust/kernel/sync/locked_by.rs | 2 +- rust/kernel/sync/refcount.rs | 8 +++++---Boqun: are you OK with these changes?
Regards,
Boqun
Quoted 13 lines
Quoted 1 line
rust/kernel/xarray.rs | 10 ++++++++--Tamir, Andreas: are you OK with these changes?
rust/kernel/dma.rs line 14
Quoted 2 lines
rust/kernel/dma.rs +1
-1- transmute::{AsBytes, FromBytes}, + transmute::{AsBytes, FromBytes}, //Nit: We should take the chance to expand this.
Thanks all!
Cheers,
Miguel
Quoted 4 lines · Gary Guo
rust: move
static_assertintobuild_assert
rust: addconst_assert!macro
rust: reworkbuild_assert!documentation
Applied (these three only, for now) to rust-next -- thanks everyone!
[ Used kernel vertical style. - Miguel ]
[ Rebased. Fixed period typo. - Miguel ]
[ Added periods on comments. - Miguel ]
Cheers,
Miguel