12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
// SPDX-License-Identifier: GPL-2.0 //! Extensions to the [`alloc`] crate. #[cfg(not(test))] #[cfg(not(testlib))] mod allocator; pub mod box_ext; pub mod vec_ext; /// Indicates an allocation error. #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub struct AllocError; /// Flags to be used when allocating memory. /// /// They can be combined with the operators `|`, `&`, and `!`. /// /// Values can be used from the [`flags`] module. #[derive(Clone, Copy)] pub struct Flags(u32); impl Flags { /// Get the raw representation of this flag. pub(crate) fn as_raw(self) -> u32 { self.0 } } impl core::ops::BitOr for Flags { type Output = Self; fn bitor(self, rhs: Self) -> Self::Output { Self(self.0 | rhs.0) } } impl core::ops::BitAnd for Flags { type Output = Self; fn bitand(self, rhs: Self) -> Self::Output { Self(self.0 & rhs.0) } } impl core::ops::Not for Flags { type Output = Self; fn not(self) -> Self::Output { Self(!self.0) } } /// Allocation flags. /// /// These are meant to be used in functions that can allocate memory. pub mod flags { use super::Flags; /// Zeroes out the allocated memory. /// /// This is normally or'd with other flags. pub const __GFP_ZERO: Flags = Flags(bindings::__GFP_ZERO); /// Allow the allocation to be in high memory. /// /// Allocations in high memory may not be mapped into the kernel's address space, so this can't /// be used with `kmalloc` and other similar methods. /// /// This is normally or'd with other flags. pub const __GFP_HIGHMEM: Flags = Flags(bindings::__GFP_HIGHMEM); /// Users can not sleep and need the allocation to succeed. /// /// A lower watermark is applied to allow access to "atomic reserves". The current /// implementation doesn't support NMI and few other strict non-preemptive contexts (e.g. /// raw_spin_lock). The same applies to [`GFP_NOWAIT`]. pub const GFP_ATOMIC: Flags = Flags(bindings::GFP_ATOMIC); /// Typical for kernel-internal allocations. The caller requires ZONE_NORMAL or a lower zone /// for direct access but can direct reclaim. pub const GFP_KERNEL: Flags = Flags(bindings::GFP_KERNEL); /// The same as [`GFP_KERNEL`], except the allocation is accounted to kmemcg. pub const GFP_KERNEL_ACCOUNT: Flags = Flags(bindings::GFP_KERNEL_ACCOUNT); /// For kernel allocations that should not stall for direct reclaim, start physical IO or /// use any filesystem callback. It is very likely to fail to allocate memory, even for very /// small allocations. pub const GFP_NOWAIT: Flags = Flags(bindings::GFP_NOWAIT); }