Struct Instruction 

pub struct Instruction<'a> { /* private fields */ }

Wrapper structure for a qemu_plugin_insn *

Safety

This structure is safe to use as long as the pointer is valid. The pointer is always opaque, and therefore may not be dereferenced.

Example

struct MyPlugin;

impl qemu_plugin::plugin::Register for MyPlugin {}

impl qemu_plugin::plugin::HasCallbacks for MyPlugin {
    fn on_translation_block_translate(
        &mut self,
        id: qemu_plugin::PluginId,
        tb: qemu_plugin::TranslationBlock,
    ) -> Result<()> {
        for insn in tb.instructions() {
            let vaddr = insn.vaddr();
            let disas = insn.disas()?;
            // Register a callback to be run on execution of this instruction
            insn.register_execute_callback(move |vcpu_index| {
                println!("{vcpu_index}@{vaddr:#x}: {disas}");
            });
        }
        Ok(())
    }
}

Implementations

impl<'a> Instruction<'a>

pub fn read_data(&self, data: &mut [u8]) -> usize

Reads the data for this instruction returning number of bytes read. This method may only be called inside the callback in which the instruction is obtained.

pub fn data(&self) -> Vec<u8>

Returns the data for this instruction. This method may only be called inside the callback in which the instruction is obtained, but the resulting data is owned.

pub fn size(&self) -> usize

Returns the size of the data for this instruction

pub fn vaddr(&self) -> u64

Returns the virtual address of this instruction

pub fn haddr(&self) -> u64

Returns the hardware (physical) address of this instruction

pub fn disas(&self) -> Result<String>

Returns the textual disassembly of this instruction

pub fn symbol(&self) -> Result<Option<String>>

Returns the symbol associated with this instruction, if one exists and the binary contains a symbol table

pub fn register_execute_callback<F>(&self, cb: F)

where F: FnMut(VCPUIndex) + Send + Sync + 'static,

Register a callback to be run on execution of this instruction with no capability to inspect registers

Arguments

• cb: The callback to be run

pub fn register_execute_callback_flags<F>(&self, cb: F, flags: CallbackFlags)

where F: FnMut(VCPUIndex) + Send + Sync + 'static,

Register a callback to be run on execution of this instruction with a choice of capability whether to inspect or modify registers or not

Arguments

• cb: The callback to be run
• flags: The flags for the callback specifying whether the callback needs permission to read or write registers

pub fn register_conditional_execute_callback<F>( &self, cb: F, cond: PluginCondition, entry: PluginU64, immediate: u64, )

where F: FnMut(VCPUIndex) + Send + Sync + 'static,

Register a callback to be conditionally run on execution of this instruction with no capability to inspect registers

Arguments

• cb: The callback to be run
• cond: The condition for the callback to be run
• entry: The entry to increment the scoreboard for
• immediate: The immediate value to use for the callback

pub fn register_conditional_execute_callback_flags<F>( &self, cb: F, flags: CallbackFlags, cond: PluginCondition, entry: PluginU64, immediate: u64, )

where F: FnMut(VCPUIndex) + Send + Sync + 'static,

Register a callback to be conditionally run on execution of this instruction with a choice of capability whether to inspect or modify registers or not

Arguments

• cb: The callback to be run
• flags: The flags for the callback specifying whether the callback needs permission to read or write registers
• cond: The condition for the callback to be run
• entry: The entry to increment the scoreboard for
• immediate: The immediate value to use for the callback

pub fn register_memory_access_callback<F>(&self, cb: F, rw: MemRW)

where F: for<'b> FnMut(VCPUIndex, MemoryInfo<'b>, u64) + Send + Sync + 'static,

Register a callback to be run on memory access of this instruction

Arguments

• cb: The callback to be run
• rw: The type of memory access to trigger the callback on

pub fn register_memory_access_callback_flags<F>( &self, cb: F, rw: MemRW, flags: CallbackFlags, )

where F: for<'b> FnMut(VCPUIndex, MemoryInfo<'b>, u64) + Send + Sync + 'static,

Register a callback to be run on memory access of this instruction

Arguments

• cb: The callback to be run
• rw: The type of memory access to trigger the callback on

Trait Implementations

impl<'a> Clone for Instruction<'a>

fn clone(&self) -> Instruction<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Instruction<'a>

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

Formats the value using the given formatter.