Struct VirtualAddress 

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

A virtual memory address.

Fields

addr: usize

The underlying address

Implementations

impl VirtualAddress

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

Creates a new VirtualAddress with the given address.

Examples

use kernel_api::memory::VirtualAddress;

let addr = VirtualAddress::new(0);

pub const fn as_ptr(self) -> *mut u8

Converts a VirtualAddress into a raw pointer.

Examples

use kernel_api::memory::VirtualAddress;

let addr = VirtualAddress::new(0x1000);
let ptr = addr.as_ptr();
// if `addr` came from allocated memory, it can be accessed through `ptr`
// unsafe { *ptr = 5 };

pub const fn is_higher_half(self) -> bool

Returns true if the address is in the upper half of the address space, i.e. kernelspace.

Examples

use kernel_api::memory::VirtualAddress;

let addr = VirtualAddress::new(usize::MAX);
assert_eq!(addr.is_higher_half(), true);

pub const fn align_down_to_page(self) -> RawPage

Returns the closest RawPage at or below the current address.

Examples

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

let address = VirtualAddress::new(0x1);
let page = address.align_down_to_page();
assert!(address >= *page);
assert!((*page).is_aligned_to(PAGE_SIZE));

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

pub const fn align_up_to_page(self) -> RawPage

Returns the closest RawPage at or above the current address.

Examples

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

let address = VirtualAddress::new(0x1);
let page = address.align_up_to_page();
assert!(address <= *page);
assert!((*page).is_aligned_to(PAGE_SIZE));

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

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::VirtualAddress;

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

pub const fn saturating_add(self, rhs: usize) -> Self

Computes self + rhs, saturating when the address reaches [usize::MAX].

Examples

use kernel_api::memory::VirtualAddress;

let a = VirtualAddress::new(0x1000);
assert_eq!(a.saturating_add(1), Some(VirtualAddress::new(0x1001)));
assert_eq!(a.saturating_add(usize::MAX), None);

pub const fn saturating_sub(self, rhs: usize) -> Self

Computes self - rhs saturating when the address reaches 0.

Examples

use kernel_api::memory::VirtualAddress;

let a = VirtualAddress::new(0x1001);
assert_eq!(a.saturating_sub(1), Some(VirtualAddress::new(0x1000)));
assert_eq!(a.saturating_sub(usize::MAX), None);

pub const fn to_physical(self) -> PhysicalAddress

Converts an address in the physical page map region into an PhysicalAddress.

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

Panics

Panics if the address is not in the physical page map region on a best effort basis.

Examples

use kernel_api::memory::VirtualAddress;

let virt = VirtualAddress::new(0);

// converting non physical page map addresses may panic
let phys = virt.to_physical();

Trait Implementations

impl Add<isize> for VirtualAddress

type Output = VirtualAddress

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<usize> for VirtualAddress

type Output = VirtualAddress

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for VirtualAddress

fn clone(&self) -> VirtualAddress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for VirtualAddress

impl Debug for VirtualAddress

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

Formats the value using the given formatter.

impl Eq for VirtualAddress

impl<T: ?Sized> From<*const T> for VirtualAddress

fn from(value: *const T) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<*mut T> for VirtualAddress

fn from(value: *mut T) -> Self

Converts to this type from the input type.

impl From<RawPage> for VirtualAddress

fn from(value: RawPage) -> Self

Converts to this type from the input type.

impl Hash for VirtualAddress

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 VirtualAddress

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

Formats the value using the given formatter.

impl Ord for VirtualAddress

fn cmp(&self, other: &VirtualAddress) -> 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 VirtualAddress

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for VirtualAddress

fn partial_cmp(&self, other: &VirtualAddress) -> 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 VirtualAddress

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 VirtualAddress

impl Sub for VirtualAddress

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 VirtualAddress

type Output = VirtualAddress

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<usize> for VirtualAddress

type Output = VirtualAddress

The resulting type after applying the - operator.

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

Performs the - operation.