Type Alias kernel::alloc::kbox::KVBox

source ·

pub type KVBox<T> = Box<T, KVmalloc>;

Expand description

Type alias for Box with a KVmalloc allocator.

§Examples

let b = KVBox::new(24_u64, GFP_KERNEL)?;

assert_eq!(*b, 24_u64);

Aliased Type§

struct KVBox<T>(/* private fields */);

Implementations

source §

impl<T, A> Box<MaybeUninit<T>, A>
where A: Allocator,

source

pub unsafe fn assume_init(self) -> Box<T, A>

Converts a Box<MaybeUninit<T>, A> to a Box<T, A>.

It is undefined behavior to call this function while the value inside of b is not yet fully initialized.

§Safety

Callers must ensure that the value inside of b is in an initialized state.

source

pub fn write(self, value: T) -> Box<T, A>

Writes the value and converts to Box<T, A>.

source §

impl<T, A> Box<T, A>
where T: ?Sized, A: Allocator,

source

pub const unsafe fn from_raw(raw: *mut T) -> Self

Creates a new Box<T, A> from a raw pointer.

§Safety

For non-ZSTs, raw must point at an allocation allocated with A that is sufficiently aligned for and holds a valid T. The caller passes ownership of the allocation to the Box.

For ZSTs, raw must be a dangling, well aligned pointer.

source

pub fn into_raw(b: Self) -> *mut T

Consumes the Box<T, A> and returns a raw pointer.

This will not run the destructor of T and for non-ZSTs the allocation will stay alive indefinitely. Use Box::from_raw to recover the Box, drop the value and free the allocation, if any.

§Examples

let x = KBox::new(24, GFP_KERNEL)?;
let ptr = KBox::into_raw(x);
// SAFETY: `ptr` comes from a previous call to `KBox::into_raw`.
let x = unsafe { KBox::from_raw(ptr) };

assert_eq!(*x, 24);

source

pub fn leak<'a>(b: Self) -> &'a mut T

Consumes and leaks the Box<T, A> and returns a mutable reference.

See Box::into_raw for more details.

source §

impl<T, A> Box<T, A>
where A: Allocator,

source

pub fn new(x: T, flags: Flags) -> Result<Self, AllocError>

Creates a new Box<T, A> and initializes its contents with x.

New memory is allocated with A. The allocation may fail, in which case an error is returned. For ZSTs no memory is allocated.

source

pub fn new_uninit(flags: Flags) -> Result<Box<MaybeUninit<T>, A>, AllocError>

Creates a new Box<T, A> with uninitialized contents.

New memory is allocated with A. The allocation may fail, in which case an error is returned. For ZSTs no memory is allocated.

§Examples

let b = KBox::<u64>::new_uninit(GFP_KERNEL)?;
let b = KBox::write(b, 24);

assert_eq!(*b, 24_u64);

source

pub fn pin(x: T, flags: Flags) -> Result<Pin<Box<T, A>>, AllocError>
where A: 'static,

Constructs a new Pin<Box<T, A>>. If T does not implement Unpin, then x will be pinned in memory and can’t be moved.

source

pub fn into_pin(this: Self) -> Pin<Self>

Convert a Box<T,A> to a Pin<Box<T,A>>. If T does not implement Unpin, then x will be pinned in memory and can’t be moved.

source

pub fn drop_contents(this: Self) -> Box<MaybeUninit<T>, A>

Drops the contents, but keeps the allocation.

§Examples

let value = KBox::new([0; 32], GFP_KERNEL)?;
assert_eq!(*value, [0; 32]);
let value = KBox::drop_contents(value);
// Now we can re-use `value`:
let value = KBox::write(value, [1; 32]);
assert_eq!(*value, [1; 32]);