chipset/ioapic/

mod.rs

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! IO-APIC emulator.
//!
//! Currently this supports IO-APIC version 0x11, from the PIIX4 era. This
//! version does not support an EOI register (unlike version 0x20 and newer).

use self::spec::IO_APIC_VERSION;
use self::spec::IOAPIC_DEVICE_MMIO_REGION_SIZE;
use self::spec::IndexRegister;
use self::spec::IoApicId;
use self::spec::IoApicVersion;
use self::spec::REDIRECTION_WRITE_MASK;
use self::spec::RedirectionEntry;
use crate::ioapic::spec::IOAPIC_DEVICE_MMIO_REGION_MASK;
use crate::ioapic::spec::Register;
use chipset_device::ChipsetDevice;
use chipset_device::interrupt::HandleEoi;
use chipset_device::interrupt::LineInterruptTarget;
use chipset_device::io::IoError;
use chipset_device::io::IoResult;
use chipset_device::mmio::MmioIntercept;
use chipset_resources::ioapic::IoApicRouting;
use inspect::Inspect;
use inspect::InspectMut;
use inspect_counters::Counter;
use std::fmt::Debug;
use std::ops::RangeInclusive;
use vmcore::device_state::ChangeDeviceState;
use x86defs::apic::DeliveryMode;
use x86defs::msi::MsiAddress;
use x86defs::msi::MsiData;

pub mod resolver;

pub const IOAPIC_DEVICE_MMIO_REGION_BASE_ADDRESS: u64 =
    acpi_spec::hyperv::IOAPIC_BASE_ADDRESS as u64;

mod spec {
    use bitfield_struct::bitfield;
    use inspect::Inspect;
    use open_enum::open_enum;

    /// The version reported by the Intel 82093AA.
    pub const IO_APIC_VERSION: u8 = 0x11;

    open_enum! {
        pub enum Register: u64 {
            INDEX = 0,
            DATA = 0x10,
        }
    }

    open_enum! {
        #[derive(Inspect)]
        #[inspect(debug)]
        pub enum IndexRegister: u8 {
            ID = 0,
            VERSION = 1,
            ARBITRATION_ID = 2,
            REDIRECTION_TABLE_START = 0x10,
        }
    }

    pub const IOAPIC_DEVICE_MMIO_REGION_SIZE: u64 = 0x20;
    pub const IOAPIC_DEVICE_MMIO_REGION_MASK: u64 = IOAPIC_DEVICE_MMIO_REGION_SIZE - 1;

    #[derive(Inspect)]
    #[bitfield(u64)]
    #[rustfmt::skip]
    pub struct RedirectionEntry {
        #[bits(8)] pub vector: u8,
        #[bits(3)] pub delivery_mode: u8,
        #[bits(1)] pub destination_mode_logical: bool,
        #[bits(1)] pub delivery_status: bool,
        #[bits(1)] pub active_low: bool,
        #[bits(1)] pub remote_irr: bool,
        #[bits(1)] pub trigger_mode_level: bool,
        #[bits(1)] pub masked: bool,
        #[bits(15)] _unused: u32,
        #[bits(16)] _unused2: u32,
        #[bits(8)] pub extended_destination: u8,
        #[bits(8)] pub destination: u8,
    }

    /// The bits of the redirection entry that can be set by the guest.
    pub const REDIRECTION_WRITE_MASK: u64 = RedirectionEntry::new()
        .with_vector(0xff)
        .with_delivery_mode(0x7)
        .with_destination_mode_logical(true)
        .with_active_low(true)
        .with_trigger_mode_level(true)
        .with_masked(true)
        .with_destination(0xff)
        .with_extended_destination(0xff)
        .0;

    #[bitfield(u32)]
    pub struct IoApicId {
        #[bits(24)]
        _reserved: u32,
        #[bits(4)]
        pub id: u8,
        #[bits(4)]
        _reserved2: u32,
    }

    #[bitfield(u32)]
    pub struct IoApicVersion {
        pub version: u8,
        _reserved: u8,
        pub max_entry: u8,
        _reserved2: u8,
    }
}

impl RedirectionEntry {
    fn init() -> Self {
        Self::new()
            .with_destination_mode_logical(true)
            .with_masked(true)
    }

