rust/kernel/alloc.rs

   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 }