Struct devices::irqchip::ioapic::Ioapic

pub struct Ioapic {
    num_pins: usize,
    ioregsel: u8,
    ioapicid: u32,
    rtc_remote_irr: bool,
    out_events: Vec<Option<OutEvent>>,
    resample_events: Vec<Vec<Event>>,
    redirect_table: Vec<IoapicRedirectionTableEntry>,
    interrupt_level: Vec<bool>,
    irq_tube: Tube,
}

Fields

num_pins: usize

Number of supported IO-APIC inputs / redirection entries.

ioregsel: u8

ioregsel register. Used for selecting which entry of the redirect table to read/write.

ioapicid: u32

ioapicid register. Bits 24 - 27 contain the APIC ID for this device.

rtc_remote_irr: bool

Remote IRR for Edge Triggered Real Time Clock interrupts, which allows the CMOS to know when one of its interrupts is being coalesced.

out_events: Vec<Option<OutEvent>>

Outgoing irq events that are used to inject MSI interrupts. Also contains the serializable form used for snapshotting.

resample_events: Vec<Vec<Event>>

Events that should be triggered on an EOI. The outer Vec is indexed by GSI, and the inner Vec is an unordered list of registered resample events for the GSI.

redirect_table: Vec<IoapicRedirectionTableEntry>

Redirection settings for each irq line.

interrupt_level: Vec<bool>

Interrupt activation state.

irq_tube: Tube

Tube used to route MSI irqs.

Implementations

impl Ioapic

pub fn new(irq_tube: Tube, num_pins: usize) -> Result<Ioapic>

pub fn get_ioapic_state(&self) -> IoapicState

pub fn set_ioapic_state(&mut self, state: &IoapicState)

pub fn register_resample_events(&mut self, resample_events: Vec<Vec<Event>>)

pub fn end_of_interrupt(&mut self, vector: u8)

pub fn service_irq(&mut self, irq: usize, level: bool) -> bool

fn ioapic_write(&mut self, val: u32)

fn setup_msi( &mut self, index: usize, msi_address: u64, msi_data: u32 ) -> Result<(), IoapicError>

fn restore_msi( &mut self, index: usize, gsi: u32, msi_address: u64, msi_data: u32 ) -> Result<(), IoapicError>

Similar to Ioapic::setup_msi, but used only to re-create an MSI as part of the snapshot restore process, which allows us to assume certain invariants (like msi_data != 0) already hold.

fn release_all_msis(&mut self) -> Result<(), IoapicError>

On warm restore, there could already be MSIs registered. We need to release them in case the routing has changed (e.g. different data <-> GSI).

fn ioapic_read(&mut self) -> u32

Trait Implementations

impl BusDevice for Ioapic

fn debug_label(&self) -> String

Returns a label suitable for debug output.

fn device_id(&self) -> DeviceId

Returns a unique id per device type suitable for metrics gathering.

fn read(&mut self, info: BusAccessInfo, data: &mut [u8])

Reads at offset from this device

fn write(&mut self, info: BusAccessInfo, data: &[u8])

Writes at offset into this device

fn config_register_write( &mut self, reg_idx: usize, offset: u64, data: &[u8] ) -> ConfigWriteResult

Sets a register in the configuration space. Only used by PCI.

fn config_register_read(&self, reg_idx: usize) -> u32

Gets a register from the configuration space. Only used by PCI.

fn init_pci_config_mapping( &mut self, shmem: &SharedMemory, base: usize, len: usize ) -> bool

Provides a memory region to back MMIO access to the configuration space. If the device can keep the memory region up to date, then it should return true, after which no more calls to config_register_read will be made. Otherwise the device should return false.

fn virtual_config_register_write(&mut self, reg_idx: usize, value: u32)

Sets a register in the virtual config space. Only used by PCI.

fn virtual_config_register_read(&self, reg_idx: usize) -> u32

Gets a register from the virtual config space. Only used by PCI.

fn on_sandboxed(&mut self)

Invoked when the device is sandboxed.

fn get_ranges(&self) -> Vec<(BusRange, BusType)>

Gets a list of all ranges registered by this BusDevice.

fn destroy_device(&mut self)

Invoked when the device is destroyed

fn is_bridge(&self) -> Option<u8>

Returns the secondary bus number if this bus device is pci bridge

impl Suspendable for Ioapic

fn snapshot(&mut self) -> Result<Value>

Save the device state in an image that can be restored.

fn restore(&mut self, data: Value) -> Result<()>

Load a saved snapshot of an image.

fn sleep(&mut self) -> Result<()>

Stop all threads related to the device. Sleep should be idempotent.

fn wake(&mut self) -> Result<()>

Create/Resume all threads related to the device. Wake should be idempotent.