    /// Converts the entry to MSI format.
    fn as_msi(&self) -> Option<(u64, u32)> {
        if self.masked() {
            return None;
        }

        // Copy the redirection entry's bits to the MSI as defined in the Intel
        // ICHx datasheets.
        let address = MsiAddress::new()
            .with_address(x86defs::msi::MSI_ADDRESS)
            .with_destination(self.destination())
            .with_extended_destination(self.extended_destination())
            .with_destination_mode_logical(self.destination_mode_logical())
            .with_redirection_hint(self.delivery_mode() == DeliveryMode::LOWEST_PRIORITY.0);

        let data = MsiData::new()
            .with_assert(true)
            .with_destination_mode_logical(self.destination_mode_logical())
            .with_delivery_mode(self.delivery_mode())
            .with_trigger_mode_level(self.trigger_mode_level())
            .with_vector(self.vector());

        Some((u32::from(address).into(), data.into()))
    }
}

#[derive(Debug, Inspect)]
struct IrqEntry {
    #[inspect(flatten)]
    redirection: RedirectionEntry,
    line_level: bool,
    #[inspect(skip)]
    registered_request: Option<(u64, u32)>,
}

impl IrqEntry {
    fn assert(&mut self, routing: &dyn IoApicRouting, stats: &mut IoApicStats, n: u8) {
        let old_level = std::mem::replace(&mut self.line_level, true);
        self.evaluate(routing, stats, n, !old_level);
    }

    fn deassert(&mut self) {
        self.line_level = false;
        // No need to evaluate; this interrupt definitely doesn't need to be
        // delivered now.
    }

    fn eoi(&mut self, vector: u32, routing: &dyn IoApicRouting, stats: &mut IoApicStats, n: u8) {
        if self.redirection.vector() as u32 == vector {
            // Clear remote IRR to allow further interrupts (if level
            // triggered).
            self.redirection.set_remote_irr(false);
            self.evaluate(routing, stats, n, false);
        }
    }

    fn evaluate(
        &mut self,
        routing: &dyn IoApicRouting,
        stats: &mut IoApicStats,
        n: u8,
        edge: bool,
    ) {
        // Only some delivery modes support level trigger mode.
        let is_level = self.redirection.trigger_mode_level()
            && matches!(
                DeliveryMode(self.redirection.delivery_mode()),
                DeliveryMode::FIXED | DeliveryMode::LOWEST_PRIORITY
            );

        // Masked edge-triggered interrupts are lost. Masked level-triggered
        // interrupts are reevaluated when the interrupt is unmasked.
        if self.redirection.masked()
            || (is_level && (!self.line_level || self.redirection.remote_irr()))
            || (!is_level && !edge)
        {
            return;
        }

        // Remote IRR tracks whether a level-triggered interrupt has been EOIed yet.
        self.redirection.set_remote_irr(is_level);
        stats.interrupts.increment();
        stats.interrupts_per_irq[n as usize].increment();
        routing.assert(n);
    }
}

#[derive(Debug, InspectMut)]
pub struct IoApicDevice {
    // Static configuration
    #[inspect(skip)]
    valid_lines: [RangeInclusive<u32>; 1],

    // Runtime glue
    #[inspect(skip)]
    routing: Box<dyn IoApicRouting>,

    // Runtime book-keeping
    stats: IoApicStats,

    // Volatile state
    #[inspect(with = r#"|x| inspect::iter_by_index(x.iter())"#)]
    irqs: Box<[IrqEntry]>,
    id: u8,
    index: IndexRegister,
}

#[derive(Debug, Inspect)]
struct IoApicStats {
    #[inspect(iter_by_index)]
    interrupts_per_irq: Vec<Counter>,
    interrupts: Counter,
}

impl IoApicDevice {
    pub fn new(num_entries: u8, routing: Box<dyn IoApicRouting>) -> Self {
        let irqs = (0..num_entries)
            .map(|_| IrqEntry {
                redirection: RedirectionEntry::init(),
                line_level: false,
                registered_request: None,
            })
            .collect();

        IoApicDevice {
            valid_lines: [0..=num_entries as u32 - 1],
            routing,

            id: 0,
            irqs,
            index: IndexRegister::ID,
            stats: IoApicStats {
                interrupts_per_irq: (0..num_entries).map(|_| Counter::new()).collect(),
                interrupts: Counter::new(),
            },
        }
    }

