perf(virtiofs): isolate virtio PCI interrupt vectors (#2129)

* perf(virtiofs): isolate virtio PCI interrupt vectors

Allocate monotonic x86 PCI MSI/MSI-X vectors for interrupt-driven VirtIO transports instead of routing every device through vector 56. Rebind allocated descriptors to the local APIC edge flow, skip reserved vectors, and keep allocation fail-safe until a complete free_irq lifecycle exists.

Defer vector allocation until IRQ setup so polling-only transports remain usable on architectures without PCI MSI support. Centralize PCI and MMIO IRQ registration in the transport layer, remove duplicate sysfs registration, and avoid descriptor lock recursion in the shared-action mismatch path.

Keep PCI ISR acknowledgement owned by the hard IRQ path while retaining bridge-side acknowledgement for polling fallback. Add a deterministic parallel-read workload with immutable per-worker files, bounded low-impact start coordination, aligned wall/CPU measurement boundaries, exact EOF and checksum validation, and transcript regression coverage.

Validated with make fmt, make kernel, host transcript tests, and a fresh-boot non-DAX VirtioFS mount/read smoke test across VirtIO filesystem, block, network, and console devices.

Signed-off-by: longjin <longjin@dragonos.org>

* fix(virtio): defer MMIO IRQ registration

Return an explicit deferred IRQ token for MMIO transports so the global IRQ action is installed only after the concrete virtio device has completed construction. Keep the existing PCI setup path unchanged.

Preserve per-device failure semantics: block, net, and console devices abort registration without panicking; pmem falls back to polling. Clean up the block worker, queues, transport, and allocated device ID when deferred IRQ installation fails.

Retain virtio-net dispatch registration at the end of probe so interrupts are routed only after the network interface is ready.

Signed-off-by: longjin <longjin@dragonos.org>

---------

Signed-off-by: longjin <longjin@dragonos.org>

Author: fslongjin

kernel/src/arch/loongarch64/msi.rs

@@ -1,4 +1,14 @@
 use crate::driver::pci::pci_irq::TriggerMode;
+use crate::exception::IrqNumber;
+use system_error::SystemError;
+
+pub fn arch_pci_msi_vector_alloc() -> Option<IrqNumber> {
+    None
+}
+
+pub fn arch_pci_msi_vector_setup(_vector: IrqNumber) -> Result<(), SystemError> {
+    Err(SystemError::ENOSYS)
+}
 
 /// 获得MSI Message Address
 ///

kernel/src/arch/riscv64/msi.rs

@@ -1,4 +1,14 @@
 use crate::driver::pci::pci_irq::TriggerMode;
+use crate::exception::IrqNumber;
+use system_error::SystemError;
+
+pub fn arch_pci_msi_vector_alloc() -> Option<IrqNumber> {
+    None
+}
+
+pub fn arch_pci_msi_vector_setup(_vector: IrqNumber) -> Result<(), SystemError> {
+    Err(SystemError::ENOSYS)
+}
 
 /// @brief 获得MSI Message Address
 /// @param processor 目标CPU ID号

kernel/src/arch/x86_64/msi.rs

@@ -1,4 +1,81 @@
-use crate::driver::pci::pci_irq::TriggerMode;
+use core::sync::atomic::{AtomicU32, Ordering};
+
+use system_error::SystemError;
+
+use crate::{
+    arch::driver::apic::lapic_vector::local_apic_chip,
+    driver::pci::pci_irq::TriggerMode,
+    exception::{
+        handle::edge_irq_handler, irqdata::IrqLineStatus, irqdesc::irq_desc_manager, IrqNumber,
+    },
+};
+
+const PCI_MSI_VECTOR_FIRST: u32 = 64;
+const PCI_MSI_VECTOR_INT80: u32 = 128;
+const PCI_MSI_VECTOR_LAST: u32 = 150;
+
+struct PciMsiVectorAllocator {
+    next: AtomicU32,
+}
+
+impl PciMsiVectorAllocator {
+    const fn new() -> Self {
+        Self {
+            next: AtomicU32::new(PCI_MSI_VECTOR_FIRST),
+        }
+    }
+
+    fn alloc(&self) -> Option<IrqNumber> {
+        loop {
+            let current = self.next.load(Ordering::Relaxed);
+            if current > PCI_MSI_VECTOR_LAST {
+                return None;
+            }
+            let next = if current == PCI_MSI_VECTOR_INT80 - 1 {
+                PCI_MSI_VECTOR_INT80 + 1
+            } else {
+                current + 1
+            };
+            if self
+                .next
+                .compare_exchange_weak(current, next, Ordering::AcqRel, Ordering::Relaxed)
+                .is_ok()
+            {
+                return Some(IrqNumber::new(current));
+            }
+        }
+    }
+}
+
+static PCI_MSI_VECTOR_ALLOCATOR: PciMsiVectorAllocator = PciMsiVectorAllocator::new();
+
+/// Reserves a CPU vector from the x86 range owned by PCI MSI/MSI-X.
+///
+/// Vectors are intentionally not reused. DragonOS does not yet have a safe PCI `free_irq`
+/// lifecycle, so reuse could route a live MSI action to a different device.
+pub fn arch_pci_msi_vector_alloc() -> Option<IrqNumber> {
+    PCI_MSI_VECTOR_ALLOCATOR.alloc()
+}
+
+/// Rebinds an allocated vector from the blanket IOAPIC setup to message-interrupt semantics.
+pub fn arch_pci_msi_vector_setup(vector: IrqNumber) -> Result<(), SystemError> {
+    if !(PCI_MSI_VECTOR_FIRST..=PCI_MSI_VECTOR_LAST).contains(&vector.data())
+        || vector.data() == PCI_MSI_VECTOR_INT80
+    {
+        return Err(SystemError::EINVAL);
+    }
+    let desc = irq_desc_manager()
+        .lookup(vector)
+        .ok_or(SystemError::EINVAL)?;
+    let irq_data = desc.irq_data();
+    let mut chip_info = irq_data.chip_info_write_irqsave();
+    chip_info.set_chip(Some(local_apic_chip().clone()));
+    chip_info.set_chip_data(None);
+    drop(chip_info);
+    desc.modify_status(IrqLineStatus::IRQ_LEVEL, IrqLineStatus::empty());
+    desc.set_handler(edge_irq_handler());
+    Ok(())
+}
 /// @brief 获得MSI Message Address
 /// @param processor 目标CPU ID号
 /// @return MSI Message Address
@@ -17,3 +94,25 @@ pub fn arch_msi_message_data(vector: u16, _processor: u16, trigger: TriggerMode)
         TriggerMode::AssertLow => vector as u32 | 1 << 15,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{PciMsiVectorAllocator, PCI_MSI_VECTOR_LAST};
+
+    #[test]
+    fn pci_msi_vector_allocator_skips_int80_and_exhausts() {
+        let allocator = PciMsiVectorAllocator::new();
+        let mut vectors = alloc::vec::Vec::new();
+        while let Some(vector) = allocator.alloc() {
+            vectors.push(vector.data());
+        }
+
+        assert_eq!(vectors.first().copied(), Some(64));
+        assert!(vectors.contains(&127));
+        assert!(!vectors.contains(&128));
+        assert!(vectors.contains(&129));
+        assert_eq!(vectors.last().copied(), Some(PCI_MSI_VECTOR_LAST));
+        assert_eq!(vectors.len(), 86);
+        assert_eq!(allocator.alloc(), None);
+    }
+}

