Struct TranslationBlock 

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

Wrapper structure for a qemu_plugin_tb *

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() {
            println!("{:08x}: {}", insn.vaddr(), insn.disas()?);
        }   
        Ok(())
    }
}

Implementations

impl<'a> TranslationBlock<'a>

pub fn size(&self) -> usize

Returns the number of instructions in the translation block

pub fn vaddr(&self) -> u64

Returns the virtual address for the start of a translation block

pub fn instruction(&'a self, index: usize) -> Result<Instruction<'a>>

Returns the instruction in the translation block at index. If the index is out of bounds, an error is returned.

Arguments

• index: The index of the instruction to return

pub fn instructions(&'a self) -> TranslationBlockIterator<'a>

Returns an iterator over the instructions in the translation block

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 translation block

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 translation block

Arguments

• cb: The callback to be run

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 translation block

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 translation block

Arguments

• cb: The callback to be run
• flags: The flags for the callback
• 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

Trait Implementations

impl<'a> From<*mut qemu_plugin_tb> for TranslationBlock<'a>

fn from(tb: *mut qemu_plugin_tb) -> Self

Converts to this type from the input type.