Struct DescriptorAddress 

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

A canonical 64-bit virtual memory address.

This is a wrapper type around an u64, so it is always 8 bytes, even when compiled on non 64-bit systems. The TryFrom trait can be used for performing conversions between u64 and usize.

On x86_64, only the 48 lower bits of a virtual address can be used. The top 16 bits need to be copies of bit 47, i.e. the most significant bit. Addresses that fulfil this criterion are called “canonical”. This type guarantees that it always represents a canonical address.

Implementations

impl VirtAddr

pub const fn new(addr: u64) -> VirtAddr

Creates a new canonical virtual address.

The provided address should already be canonical. If you want to check whether an address is canonical, use try_new.

Panics

This function panics if the bits in the range 48 to 64 are invalid (i.e. are not a proper sign extension of bit 47).

pub const fn try_new(addr: u64) -> Result<VirtAddr, VirtAddrNotValid>

Tries to create a new canonical virtual address.

This function checks whether the given address is canonical and returns an error otherwise. An address is canonical if bits 48 to 64 are a correct sign extension (i.e. copies of bit 47).

pub const fn new_truncate(addr: u64) -> VirtAddr

Creates a new canonical virtual address, throwing out bits 48..64.

This function performs sign extension of bit 47 to make the address canonical, overwriting bits 48 to 64. If you want to check whether an address is canonical, use new or try_new.

pub const unsafe fn new_unsafe(addr: u64) -> VirtAddr

Creates a new virtual address, without any checks.

Safety

You must make sure bits 48..64 are equal to bit 47. This is not checked.

pub const fn zero() -> VirtAddr

Creates a virtual address that points to 0.

pub const fn as_u64(self) -> u64

Converts the address to an u64.

pub fn from_ptr<T>(ptr: *const T) -> VirtAddr

where T: ?Sized,

Available on 64-bit only.

Creates a virtual address from the given pointer

pub const fn as_ptr<T>(self) -> *const T

Available on 64-bit only.

Converts the address to a raw pointer.

pub const fn as_mut_ptr<T>(self) -> *mut T

Available on 64-bit only.

Converts the address to a mutable raw pointer.

pub const fn is_null(self) -> bool

Convenience method for checking if a virtual address is null.

pub fn align_up<U>(self, align: U) -> VirtAddr

where U: Into<u64>,

Aligns the virtual address upwards to the given alignment.

See the align_up function for more information.

Panics

This function panics if the resulting address is higher than 0xffff_ffff_ffff_ffff.

pub fn align_down<U>(self, align: U) -> VirtAddr

where U: Into<u64>,

Aligns the virtual address downwards to the given alignment.

See the align_down function for more information.

pub fn is_aligned<U>(self, align: U) -> bool

where U: Into<u64>,

Checks whether the virtual address has the demanded alignment.

pub const fn page_offset(self) -> PageOffset

Returns the 12-bit page offset of this virtual address.

pub const fn p1_index(self) -> PageTableIndex

Returns the 9-bit level 1 page table index.

pub const fn p2_index(self) -> PageTableIndex

Returns the 9-bit level 2 page table index.

pub const fn p3_index(self) -> PageTableIndex

Returns the 9-bit level 3 page table index.

pub const fn p4_index(self) -> PageTableIndex

Returns the 9-bit level 4 page table index.

pub const fn page_table_index(self, level: PageTableLevel) -> PageTableIndex

Returns the 9-bit level page table index.

Trait Implementations

impl Add<u64> for VirtAddr

fn add(self, rhs: u64) -> <VirtAddr as Add<u64>>::Output

Add an offset to a virtual address.

This function performs normal arithmetic addition and doesn’t jump the address gap. If you’re looking for a successor operation that jumps the address gap, use [Step::forward].

Panics

This function will panic on overflow or if the result is not a canonical address.

type Output = VirtAddr

The resulting type after applying the + operator.

impl AddAssign<u64> for VirtAddr

fn add_assign(&mut self, rhs: u64)

Add an offset to a virtual address.

This function performs normal arithmetic addition and doesn’t jump the address gap. If you’re looking for a successor operation that jumps the address gap, use [Step::forward].

Panics

This function will panic on overflow or if the result is not a canonical address.

impl Binary for VirtAddr

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

Formats the value using the given formatter.

impl Clone for VirtAddr

fn clone(&self) -> VirtAddr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for VirtAddr

impl Debug for VirtAddr

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

Formats the value using the given formatter.

impl Eq for VirtAddr

impl Hash for VirtAddr

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

where __H: Hasher,

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 VirtAddr

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

Formats the value using the given formatter.

impl Octal for VirtAddr

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

Formats the value using the given formatter.

impl Ord for VirtAddr

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

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for VirtAddr

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

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

Formats the value using the given formatter.

impl StructuralPartialEq for VirtAddr

impl Sub for VirtAddr

fn sub(self, rhs: VirtAddr) -> <VirtAddr as Sub>::Output

Returns the difference between two addresses.

Panics

This function will panic on overflow.

type Output = u64

The resulting type after applying the - operator.

impl Sub<u64> for VirtAddr

fn sub(self, rhs: u64) -> <VirtAddr as Sub<u64>>::Output

Subtract an offset from a virtual address.

This function performs normal arithmetic subtraction and doesn’t jump the address gap. If you’re looking for a predecessor operation that jumps the address gap, use [Step::backward].

Panics

This function will panic on overflow or if the result is not a canonical address.

type Output = VirtAddr

The resulting type after applying the - operator.

impl SubAssign<u64> for VirtAddr

fn sub_assign(&mut self, rhs: u64)

Subtract an offset from a virtual address.

This function performs normal arithmetic subtraction and doesn’t jump the address gap. If you’re looking for a predecessor operation that jumps the address gap, use [Step::backward].

Panics

This function will panic on overflow or if the result is not a canonical address.

impl UpperHex for VirtAddr

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

Formats the value using the given formatter.