Struct Fmap 

#[repr(packed(1))]
pub struct Fmap {
    pub signature: [u8; 8],
    pub ver_major: u8,
    pub ver_minor: u8,
    pub base: u64,
    pub size: u32,
    pub name: [u8; 32],
    pub nareas: u16,
}

Fields

signature: [u8; 8]

ver_major: u8

ver_minor: u8

base: u64

size: u32

name: [u8; 32]

nareas: u16

Implementations

impl Fmap

pub fn area(&self, i: u16) -> &FmapArea

Examples found in repository

examples/file.rs (line 20)

fn inner(path: &str) -> io::Result<()> {
    let data = fs::read(path)?;
    let rom = Rom::new(&data);

    if let Some(fmap) = rom.fmap() {
        let mut name = String::new();
        for &b in fmap.name.iter() {
            if b == 0 {
                break;
            }
            name.push(b as char);
        }

        eprintln!("  {}", name);

        for i in 0..fmap.nareas {
            let area = fmap.area(i);

            let mut name = String::new();
            for &b in area.name.iter() {
                if b == 0 {
                    break;
                }
                name.push(b as char);
            }

            eprintln!("    {}: {}", i, name);
        }
    }

    if let Some(header) = rom.header() {
        eprintln!("  CBFS");

        let align = u32::from(header.align) as usize;
        let mut offset = u32::from(header.offset) as usize;
        while let Some(file) = rom.file(offset) {
            let name_bytes = file.name();

            let mut name = String::new();
            for &b in name_bytes.iter() {
                if b == 0 {
                    break;
                }
                name.push(b as char);
            }

            eprintln!("    {:#X}: {}", offset, name);

            let file_offset = u32::from(file.offset) as usize;
            let file_len = u32::from(file.len) as usize;
            offset = ((offset + file_offset + file_len + align - 1) / align) * align;
        }
    } else {
        eprintln!("coreboot header not found");
    }

    Ok(())
}

Trait Implementations

impl Clone for Fmap

fn clone(&self) -> Fmap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fmap

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

Formats the value using the given formatter.

impl Plain for Fmap

fn from_bytes(bytes: &[u8]) -> Result<&Self, Error>

where Self: Sized,

fn slice_from_bytes(bytes: &[u8]) -> Result<&[Self], Error>

where Self: Sized,

fn slice_from_bytes_len(bytes: &[u8], len: usize) -> Result<&[Self], Error>

where Self: Sized,

fn from_mut_bytes(bytes: &mut [u8]) -> Result<&mut Self, Error>

where Self: Sized,

fn slice_from_mut_bytes(bytes: &mut [u8]) -> Result<&mut [Self], Error>

where Self: Sized,

fn slice_from_mut_bytes_len( bytes: &mut [u8], len: usize, ) -> Result<&mut [Self], Error>

where Self: Sized,

fn copy_from_bytes(&mut self, bytes: &[u8]) -> Result<(), Error>

impl Copy for Fmap