rust: treewide: switch to our kernel `Box` type (8373147c) · Commits · git / linux-nf

drivers/block/rnull.rs

+2 −2

Original line number	Diff line number	Diff line
		@@ -32,7 +32,7 @@
		}

		struct NullBlkModule {
		_disk: Pin<Box<Mutex<GenDisk<NullBlkDevice>>>>,
		_disk: Pin<KBox<Mutex<GenDisk<NullBlkDevice>>>>,
		}

		impl kernel::Module for NullBlkModule {
		@@ -47,7 +47,7 @@ fn init(_module: &'static ThisModule) -> Result<Self> {
		.rotational(false)
		.build(format_args!("rnullb{}", 0), tagset)?;

		let disk = Box::pin_init(new_mutex!(disk, "nullb:disk"), flags::GFP_KERNEL)?;
		let disk = KBox::pin_init(new_mutex!(disk, "nullb:disk"), flags::GFP_KERNEL)?;

		Ok(Self { _disk: disk })
		}

rust/kernel/init.rs

+26 −25

Original line number	Diff line number	Diff line
		@@ -13,7 +13,7 @@
		//! To initialize a `struct` with an in-place constructor you will need two things:
		//! - an in-place constructor,
		//! - a memory location that can hold your `struct` (this can be the [stack], an [`Arc<T>`],
		//! [`UniqueArc<T>`], [`Box<T>`] or any other smart pointer that implements [`InPlaceInit`]).
		//! [`UniqueArc<T>`], [`KBox<T>`] or any other smart pointer that implements [`InPlaceInit`]).
		//!
		//! To get an in-place constructor there are generally three options:
		//! - directly creating an in-place constructor using the [`pin_init!`] macro,
		@@ -68,7 +68,7 @@
		//! # a <- new_mutex!(42, "Foo::a"),
		//! # b: 24,
		//! # });
		//! let foo: Result<Pin<Box<Foo>>> = Box::pin_init(foo, GFP_KERNEL);
		//! let foo: Result<Pin<KBox<Foo>>> = KBox::pin_init(foo, GFP_KERNEL);
		//! ```
		//!
		//! For more information see the [`pin_init!`] macro.
		@@ -92,14 +92,14 @@
		//! struct DriverData {
		//! #[pin]
		//! status: Mutex<i32>,
		//! buffer: Box<[u8; 1_000_000]>,
		//! buffer: KBox<[u8; 1_000_000]>,
		//! }
		//!
		//! impl DriverData {
		//! fn new() -> impl PinInit<Self, Error> {
		//! try_pin_init!(Self {
		//! status <- new_mutex!(0, "DriverData::status"),
		//! buffer: Box::init(kernel::init::zeroed(), GFP_KERNEL)?,
		//! buffer: KBox::init(kernel::init::zeroed(), GFP_KERNEL)?,
		//! })
		//! }
		//! }
		@@ -211,7 +211,7 @@
		//! [`pin_init!`]: crate::pin_init!

		use crate::{
		alloc::{box_ext::BoxExt, AllocError, Flags},
		alloc::{box_ext::BoxExt, AllocError, Flags, KBox},
		error::{self, Error},
		sync::Arc,
		sync::UniqueArc,
		@@ -298,7 +298,7 @@ macro_rules! stack_pin_init {
		/// struct Foo {
		/// #[pin]
		/// a: Mutex<usize>,
		/// b: Box<Bar>,
		/// b: KBox<Bar>,
		/// }
		///
		/// struct Bar {
		@@ -307,7 +307,7 @@ macro_rules! stack_pin_init {
		///
		/// stack_try_pin_init!(let foo: Result<Pin<&mut Foo>, AllocError> = pin_init!(Foo {
		/// a <- new_mutex!(42),
		/// b: Box::new(Bar {
		/// b: KBox::new(Bar {
		/// x: 64,
		/// }, GFP_KERNEL)?,
		/// }));
		@@ -324,7 +324,7 @@ macro_rules! stack_pin_init {
		/// struct Foo {
		/// #[pin]
		/// a: Mutex<usize>,
		/// b: Box<Bar>,
		/// b: KBox<Bar>,
		/// }
		///
		/// struct Bar {
		@@ -333,7 +333,7 @@ macro_rules! stack_pin_init {
		///
		/// stack_try_pin_init!(let foo: Pin<&mut Foo> =? pin_init!(Foo {
		/// a <- new_mutex!(42),
		/// b: Box::new(Bar {
		/// b: KBox::new(Bar {
		/// x: 64,
		/// }, GFP_KERNEL)?,
		/// }));
		@@ -391,7 +391,7 @@ macro_rules! stack_try_pin_init {
		/// },
		/// });
		/// # initializer }
		/// # Box::pin_init(demo(), GFP_KERNEL).unwrap();
		/// # KBox::pin_init(demo(), GFP_KERNEL).unwrap();
		/// ```
		///
		/// Arbitrary Rust expressions can be used to set the value of a variable.
		@@ -460,7 +460,7 @@ macro_rules! stack_try_pin_init {
		/// # })
		/// # }
		/// # }
		/// let foo = Box::pin_init(Foo::new(), GFP_KERNEL);
		/// let foo = KBox::pin_init(Foo::new(), GFP_KERNEL);
		/// ```
		///
		/// They can also easily embed it into their own `struct`s:
		@@ -592,7 +592,7 @@ macro_rules! pin_init {
		/// use kernel::{init::{self, PinInit}, error::Error};
		/// #[pin_data]
		/// struct BigBuf {
		/// big: Box<[u8; 1024 * 1024 * 1024]>,
		/// big: KBox<[u8; 1024 * 1024 * 1024]>,
		/// small: [u8; 1024 * 1024],
		/// ptr: *mut u8,
		/// }
		@@ -600,7 +600,7 @@ macro_rules! pin_init {
		/// impl BigBuf {
		/// fn new() -> impl PinInit<Self, Error> {
		/// try_pin_init!(Self {
		/// big: Box::init(init::zeroed(), GFP_KERNEL)?,
		/// big: KBox::init(init::zeroed(), GFP_KERNEL)?,
		/// small: [0; 1024 * 1024],
		/// ptr: core::ptr::null_mut(),
		/// }? Error)
		@@ -692,16 +692,16 @@ macro_rules! init {
		/// # Examples
		///
		/// ```rust
		/// use kernel::{init::{PinInit, zeroed}, error::Error};
		/// use kernel::{alloc::KBox, init::{PinInit, zeroed}, error::Error};
		/// struct BigBuf {
		/// big: Box<[u8; 1024 * 1024 * 1024]>,
		/// big: KBox<[u8; 1024 * 1024 * 1024]>,
		/// small: [u8; 1024 * 1024],
		/// }
		///
		/// impl BigBuf {
		/// fn new() -> impl Init<Self, Error> {
		/// try_init!(Self {
		/// big: Box::init(zeroed(), GFP_KERNEL)?,
		/// big: KBox::init(zeroed(), GFP_KERNEL)?,
		/// small: [0; 1024 * 1024],
		/// }? Error)
		/// }
		@@ -812,8 +812,8 @@ macro_rules! assert_pinned {
		/// A pin-initializer for the type `T`.
		///
		/// To use this initializer, you will need a suitable memory location that can hold a `T`. This can
		/// be [`Box<T>`], [`Arc<T>`], [`UniqueArc<T>`] or even the stack (see [`stack_pin_init!`]). Use the
		/// [`InPlaceInit::pin_init`] function of a smart pointer like [`Arc<T>`] on this.
		/// be [`KBox<T>`], [`Arc<T>`], [`UniqueArc<T>`] or even the stack (see [`stack_pin_init!`]). Use
		/// the [`InPlaceInit::pin_init`] function of a smart pointer like [`Arc<T>`] on this.
		///
		/// Also see the [module description](self).
		///
		@@ -893,7 +893,7 @@ fn pin_chain<F>(self, f: F) -> ChainPinInit<Self, F, T, E>
		}

		/// An initializer returned by [`PinInit::pin_chain`].
		pub struct ChainPinInit<I, F, T: ?Sized, E>(I, F, __internal::Invariant<(E, Box<T>)>);
		pub struct ChainPinInit<I, F, T: ?Sized, E>(I, F, __internal::Invariant<(E, KBox<T>)>);

		// SAFETY: The `__pinned_init` function is implemented such that it
		// - returns `Ok(())` on successful initialization,
		@@ -919,8 +919,8 @@ unsafe fn __pinned_init(self, slot: *mut T) -> Result<(), E> {
		/// An initializer for `T`.
		///
		/// To use this initializer, you will need a suitable memory location that can hold a `T`. This can
		/// be [`Box<T>`], [`Arc<T>`], [`UniqueArc<T>`] or even the stack (see [`stack_pin_init!`]). Use the
		/// [`InPlaceInit::init`] function of a smart pointer like [`Arc<T>`] on this. Because
		/// be [`KBox<T>`], [`Arc<T>`], [`UniqueArc<T>`] or even the stack (see [`stack_pin_init!`]). Use
		/// the [`InPlaceInit::init`] function of a smart pointer like [`Arc<T>`] on this. Because
		/// [`PinInit<T, E>`] is a super trait, you can use every function that takes it as well.
		///
		/// Also see the [module description](self).
		@@ -992,7 +992,7 @@ fn chain<F>(self, f: F) -> ChainInit<Self, F, T, E>
		}

		/// An initializer returned by [`Init::chain`].
		pub struct ChainInit<I, F, T: ?Sized, E>(I, F, __internal::Invariant<(E, Box<T>)>);
		pub struct ChainInit<I, F, T: ?Sized, E>(I, F, __internal::Invariant<(E, KBox<T>)>);

		// SAFETY: The `__init` function is implemented such that it
		// - returns `Ok(())` on successful initialization,
		@@ -1076,8 +1076,9 @@ pub fn uninit<T, E>() -> impl Init<MaybeUninit<T>, E> {
		/// # Examples
		///
		/// ```rust
		/// use kernel::{error::Error, init::init_array_from_fn};
		/// let array: Box<[usize; 1_000]> = Box::init::<Error>(init_array_from_fn(\|i\| i), GFP_KERNEL).unwrap();
		/// use kernel::{alloc::KBox, error::Error, init::init_array_from_fn};
		/// let array: KBox<[usize; 1_000]> =
		/// KBox::init::<Error>(init_array_from_fn(\|i\| i), GFP_KERNEL).unwrap();
		/// assert_eq!(array.len(), 1_000);
		/// ```
		pub fn init_array_from_fn<I, const N: usize, T, E>(
		@@ -1453,7 +1454,7 @@ macro_rules! impl_zeroable {
		//
		// In this case we are allowed to use `T: ?Sized`, since all zeros is the `None` variant.
		{<T: ?Sized>} Option<NonNull<T>>,
		{<T: ?Sized>} Option<Box<T>>,
		{<T: ?Sized>} Option<KBox<T>>,

		// SAFETY: `null` pointer is valid.
		//

rust/kernel/init/__internal.rs

+1 −1

Original line number	Diff line number	Diff line
		@@ -105,7 +105,7 @@ fn make_closure<F, O, E>(self, f: F) -> F
		}
		}

		pub struct AllData<T: ?Sized>(PhantomData<fn(Box<T>) -> Box<T>>);
		pub struct AllData<T: ?Sized>(PhantomData<fn(KBox<T>) -> KBox<T>>);

		impl<T: ?Sized> Clone for AllData<T> {
		fn clone(&self) -> Self {

rust/kernel/rbtree.rs

+27 −22

Original line number	Diff line number	Diff line
		@@ -7,7 +7,6 @@
		//! Reference: <https://docs.kernel.org/core-api/rbtree.html>

		use crate::{alloc::Flags, bindings, container_of, error::Result, prelude::*};
		use alloc::boxed::Box;
		use core::{
		cmp::{Ord, Ordering},
		marker::PhantomData,
		@@ -497,7 +496,7 @@ fn drop(&mut self) {
		// but it is not observable. The loop invariant is still maintained.

		// SAFETY: `this` is valid per the loop invariant.
		unsafe { drop(Box::from_raw(this.cast_mut())) };
		unsafe { drop(KBox::from_raw(this.cast_mut())) };
		}
		}
		}
		@@ -764,7 +763,7 @@ pub fn remove_current(self) -> (Option<Self>, RBTreeNode<K, V>) {
		// point to the links field of `Node<K, V>` objects.
		let this = unsafe { container_of!(self.current.as_ptr(), Node<K, V>, links) }.cast_mut();
		// SAFETY: `this` is valid by the type invariants as described above.
		let node = unsafe { Box::from_raw(this) };
		let node = unsafe { KBox::from_raw(this) };
		let node = RBTreeNode { node };
		// SAFETY: The reference to the tree used to create the cursor outlives the cursor, so
		// the tree cannot change. By the tree invariant, all nodes are valid.
		@@ -809,7 +808,7 @@ fn remove_neighbor(&mut self, direction: Direction) -> Option<RBTreeNode<K, V>>
		// point to the links field of `Node<K, V>` objects.
		let this = unsafe { container_of!(neighbor, Node<K, V>, links) }.cast_mut();
		// SAFETY: `this` is valid by the type invariants as described above.
		let node = unsafe { Box::from_raw(this) };
		let node = unsafe { KBox::from_raw(this) };
		return Some(RBTreeNode { node });
		}
		None
		@@ -1038,7 +1037,7 @@ fn next(&mut self) -> Option<Self::Item> {
		/// It contains the memory needed to hold a node that can be inserted into a red-black tree. One
		/// can be obtained by directly allocating it ([`RBTreeNodeReservation::new`]).
		pub struct RBTreeNodeReservation<K, V> {
		node: Box<MaybeUninit<Node<K, V>>>,
		node: KBox<MaybeUninit<Node<K, V>>>,
		}

		impl<K, V> RBTreeNodeReservation<K, V> {
		@@ -1046,7 +1045,7 @@ impl<K, V> RBTreeNodeReservation<K, V> {
		/// call to [`RBTree::insert`].
		pub fn new(flags: Flags) -> Result<RBTreeNodeReservation<K, V>> {
		Ok(RBTreeNodeReservation {
		node: <Box<_> as BoxExt<_>>::new_uninit(flags)?,
		node: KBox::new_uninit(flags)?,
		})
		}
		}
		@@ -1062,14 +1061,15 @@ impl<K, V> RBTreeNodeReservation<K, V> {
		/// Initialises a node reservation.
		///
		/// It then becomes an [`RBTreeNode`] that can be inserted into a tree.
		pub fn into_node(mut self, key: K, value: V) -> RBTreeNode<K, V> {
		self.node.write(Node {
		pub fn into_node(self, key: K, value: V) -> RBTreeNode<K, V> {
		let node = KBox::write(
		self.node,
		Node {
		key,
		value,
		links: bindings::rb_node::default(),
		});
		// SAFETY: We just wrote to it.
		let node = unsafe { self.node.assume_init() };
		},
		);
		RBTreeNode { node }
		}
		}
		@@ -1079,7 +1079,7 @@ pub fn into_node(mut self, key: K, value: V) -> RBTreeNode<K, V> {
		/// The node is fully initialised (with key and value) and can be inserted into a tree without any
		/// extra allocations or failure paths.
		pub struct RBTreeNode<K, V> {
		node: Box<Node<K, V>>,
		node: KBox<Node<K, V>>,
		}

		impl<K, V> RBTreeNode<K, V> {
		@@ -1091,7 +1091,9 @@ pub fn new(key: K, value: V, flags: Flags) -> Result<RBTreeNode<K, V>> {

		/// Get the key and value from inside the node.
		pub fn to_key_value(self) -> (K, V) {
		(self.node.key, self.node.value)
		let node = KBox::into_inner(self.node);

		(node.key, node.value)
		}
		}

		@@ -1113,7 +1115,7 @@ impl<K, V> RBTreeNode<K, V> {
		/// may be freed (but only for the key/value; memory for the node itself is kept for reuse).
		pub fn into_reservation(self) -> RBTreeNodeReservation<K, V> {
		RBTreeNodeReservation {
		node: Box::drop_contents(self.node),
		node: KBox::drop_contents(self.node),
		}
		}
		}
		@@ -1164,7 +1166,7 @@ impl<'a, K, V> RawVacantEntry<'a, K, V> {
		/// The `node` must have a key such that inserting it here does not break the ordering of this
		/// [`RBTree`].
		fn insert(self, node: RBTreeNode<K, V>) -> &'a mut V {
		let node = Box::into_raw(node.node);
		let node = KBox::into_raw(node.node);

		// SAFETY: `node` is valid at least until we call `Box::from_raw`, which only happens when
		// the node is removed or replaced.
		@@ -1238,21 +1240,24 @@ pub fn remove_node(self) -> RBTreeNode<K, V> {
		// SAFETY: The node was a node in the tree, but we removed it, so we can convert it
		// back into a box.
		node: unsafe {
		Box::from_raw(container_of!(self.node_links, Node<K, V>, links).cast_mut())
		KBox::from_raw(container_of!(self.node_links, Node<K, V>, links).cast_mut())
		},
		}
		}

		/// Takes the value of the entry out of the map, and returns it.
		pub fn remove(self) -> V {
		self.remove_node().node.value
		let rb_node = self.remove_node();
		let node = KBox::into_inner(rb_node.node);

		node.value
		}

		/// Swap the current node for the provided node.
		///
		/// The key of both nodes must be equal.
		fn replace(self, node: RBTreeNode<K, V>) -> RBTreeNode<K, V> {
		let node = Box::into_raw(node.node);
		let node = KBox::into_raw(node.node);

		// SAFETY: `node` is valid at least until we call `Box::from_raw`, which only happens when
		// the node is removed or replaced.
		@@ -1268,7 +1273,7 @@ fn replace(self, node: RBTreeNode<K, V>) -> RBTreeNode<K, V> {
		// - `self.node_ptr` produces a valid pointer to a node in the tree.
		// - Now that we removed this entry from the tree, we can convert the node to a box.
		let old_node =
		unsafe { Box::from_raw(container_of!(self.node_links, Node<K, V>, links).cast_mut()) };
		unsafe { KBox::from_raw(container_of!(self.node_links, Node<K, V>, links).cast_mut()) };

		RBTreeNode { node: old_node }
		}

rust/kernel/sync/arc.rs

+8 −9

Original line number	Diff line number	Diff line
		@@ -17,13 +17,12 @@
		//! [`Arc`]: https://doc.rust-lang.org/std/sync/struct.Arc.html

		use crate::{
		alloc::{box_ext::BoxExt, AllocError, Flags},
		alloc::{AllocError, Flags, KBox},
		bindings,
		init::{self, InPlaceInit, Init, PinInit},
		try_init,
		types::{ForeignOwnable, Opaque},
		};
		use alloc::boxed::Box;
		use core::{
		alloc::Layout,
		fmt,
		@@ -201,11 +200,11 @@ pub fn new(contents: T, flags: Flags) -> Result<Self, AllocError> {
		data: contents,
		};

		let inner = <Box<_> as BoxExt<_>>::new(value, flags)?;
		let inner = KBox::new(value, flags)?;

		// SAFETY: We just created `inner` with a reference count of 1, which is owned by the new
		// `Arc` object.
		Ok(unsafe { Self::from_inner(Box::leak(inner).into()) })
		Ok(unsafe { Self::from_inner(KBox::leak(inner).into()) })
		}
		}

		@@ -398,8 +397,8 @@ fn drop(&mut self) {
		if is_zero {
		// The count reached zero, we must free the memory.
		//
		// SAFETY: The pointer was initialised from the result of `Box::leak`.
		unsafe { drop(Box::from_raw(self.ptr.as_ptr())) };
		// SAFETY: The pointer was initialised from the result of `KBox::leak`.
		unsafe { drop(KBox::from_raw(self.ptr.as_ptr())) };
		}
		}
		}
		@@ -641,7 +640,7 @@ pub fn new(value: T, flags: Flags) -> Result<Self, AllocError> {
		/// Tries to allocate a new [`UniqueArc`] instance whose contents are not initialised yet.
		pub fn new_uninit(flags: Flags) -> Result<UniqueArc<MaybeUninit<T>>, AllocError> {
		// INVARIANT: The refcount is initialised to a non-zero value.
		let inner = Box::try_init::<AllocError>(
		let inner = KBox::try_init::<AllocError>(
		try_init!(ArcInner {
		// SAFETY: There are no safety requirements for this FFI call.
		refcount: Opaque::new(unsafe { bindings::REFCOUNT_INIT(1) }),
		@@ -651,8 +650,8 @@ pub fn new_uninit(flags: Flags) -> Result<UniqueArc<MaybeUninit<T>>, AllocError>
		)?;
		Ok(UniqueArc {
		// INVARIANT: The newly-created object has a refcount of 1.
		// SAFETY: The pointer from the `Box` is valid.
		inner: unsafe { Arc::from_inner(Box::leak(inner).into()) },
		// SAFETY: The pointer from the `KBox` is valid.
		inner: unsafe { Arc::from_inner(KBox::leak(inner).into()) },
		})
		}
		}