Struct StartInfoReader 

pub struct StartInfoReader<'a, M> { /* private fields */ }

Available on crate feature reader only.

A start info reader.

This struct allows reading the data that is provided as physical addresses via the start info.

For this, a way of creating pointers from physical addresses is needed (MemMap), for example IdentityMap.

Examples

use pvh::start_info::reader::StartInfoReader;

let start_info = unsafe { StartInfoReader::from_paddr_identity(start_info_paddr).unwrap() };

println!("Start info:");
println!("{start_info:#?}");

Implementations

impl StartInfoReader<'_, IdentityMap>

pub unsafe fn from_paddr_identity(paddr: u32) -> Option<Self>

Creates a start info reader from a physical address that relies on identity-mapping.

This is a convenience method for from_paddr(IdentityMap).

Safety

• The structure at paddr must be valid. Specifically, the physical addresses in the structure’s fields must be valid.
• IdentityMap must be valid for the lifetime of the start info.

Examples found in repository

examples/print/main.rs (line 32)

unsafe extern "C" fn rust_start(start_info_paddr: u32) -> ! {
    // SAFETY: The caller upholds that `start_info_paddr` is valid.
    // We have configured the machine to use identity-mapping.
    let start_info = unsafe { StartInfoReader::from_paddr_identity(start_info_paddr).unwrap() };

    println!("Raw start info:\n\n{:#x?}\n", start_info.raw());

    println!("Start info reader:\n\n{start_info:?}\n");
    println!("Alternative start info reader:\n\n{start_info:#?}\n");

    for module in start_info.modlist() {
        let bytes = module.as_slice();
        if let Ok(s) = str::from_utf8(bytes) {
            println!("Module: {s:?}\n");
        } else {
            println!("Module: {bytes:?}\n");
        }
    }

    println!("Done!");

    loop {
        hint::spin_loop();
    }
}

impl<'a, M: MemMap> StartInfoReader<'a, M>

pub unsafe fn from_paddr(paddr: u32, mem_map: M) -> Option<Self>

Creates a start info reader from a physical address and a memory map.

from_paddr_identity is convenience method for identity-mappings.

Safety

• The structure at paddr must be valid. Specifically, the physical addresses in the structure’s fields must be valid.
• mem_map must be valid for the lifetime of the start info. For details, see MemMap.

pub fn raw(&self) -> &'a StartInfo

Returns the underlying raw start info.

Examples found in repository

examples/print/main.rs (line 34)

unsafe extern "C" fn rust_start(start_info_paddr: u32) -> ! {
    // SAFETY: The caller upholds that `start_info_paddr` is valid.
    // We have configured the machine to use identity-mapping.
    let start_info = unsafe { StartInfoReader::from_paddr_identity(start_info_paddr).unwrap() };

    println!("Raw start info:\n\n{:#x?}\n", start_info.raw());

    println!("Start info reader:\n\n{start_info:?}\n");
    println!("Alternative start info reader:\n\n{start_info:#?}\n");

    for module in start_info.modlist() {
        let bytes = module.as_slice();
        if let Ok(s) = str::from_utf8(bytes) {
            println!("Module: {s:?}\n");
        } else {
            println!("Module: {bytes:?}\n");
        }
    }

    println!("Done!");

    loop {
        hint::spin_loop();
    }
}

pub fn modlist(&self) -> impl Iterator<Item = ModlistEntryReader<'a, &M>>

Returns an iterator of module list entry readers.

Examples found in repository

examples/print/main.rs (line 39)

unsafe extern "C" fn rust_start(start_info_paddr: u32) -> ! {
    // SAFETY: The caller upholds that `start_info_paddr` is valid.
    // We have configured the machine to use identity-mapping.
    let start_info = unsafe { StartInfoReader::from_paddr_identity(start_info_paddr).unwrap() };

    println!("Raw start info:\n\n{:#x?}\n", start_info.raw());

    println!("Start info reader:\n\n{start_info:?}\n");
    println!("Alternative start info reader:\n\n{start_info:#?}\n");

    for module in start_info.modlist() {
        let bytes = module.as_slice();
        if let Ok(s) = str::from_utf8(bytes) {
            println!("Module: {s:?}\n");
        } else {
            println!("Module: {bytes:?}\n");
        }
    }

    println!("Done!");

    loop {
        hint::spin_loop();
    }
}

pub fn cmdline(&self) -> Option<&'a CStr>

Returns the command line.

pub fn memmap(&self) -> &'a [MemmapTableEntry]

Returns the memory map.

Trait Implementations

impl<M: MemMap> Debug for StartInfoReader<'_, M>

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

Formats the value using the given formatter.