Struct CoreDump

pub struct CoreDump {
    pub registers: HashMap<RegisterId, RegisterValue>,
    pub data: Vec<(Range<u64>, Vec<u8>)>,
    pub instruction_set: InstructionSet,
    pub supports_native_64bit_access: bool,
    pub core_type: CoreType,
    pub fpu_support: bool,
    pub floating_point_register_count: Option<usize>,
}

A snapshot representation of a core state.

Fields

registers: HashMap<RegisterId, RegisterValue>

The registers we dumped from the core.

data: Vec<(Range<u64>, Vec<u8>)>

The memory we dumped from the core.

instruction_set: InstructionSet

The instruction set of the dumped core.

supports_native_64bit_access: bool

Whether or not the target supports native 64 bit support (64bit architectures)

core_type: CoreType

The type of core we have at hand.

fpu_support: bool

Whether this core supports floating point.

floating_point_register_count: Option<usize>

The number of floating point registers.

Implementations

impl CoreDump

pub fn dump_core( core: &mut Core<'_>, ranges: Vec<Range<u64>>, ) -> Result<Self, Error>

Dump the core info with the current state.

Arguments

• core: The core to dump.
• ranges: Memory ranges that should be dumped.

pub fn store(&self, path: &Path) -> Result<(), CoreDumpError>

Store the dumped core to a file.

pub fn load(path: &Path) -> Result<Self, CoreDumpError>

Load the dumped core from a file.

pub fn load_raw(data: &[u8]) -> Result<Self, CoreDumpError>

Load the dumped core from a file.

pub fn debug_registers(&self) -> DebugRegisters

Read all registers defined in crate::core::CoreRegisters from the given core.

pub fn core_type(&self) -> CoreType

Returns the type of the core.

pub fn instruction_set(&self) -> InstructionSet

Returns the currently active instruction-set

Trait Implementations

impl Clone for CoreDump

fn clone(&self) -> CoreDump

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CoreDump

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CoreDump

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MemoryInterface for CoreDump

fn supports_native_64bit_access(&mut self) -> bool

Does this interface support native 64-bit wide accesses

fn read_word_64(&mut self, address: u64) -> Result<u64, Error>

Read a 64bit word of at address.

fn read_word_32(&mut self, address: u64) -> Result<u32, Error>

Read a 32bit word of at address.

fn read_word_16(&mut self, address: u64) -> Result<u16, Error>

Read a 16bit word of at address.

fn read_word_8(&mut self, address: u64) -> Result<u8, Error>

Read an 8bit word of at address.

fn read_64(&mut self, address: u64, data: &mut [u64]) -> Result<(), Error>

Read a block of 64bit words at address.

fn read_32(&mut self, address: u64, data: &mut [u32]) -> Result<(), Error>

Read a block of 32bit words at address.

fn read_16(&mut self, address: u64, data: &mut [u16]) -> Result<(), Error>

Read a block of 16bit words at address.

fn read_8(&mut self, address: u64, data: &mut [u8]) -> Result<(), Error>

Read a block of 8bit words at address.

fn write_word_64(&mut self, _address: u64, _data: u64) -> Result<(), Error>

Write a 64bit word at address.

fn write_word_32(&mut self, _address: u64, _data: u32) -> Result<(), Error>

Write a 32bit word at address.

fn write_word_16(&mut self, _address: u64, _data: u16) -> Result<(), Error>

Write a 16bit word at address.

fn write_word_8(&mut self, _address: u64, _data: u8) -> Result<(), Error>

Write an 8bit word at address.

fn write_64(&mut self, _address: u64, _data: &[u64]) -> Result<(), Error>

Write a block of 64bit words at address.

fn write_32(&mut self, _address: u64, _data: &[u32]) -> Result<(), Error>

Write a block of 32bit words at address.

fn write_16(&mut self, _address: u64, _data: &[u16]) -> Result<(), Error>

Write a block of 16bit words at address.

fn write_8(&mut self, _address: u64, _data: &[u8]) -> Result<(), Error>

Write a block of 8bit words at address.

fn supports_8bit_transfers(&self) -> Result<bool, Error>

Returns whether the current platform supports native 8bit transfers.

fn flush(&mut self) -> Result<(), Error>

Flush any outstanding operations.

fn read_mem_64bit(&mut self, address: u64, data: &mut [u8]) -> Result<(), ERR>

Reads bytes using 64 bit memory access.

fn read_mem_32bit(&mut self, address: u64, data: &mut [u8]) -> Result<(), ERR>

Reads bytes using 32 bit memory access.

fn read(&mut self, address: u64, data: &mut [u8]) -> Result<(), ERR>

Read data from address.

fn write_mem_64bit(&mut self, address: u64, data: &[u8]) -> Result<(), ERR>

Writes bytes using 64 bit memory access. Address must be 64 bit aligned and data must be an exact multiple of 8.

fn write_mem_32bit(&mut self, address: u64, data: &[u8]) -> Result<(), ERR>

Writes bytes using 32 bit memory access. Address must be 32 bit aligned and data must be an exact multiple of 8.

fn write(&mut self, address: u64, data: &[u8]) -> Result<(), ERR>

Write a block of 8bit words at address. May use 64 bit memory access, so should only be used if reading memory locations that don’t have side effects. Generally faster than MemoryInterface::write_8.

impl Serialize for CoreDump

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

where __S: Serializer,

Serialize this value into the given Serde serializer.