Re: [PATCH v3 1/8] rust: alloc: add Vec::try_push_init

[sashiko-bot@kernel.org]

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] rust: missing #[inline] on try_push_init()
--

commit 5b0998c4906cb7b8fa1c27d53ac13078b73e0f91
Author: Eliot Courtney <ecourtney@nvidia.com>

rust: alloc: add Vec::try_push_init

This commit adds Vec::try_push_init for fallible initializers along
with a new PushInitError sum type. It allows the original initializer
to be returned to the caller if the allocation fails.

> diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs
> index c7546b9da4fa3..a2b72a7779d9d 100644
> --- a/rust/kernel/alloc/kvec.rs
> +++ b/rust/kernel/alloc/kvec.rs
[ ... ]
> @@ -359,6 +367,49 @@ pub fn push(&mut self, v: T, flags: Flags) -> Result<(), AllocError> {
>          Ok(())
>      }
>  
> +    /// Appends an element to the back of the [`Vec`] instance by initializing it in place.
> +    ///
> +    /// Unlike [`Vec::push`], the initializer may be fallible. If the allocation fails, the
[ ... ]
> +    /// let mut v: KVec<Element> = KVec::new();
> +    /// v.try_push_init(Element::new(), GFP_KERNEL)?;
> +    /// assert!(v[0].buf.is_empty());
> +    /// # Ok::<(), Error>(())
> +    /// ```
> +    pub fn try_push_init<I, E>(&mut self, init: I, flags: Flags) -> Result<(), PushInitError<I, E>>
> +    where
> +        I: Init<T, E>,
> +    {

[Severity: Low]
Should try_push_init() be annotated with #[inline]?

The Rust subsystem coding guidelines recommend that small functions in
abstractions should be annotated with #[inline] to allow the compiler
to better optimize them.

> +        if self.reserve(1, flags).is_err() {
> +            return Err(PushInitError::AllocError(init));
> +        }
> +        // SAFETY: The call to `reserve` was successful, so there is at least one spare slot.
> +        unsafe { init.__init(self.spare_capacity_mut().as_mut_ptr().cast::<T>()) }
> +            .map_err(PushInitError::InitError)?;
> +        // SAFETY: The call to `__init` returned `Ok`, so the first spare slot now holds an
> +        // initialized `T`. The new length does not exceed the capacity because `reserve` ensured
> +        // the capacity is greater than the length by at least one.
> +        unsafe { self.inc_len(1) };
> +        Ok(())
> +    }
> +
>      /// Appends an element to the back of the [`Vec`] instance without reallocating.
>      ///
>      /// Fails if the vector does not have capacity for the new element.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260928-b4-nvkv-v3-0-f04504c262c2@nvidia.com?part=1