    fn read_redirection_register(&self, index: u8) -> u32 {
        let mut value = self
            .irqs
            .get(index as usize / 2)
            .map_or(0, |irq| irq.redirection.into());
        if index & 1 == 1 {
            value >>= 32;
        }
        value as u32
    }

    fn write_redirection_register(&mut self, index: u8, val: u32) {
        let n = index as usize / 2;
        if let Some(irq) = self.irqs.get_mut(n) {
            let mut val = val as u64;
            let mut redirection = u64::from(irq.redirection);
            if index & 1 == 1 {
                redirection &= 0xffffffff;
                val <<= 32;
            } else {
                redirection &= !0xffffffff;
            }
            redirection |= val & REDIRECTION_WRITE_MASK;
            irq.redirection = redirection.into();

            tracing::trace!(n, entry = ?irq.redirection, "new redirection entry");

            let request = irq.redirection.as_msi();
            if request != irq.registered_request {
                self.routing.set_route(n as u8, request);
                irq.registered_request = request;
            }

            // Reevaluate in case this unmasked a level-triggered interrupt.
            irq.evaluate(self.routing.as_ref(), &mut self.stats, n as u8, false);
        }
    }

    fn read_register(&self, index: IndexRegister) -> u32 {
        match index {
            IndexRegister::ID => IoApicId::new().with_id(self.id).into(),
            IndexRegister::VERSION => IoApicVersion::new()
                .with_version(IO_APIC_VERSION)
                .with_max_entry((self.irqs.len() - 1) as u8)
                .into(),
            IndexRegister::ARBITRATION_ID => 0,
            _ if self.index >= IndexRegister::REDIRECTION_TABLE_START => {
                self.read_redirection_register(index.0 - IndexRegister::REDIRECTION_TABLE_START.0)
            }
            _ => {
                tracelimit::warn_ratelimited!(?index, "unsupported register index read");
                !0
            }
        }
    }

    fn write_register(&mut self, index: IndexRegister, val: u32) {
        match index {
            IndexRegister::ID => self.id = IoApicId::from(val).id(),
            IndexRegister::VERSION | IndexRegister::ARBITRATION_ID => {
                tracing::debug!(?index, val, "ignoring write to read-only register");
            }
            _ if self.index >= IndexRegister::REDIRECTION_TABLE_START => {
                self.write_redirection_register(
                    index.0 - IndexRegister::REDIRECTION_TABLE_START.0,
                    val,
                );
            }
            _ => {
                tracelimit::warn_ratelimited!(?index, "unsupported register index write");
            }
        }
    }
}

impl LineInterruptTarget for IoApicDevice {
    fn set_irq(&mut self, n: u32, high: bool) {
        if let Some(irq) = self.irqs.get_mut(n as usize) {
            if high {
                irq.assert(self.routing.as_ref(), &mut self.stats, n as u8);
            } else {
                irq.deassert();
            }
        }
    }

    fn valid_lines(&self) -> &[RangeInclusive<u32>] {
        &self.valid_lines
    }
}

impl HandleEoi for IoApicDevice {
    /// reSearch query: `IoApicEmulator::NotifyEoi`
    fn handle_eoi(&mut self, irq_to_end: u32) {
        for (index, irq) in self.irqs.iter_mut().enumerate() {
            irq.eoi(
                irq_to_end,
                self.routing.as_ref(),
                &mut self.stats,
                index as u8,
            );
        }
    }
}

impl ChangeDeviceState for IoApicDevice {
    fn start(&mut self) {}

    async fn stop(&mut self) {}

    async fn reset(&mut self) {
        let Self {
            valid_lines: _,
            routing: _,
            irqs,
            id,
            index,
            stats: _,
        } = self;
        *id = 0;
        *index = IndexRegister::ID;
        for (n, irq) in irqs.iter_mut().enumerate() {
            irq.redirection = RedirectionEntry::init();
            self.routing.set_route(n as u8, None);
            irq.registered_request = None;
        }
    }
}

impl ChipsetDevice for IoApicDevice {
    fn supports_mmio(&mut self) -> Option<&mut dyn MmioIntercept> {
        Some(self)
    }

    fn supports_line_interrupt_target(&mut self) -> Option<&mut dyn LineInterruptTarget> {
        Some(self)
    }

