Struct PageFrame

Source

pub struct PageFrame { /* private fields */ }

Expand description

A physical page frame.

Represents a contiguous block of physical memory with a specific physical address and order (size).

§Examples

use ruvix_physmem::{PageFrame, PhysAddr, PageOrder};

let frame = PageFrame::new(PhysAddr::new(0x1000), PageOrder::new(2).unwrap());
assert_eq!(frame.addr().as_u64(), 0x1000);
assert_eq!(frame.pages(), 4);
assert_eq!(frame.bytes(), 16384);

Implementations§

Source §

impl PageFrame

Source

pub const fn new(addr: PhysAddr, order: PageOrder) -> Self

Creates a new page frame.

§Arguments

addr - The physical address of the frame’s start.
order - The order determining the frame’s size.

§Examples

use ruvix_physmem::{PageFrame, PhysAddr, PageOrder};

let frame = PageFrame::new(
    PhysAddr::new(0x1000_0000),
    PageOrder::new(3).unwrap()
);
assert_eq!(frame.pages(), 8);

Source

pub const fn single_page(addr: PhysAddr) -> Self

Creates a page frame for a single page.

§Arguments

addr - The physical address of the page.

§Examples

use ruvix_physmem::{PageFrame, PhysAddr};

let frame = PageFrame::single_page(PhysAddr::new(0x1000));
assert_eq!(frame.pages(), 1);
assert_eq!(frame.order().as_usize(), 0);

Source

pub const fn addr(&self) -> PhysAddr

Returns the physical address of the frame’s start.

Source

pub const fn order(&self) -> PageOrder

Returns the order of the frame.

Source

pub const fn pages(&self) -> usize

Returns the number of pages in the frame.

Source

pub const fn bytes(&self) -> usize

Returns the size of the frame in bytes.

Source

pub const fn end_addr(&self) -> PhysAddr

Returns the physical address of the frame’s end (exclusive).

§Examples

use ruvix_physmem::{PageFrame, PhysAddr, PageOrder};

let frame = PageFrame::new(
    PhysAddr::new(0x1000),
    PageOrder::new(2).unwrap()
);
assert_eq!(frame.end_addr().as_u64(), 0x5000); // 0x1000 + 4*0x1000

Source

pub const fn pfn(&self) -> u64

Returns the page frame number of the first page.

Source

pub const fn contains(&self, addr: PhysAddr) -> bool

Checks if an address is contained within this frame.

§Arguments

addr - The address to check.

§Examples

use ruvix_physmem::{PageFrame, PhysAddr, PageOrder};

let frame = PageFrame::new(
    PhysAddr::new(0x1000),
    PageOrder::new(2).unwrap() // 4 pages: 0x1000..0x5000
);

assert!(frame.contains(PhysAddr::new(0x1000)));
assert!(frame.contains(PhysAddr::new(0x2500)));
assert!(frame.contains(PhysAddr::new(0x4FFF)));
assert!(!frame.contains(PhysAddr::new(0x5000)));
assert!(!frame.contains(PhysAddr::new(0x0FFF)));

Source

pub const fn split(&self) -> Option<(Self, Self)>

Splits the frame into two buddy frames of the next lower order.

Returns None if the frame is already at the minimum order.

§Examples

use ruvix_physmem::{PageFrame, PhysAddr, PageOrder};

let frame = PageFrame::new(
    PhysAddr::new(0x1000),
    PageOrder::new(2).unwrap() // 4 pages
);

if let Some((left, right)) = frame.split() {
    assert_eq!(left.pages(), 2);
    assert_eq!(right.pages(), 2);
    assert_eq!(left.addr().as_u64(), 0x1000);
    assert_eq!(right.addr().as_u64(), 0x3000);
}

Source

pub const fn buddy_addr(&self) -> PhysAddr

Returns the buddy address for this frame.

The buddy is the adjacent block of the same size that can be merged with this block to form a larger block.

§Examples

use ruvix_physmem::{PageFrame, PhysAddr, PageOrder};

// Frame at 0x1000, order 1 (2 pages)
let frame = PageFrame::new(
    PhysAddr::new(0x1000),
    PageOrder::new(1).unwrap()
);
// Buddy is at 0x3000 (XOR with block size)
assert_eq!(frame.buddy_addr().as_u64(), 0x3000);

// Frame at 0x3000, order 1 (2 pages)
let frame = PageFrame::new(
    PhysAddr::new(0x3000),
    PageOrder::new(1).unwrap()
);
// Buddy is at 0x1000
assert_eq!(frame.buddy_addr().as_u64(), 0x1000);

Source

pub const fn merge(&self, buddy: &Self) -> Option<Self>

Merges this frame with its buddy to create a larger frame.

Returns None if the merge would exceed the maximum order.

§Arguments

buddy - The buddy frame to merge with.

§Examples

use ruvix_physmem::{PageFrame, PhysAddr, PageOrder};

let left = PageFrame::new(PhysAddr::new(0x1000), PageOrder::new(1).unwrap());
let right = PageFrame::new(PhysAddr::new(0x3000), PageOrder::new(1).unwrap());

if let Some(merged) = left.merge(&right) {
    assert_eq!(merged.pages(), 4);
    assert_eq!(merged.addr().as_u64(), 0x1000);
}