linux-kernel - Re: [PATCH v1 12/28] rust: alloc: add `RawVec::try_with_capacity

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Message-ID: <20221114143405.2334ed8b@GaryWorkstation>
Date:   Mon, 14 Nov 2022 14:34:05 +0000
From:   Gary Guo <gary@...yguo.net>
To:     Miguel Ojeda <ojeda@...nel.org>
Cc:     Wedson Almeida Filho <wedsonaf@...il.com>,
        Alex Gaynor <alex.gaynor@...il.com>,
        Boqun Feng <boqun.feng@...il.com>,
        Björn Roy Baron <bjorn3_gh@...tonmail.com>,
        rust-for-linux@...r.kernel.org, linux-kernel@...r.kernel.org,
        patches@...ts.linux.dev
Subject: Re: [PATCH v1 12/28] rust: alloc: add
 `RawVec::try_with_capacity_in()` constructor

On Thu, 10 Nov 2022 17:41:24 +0100
Miguel Ojeda <ojeda@...nel.org> wrote:

> Add the `RawVec::try_with_capacity_in()` constructor as the fallible
> version of `RawVec::with_capacity_in()`.
> 
> The implementation follows the original.
> 
> The infallible constructor is implemented in terms of the private
> `RawVec::allocate_in()` constructor, thus also add the private
> `RawVec::try_allocate_in()` constructor following the other.
> 
> It will be used to implement `Vec::try_with_capacity{,_in}()` in
> the next patch.
> 
> Signed-off-by: Miguel Ojeda <ojeda@...nel.org>

Reviewed-by: Gary Guo <gary@...yguo.net>

> ---
>  rust/alloc/raw_vec.rs | 34 +++++++++++++++++++++++++++++++++-
>  1 file changed, 33 insertions(+), 1 deletion(-)
> 
> diff --git a/rust/alloc/raw_vec.rs b/rust/alloc/raw_vec.rs
> index daf5f2da7168..c342f3843972 100644
> --- a/rust/alloc/raw_vec.rs
> +++ b/rust/alloc/raw_vec.rs
> @@ -20,11 +20,11 @@ use crate::collections::TryReserveErrorKind::*;
>  #[cfg(test)]
>  mod tests;
>  
> -#[cfg(not(no_global_oom_handling))]
>  enum AllocInit {
>      /// The contents of the new memory are uninitialized.
>      Uninitialized,
>      /// The new memory is guaranteed to be zeroed.
> +    #[allow(dead_code)]
>      Zeroed,
>  }
>  
> @@ -133,6 +133,14 @@ impl<T, A: Allocator> RawVec<T, A> {
>          Self::allocate_in(capacity, AllocInit::Uninitialized, alloc)
>      }
>  
> +    /// Like `try_with_capacity`, but parameterized over the choice of
> +    /// allocator for the returned `RawVec`.
> +    #[allow(dead_code)]
> +    #[inline]
> +    pub fn try_with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserveError> {
> +        Self::try_allocate_in(capacity, AllocInit::Uninitialized, alloc)
> +    }
> +
>      /// Like `with_capacity_zeroed`, but parameterized over the choice
>      /// of allocator for the returned `RawVec`.
>      #[cfg(not(no_global_oom_handling))]
> @@ -203,6 +211,30 @@ impl<T, A: Allocator> RawVec<T, A> {
>          }
>      }
>  
> +    fn try_allocate_in(capacity: usize, init: AllocInit, alloc: A) -> Result<Self, TryReserveError> {
> +        // Don't allocate here because `Drop` will not deallocate when `capacity` is 0.
> +        if mem::size_of::<T>() == 0 || capacity == 0 {
> +            return Ok(Self::new_in(alloc));
> +        }
> +
> +        let layout = Layout::array::<T>(capacity).map_err(|_| CapacityOverflow)?;
> +        alloc_guard(layout.size())?;
> +        let result = match init {
> +            AllocInit::Uninitialized => alloc.allocate(layout),
> +            AllocInit::Zeroed => alloc.allocate_zeroed(layout),
> +        };
> +        let ptr = result.map_err(|_| AllocError { layout, non_exhaustive: () })?;
> +
> +        // Allocators currently return a `NonNull<[u8]>` whose length
> +        // matches the size requested. If that ever changes, the capacity
> +        // here should change to `ptr.len() / mem::size_of::<T>()`.
> +        Ok(Self {
> +            ptr: unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) },
> +            cap: capacity,
> +            alloc,
> +        })
> +    }
> +
>      /// Reconstitutes a `RawVec` from a pointer, capacity, and allocator.
>      ///
>      /// # Safety