Struct memflow::types::physical_address::PhysicalAddress

#[repr(C)]
pub struct PhysicalAddress {
    pub address: Address,
    pub page_type: PageType,
    /* private fields */
}

This type represents a wrapper over a address with additional information about the containing page in the physical memory domain.

This type will mostly be used by the virtual to physical address translation. When a physical address is translated from a virtual address the additional information about the allocated page the virtual address points to can be obtained from this structure.

Most architectures have support multiple page sizes (see huge pages) which will be represented by the containing page of the PhysicalAddress struct.

Fields

address: Address

page_type: PageType

Implementations

impl PhysicalAddress

pub const NULL: PhysicalAddress = _

A physical address with a value of zero.

pub const INVALID: PhysicalAddress = _

A physical address with an invalid value.

pub const fn null() -> Self

Returns a physical address with a value of zero.

pub fn with_page(address: Address, page_type: PageType, page_size: umem) -> Self

Constructs a new PhysicalAddress form an Address with additional information about the page this address is contained in.

Note: The page size must be a power of 2.

pub const fn is_null(&self) -> bool

Checks wether the physical address is zero or not.

pub const fn invalid() -> Self

Returns a physical address that is invalid.

pub const fn is_valid(&self) -> bool

Checks wether the physical is valid or not.

pub const fn has_page(&self) -> bool

Checks wether the physical address also contains page informations or not.

pub const fn address(&self) -> Address

Returns the address of this physical address.

pub const fn page_type(&self) -> PageType

Returns the type of page this physical address is contained in.

pub fn page_size(&self) -> umem

Returns the size of the page this physical address is contained in.

pub fn page_base(&self) -> Address

Returns the base address of the containing page.

pub fn containing_page(&self) -> Page

Converts the physical address into it’s containing page page

pub const fn to_umem(self) -> umem

Returns the containing address converted to a raw umem.

Trait Implementations

impl Clone for PhysicalAddress

fn clone(&self) -> PhysicalAddress

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PhysicalAddress

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

Formats the value using the given formatter.

impl Default for PhysicalAddress

Returns a physical address with a value of zero.

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PhysicalAddress

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PhysicalAddress

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

Formats the value using the given formatter.

impl From<Address> for PhysicalAddress

Converts a PhysicalAddress into a Address.

fn from(address: Address) -> Self

Converts to this type from the input type.

impl From<PhysicalAddress> for Address

Converts a PhysicalAddress into a Address.

fn from(address: PhysicalAddress) -> Self

Converts to this type from the input type.

impl<U: PrimitiveAddress, T: ?Sized> From<Pointer<U, T>> for PhysicalAddress

fn from(ptr: Pointer<U, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i16, T>> for PhysicalAddress

fn from(ptr: Pointer<i16, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i32, T>> for PhysicalAddress

fn from(ptr: Pointer<i32, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i64, T>> for PhysicalAddress

fn from(ptr: Pointer<i64, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<i8, T>> for PhysicalAddress

fn from(ptr: Pointer<i8, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<u8, T>> for PhysicalAddress

fn from(ptr: Pointer<u8, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Pointer<usize, T>> for PhysicalAddress

fn from(ptr: Pointer<usize, T>) -> Self

Converts to this type from the input type.

impl<U: PrimitiveAddress> From<U> for PhysicalAddress

fn from(val: U) -> Self

Converts to this type from the input type.

impl From<i16> for PhysicalAddress

fn from(item: i16) -> Self

Converts to this type from the input type.

impl From<i32> for PhysicalAddress

fn from(item: i32) -> Self

Converts to this type from the input type.

impl From<i64> for PhysicalAddress

fn from(item: i64) -> Self

Converts to this type from the input type.

impl From<i8> for PhysicalAddress

fn from(item: i8) -> Self

Converts to this type from the input type.

impl From<u8> for PhysicalAddress

fn from(item: u8) -> Self

Converts to this type from the input type.

impl From<usize> for PhysicalAddress

fn from(item: usize) -> Self

Converts to this type from the input type.

impl GetStaticEquivalent_ for PhysicalAddress

type StaticEquivalent = _static_PhysicalAddress

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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for PhysicalAddress

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for PhysicalAddress

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StableAbi for PhysicalAddress

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl UpperHex for PhysicalAddress

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

Formats the value using the given formatter.

impl Copy for PhysicalAddress

impl Eq for PhysicalAddress

impl StructuralEq for PhysicalAddress

impl StructuralPartialEq for PhysicalAddress