rust: alloc: remove extension of std's `Box` (e8c6ccdb) · Commits · git / linux-nf

rust/kernel/alloc.rs

+0 −1

Original line number	Diff line number	Diff line
		@@ -4,7 +4,6 @@

		#[cfg(not(any(test, testlib)))]
		pub mod allocator;
		pub mod box_ext;
		pub mod kbox;
		pub mod vec_ext;

rust/kernel/alloc/box_ext.rs

deleted100644 → 0

+0 −89

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0

		//! Extensions to [`Box`] for fallible allocations.

		use super::{AllocError, Flags};
		use alloc::boxed::Box;
		use core::{mem::MaybeUninit, ptr, result::Result};

		/// Extensions to [`Box`].
		pub trait BoxExt<T>: Sized {
		/// Allocates a new box.
		///
		/// The allocation may fail, in which case an error is returned.
		fn new(x: T, flags: Flags) -> Result<Self, AllocError>;

		/// Allocates a new uninitialised box.
		///
		/// The allocation may fail, in which case an error is returned.
		fn new_uninit(flags: Flags) -> Result<Box<MaybeUninit<T>>, AllocError>;

		/// Drops the contents, but keeps the allocation.
		///
		/// # Examples
		///
		/// ```
		/// use kernel::alloc::{flags, box_ext::BoxExt};
		/// let value = Box::new([0; 32], flags::GFP_KERNEL)?;
		/// assert_eq!(*value, [0; 32]);
		/// let mut value = Box::drop_contents(value);
		/// // Now we can re-use `value`:
		/// value.write([1; 32]);
		/// // SAFETY: We just wrote to it.
		/// let value = unsafe { value.assume_init() };
		/// assert_eq!(*value, [1; 32]);
		/// # Ok::<(), Error>(())
		/// ```
		fn drop_contents(this: Self) -> Box<MaybeUninit<T>>;
		}

		impl<T> BoxExt<T> for Box<T> {
		fn new(x: T, flags: Flags) -> Result<Self, AllocError> {
		let mut b = <Self as BoxExt<_>>::new_uninit(flags)?;
		b.write(x);
		// SAFETY: We just wrote to it.
		Ok(unsafe { b.assume_init() })
		}

		#[cfg(any(test, testlib))]
		fn new_uninit(_flags: Flags) -> Result<Box<MaybeUninit<T>>, AllocError> {
		Ok(Box::new_uninit())
		}

		#[cfg(not(any(test, testlib)))]
		fn new_uninit(flags: Flags) -> Result<Box<MaybeUninit<T>>, AllocError> {
		let ptr = if core::mem::size_of::<MaybeUninit<T>>() == 0 {
		core::ptr::NonNull::<_>::dangling().as_ptr()
		} else {
		let layout = core::alloc::Layout::new::<MaybeUninit<T>>();

		// SAFETY: Memory is being allocated (first arg is null). The only other source of
		// safety issues is sleeping on atomic context, which is addressed by klint. Lastly,
		// the type is not a SZT (checked above).
		let ptr =
		unsafe { super::allocator::krealloc_aligned(core::ptr::null_mut(), layout, flags) };
		if ptr.is_null() {
		return Err(AllocError);
		}

		ptr.cast::<MaybeUninit<T>>()
		};

		// SAFETY: For non-zero-sized types, we allocate above using the global allocator. For
		// zero-sized types, we use `NonNull::dangling`.
		Ok(unsafe { Box::from_raw(ptr) })
		}

		fn drop_contents(this: Self) -> Box<MaybeUninit<T>> {
		let ptr = Box::into_raw(this);
		// SAFETY: `ptr` is valid, because it came from `Box::into_raw`.
		unsafe { ptr::drop_in_place(ptr) };

		// CAST: `MaybeUninit<T>` is a transparent wrapper of `T`.
		let ptr = ptr.cast::<MaybeUninit<T>>();

		// SAFETY: `ptr` is valid for writes, because it came from `Box::into_raw` and it is valid for
		// reads, since the pointer came from `Box::into_raw` and the type is `MaybeUninit<T>`.
		unsafe { Box::from_raw(ptr) }
		}
		}

