1 // SPDX-License-Identifier: GPL-2.0 2 3 //! Extensions to the [`alloc`] crate. 4 5 #[cfg(not(test))] 6 #[cfg(not(testlib))] 7 mod allocator; 8 pub mod box_ext; 9 pub mod vec_ext; 10 11 /// Indicates an allocation error. 12 #[derive(Copy, Clone, PartialEq, Eq, Debug)] 13 pub struct AllocError; 14 15 /// Flags to be used when allocating memory. 16 /// 17 /// They can be combined with the operators `|`, `&`, and `!`. 18 /// 19 /// Values can be used from the [`flags`] module. 20 #[derive(Clone, Copy)] 21 pub struct Flags(u32); 22 23 impl Flags { 24 /// Get the raw representation of this flag. 25 pub(crate) fn as_raw(self) -> u32 { 26 self.0 27 } 28 } 29 30 impl core::ops::BitOr for Flags { 31 type Output = Self; 32 fn bitor(self, rhs: Self) -> Self::Output { 33 Self(self.0 | rhs.0) 34 } 35 } 36 37 impl core::ops::BitAnd for Flags { 38 type Output = Self; 39 fn bitand(self, rhs: Self) -> Self::Output { 40 Self(self.0 & rhs.0) 41 } 42 } 43 44 impl core::ops::Not for Flags { 45 type Output = Self; 46 fn not(self) -> Self::Output { 47 Self(!self.0) 48 } 49 } 50 51 /// Allocation flags. 52 /// 53 /// These are meant to be used in functions that can allocate memory. 54 pub mod flags { 55 use super::Flags; 56 57 /// Zeroes out the allocated memory. 58 /// 59 /// This is normally or'd with other flags. 60 pub const __GFP_ZERO: Flags = Flags(bindings::__GFP_ZERO); 61 62 /// Allow the allocation to be in high memory. 63 /// 64 /// Allocations in high memory may not be mapped into the kernel's address space, so this can't 65 /// be used with `kmalloc` and other similar methods. 66 /// 67 /// This is normally or'd with other flags. 68 pub const __GFP_HIGHMEM: Flags = Flags(bindings::__GFP_HIGHMEM); 69 70 /// Users can not sleep and need the allocation to succeed. 71 /// 72 /// A lower watermark is applied to allow access to "atomic reserves". The current 73 /// implementation doesn't support NMI and few other strict non-preemptive contexts (e.g. 74 /// raw_spin_lock). The same applies to [`GFP_NOWAIT`]. 75 pub const GFP_ATOMIC: Flags = Flags(bindings::GFP_ATOMIC); 76 77 /// Typical for kernel-internal allocations. The caller requires ZONE_NORMAL or a lower zone 78 /// for direct access but can direct reclaim. 79 pub const GFP_KERNEL: Flags = Flags(bindings::GFP_KERNEL); 80 81 /// The same as [`GFP_KERNEL`], except the allocation is accounted to kmemcg. 82 pub const GFP_KERNEL_ACCOUNT: Flags = Flags(bindings::GFP_KERNEL_ACCOUNT); 83 84 /// For kernel allocations that should not stall for direct reclaim, start physical IO or 85 /// use any filesystem callback. It is very likely to fail to allocate memory, even for very 86 /// small allocations. 87 pub const GFP_NOWAIT: Flags = Flags(bindings::GFP_NOWAIT); 88 } 89