kernel/src/driver/block/virtio_blk.rs

@@ -42,7 +42,7 @@ use crate::{
         },
         virtio::{
             sysfs::{virtio_bus, virtio_device_manager, virtio_driver_manager},
-            transport::VirtIOTransport,
+            transport::{DeferredVirtioIrq, VirtIOTransport},
             virtio_impl::HalImpl,
             VirtIODevice, VirtIODeviceIndex, VirtIODriver, VirtIODriverCommonData, VirtioDeviceId,
             VIRTIO_VENDOR_ID,
@@ -306,10 +306,21 @@ pub fn virtio_blk(
     dev_parent: Option<Arc<dyn Device>>,
 ) {
     let device = VirtIOBlkDevice::new(transport, dev_id);
-    if let Some(device) = device {
+    if let Some((device, deferred_irq)) = device {
         if let Some(dev_parent) = dev_parent {
             device.set_dev_parent(Some(Arc::downgrade(&dev_parent)));
         }
+        if let Some(deferred_irq) = deferred_irq {
+            if let Err(err) = deferred_irq.install(device.dev_id().clone()) {
+                error!(
+                    "VirtIOBlkDevice '{:?}' setup_irq failed: {:?}",
+                    device.dev_id(),
+                    err
+                );
+                device.abort_initialization();
+                return;
+            }
+        }
         virtio_device_manager()
             .device_add(device.clone() as Arc<dyn VirtIODevice>)
             .expect("Add virtio blk failed");
@@ -408,12 +419,18 @@ unsafe impl Send for VirtIOBlkDevice {}
 unsafe impl Sync for VirtIOBlkDevice {}
 
 impl VirtIOBlkDevice {
-    pub fn new(transport: VirtIOTransport, dev_id: Arc<DeviceId>) -> Option<Arc<Self>> {
+    pub(crate) fn new(
+        transport: VirtIOTransport,
+        dev_id: Arc<DeviceId>,
+    ) -> Option<(Arc<Self>, Option<DeferredVirtioIrq>)> {
         // 设置中断
-        if let Err(err) = transport.setup_irq(dev_id.clone()) {
-            error!("VirtIOBlkDevice '{dev_id:?}' setup_irq failed: {:?}", err);
-            return None;
-        }
+        let irq_setup = match transport.setup_irq(dev_id.clone()) {
+            Ok(setup) => setup,
+            Err(err) => {
+                error!("VirtIOBlkDevice '{dev_id:?}' setup_irq failed: {:?}", err);
+                return None;
+            }
+        };
 
         let devname = virtioblk_manager().alloc_id()?;
         let irq = Some(transport.irq());
@@ -490,13 +507,25 @@ impl VirtIOBlkDevice {
             return None;
         }
 
-        Some(dev)
+        Some((dev, irq_setup.into_deferred()))
     }
 
     fn inner(&self) -> SpinLockGuard<'_, InnerVirtIOBlkDevice> {
         self.inner.lock_irqsave()
     }
 
+    fn abort_initialization(self: &Arc<Self>) {
+        let devname_id = self.blkdev_meta.devname.id();
+        if let Err(err) = self.shutdown() {
+            error!(
+                "VirtIOBlkDevice '{:?}' initialization cleanup failed: {:?}",
+                self.dev_id, err
+            );
+            return;
+        }
+        virtioblk_manager().free_id(devname_id);
+    }
+
     fn shutdown(self: &Arc<Self>) -> Result<(), SystemError> {
         let (bio_queue, bio_token_map, io_thread_pcb) = {
             let mut inner = self.inner();

kernel/src/driver/char/virtio_console.rs

@@ -22,7 +22,7 @@ use crate::{
         video::console::dummycon::dummy_console,
         virtio::{
             sysfs::{virtio_bus, virtio_device_manager, virtio_driver_manager},
-            transport::VirtIOTransport,
+            transport::{DeferredVirtioIrq, VirtIOTransport},
             virtio_drivers_error_to_system_error,
             virtio_impl::HalImpl,
             VirtIODevice, VirtIODeviceIndex, VirtIODriver, VirtIODriverCommonData, VirtioDeviceId,
@@ -307,16 +307,23 @@ pub fn virtio_console(
         dev_id,
         dev_parent.as_ref().map(|x| x.name())
     );
-    let device = VirtIOConsoleDevice::new(transport, dev_id.clone());
-    if device.is_none() {
+    let Some((device, deferred_irq)) = VirtIOConsoleDevice::new(transport, dev_id.clone()) else {
         return;
-    }
-
-    let device = device.unwrap();
+    };
 
     if let Some(dev_parent) = dev_parent {
         device.set_dev_parent(Some(Arc::downgrade(&dev_parent)));
     }
+    if let Some(deferred_irq) = deferred_irq {
+        if let Err(err) = deferred_irq.install(device.dev_id().clone()) {
+            log::error!(
+                "VirtIOConsoleDevice '{:?}' setup_irq failed: {:?}",
+                device.dev_id(),
+                err
+            );
+            return;
+        }
+    }
     virtio_device_manager()
         .device_add(device.clone() as Arc<dyn VirtIODevice>)
         .expect("Add virtio console failed");
@@ -353,15 +360,21 @@ impl Debug for VirtIOConsoleDevice {
 }
 
 impl VirtIOConsoleDevice {
-    pub fn new(transport: VirtIOTransport, dev_id: Arc<DeviceId>) -> Option<Arc<Self>> {
+    pub(crate) fn new(
+        transport: VirtIOTransport,
+        dev_id: Arc<DeviceId>,
+    ) -> Option<(Arc<Self>, Option<DeferredVirtioIrq>)> {
         // 设置中断
-        if let Err(err) = transport.setup_irq(dev_id.clone()) {
-            log::error!(
-                "VirtIOConsoleDevice '{dev_id:?}' setup_irq failed: {:?}",
-                err
-            );
-            return None;
-        }
+        let irq_setup = match transport.setup_irq(dev_id.clone()) {
+            Ok(setup) => setup,
+            Err(err) => {
+                log::error!(
+                    "VirtIOConsoleDevice '{dev_id:?}' setup_irq failed: {:?}",
+                    err
+                );
+                return None;
+            }
+        };
 
         let irq = Some(transport.irq());
         let device_inner = DragonVirtIOConsole::new(transport);
@@ -394,7 +407,7 @@ impl VirtIOConsoleDevice {
             }),
         });
 
-        Some(dev)
+        Some((dev, irq_setup.into_deferred()))
     }
 
     fn inner(&self) -> SpinLockGuard<'_, InnerVirtIOConsoleDevice> {

kernel/src/driver/net/virtio_net.rs

@@ -37,7 +37,7 @@ use crate::{
         virtio::{
             irq::virtio_irq_manager,
             sysfs::{virtio_bus, virtio_device_manager, virtio_driver_manager},
-            transport::VirtIOTransport,
+            transport::{DeferredVirtioIrq, VirtIOTransport},
             virtio_impl::HalImpl,
             VirtIODevice, VirtIODeviceIndex, VirtIODriver, VirtIODriverCommonData, VirtioDeviceId,
             VIRTIO_VENDOR_ID,
@@ -108,12 +108,18 @@ impl Debug for InnerVirtIONetDevice {
 }
 
 impl VirtIONetDevice {
-    pub fn new(transport: VirtIOTransport, dev_id: Arc<DeviceId>) -> Option<Arc<Self>> {
+    pub(crate) fn new(
+        transport: VirtIOTransport,
+        dev_id: Arc<DeviceId>,
+    ) -> Option<(Arc<Self>, Option<DeferredVirtioIrq>)> {
         // 设置中断
-        if let Err(err) = transport.setup_irq(dev_id.clone()) {
-            error!("VirtIONetDevice '{dev_id:?}' setup_irq failed: {:?}", err);
-            return None;
-        }
+        let irq_setup = match transport.setup_irq(dev_id.clone()) {
+            Ok(setup) => setup,
+            Err(err) => {
+                error!("VirtIONetDevice '{dev_id:?}' setup_irq failed: {:?}", err);
+                return None;
+            }
+        };
 
         let irq_is_msix = transport.irq_is_msix();
         let driver_net: VirtIONet<HalImpl, VirtIOTransport, 2> =
@@ -144,7 +150,7 @@ impl VirtIONetDevice {
 
         // dev.set_driver(Some(Arc::downgrade(&virtio_net_driver()) as Weak<dyn Driver>));
 
-        return Some(dev);
+        return Some((dev, irq_setup.into_deferred()));
     }
 
     fn inner(&self) -> SpinLockGuard<'_, InnerVirtIONetDevice> {
@@ -767,11 +773,21 @@ pub fn virtio_net(
     dev_parent: Option<Arc<dyn Device>>,
 ) {
     let virtio_net_deivce = VirtIONetDevice::new(transport, dev_id);
-    if let Some(virtio_net_deivce) = virtio_net_deivce {
+    if let Some((virtio_net_deivce, deferred_irq)) = virtio_net_deivce {
         debug!("VirtIONetDevice '{:?}' created", virtio_net_deivce.dev_id);
         if let Some(dev_parent) = dev_parent {
             virtio_net_deivce.set_dev_parent(Some(Arc::downgrade(&dev_parent)));
         }
+        if let Some(deferred_irq) = deferred_irq {
+            if let Err(err) = deferred_irq.install(virtio_net_deivce.dev_id().clone()) {
+                error!(
+                    "VirtIONetDevice '{:?}' setup_irq failed: {:?}",
+                    virtio_net_deivce.dev_id(),
+                    err
+                );
+                return;
+            }
+        }
         virtio_device_manager()
             .device_add(virtio_net_deivce.clone() as Arc<dyn VirtIODevice>)
             .expect("Add virtio net failed");

kernel/src/driver/virtio/sysfs.rs

@@ -20,9 +20,8 @@ use crate::{
             kobject::KObject,
             subsys::SubSysPrivate,
         },
-        virtio::irq::{virtio_irq_manager, DefaultVirtioIrqHandler},
+        virtio::irq::virtio_irq_manager,
     },
-    exception::{irqdesc::IrqHandleFlags, manage::irq_manager},
     filesystem::{
         sysfs::{
             file::sysfs_emit_str, Attribute, AttributeGroup, SysFSOpsSupport, SYSFS_ATTR_MODE_RO,
@@ -265,22 +264,6 @@ impl VirtIODeviceManager {
             return Ok(());
         }
         let irq = irq.unwrap();
-        if let Err(e) = irq_manager().request_irq(
-            irq,
-            dev.device_name(),
-            &DefaultVirtioIrqHandler,
-            IrqHandleFlags::IRQF_SHARED,
-            Some(dev.dev_id().clone()),
-        ) {
-            error!(
-                "Failed to request irq for virtio device '{}': irq: {:?}, error {:?}",
-                dev.device_name(),
-                irq,
-                e
-            );
-            return Err(e);
-        }
-
         virtio_irq_manager()
             .register_device(dev.clone())
             .map_err(|e| {