Struct Interrupt

pub struct Interrupt {
    pub vector: ExceptionVector,
    pub typ: InterruptType,
    pub error_code: u32,
    pub instruction_length: u8,
    pub extra: u64,
}

Available on crate feature arch-amd64 only.

Information about an interrupt or exception.

Fields

vector: ExceptionVector

Vector number of the interrupt.

typ: InterruptType

Type of interrupt.

error_code: u32

Error code associated with the interrupt.

instruction_length: u8

Length of the instruction that caused the interrupt.

extra: u64

Extra information about the interrupt.

For page faults, this is the virtual address that caused the fault (i.e., CR2).

Implementations

impl Interrupt

pub fn breakpoint(instruction_length: u8) -> Interrupt

Creates a new software breakpoint exception.

pub fn page_fault(va: Va, error_code: u32) -> Interrupt

Creates a new page fault exception.

Examples found in repository

examples/windows-breakpoint-manager.rs (line 522)

    fn dispatch(
        &mut self,
        vmi: &VmiContext<'_, Driver, WindowsOs<Driver>>,
    ) -> Result<VmiEventResponse<Amd64>, VmiError> {
        let event = vmi.event();
        let result = match event.reason() {
            EventReason::MemoryAccess(_) => self.memory_access(vmi),
            EventReason::Interrupt(_) => self.interrupt(vmi),
            EventReason::Singlestep(_) => self.singlestep(vmi),
            _ => panic!("Unhandled event: {:?}", event.reason()),
        };

        // If VMI tries to read from a page that is not present, it will return
        // a page fault error. In this case, we inject a page fault interrupt
        // to the guest.
        //
        // Once the guest handles the page fault, it will try to retry the
        // instruction that caused the page fault.
        if let Err(VmiError::PageFault(pfs)) = result {
            tracing::warn!(?pfs, "Page fault, injecting");
            vmi.inject_interrupt(event.vcpu_id(), Interrupt::page_fault(pfs[0].address, 0))?;
            return Ok(VmiEventResponse::default());
        }

        result
    }

Trait Implementations

impl Clone for Interrupt

fn clone(&self) -> Interrupt

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Interrupt

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

Formats the value using the given formatter.

impl Copy for Interrupt