0903b9e2a4
Upstream Rust's libs-api team has consensus for stabilizing some of `feature(new_uninit)`, but not for `Box<MaybeUninit<T>>::write`. Instead, we can use `MaybeUninit<T>::write`, so Rust for Linux can drop the feature after stabilization. That will happen after merging, as the FCP has completed [1]. This is required before stabilization because remaining-unstable API will be divided into new features. This code doesn't know about those yet. It can't: they haven't landed, as the relevant PR is blocked on rustc's CI testing Rust-for-Linux without this patch. [ The PR has landed [2] and will be released in Rust 1.82.0 (expected on 2024-10-17), so we could conditionally enable the new unstable feature (`box_uninit_write` [3]) instead, but just for a single `unsafe` block it is probably not worth it. For the time being, I added it to the "nice to have" section of our unstable features list. - Miguel ] Link: https://github.com/rust-lang/rust/issues/63291#issuecomment-2183022955 [1] Link: https://github.com/rust-lang/rust/pull/129416 [2] Link: https://github.com/rust-lang/rust/issues/129397 [3] Signed-off-by: Jubilee Young <workingjubilee@gmail.com> Reviewed-by: Alice Ryhl <aliceryhl@google.com> Reviewed-by: Trevor Gross <tmgross@umich.edu> [ Reworded slightly. - Miguel ] Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
58 lines
2 KiB
Rust
58 lines
2 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
//! Extensions to [`Box`] for fallible allocations.
|
|
|
|
use super::{AllocError, Flags};
|
|
use alloc::boxed::Box;
|
|
use core::mem::MaybeUninit;
|
|
|
|
/// 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>;
|
|
}
|
|
|
|
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) })
|
|
}
|
|
}
|