Struct BuddyAllocator 

pub struct BuddyAllocator {
    zones: [Zone; 3],
    bitmap_pool: [(u64, u64); 3],
}

Fields

zones: [Zone; 3]

bitmap_pool: [(u64, u64); 3]

Per-zone bitmap pool reserved from free memory: [start, end).

Implementations

impl BuddyAllocator

pub const fn new() -> Self

Creates a new instance.

pub fn init(&mut self, memory_regions: &[MemoryRegion])

Performs the init operation.

fn pass_count(&mut self, memory_regions: &[MemoryRegion])

Performs the pass count operation.

fn pass_reserve_segment_storage(&mut self, memory_regions: &[MemoryRegion])

Reserve per-zone segment tables sized to the actual fragmented layout.

fn pass_reserve_bitmap_pools(&mut self, memory_regions: &[MemoryRegion])

Reserve per-zone bitmap pools using a segmentation-safe upper bound.

fn pass_finalize_zone_accounting(&mut self)

Finalise zone accounting once the managed segment set is known.

fn watermark_target_pages( managed_pages: usize, divisor: usize, floor: usize, cap: usize, ) -> usize

Compute a bounded watermark target for a zone.

fn lowmem_reserve_target_pages( zone_type: ZoneType, managed_pages: usize, ) -> usize

Compute a bounded low-memory reserve target.

fn bounded_zone_target( managed_pages: usize, divisor: usize, floor: usize, cap: usize, max_fraction_divisor: usize, ) -> usize

Bound a policy target to something meaningful for the current zone size.

fn pass_build_segments(&mut self, memory_regions: &[MemoryRegion])

Build the final segmented physical layout from remaining boot allocator ranges.

fn pass_setup_segment_bitmaps(&mut self)

Assign bitmap slices to each populated segment.

fn pass_populate(&mut self)

Seed each contiguous segment with greedy block insertion.

fn seed_range_as_free( zone_type: ZoneType, segment: &mut ZoneSegment, start: u64, end: u64, )

Seeds a contiguous physical range [start, end) as free using greedy block insertion.

Unlike the previous min/max span design, segment is guaranteed to be a genuinely contiguous free extent. Greedy seeding therefore improves boot time without ever making holes visible to the buddy topology.

fn alloc_from_zone( zone: &mut Zone, zone_idx: usize, order: u8, migratetype: Migratetype, honor_watermarks: bool, token: &IrqDisabledToken, ) -> Option<PhysFrame>

Allocates from zone.

fn alloc_from_segment( segment: &mut ZoneSegment, order: u8, requested_migratetype: Migratetype, _token: &IrqDisabledToken, ) -> Option<u64>

Allocate from one contiguous segment.

fn find_segment_index(zone: &Zone, phys: u64, order: u8) -> Option<usize>

fn segment_contains_block(segment: &ZoneSegment, phys: u64, order: u8) -> bool

fn free_to_zone( zone: &mut Zone, frame: PhysFrame, order: u8, _token: &IrqDisabledToken, )

Releases to zone.

fn quarantine_poisoned_block_in_zone( zone: &mut Zone, frame: PhysFrame, order: u8, _token: &IrqDisabledToken, )

Drops allocator accounting for a poisoned block without returning it to the free list.

The block is not placed on any free list and its debug-bitmap entries remain marked as “allocated” : because they genuinely are: the pages are quarantined and inaccessible. Clearing them would defeat the double-free detector for any later attempt to free the same block.

fn insert_free_block( segment: &mut ZoneSegment, frame_phys: u64, initial_order: u8, migratetype: Migratetype, )

Linux-style parity-map coalescing insertion. Returns after inserting the (potentially coalesced) block into the appropriate free list, without recursing further. If the buddy bit is already set or we reach MAX_ORDER, the block is inserted as-is. Otherwise, the buddy block is removed from its free list and coalesced with the current block, and the process repeats at the next order.

fn page_index(segment: &ZoneSegment, phys: u64) -> usize

Performs the page index operation.

fn pair_index(segment: &ZoneSegment, phys: u64, order: u8) -> usize