    fn supports_handle_eoi(&mut self) -> Option<&mut dyn HandleEoi> {
        Some(self)
    }
}

mod save_restore {
    use super::IoApicDevice;
    use super::spec::IndexRegister;
    use super::spec::RedirectionEntry;
    use thiserror::Error;
    use vmcore::save_restore::RestoreError;
    use vmcore::save_restore::SaveError;
    use vmcore::save_restore::SaveRestore;

    mod state {
        use mesh::payload::Protobuf;
        use vmcore::save_restore::SavedStateRoot;

        #[derive(Clone, Debug, Default, Protobuf, SavedStateRoot)]
        #[mesh(package = "chipset.ioapic")]
        pub struct SavedState {
            #[mesh(1)]
            pub(super) id: u8,
            #[mesh(2)]
            pub(super) index: u8,
            #[mesh(3)]
            pub(super) redirection_entries: Vec<u64>,
            // Preserve edge-detector history, not ownership of device outputs.
            #[mesh(4)]
            pub(super) line_levels: Vec<bool>,
        }
    }

    #[derive(Error, Debug)]
    #[error("wrong number of redirection entries")]
    struct WrongNumberOfRedirectionEntries;

    #[derive(Error, Debug)]
    #[error("wrong number of line levels")]
    struct WrongNumberOfLineLevels;

    impl SaveRestore for IoApicDevice {
        type SavedState = state::SavedState;

        fn save(&mut self) -> Result<state::SavedState, SaveError> {
            let Self {
                valid_lines: _,
                routing: _,
                irqs,
                id,
                index,
                stats: _,
            } = &self;

            Ok(state::SavedState {
                redirection_entries: irqs.iter().map(|irq| irq.redirection.into()).collect(),
                line_levels: irqs.iter().map(|irq| irq.line_level).collect(),
                index: index.0,
                id: *id,
            })
        }

