89 lines · rust
1// SPDX-License-Identifier: GPL-2.02 3//! Extensions to the [`alloc`] crate.4 5#[cfg(not(test))]6#[cfg(not(testlib))]7mod allocator;8pub mod box_ext;9pub mod vec_ext;10 11/// Indicates an allocation error.12#[derive(Copy, Clone, PartialEq, Eq, Debug)]13pub 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)]21pub struct Flags(u32);22 23impl Flags {24 /// Get the raw representation of this flag.25 pub(crate) fn as_raw(self) -> u32 {26 self.027 }28}29 30impl 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 37impl 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 44impl 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.54pub 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't65 /// 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 current73 /// 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 zone78 /// 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 or85 /// use any filesystem callback. It is very likely to fail to allocate memory, even for very86 /// small allocations.87 pub const GFP_NOWAIT: Flags = Flags(bindings::GFP_NOWAIT);88}89