Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274// SPDX-License-Identifier: GPL-2.0
//! Implementation of the kernel's memory allocation infrastructure.
pub mod allocator;pub mod kbox;pub mod kvec;pub mod layout;
pub use self::kbox::Box;pub use self::kbox::KBox;pub use self::kbox::KVBox;pub use self::kbox::VBox;
pub use self::kvec::IntoIter;pub use self::kvec::KVVec;pub use self::kvec::KVec;pub use self::kvec::VVec;pub use self::kvec::Vec;
/// Indicates an allocation error.#[derive(Copy, Clone, PartialEq, Eq, Debug)]pub struct AllocError;
use crate::prelude::*;
use core::{ alloc::Layout, ptr::NonNull, //};
/// 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, PartialEq)]pub struct Flags(u32);
impl Flags { /// Get the raw representation of this flag. pub(crate) fn as_raw(self) -> u32 { self.0 }
/// Check whether `flags` is contained in `self`. pub fn contains(self, flags: Flags) -> bool { (self & flags) == flags }}
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);
/// Suppresses allocation failure reports. /// /// This is normally or'd with other flags. pub const __GFP_NOWARN: Flags = Flags(bindings::__GFP_NOWARN);}
/// Non Uniform Memory Access (NUMA) node identifier.#[derive(Clone, Copy, PartialEq)]pub struct NumaNode(i32);
impl NumaNode { /// Create a new NUMA node identifier (non-negative integer). /// /// Returns [`EINVAL`] if a negative id or an id exceeding [`bindings::MAX_NUMNODES`] is /// specified. pub fn new(node: i32) -> Result<Self> { // MAX_NUMNODES never exceeds 2**10 because NODES_SHIFT is 0..10. if node < 0 || node >= bindings::MAX_NUMNODES as i32 { return Err(EINVAL); } Ok(Self(node)) }}
/// Specify necessary constant to pass the information to Allocator that the caller doesn't care/// about the NUMA node to allocate memory from.impl NumaNode { /// No node preference. pub const NO_NODE: NumaNode = NumaNode(bindings::NUMA_NO_NODE);}
/// The kernel's [`Allocator`] trait.////// An implementation of [`Allocator`] can allocate, re-allocate and free memory buffers described/// via [`Layout`].////// [`Allocator`] is designed to be implemented as a ZST; [`Allocator`] functions do not operate on/// an object instance.////// In order to be able to support `#[derive(CoercePointee)]` later on, we need to avoid a design/// that requires an `Allocator` to be instantiated, hence its functions must not contain any kind/// of `self` parameter.////// # Safety////// - A memory allocation returned from an allocator must remain valid until it is explicitly freed.////// - Any pointer to a valid memory allocation must be valid to be passed to any other [`Allocator`]/// function of the same type.////// - Implementers must ensure that all trait functions abide by the guarantees documented in the/// `# Guarantees` sections.pub unsafe trait Allocator { /// The minimum alignment satisfied by all allocations from this allocator. /// /// # Guarantees /// /// Any pointer allocated by this allocator is guaranteed to be aligned to `MIN_ALIGN` even if /// the requested layout has a smaller alignment. const MIN_ALIGN: usize;
/// Allocate memory based on `layout`, `flags` and `nid`. /// /// On success, returns a buffer represented as `NonNull<[u8]>` that satisfies the layout /// constraints (i.e. minimum size and alignment as specified by `layout`). /// /// This function is equivalent to `realloc` when called with `None`. /// /// # Guarantees /// /// When the return value is `Ok(ptr)`, then `ptr` is /// - valid for reads and writes for `layout.size()` bytes, until it is passed to /// [`Allocator::free`] or [`Allocator::realloc`], /// - aligned to `layout.align()`, /// /// Additionally, `Flags` are honored as documented in /// <https://docs.kernel.org/core-api/mm-api.html#mm-api-gfp-flags>. fn alloc(layout: Layout, flags: Flags, nid: NumaNode) -> Result<NonNull<[u8]>, AllocError> { // SAFETY: Passing `None` to `realloc` is valid by its safety requirements and asks for a // new memory allocation. unsafe { Self::realloc(None, layout, Layout::new::<()>(), flags, nid) } }
/// Re-allocate an existing memory allocation to satisfy the requested `layout` and /// a specific NUMA node request to allocate the memory for. /// /// Systems employing a Non Uniform Memory Access (NUMA) architecture contain collections of /// hardware resources including processors, memory, and I/O buses, that comprise what is /// commonly known as a NUMA node. /// /// `nid` stands for NUMA id, i. e. NUMA node identifier, which is a non-negative integer /// if a node needs to be specified, or [`NumaNode::NO_NODE`] if the caller doesn't care. /// /// If the requested size is zero, `realloc` behaves equivalent to `free`. /// /// If the requested size is larger than the size of the existing allocation, a successful call /// to `realloc` guarantees that the new or grown buffer has at least `Layout::size` bytes, but /// may also be larger. /// /// If the requested size is smaller than the size of the existing allocation, `realloc` may or /// may not shrink the buffer; this is implementation specific to the allocator. /// /// On allocation failure, the existing buffer, if any, remains valid. /// /// The buffer is represented as `NonNull<[u8]>`. /// /// # Safety /// /// - If `ptr == Some(p)`, then `p` must point to an existing and valid memory allocation /// created by this [`Allocator`]; if `old_layout` is zero-sized `p` does not need to be a /// pointer returned by this [`Allocator`]. /// - `ptr` is allowed to be `None`; in this case a new memory allocation is created and /// `old_layout` is ignored. /// - `old_layout` must match the `Layout` the allocation has been created with. /// /// # Guarantees /// /// This function has the same guarantees as [`Allocator::alloc`]. When `ptr == Some(p)`, then /// it additionally guarantees that: /// - the contents of the memory pointed to by `p` are preserved up to the lesser of the new /// and old size, i.e. `ret_ptr[0..min(layout.size(), old_layout.size())] == /// p[0..min(layout.size(), old_layout.size())]`. /// - when the return value is `Err(AllocError)`, then `ptr` is still valid. unsafe fn realloc( ptr: Option<NonNull<u8>>, layout: Layout, old_layout: Layout, flags: Flags, nid: NumaNode, ) -> Result<NonNull<[u8]>, AllocError>;
/// Free an existing memory allocation. /// /// # Safety /// /// - `ptr` must point to an existing and valid memory allocation created by this [`Allocator`]; /// if `old_layout` is zero-sized `p` does not need to be a pointer returned by this /// [`Allocator`]. /// - `layout` must match the `Layout` the allocation has been created with. /// - The memory allocation at `ptr` must never again be read from or written to. unsafe fn free(ptr: NonNull<u8>, layout: Layout) { // SAFETY: The caller guarantees that `ptr` points at a valid allocation created by this // allocator. We are passing a `Layout` with the smallest possible alignment, so it is // smaller than or equal to the alignment previously used with this allocation. let _ = unsafe { Self::realloc( Some(ptr), Layout::new::<()>(), layout, Flags(0), NumaNode::NO_NODE, ) }; }}
/// Returns a properly aligned dangling pointer from the given `layout`.pub(crate) fn dangling_from_layout(layout: Layout) -> NonNull<u8> { let ptr = layout.align() as *mut u8;
// SAFETY: `layout.align()` (and hence `ptr`) is guaranteed to be non-zero. unsafe { NonNull::new_unchecked(ptr) }}