Performs the pair index operation.

fn toggle_pair(segment: &mut ZoneSegment, phys: u64, order: u8) -> bool

Performs the toggle pair operation.

fn buddy_phys(segment: &ZoneSegment, phys: u64, order: u8) -> Option<u64>

Performs the buddy phys operation.

fn mark_allocated( segment: &mut ZoneSegment, frame_phys: u64, order: u8, allocated: bool, )

Performs the mark allocated operation.

fn free_list_push( segment: &mut ZoneSegment, phys: u64, order: u8, migratetype: Migratetype, )

Releases list push.

fn free_list_pop( segment: &mut ZoneSegment, order: u8, migratetype: Migratetype, ) -> Option<u64>

Releases list pop.

fn free_list_remove( segment: &mut ZoneSegment, phys: u64, order: u8, migratetype: Migratetype, ) -> bool

Releases list remove.

fn read_free_next(phys: u64) -> u64

Reads free next.

fn write_free_next(phys: u64, next: u64)

Writes free next.

fn read_free_prev(phys: u64) -> u64

Reads free prev.

fn write_free_prev(phys: u64, prev: u64)

Writes free prev.

fn zone_index_for_addr(addr: u64) -> usize

Performs the zone index for addr operation.

fn zone_bounds(zone_idx: usize) -> (u64, u64)

Performs the zone bounds operation.

fn zone_intersection_aligned( region: &MemoryRegion, zone_idx: usize, ) -> Option<(u64, u64)>

Performs the zone intersection aligned operation.

fn protected_overlap_end(start: u64, end: u64) -> Option<u64>

Performs the protected overlap end operation.

fn protected_module_ranges() -> [Option<(u64, u64)>; 32]

Performs the protected module ranges operation.

fn pairs_for_order(span_pages: usize, order: u8) -> usize

Performs the pairs for order operation.

fn bits_to_bytes(bits: usize) -> usize

Performs the bits to bytes operation.

fn bitmap_bytes_for_span(span_pages: usize) -> usize

Performs the bitmap bytes for span operation.

fn bitmap_bytes_upper_bound_for_pages(page_count: usize) -> usize

Upper bound for bitmap storage over any segmentation of page_count pages.

For one page, every order contributes at most one parity bit. Summing that pessimistic bound across all pages yields a simple safe allocation bound, even if bitmap-pool reservations split ranges further.

fn pageblock_tag_bytes_for_span(span_pages: usize) -> usize

Exact byte count required for pageblock migratetype tags over one contiguous span.

fn pageblock_tag_bytes_upper_bound_for_pages(page_count: usize) -> usize

Safe upper bound for pageblock-tag storage across any segmentation of page_count pages.

fn align_up(value: u64, align: u64) -> u64

Performs the align up operation.

fn align_down(value: u64, align: u64) -> u64

Performs the align down operation.

fn default_pageblock_migratetype(zone_type: ZoneType) -> Migratetype

Default pageblock migratetype assigned at bootstrap for one zone.

fn pageblock_index(segment: &ZoneSegment, phys: u64) -> usize

Returns the pageblock index covering phys inside segment.

fn decode_pageblock_tag(tag: u8) -> Migratetype

Decode one pageblock tag byte into a migratetype.

fn pageblock_migratetype( segment: &ZoneSegment, phys: u64, fallback: Migratetype, ) -> Migratetype

Returns the current pageblock migratetype for a block start.

fn retag_pageblock_range( segment: &mut ZoneSegment, phys: u64, order: u8, migratetype: Migratetype, )

Retag every pageblock overlapped by the buddy block [phys, phys + 2^order * PAGE_SIZE).

fn zone_pageblock_counts(zone: &Zone) -> [usize; 2]

Count pageblocks by migratetype for one zone.

fn zone_effective_free_pages(zone: &Zone, zone_idx: usize) -> usize

fn zone_allows_allocation( zone: &Zone, zone_idx: usize, order: u8, honor_watermarks: bool, ) -> bool

Returns whether the zone should be considered for the current request.

