Struct PhysicalAddress 

#[repr(transparent)]
pub struct PhysicalAddress {
    pub addr: usize,
}

A physical memory address.

Fields

addr: usize

The underlying address

Implementations

impl PhysicalAddress

pub const fn new(addr: usize) -> Self

Creates a new PhysicalAddress with the given address.

Examples

use kernel_api::memory::PhysicalAddress;

let addr = PhysicalAddress::new(0);

pub const fn to_virtual(self) -> VirtualAddress

Converts a PhysicalAddress into a VirtualAddress via the physical page map region.

The returned VirtualAddress is only safe to access if the PhysicalAddress points into conventional RAM.

This is the physical-to-virtual counterpart to to_physical().

Examples

use kernel_api::memory::PhysicalAddress;

let phys = PhysicalAddress::new(0x1000);
let virt = phys.to_virtual();
// if there was conventional RAM at addr 0x1000,
// `virt` could now be accessed to write to that memory

pub const fn align_down_to_frame(self) -> RawFrame

Returns the closest RawFrame at or below the current address.

Examples

use kernel_api::memory::{PhysicalAddress, PAGE_SIZE};

let address = PhysicalAddress::new(0x1);
let frame = address.align_down_to_frame();
assert!(address >= *frame);
assert!((*frame).is_aligned_to(PAGE_SIZE));

// If the address is already aligned, then the value will remain unchanged.
let address = PhysicalAddress::new(PAGE_SIZE);
let frame = address.align_down_to_frame();
assert!(address == *frame);

pub const fn align_up_to_frame(self) -> RawFrame

Returns the closest RawFrame at or above the current address.

Examples

use kernel_api::memory::{PhysicalAddress, PAGE_SIZE};

let address = PhysicalAddress::new(0x1);
let frame = address.align_up_to_frame();
assert!(address <= *frame);
assert!((*frame).is_aligned_to(PAGE_SIZE));

// If the address is already aligned, then the value will remain unchanged.
let address = PhysicalAddress::new(PAGE_SIZE);
let frame = address.align_up_to_frame();
assert!(address == *frame);

pub const fn is_aligned_to(self, align: usize) -> bool

Returns true if the address is aligned to align.

Panics

If align is not a power of two.

Examples

use kernel_api::memory::PhysicalAddress;

let addr = PhysicalAddress::new(64);
assert_eq!(addr.is_aligned_to(32), true);
assert_eq!(addr.is_aligned_to(128), false);

Trait Implementations

impl Add<isize> for PhysicalAddress

type Output = PhysicalAddress

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl Add<usize> for PhysicalAddress

type Output = PhysicalAddress

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl Clone for PhysicalAddress

fn clone(&self) -> PhysicalAddress

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for PhysicalAddress

impl Debug for PhysicalAddress

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for PhysicalAddress

impl From<RawFrame> for PhysicalAddress

fn from(value: RawFrame) -> Self

Converts to this type from the input type.

impl Hash for PhysicalAddress

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given [Hasher].

impl LowerHex for PhysicalAddress

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Ord for PhysicalAddress

fn cmp(&self, other: &PhysicalAddress) -> Ordering

This method returns an [Ordering] between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for PhysicalAddress

fn eq(&self, other: &PhysicalAddress) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for PhysicalAddress

fn partial_cmp(&self, other: &PhysicalAddress) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Step for PhysicalAddress

fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>)

🔬This is a nightly-only experimental API. (step_trait)

Returns the bounds on the number of successor steps required to get from start to end like [Iterator::size_hint()][Iterator::size_hint()].

fn forward_checked(start: Self, count: usize) -> Option<Self>

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

fn forward_overflowing(start: Self, count: usize) -> (Self, bool)

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times along with a boolean tracking whether overflow occurred.

fn backward_checked(start: Self, count: usize) -> Option<Self>

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

fn backward_overflowing(start: Self, count: usize) -> (Self, bool)

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times along with a boolean tracking whether overflow occurred.

fn forward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

unsafe fn forward_unchecked(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

fn backward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

unsafe fn backward_unchecked(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

impl StructuralPartialEq for PhysicalAddress

impl Sub for PhysicalAddress

Returns the number of bytes between self and rhs.

type Output = usize

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Sub<isize> for PhysicalAddress

type Output = PhysicalAddress

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl Sub<usize> for PhysicalAddress

type Output = PhysicalAddress

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.