        fn restore(&mut self, state: state::SavedState) -> Result<(), RestoreError> {
            let state::SavedState {
                redirection_entries,
                line_levels,
                id,
                index,
            } = state;
            if redirection_entries.len() != self.irqs.len() {
                return Err(RestoreError::Other(WrongNumberOfRedirectionEntries.into()));
            }
            let line_levels = if line_levels.is_empty() {
                vec![false; self.irqs.len()]
            } else if line_levels.len() == self.irqs.len() {
                line_levels
            } else {
                return Err(RestoreError::Other(WrongNumberOfLineLevels.into()));
            };
            for (n, ((state, line_level), irq)) in redirection_entries
                .into_iter()
                .zip(line_levels)
                .zip(self.irqs.iter_mut())
                .enumerate()
            {
                irq.redirection = RedirectionEntry::from(state);
                irq.line_level = line_level;
                let request = irq.redirection.as_msi();
                self.routing.set_route(n as u8, request);
                irq.registered_request = request;
            }
            self.id = id;
            self.index = IndexRegister(index);
            Ok(())
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;
        use chipset_device::interrupt::HandleEoi;
        use chipset_device::interrupt::LineInterruptTarget;
        use chipset_resources::ioapic::IoApicRouting;
        use parking_lot::Mutex;
        use std::sync::Arc;
        use test_with_tracing::test;

        const ENTRY_COUNT: u8 = 2;
        const IRQ: u8 = 1;
        const VECTOR: u8 = 0x30;

        #[derive(Clone, Default)]
        struct RecordingRouting {
            assertions: Arc<Mutex<Vec<u8>>>,
        }

        impl IoApicRouting for RecordingRouting {
            fn assert(&self, irq: u8) {
                self.assertions.lock().push(irq);
            }

            fn set_route(&self, _irq: u8, _request: Option<(u64, u32)>) {}
        }

        fn device() -> (IoApicDevice, RecordingRouting) {
            let routing = RecordingRouting::default();
            (
                IoApicDevice::new(ENTRY_COUNT, Box::new(routing.clone())),
                routing,
            )
        }

        fn set_entry(device: &mut IoApicDevice, level: bool, masked: bool) {
            let entry = RedirectionEntry::new()
                .with_vector(VECTOR)
                .with_trigger_mode_level(level)
                .with_masked(masked);
            device.write_redirection_register(IRQ * 2, u64::from(entry) as u32);
        }

        #[test]
        fn restore_preserves_edge_history() {
            let (mut source, _) = device();
            set_entry(&mut source, false, false);
            source.set_irq(IRQ.into(), true);
            let state = source.save().expect("save succeeds");

            let (mut restored, routing) = device();
            restored.restore(state).expect("restore succeeds");
            restored.set_irq(IRQ.into(), true);
            assert!(routing.assertions.lock().is_empty());

            restored.set_irq(IRQ.into(), false);
            restored.set_irq(IRQ.into(), true);
            assert_eq!(*routing.assertions.lock(), [IRQ]);
        }

        #[test]
        fn restore_allows_new_rising_edge() {
            let (mut source, _) = device();
            set_entry(&mut source, false, false);
            let state = source.save().expect("save succeeds");

            let (mut restored, routing) = device();
            set_entry(&mut restored, false, false);
            restored.set_irq(IRQ.into(), true);
            routing.assertions.lock().clear();

            restored.restore(state).expect("restore succeeds");
            assert!(routing.assertions.lock().is_empty());
            restored.set_irq(IRQ.into(), true);
            assert_eq!(*routing.assertions.lock(), [IRQ]);
        }

        #[test]
        fn restore_preserves_asserted_level_until_unmasked() {
            let (mut source, _) = device();
            set_entry(&mut source, true, true);
            source.set_irq(IRQ.into(), true);
            let state = source.save().expect("save succeeds");

            let (mut restored, routing) = device();
            restored.restore(state).expect("restore succeeds");
            assert!(routing.assertions.lock().is_empty());
            set_entry(&mut restored, true, false);

            assert_eq!(*routing.assertions.lock(), [IRQ]);
        }

        #[test]
        fn restore_preserves_remote_irr_until_eoi() {
            let (mut source, _) = device();
            set_entry(&mut source, true, false);
            source.set_irq(IRQ.into(), true);
            let state = source.save().expect("save succeeds");

            let (mut restored, routing) = device();
            restored.restore(state).expect("restore succeeds");
            restored.set_irq(IRQ.into(), true);
            assert!(routing.assertions.lock().is_empty());

            restored.handle_eoi(VECTOR.into());
            assert_eq!(*routing.assertions.lock(), [IRQ]);
            restored.set_irq(IRQ.into(), false);
            restored.handle_eoi(VECTOR.into());
            assert_eq!(*routing.assertions.lock(), [IRQ]);
        }

        #[test]
        fn restore_does_not_evaluate_level_interrupts() {
            let (mut source, _) = device();
            set_entry(&mut source, true, true);
            source.set_irq(IRQ.into(), true);
            let mut state = source.save().expect("save succeeds");
            state.redirection_entries[IRQ as usize] =
                RedirectionEntry::from(state.redirection_entries[IRQ as usize])
                    .with_masked(false)
                    .into();

            let (mut restored, routing) = device();
            restored.restore(state).expect("restore succeeds");
            assert!(routing.assertions.lock().is_empty());

            restored.set_irq(IRQ.into(), true);
            assert_eq!(*routing.assertions.lock(), [IRQ]);
        }

        #[test]
        fn restore_defaults_absent_line_levels_to_deasserted() {
            let (mut source, _) = device();
            set_entry(&mut source, true, true);
            source.set_irq(IRQ.into(), true);
            let mut state = source.save().expect("save succeeds");
            state.line_levels.clear();

            let (mut restored, routing) = device();
            restored.restore(state).expect("restore succeeds");
            set_entry(&mut restored, true, false);

            assert!(routing.assertions.lock().is_empty());
        }

        #[test]
        fn restore_rejects_wrong_number_of_line_levels() {
            let (mut source, _) = device();
            let mut state = source.save().expect("save succeeds");
            state.line_levels.pop();

            let (mut restored, routing) = device();
            set_entry(&mut restored, false, false);
            let before = restored.save().expect("save succeeds");
            let error = restored.restore(state).expect_err("restore must fail");

            assert_eq!(error.to_string(), "wrong number of line levels");
            let after = restored.save().expect("save succeeds");
            assert_eq!(after.redirection_entries, before.redirection_entries);
            assert_eq!(after.line_levels, before.line_levels);
            assert!(routing.assertions.lock().is_empty());
        }
    }
}

impl MmioIntercept for IoApicDevice {
    fn mmio_read(&mut self, address: u64, data: &mut [u8]) -> IoResult {
        assert_eq!(
            address & !IOAPIC_DEVICE_MMIO_REGION_MASK,
            IOAPIC_DEVICE_MMIO_REGION_BASE_ADDRESS
        );

        let v = match Register(address & IOAPIC_DEVICE_MMIO_REGION_MASK) {
            Register::INDEX => self.index.0.into(),
            Register::DATA => self.read_register(self.index),
            _ => return IoResult::Err(IoError::InvalidRegister),
        };

        // Allow any size read.
        let n = data.len().min(size_of_val(&v));
        data.copy_from_slice(&v.to_ne_bytes()[..n]);
        IoResult::Ok
    }