fn can_merge_with_buddy(phys: u64, order: u8, migratetype: Migratetype) -> bool

Returns whether a buddy block is free and coalescible with migratetype.

fn block_migratetype(frame_phys: u64) -> Migratetype

Decode the block migratetype stored in frame metadata flags.

fn migratetype_from_flags(flags: u32) -> Migratetype

Decode a migratetype from frame flags.

fn free_flags_for(migratetype: Migratetype) -> u32

Encode the metadata flags for a free block of the given migratetype.

fn allocated_flags_for(migratetype: Migratetype) -> u32

Encode the metadata flags for an allocated block of the given migratetype.

fn alloc_in_zone_order( &mut self, order: u8, migratetype: Migratetype, zone_order: &[usize], token: &IrqDisabledToken, ) -> Option<PhysFrame>

Try to allocate from the supplied zone order, first honoring reserves and then bypassing them.

fn preferred_zone_order(migratetype: Migratetype) -> &'static [usize; 3]

Returns the preferred zone scan order for one migratetype.

Unmovable allocations still prefer Normal first because the current kernel hot-touches those pages directly. Movable allocations instead prefer HighMem first to preserve scarce low memory for pinned kernel structures and emergency paths.

fn zone_pressure_for_free_pages(zone: &Zone, free_pages: usize) -> ZonePressure

fn compaction_candidate( &self, order: u8, migratetype: Migratetype, zone_order: &[usize], ) -> Option<CompactionCandidate>

fn compaction_drain_budget(candidate: CompactionCandidate) -> usize

fn alloc_locked_with_migratetype( &mut self, order: u8, migratetype: Migratetype, token: &IrqDisabledToken, ) -> Result<PhysFrame, AllocError>

Allocate while the caller already owns the global allocator lock.

fn alloc_zone_locked( &mut self, order: u8, zone: ZoneType, migratetype: Migratetype, token: &IrqDisabledToken, ) -> Result<PhysFrame, AllocError>

Allocate from one explicit zone while the caller already owns the global allocator lock.

fn mark_block_allocated(frame_phys: u64, order: u8, migratetype: Migratetype)

fn mark_block_free(frame_phys: u64, order: u8, migratetype: Migratetype)

fn set_block_meta(frame_phys: u64, order: u8, flags: u32, refcount: u32)

Stamp every 4 KiB [MetaSlot] in the buddy block (flags, order, free-list links, refcount).

[MetaSlot::reset_with_free_list_meta] runs on each page, including non-head pages of a multi-page block: the whole block returns to the buddy as one unit, so vtable and guard bits are cleared (except poison preserved per-slot) on every constituent frame.

impl BuddyAllocator

pub fn alloc_zone( &mut self, order: u8, zone: ZoneType, token: &IrqDisabledToken, ) -> Result<PhysFrame, AllocError>

Allocate explicitly from one zone (e.g. DMA-only callers).

pub fn alloc_zone_migratetype( &mut self, order: u8, zone: ZoneType, migratetype: Migratetype, token: &IrqDisabledToken, ) -> Result<PhysFrame, AllocError>

Allocate explicitly from one zone with a migratetype hint.

This keeps the target zone fixed but still selects the preferred free-list class and fallback donor order from migratetype.

impl BuddyAllocator

pub fn page_totals(&self) -> (usize, usize)

Fast totals without heap allocation (safe in low-level paths).

pub fn get_zone(&self, idx: usize) -> &Zone

Get a reference to a zone by index.

pub fn zone_snapshot(&self, out: &mut [ZoneStats]) -> usize

Snapshot zones without heap allocation. Returns the number of entries written to out.

Trait Implementations

impl FrameAllocator for BuddyAllocator

fn alloc( &mut self, order: u8, token: &IrqDisabledToken, ) -> Result<PhysFrame, AllocError>

Performs the alloc operation.

fn free(&mut self, frame: PhysFrame, order: u8, token: &IrqDisabledToken)

Performs the free operation.

fn alloc_frame( &mut self, token: &IrqDisabledToken, ) -> Result<PhysFrame, AllocError>

Allocate a single frame (convenience method)