Struct PageOrder

Source

pub struct PageOrder(/* private fields */);

Expand description

The order of a page frame block.

Order n represents 2^n contiguous pages:

Order 0: 1 page (4KB)
Order 1: 2 pages (8KB)
Order 2: 4 pages (16KB)
…
Order 9: 512 pages (2MB)

§Examples

use ruvix_physmem::PageOrder;

let order = PageOrder::new(2).unwrap();
assert_eq!(order.pages(), 4);
assert_eq!(order.bytes(), 16384);

Implementations§

Source §

impl PageOrder

Source

pub const MIN: Self

The minimum order (single page, 4KB).

Source

pub const MAX: Self

The maximum order (512 pages, 2MB).

Source

pub const fn new(order: usize) -> Option<Self>

Creates a new page order.

Returns None if the order is greater than or equal to MAX_ORDER.

§Arguments

order - The order value (0 to MAX_ORDER - 1).

§Examples

use ruvix_physmem::PageOrder;

assert!(PageOrder::new(0).is_some());
assert!(PageOrder::new(9).is_some());
assert!(PageOrder::new(10).is_none()); // MAX_ORDER = 10

Source

pub const fn new_unchecked(order: usize) -> Self

Creates a new page order without bounds checking.

§Safety

This is safe because we only store a u8 and the buddy allocator will validate the order. However, using an invalid order will result in unexpected behavior.

§Arguments

order - The order value.

Source

pub const fn as_usize(self) -> usize

Returns the order as a usize.

Source

pub const fn pages(self) -> usize

Returns the number of pages for this order.

§Examples

use ruvix_physmem::PageOrder;

assert_eq!(PageOrder::new(0).unwrap().pages(), 1);
assert_eq!(PageOrder::new(1).unwrap().pages(), 2);
assert_eq!(PageOrder::new(2).unwrap().pages(), 4);
assert_eq!(PageOrder::new(9).unwrap().pages(), 512);

Source

pub const fn bytes(self) -> usize

Returns the block size in bytes for this order.

§Examples

use ruvix_physmem::PageOrder;

assert_eq!(PageOrder::new(0).unwrap().bytes(), 4096);
assert_eq!(PageOrder::new(1).unwrap().bytes(), 8192);
assert_eq!(PageOrder::new(9).unwrap().bytes(), 2 * 1024 * 1024);

Source

pub const fn next(self) -> Option<Self>

Returns the next higher order, if it exists.

§Examples

use ruvix_physmem::PageOrder;

let order = PageOrder::new(2).unwrap();
assert_eq!(order.next().map(|o| o.as_usize()), Some(3));

let max = PageOrder::MAX;
assert!(max.next().is_none());

Source

pub const fn prev(self) -> Option<Self>

Returns the next lower order, if it exists.

§Examples

use ruvix_physmem::PageOrder;

let order = PageOrder::new(2).unwrap();
assert_eq!(order.prev().map(|o| o.as_usize()), Some(1));

let min = PageOrder::MIN;
assert!(min.prev().is_none());

Source

pub const fn from_pages(pages: usize) -> Option<Self>

Creates an order from a page count, rounding up if necessary.

Returns None if the resulting order would exceed MAX_ORDER - 1.

§Arguments

pages - The number of pages needed.

§Examples

use ruvix_physmem::PageOrder;

assert_eq!(PageOrder::from_pages(1).map(|o| o.as_usize()), Some(0));
assert_eq!(PageOrder::from_pages(2).map(|o| o.as_usize()), Some(1));
assert_eq!(PageOrder::from_pages(3).map(|o| o.as_usize()), Some(2)); // rounds up
assert_eq!(PageOrder::from_pages(4).map(|o| o.as_usize()), Some(2));
assert_eq!(PageOrder::from_pages(512).map(|o| o.as_usize()), Some(9));
assert!(PageOrder::from_pages(513).is_none()); // Too large

Source

pub const fn from_bytes(bytes: usize) -> Option<Self>

Creates an order from a byte size, rounding up if necessary.

Returns None if the resulting order would exceed MAX_ORDER - 1.

§Arguments

bytes - The number of bytes needed.

§Examples

use ruvix_physmem::PageOrder;

assert_eq!(PageOrder::from_bytes(1).map(|o| o.as_usize()), Some(0));
assert_eq!(PageOrder::from_bytes(4096).map(|o| o.as_usize()), Some(0));
assert_eq!(PageOrder::from_bytes(4097).map(|o| o.as_usize()), Some(1));
assert_eq!(PageOrder::from_bytes(8192).map(|o| o.as_usize()), Some(1));