    fn mmio_write(&mut self, address: u64, data: &[u8]) -> IoResult {
        assert_eq!(
            address & !IOAPIC_DEVICE_MMIO_REGION_MASK,
            IOAPIC_DEVICE_MMIO_REGION_BASE_ADDRESS
        );

        match Register(address & IOAPIC_DEVICE_MMIO_REGION_MASK) {
            Register::INDEX => self.index = IndexRegister(data[0]),
            Register::DATA => {
                // Only allow 4-byte writes.
                let Ok(data) = data.try_into() else {
                    return IoResult::Err(IoError::InvalidAccessSize);
                };
                let data = u32::from_ne_bytes(data);
                self.write_register(self.index, data);
            }
            _ => return IoResult::Err(IoError::InvalidRegister),
        }

        IoResult::Ok
    }

    fn get_static_regions(&mut self) -> &[(&str, RangeInclusive<u64>)] {
        &[(
            "mmio",
            IOAPIC_DEVICE_MMIO_REGION_BASE_ADDRESS
                ..=IOAPIC_DEVICE_MMIO_REGION_BASE_ADDRESS + IOAPIC_DEVICE_MMIO_REGION_SIZE - 1,
        )]
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// A redirection entry in the VT-d/AMD remappable interrupt format must be
    /// emitted as a remappable-format MSI, carrying the interrupt-remap index
    /// as the message handle. The remappable RTE deliberately overlays the
    /// index onto the legacy destination fields, so the ordinary address
    /// computation already produces the correct message with no special-casing.
    #[test]
    fn remappable_rte_emits_remappable_msi() {
        // Remappable RTE: format bit (48) set, index[14:0] in bits 63:49 and
        // index[15] in bit 11, vector in bits 7:0. Use an index with bit 15
        // set to also exercise the bit-11 path.
        let index: u16 = 0x9234;
        let vector = 0x30u8;
        let bits = u64::from(vector)
            | (1 << 48)
            | ((u64::from(index) & 0x7fff) << 49)
            | (((u64::from(index) >> 15) & 1) << 11);
        let rte = RedirectionEntry::from(bits);

        let (address, data) = rte.as_msi().expect("unmasked entry yields an MSI");

        // Remappable format (address bit 4), no subhandle (SHV, bit 3), and the
        // index recoverable as the handle = {addr[2], addr[19:5]}.
        assert_eq!((address >> 4) & 1, 1, "remappable format bit set");
        assert_eq!((address >> 3) & 1, 0, "SHV clear (no subhandle)");
        let handle = (((address >> 2) & 1) << 15) | ((address >> 5) & 0x7fff);
        assert_eq!(handle as u16, index, "handle carries the IRTE index");
        assert_eq!(data as u8, vector, "vector preserved for EOI matching");
    }

    /// A compatibility-format entry (format bit clear) is emitted as a
    /// compatibility-format MSI (address bit 4 clear).
    #[test]
    fn compat_rte_emits_compat_msi() {
        let rte = RedirectionEntry::new()
            .with_vector(0x30)
            .with_destination(0x04);
        let (address, _data) = rte.as_msi().expect("unmasked entry yields an MSI");
        assert_eq!(
            (address >> 4) & 1,
            0,
            "compatibility format (not remappable)"
        );
    }

    /// A masked entry produces no MSI regardless of format.
    #[test]
    fn masked_rte_emits_nothing() {
        let rte = RedirectionEntry::new().with_masked(true).with_vector(0x30);
        assert_eq!(rte.as_msi(), None);
    }
}