Re: [PATCH v2 01/13] rust: pin-init: rename `zeroed` to `init_zeroed`

["Benoît du Garreau" <benoit@dugarreau.fr>]

On Fri, 23 May 2025 16:50:57 +0200 Benno Lossin <lossin@kernel.org> wrote:

> The name `zeroed` is a much better fit for a function that returns the
> type by-value.
> 
> Link: https://github.com/Rust-for-Linux/pin-init/pull/56/commits/7dbe38682c9725405bab91dcabe9c4d8893d2f5e
> [ also rename uses in `rust/kernel/init.rs` - Benno]
> Signed-off-by: Benno Lossin <lossin@kernel.org>
> ---
>  rust/kernel/init.rs                           |  8 +++---
>  rust/pin-init/README.md                       |  2 +-
>  rust/pin-init/examples/big_struct_in_place.rs |  4 +--
>  rust/pin-init/src/lib.rs                      | 28 +++++++++----------
>  rust/pin-init/src/macros.rs                   | 16 +++++------
>  5 files changed, 29 insertions(+), 29 deletions(-)
> 
> diff --git a/rust/kernel/init.rs b/rust/kernel/init.rs
> index 8d228c237954..15a1c5e397d8 100644
> --- a/rust/kernel/init.rs
> +++ b/rust/kernel/init.rs
> @@ -206,7 +206,7 @@ fn init<E>(init: impl Init<T, E>, flags: Flags) -> error::Result<Self>
>  ///
>  /// ```rust
>  /// use kernel::error::Error;
> -/// use pin_init::zeroed;
> +/// use pin_init::init_zeroed;
>  /// struct BigBuf {
>  ///     big: KBox<[u8; 1024 * 1024 * 1024]>,
>  ///     small: [u8; 1024 * 1024],
> @@ -215,7 +215,7 @@ fn init<E>(init: impl Init<T, E>, flags: Flags) -> error::Result<Self>
>  /// impl BigBuf {
>  ///     fn new() -> impl Init<Self, Error> {
>  ///         try_init!(Self {
> -///             big: KBox::init(zeroed(), GFP_KERNEL)?,
> +///             big: KBox::init(init_zeroed(), GFP_KERNEL)?,
>  ///             small: [0; 1024 * 1024],
>  ///         }? Error)
>  ///     }
> @@ -264,7 +264,7 @@ macro_rules! try_init {
>  /// ```rust
>  /// # #![feature(new_uninit)]
>  /// use kernel::error::Error;
> -/// use pin_init::zeroed;
> +/// use pin_init::init_zeroed;
>  /// #[pin_data]
>  /// struct BigBuf {
>  ///     big: KBox<[u8; 1024 * 1024 * 1024]>,
> @@ -275,7 +275,7 @@ macro_rules! try_init {
>  /// impl BigBuf {
>  ///     fn new() -> impl PinInit<Self, Error> {
>  ///         try_pin_init!(Self {
> -///             big: KBox::init(zeroed(), GFP_KERNEL)?,
> +///             big: KBox::init(init_zeroed(), GFP_KERNEL)?,
>  ///             small: [0; 1024 * 1024],
>  ///             ptr: core::ptr::null_mut(),
>  ///         }? Error)
> diff --git a/rust/pin-init/README.md b/rust/pin-init/README.md
> index 2d0cda961d45..a4c01a8d78b2 100644
> --- a/rust/pin-init/README.md
> +++ b/rust/pin-init/README.md
> @@ -125,7 +125,7 @@ impl DriverData {
>      fn new() -> impl PinInit<Self, Error> {
>          try_pin_init!(Self {
>              status <- CMutex::new(0),
> -            buffer: Box::init(pin_init::zeroed())?,
> +            buffer: Box::init(pin_init::init_zeroed())?,
>          }? Error)
>      }
>  }
> diff --git a/rust/pin-init/examples/big_struct_in_place.rs b/rust/pin-init/examples/big_struct_in_place.rs
> index b0ee793a0a0c..c05139927486 100644
> --- a/rust/pin-init/examples/big_struct_in_place.rs
> +++ b/rust/pin-init/examples/big_struct_in_place.rs
> @@ -21,7 +21,7 @@ pub struct ManagedBuf {
>  
>  impl ManagedBuf {
>      pub fn new() -> impl Init<Self> {
> -        init!(ManagedBuf { buf <- zeroed() })
> +        init!(ManagedBuf { buf <- init_zeroed() })
>      }
>  }
>  
> @@ -30,7 +30,7 @@ fn main() {
>      {
>          // we want to initialize the struct in-place, otherwise we would get a stackoverflow
>          let buf: Box<BigStruct> = Box::init(init!(BigStruct {
> -            buf <- zeroed(),
> +            buf <- init_zeroed(),
>              a: 7,
>              b: 186,
>              c: 7789,
> diff --git a/rust/pin-init/src/lib.rs b/rust/pin-init/src/lib.rs
> index 9ab34036e6bc..3bb0700355df 100644
> --- a/rust/pin-init/src/lib.rs
> +++ b/rust/pin-init/src/lib.rs
> @@ -148,7 +148,7 @@
>  //!     fn new() -> impl PinInit<Self, Error> {
>  //!         try_pin_init!(Self {
>  //!             status <- CMutex::new(0),
> -//!             buffer: Box::init(pin_init::zeroed())?,
> +//!             buffer: Box::init(pin_init::init_zeroed())?,
>  //!         }? Error)
>  //!     }
>  //! }
> @@ -742,7 +742,7 @@ macro_rules! stack_try_pin_init {
>  /// - Fields that you want to initialize in-place have to use `<-` instead of `:`.
>  /// - In front of the initializer you can write `&this in` to have access to a [`NonNull<Self>`]
>  ///   pointer named `this` inside of the initializer.
> -/// - Using struct update syntax one can place `..Zeroable::zeroed()` at the very end of the
> +/// - Using struct update syntax one can place `..Zeroable::init_zeroed()` at the very end of the
>  ///   struct, this initializes every field with 0 and then runs all initializers specified in the
>  ///   body. This can only be done if [`Zeroable`] is implemented for the struct.
>  ///
> @@ -769,7 +769,7 @@ macro_rules! stack_try_pin_init {
>  /// });
>  /// let init = pin_init!(Buf {
>  ///     buf: [1; 64],
> -///     ..Zeroable::zeroed()
> +///     ..Zeroable::init_zeroed()
>  /// });
>  /// ```
>  ///
> @@ -805,7 +805,7 @@ macro_rules! pin_init {
>  /// ```rust
>  /// # #![feature(allocator_api)]
>  /// # #[path = "../examples/error.rs"] mod error; use error::Error;
> -/// use pin_init::{pin_data, try_pin_init, PinInit, InPlaceInit, zeroed};
> +/// use pin_init::{pin_data, try_pin_init, PinInit, InPlaceInit, init_zeroed};
>  ///
>  /// #[pin_data]
>  /// struct BigBuf {
> @@ -817,7 +817,7 @@ macro_rules! pin_init {
>  /// impl BigBuf {
>  ///     fn new() -> impl PinInit<Self, Error> {
>  ///         try_pin_init!(Self {
> -///             big: Box::init(zeroed())?,
> +///             big: Box::init(init_zeroed())?,
>  ///             small: [0; 1024 * 1024],
>  ///             ptr: core::ptr::null_mut(),
>  ///         }? Error)
> @@ -866,7 +866,7 @@ macro_rules! try_pin_init {
>  /// # #[path = "../examples/error.rs"] mod error; use error::Error;
>  /// # #[path = "../examples/mutex.rs"] mod mutex; use mutex::*;
>  /// # use pin_init::InPlaceInit;
> -/// use pin_init::{init, Init, zeroed};
> +/// use pin_init::{init, Init, init_zeroed};
>  ///
>  /// struct BigBuf {
>  ///     small: [u8; 1024 * 1024],
> @@ -875,7 +875,7 @@ macro_rules! try_pin_init {
>  /// impl BigBuf {
>  ///     fn new() -> impl Init<Self> {
>  ///         init!(Self {
> -///             small <- zeroed(),
> +///             small <- init_zeroed(),
>  ///         })
>  ///     }
>  /// }
> @@ -913,7 +913,7 @@ macro_rules! init {
>  /// # #![feature(allocator_api)]
>  /// # use core::alloc::AllocError;
>  /// # use pin_init::InPlaceInit;
> -/// use pin_init::{try_init, Init, zeroed};
> +/// use pin_init::{try_init, Init, init_zeroed};
>  ///
>  /// struct BigBuf {
>  ///     big: Box<[u8; 1024 * 1024 * 1024]>,
> @@ -923,7 +923,7 @@ macro_rules! init {
>  /// impl BigBuf {
>  ///     fn new() -> impl Init<Self, AllocError> {
>  ///         try_init!(Self {
> -///             big: Box::init(zeroed())?,
> +///             big: Box::init(init_zeroed())?,
>  ///             small: [0; 1024 * 1024],
>  ///         }? AllocError)
>  ///     }
> @@ -1170,7 +1170,7 @@ pub unsafe trait Init<T: ?Sized, E = Infallible>: PinInit<T, E> {
>      ///
>      /// ```rust
>      /// # #![expect(clippy::disallowed_names)]
> -    /// use pin_init::{init, zeroed, Init};
> +    /// use pin_init::{init, init_zeroed, Init};
>      ///
>      /// struct Foo {
>      ///     buf: [u8; 1_000_000],
> @@ -1183,7 +1183,7 @@ pub unsafe trait Init<T: ?Sized, E = Infallible>: PinInit<T, E> {
>      /// }
>      ///
>      /// let foo = init!(Foo {
> -    ///     buf <- zeroed()
> +    ///     buf <- init_zeroed()
>      /// }).chain(|foo| {
>      ///     foo.setup();
>      ///     Ok(())
> @@ -1469,7 +1469,7 @@ pub unsafe trait PinnedDrop: __internal::HasPinData {
>  /// this is not UB:
>  ///
>  /// ```rust,ignore
> -/// let val: Self = unsafe { core::mem::zeroed() };
> +/// let val: Self = unsafe { core::mem::init_zeroed() };

This looks like a find/replace that was a bit too eager :)

>  /// ```
>  pub unsafe trait Zeroable {}
>  
> @@ -1484,11 +1484,11 @@ pub unsafe trait ZeroableOption {}
>  // SAFETY: by the safety requirement of `ZeroableOption`, this is valid.
>  unsafe impl<T: ZeroableOption> Zeroable for Option<T> {}
>  
> -/// Create a new zeroed T.
> +/// Create an initializer for a zeroed `T`.
>  ///
>  /// The returned initializer will write `0x00` to every byte of the given `slot`.
>  #[inline]
> -pub fn zeroed<T: Zeroable>() -> impl Init<T> {
> +pub fn init_zeroed<T: Zeroable>() -> impl Init<T> {
>      // SAFETY: Because `T: Zeroable`, all bytes zero is a valid bit pattern for `T`
>      // and because we write all zeroes, the memory is initialized.
>      unsafe {
> diff --git a/rust/pin-init/src/macros.rs b/rust/pin-init/src/macros.rs
> index 935d77745d1d..9ced630737b8 100644
> --- a/rust/pin-init/src/macros.rs
> +++ b/rust/pin-init/src/macros.rs
> @@ -1030,7 +1030,7 @@ impl<$($impl_generics)*> $pin_data<$($ty_generics)*>
>  ///
>  /// This macro has multiple internal call configurations, these are always the very first ident:
>  /// - nothing: this is the base case and called by the `{try_}{pin_}init!` macros.
> -/// - `with_update_parsed`: when the `..Zeroable::zeroed()` syntax has been handled.
> +/// - `with_update_parsed`: when the `..Zeroable::init_zeroed()` syntax has been handled.
>  /// - `init_slot`: recursively creates the code that initializes all fields in `slot`.
>  /// - `make_initializer`: recursively create the struct initializer that guarantees that every
>  ///   field has been initialized exactly once.
> @@ -1059,7 +1059,7 @@ macro_rules! __init_internal {
>              @data($data, $($use_data)?),
>              @has_data($has_data, $get_data),
>              @construct_closure($construct_closure),
> -            @zeroed(), // Nothing means default behavior.
> +            @init_zeroed(), // Nothing means default behavior.
>          )
>      };
>      (
> @@ -1074,7 +1074,7 @@ macro_rules! __init_internal {
>          @has_data($has_data:ident, $get_data:ident),
>          // `pin_init_from_closure` or `init_from_closure`.
>          @construct_closure($construct_closure:ident),
> -        @munch_fields(..Zeroable::zeroed()),
> +        @munch_fields(..Zeroable::init_zeroed()),
>      ) => {
>          $crate::__init_internal!(with_update_parsed:
>              @this($($this)?),
> @@ -1084,7 +1084,7 @@ macro_rules! __init_internal {
>              @data($data, $($use_data)?),
>              @has_data($has_data, $get_data),
>              @construct_closure($construct_closure),
> -            @zeroed(()), // `()` means zero all fields not mentioned.
> +            @init_zeroed(()), // `()` means zero all fields not mentioned.
>          )
>      };
>      (
> @@ -1124,7 +1124,7 @@ macro_rules! __init_internal {
>          @has_data($has_data:ident, $get_data:ident),
>          // `pin_init_from_closure` or `init_from_closure`.
>          @construct_closure($construct_closure:ident),
> -        @zeroed($($init_zeroed:expr)?),
> +        @init_zeroed($($init_zeroed:expr)?),
>      ) => {{
>          // We do not want to allow arbitrary returns, so we declare this type as the `Ok` return
>          // type and shadow it later when we insert the arbitrary user code. That way there will be
> @@ -1196,7 +1196,7 @@ fn assert_zeroable<T: $crate::Zeroable>(_: *mut T) {}
>          @data($data:ident),
>          @slot($slot:ident),
>          @guards($($guards:ident,)*),
> -        @munch_fields($(..Zeroable::zeroed())? $(,)?),
> +        @munch_fields($(..Zeroable::init_zeroed())? $(,)?),
>      ) => {
>          // Endpoint of munching, no fields are left. If execution reaches this point, all fields
>          // have been initialized. Therefore we can now dismiss the guards by forgetting them.
> @@ -1300,11 +1300,11 @@ fn assert_zeroable<T: $crate::Zeroable>(_: *mut T) {}
>      (make_initializer:
>          @slot($slot:ident),
>          @type_name($t:path),
> -        @munch_fields(..Zeroable::zeroed() $(,)?),
> +        @munch_fields(..Zeroable::init_zeroed() $(,)?),
>          @acc($($acc:tt)*),
>      ) => {
>          // Endpoint, nothing more to munch, create the initializer. Since the users specified
> -        // `..Zeroable::zeroed()`, the slot will already have been zeroed and all field that have
> +        // `..Zeroable::init_zeroed()`, the slot will already have been zeroed and all field that have
>          // not been overwritten are thus zero and initialized. We still check that all fields are
>          // actually accessible by using the struct update syntax ourselves.
>          // We are inside of a closure that is never executed and thus we can abuse `slot` to
> 
> base-commit: ae8b3a83fb9de394f609035041cd7a668fda2ab3
> prerequisite-patch-id: https://lore.kernel.org/all/20250523125424.192843-2-lossin@kernel.org
> prerequisite-patch-id: https://lore.kernel.org/all/20250523125424.192843-3-lossin@kernel.org
> prerequisite-patch-id: https://lore.kernel.org/all/20250523125424.192843-4-lossin@kernel.org
> -- 
> 2.49.0

Benoît du Garreau