rust/kernel/init.rs

+1 −45

Original line number	Diff line number	Diff line
		@@ -211,13 +211,12 @@
		//! [`pin_init!`]: crate::pin_init!

		use crate::{
		alloc::{box_ext::BoxExt, AllocError, Flags, KBox},
		alloc::{AllocError, Flags, KBox},
		error::{self, Error},
		sync::Arc,
		sync::UniqueArc,
		types::{Opaque, ScopeGuard},
		};
		use alloc::boxed::Box;
		use core::{
		cell::UnsafeCell,
		convert::Infallible,
		@@ -588,7 +587,6 @@ macro_rules! pin_init {
		/// # Examples
		///
		/// ```rust
		/// # #![feature(new_uninit)]
		/// use kernel::{init::{self, PinInit}, error::Error};
		/// #[pin_data]
		/// struct BigBuf {
		@@ -1245,26 +1243,6 @@ fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E>
		}
		}

		impl<T> InPlaceInit<T> for Box<T> {
		type PinnedSelf = Pin<Self>;

		#[inline]
		fn try_pin_init<E>(init: impl PinInit<T, E>, flags: Flags) -> Result<Self::PinnedSelf, E>
		where
		E: From<AllocError>,
		{
		<Box<_> as BoxExt<_>>::new_uninit(flags)?.write_pin_init(init)
		}

		#[inline]
		fn try_init<E>(init: impl Init<T, E>, flags: Flags) -> Result<Self, E>
		where
		E: From<AllocError>,
		{
		<Box<_> as BoxExt<_>>::new_uninit(flags)?.write_init(init)
		}
		}

		impl<T> InPlaceInit<T> for UniqueArc<T> {
		type PinnedSelf = Pin<Self>;

		@@ -1301,28 +1279,6 @@ pub trait InPlaceWrite<T> {
		fn write_pin_init<E>(self, init: impl PinInit<T, E>) -> Result<Pin<Self::Initialized>, E>;
		}

		impl<T> InPlaceWrite<T> for Box<MaybeUninit<T>> {
		type Initialized = Box<T>;

		fn write_init<E>(mut self, init: impl Init<T, E>) -> Result<Self::Initialized, E> {
		let slot = self.as_mut_ptr();
		// SAFETY: When init errors/panics, slot will get deallocated but not dropped,
		// slot is valid.
		unsafe { init.__init(slot)? };
		// SAFETY: All fields have been initialized.
		Ok(unsafe { self.assume_init() })
		}

		fn write_pin_init<E>(mut self, init: impl PinInit<T, E>) -> Result<Pin<Self::Initialized>, E> {
		let slot = self.as_mut_ptr();
		// SAFETY: When init errors/panics, slot will get deallocated but not dropped,
		// slot is valid and will not be moved, because we pin it later.
		unsafe { init.__pinned_init(slot)? };
		// SAFETY: All fields have been initialized.
		Ok(unsafe { self.assume_init() }.into())
		}
		}

		impl<T> InPlaceWrite<T> for UniqueArc<MaybeUninit<T>> {
		type Initialized = UniqueArc<T>;

rust/kernel/lib.rs

+0 −1

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@
		#![feature(coerce_unsized)]
		#![feature(dispatch_from_dyn)]
		#![feature(lint_reasons)]
		#![feature(new_uninit)]
		#![feature(unsize)]

		// Ensure conditional compilation based on the kernel configuration works;

rust/kernel/prelude.rs

+2 −2

Original line number	Diff line number	Diff line
		@@ -14,10 +14,10 @@
		#[doc(no_inline)]
		pub use core::pin::Pin;

		pub use crate::alloc::{box_ext::BoxExt, flags::*, vec_ext::VecExt, KBox, KVBox, VBox};
		pub use crate::alloc::{flags::*, vec_ext::VecExt, KBox, KVBox, VBox};

		#[doc(no_inline)]
		pub use alloc::{boxed::Box, vec::Vec};
		pub use alloc::vec::Vec;

		#[doc(no_inline)]
		pub use macros::{module, pin_data, pinned_drop, vtable, Zeroable};