Manage x86 legacy interrupts based on KVM

Implement InterruptSourceGroup trait to manage x86 legacy interruts.
On x86 platforms, pin-based device interrupts connecting to the master
PIC, the slave PIC and IOAPICs are named as legacy interrupts. For
legacy interrupts, the interrupt routing logic are manged by the
PICs/IOAPICs and the interrupt group logic only takes responsibility
to enable/disable the interrupts.

Signed-off-by: Liu Jiang <[email protected]>
Signed-off-by: Bin Zha <[email protected]>

Author: jiangliu

Cargo.toml

@@ -16,3 +16,4 @@ vmm-sys-util = "~0"
 legacy-irq = []
 msi-irq = []
 kvm-irq = ["kvm-ioctls", "kvm-bindings"]
+kvm-legacy-irq = ["legacy-irq", "kvm-irq"]

src/interrupt/kvm/legacy_irq.rs

@@ -0,0 +1,150 @@
+// Copyright (C) 2019 Alibaba Cloud. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Manage virtual device's legacy interrupts based on Linux KVM framework.
+//!
+//! On x86 platforms, legacy interrupts are those managed by the Master PIC, the slave PIC and
+//! IOAPICs.
+
+use super::*;
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+use kvm_bindings::{
+    KVM_IRQCHIP_IOAPIC, KVM_IRQCHIP_PIC_MASTER, KVM_IRQCHIP_PIC_SLAVE, KVM_IRQ_ROUTING_IRQCHIP,
+};
+
+pub(super) struct LegacyIrq {
+    base: u32,
+    vmfd: Arc<VmFd>,
+    irqfd: EventFd,
+}
+
+impl LegacyIrq {
+    #[allow(clippy::new_ret_no_self)]
+    pub(super) fn new(
+        base: InterruptIndex,
+        count: InterruptIndex,
+        vmfd: Arc<VmFd>,
+        _routes: Arc<KvmIrqRouting>,
+    ) -> Result<Self> {
+        if count != 1 {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+        Ok(LegacyIrq {
+            base,
+            vmfd,
+            irqfd: EventFd::new(0)?,
+        })
+    }
+
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    fn add_legacy_entry(
+        gsi: u32,
+        chip: u32,
+        pin: u32,
+        routes: &mut HashMap<u64, kvm_irq_routing_entry>,
+    ) -> Result<()> {
+        let mut entry = kvm_irq_routing_entry {
+            gsi,
+            type_: KVM_IRQ_ROUTING_IRQCHIP,
+            ..Default::default()
+        };
+        // Safe because we are initializing all fields of the `irqchip` struct.
+        entry.u.irqchip.irqchip = chip;
+        entry.u.irqchip.pin = pin;
+        routes.insert(hash_key(&entry), entry);
+
+        Ok(())
+    }
+
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    /// Build routings for IRQs connected to the master PIC, the slave PIC or the first IOAPIC.
+    pub(super) fn initialize_legacy(
+        routes: &mut HashMap<u64, kvm_irq_routing_entry>,
+    ) -> Result<()> {
+        // Build routings for the master PIC
+        for i in 0..8 {
+            if i != 2 {
+                Self::add_legacy_entry(i, KVM_IRQCHIP_PIC_MASTER, i, routes)?;
+            }
+        }
+
+        // Build routings for the slave PIC
+        for i in 8..16 {
+            Self::add_legacy_entry(i, KVM_IRQCHIP_PIC_SLAVE, i - 8, routes)?;
+        }
+
+        // Build routings for the first IOAPIC
+        for i in 0..24 {
+            if i == 0 {
+                Self::add_legacy_entry(i, KVM_IRQCHIP_IOAPIC, 2, routes)?;
+            } else if i != 2 {
+                Self::add_legacy_entry(i, KVM_IRQCHIP_IOAPIC, i, routes)?;
+            };
+        }
+
+        Ok(())
+    }
+
+    #[cfg(any(target_arch = "aarch", target_arch = "aarch64"))]
+    pub(super) fn initialize_legacy(
+        _routes: &mut HashMap<u64, kvm_irq_routing_entry>,
+    ) -> Result<()> {
+        //TODO
+        Ok(())
+    }
+}
+
+impl InterruptSourceGroup for LegacyIrq {
+    fn interrupt_type(&self) -> InterruptSourceType {
+        InterruptSourceType::LegacyIrq
+    }
+
+    fn len(&self) -> u32 {
+        1
+    }
+
+    fn base(&self) -> u32 {
+        self.base
+    }
+
+    fn enable(&self, configs: &[InterruptSourceConfig]) -> Result<()> {
+        if configs.len() != 1 {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+        // The IRQ routings for legacy IRQs have been configured during
+        // KvmIrqManager::initialize(), so only need to register irqfd to the KVM driver.
+        self.vmfd
+            .register_irqfd(&self.irqfd, self.base)
+            .map_err(from_sys_util_errno)
+    }
+
+    fn disable(&self) -> Result<()> {
+        self.vmfd
+            .unregister_irqfd(&self.irqfd, self.base)
+            .map_err(from_sys_util_errno)
+    }
+
+    fn update(&self, index: InterruptIndex, _config: &InterruptSourceConfig) -> Result<()> {
+        // For legacy interrupts, the routing configuration is managed by the PIC/IOAPIC interrupt
+        // controller drivers, so nothing to do here.
+        if index != 0 {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+        Ok(())
+    }
+
+    fn notifier(&self, index: InterruptIndex) -> Option<&EventFd> {
+        if index != 0 {
+            None
+        } else {
+            Some(&self.irqfd)
+        }
+    }
+
+    fn trigger(&self, index: InterruptIndex) -> Result<()> {
+        if index != 0 {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+        self.irqfd.write(1)
+    }
+}

src/interrupt/kvm/mod.rs

@@ -16,6 +16,11 @@ use kvm_ioctls::VmFd;
 
 use super::*;
 
+#[cfg(feature = "kvm-legacy-irq")]
+mod legacy_irq;
+#[cfg(feature = "kvm-legacy-irq")]
+use self::legacy_irq::LegacyIrq;
+
 /// Structure to manage interrupt sources for a virtual machine based on the Linux KVM framework.
 ///
 /// The KVM framework provides methods to inject interrupts into the target virtual machines,
@@ -90,6 +95,13 @@ impl KvmIrqManagerObj {
     ) -> Result<Arc<Box<dyn InterruptSourceGroup>>> {
         #[allow(unreachable_patterns)]
         let group: Arc<Box<dyn InterruptSourceGroup>> = match ty {
+            #[cfg(feature = "kvm-legacy-irq")]
+            InterruptSourceType::LegacyIrq => Arc::new(Box::new(LegacyIrq::new(
+                base,
+                count,
+                self.vmfd.clone(),
+                self.routes.clone(),
+            )?)),
             _ => return Err(Error::from(ErrorKind::InvalidInput)),
         };
 
@@ -133,6 +145,9 @@ impl KvmIrqRouting {
         #[allow(unused_mut)]
         let mut routes = self.routes.lock().unwrap();
 
+        #[cfg(feature = "kvm-legacy-irq")]
+        LegacyIrq::initialize_legacy(&mut *routes)?;
+
         self.set_routing(&*routes)
     }