Manage PCI MSI/PCI MSI-x interrupts

Implement interrupt source driver to manage PCI MSI/MSI-x interrupts.

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

Author: jiangliu

Cargo.toml

@@ -18,3 +18,4 @@ msi-irq = []
 kvm-irq = ["kvm-ioctls", "kvm-bindings"]
 kvm-msi-generic = ["msi-irq", "kvm-irq"]
 kvm-legacy-irq = ["legacy-irq", "kvm-irq"]
+kvm-msi-irq = ["kvm-msi-generic"]

src/interrupt/kvm/mod.rs

@@ -22,10 +22,17 @@ mod legacy_irq;
 use self::legacy_irq::LegacyIrq;
 #[cfg(feature = "kvm-msi-generic")]
 mod msi_generic;
+#[cfg(feature = "kvm-msi-irq")]
+mod msi_irq;
+#[cfg(feature = "kvm-msi-irq")]
+use self::msi_irq::MsiIrq;
 
 /// Maximum number of global interrupt sources.
 pub const MAX_IRQS: InterruptIndex = 1024;
 
+/// Default maximum number of Message Signaled Interrupts per device.
+pub const DEFAULT_MAX_MSI_IRQS_PER_DEVICE: InterruptIndex = 128;
+
 /// 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,
@@ -49,6 +56,7 @@ impl KvmIrqManager {
                 vmfd,
                 groups: HashMap::new(),
                 routes: Arc::new(KvmIrqRouting::new(vmfd2)),
+                max_msi_irqs: DEFAULT_MAX_MSI_IRQS_PER_DEVICE,
             }),
         }
     }
@@ -59,6 +67,12 @@ impl KvmIrqManager {
         let mgr = self.mgr.lock().unwrap();
         mgr.initialize()
     }
+
+    /// Set maximum supported MSI interrupts per device.
+    pub fn set_max_msi_irqs(&self, max_msi_irqs: InterruptIndex) {
+        let mut mgr = self.mgr.lock().unwrap();
+        mgr.max_msi_irqs = max_msi_irqs;
+    }
 }
 
 impl InterruptManager for KvmIrqManager {
@@ -84,6 +98,7 @@ struct KvmIrqManagerObj {
     vmfd: Arc<VmFd>,
     routes: Arc<KvmIrqRouting>,
     groups: HashMap<InterruptIndex, Arc<Box<dyn InterruptSourceGroup>>>,
+    max_msi_irqs: InterruptIndex,
 }
 
 impl KvmIrqManagerObj {
@@ -107,6 +122,14 @@ impl KvmIrqManagerObj {
                 self.vmfd.clone(),
                 self.routes.clone(),
             )?)),
+            #[cfg(feature = "kvm-msi-irq")]
+            InterruptSourceType::MsiIrq => Arc::new(Box::new(MsiIrq::new(
+                base,
+                count,
+                self.max_msi_irqs,
+                self.vmfd.clone(),
+                self.routes.clone(),
+            )?)),
             _ => return Err(Error::from(ErrorKind::InvalidInput)),
         };
 

src/interrupt/kvm/msi_irq.rs

@@ -0,0 +1,144 @@
+// Copyright (C) 2019 Alibaba Cloud. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Manage virtual device's PCI MSI/PCI MSIx interrupts based on Linux KVM framework.
+//!
+//! To optimize for performance by avoiding unnecessary locking and state checking, we assume that
+//! the caller will take the responsibility to maintain the interrupt states and only issue valid
+//! requests to this driver. If the caller doesn't obey the contract, only the current virtual
+//! machine will be affected, it shouldn't break the host or other virtual machines.
+
+use super::msi_generic::{create_msi_routing_entries, new_msi_routing_entry, MsiConfig};
+use super::*;
+
+pub(super) struct MsiIrq {
+    base: InterruptIndex,
+    count: InterruptIndex,
+    vmfd: Arc<VmFd>,
+    irq_routing: Arc<KvmIrqRouting>,
+    msi_configs: Vec<MsiConfig>,
+}
+
+impl MsiIrq {
+    #[allow(clippy::new_ret_no_self)]
+    pub(super) fn new(
+        base: InterruptIndex,
+        count: InterruptIndex,
+        max_msi_irqs: InterruptIndex,
+        vmfd: Arc<VmFd>,
+        irq_routing: Arc<KvmIrqRouting>,
+    ) -> Result<Self> {
+        if count > max_msi_irqs || base >= MAX_IRQS || base + count > MAX_IRQS {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+
+        let mut msi_configs = Vec::with_capacity(count as usize);
+        for _ in 0..count {
+            msi_configs.push(MsiConfig::new());
+        }
+
+        Ok(MsiIrq {
+            base,
+            count,
+            vmfd,
+            irq_routing,
+            msi_configs,
+        })
+    }
+}
+
+impl InterruptSourceGroup for MsiIrq {
+    fn interrupt_type(&self) -> InterruptSourceType {
+        InterruptSourceType::MsiIrq
+    }
+
+    fn len(&self) -> u32 {
+        self.count
+    }
+
+    fn base(&self) -> u32 {
+        self.base
+    }
+
+    fn enable(&self, configs: &[InterruptSourceConfig]) -> Result<()> {
+        if configs.len() != self.count as usize {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+
+        // First add IRQ routings for all the MSI interrupts.
+        let entries = create_msi_routing_entries(self.base, configs)?;
+        self.irq_routing.add(&entries)?;
+
+        // Then register irqfds to the KVM module.
+        for i in 0..self.count {
+            let irqfd = &self.msi_configs[i as usize].irqfd;
+            self.vmfd
+                .register_irqfd(irqfd, self.base + i)
+                .map_err(from_sys_util_errno)?;
+        }
+
+        Ok(())
+    }
+
+    fn disable(&self) -> Result<()> {
+        // First unregister all irqfds, so it won't trigger anymore.
+        for i in 0..self.count {
+            let irqfd = &self.msi_configs[i as usize].irqfd;
+            self.vmfd
+                .unregister_irqfd(irqfd, self.base + i)
+                .map_err(from_sys_util_errno)?;
+        }
+
+        // Then tear down the IRQ routings for all the MSI interrupts.
+        let mut entries = Vec::with_capacity(self.count as usize);
+        for i in 0..self.count {
+            // Safe to unwrap because there's no legal way to break the mutex.
+            let msicfg = self.msi_configs[i as usize].config.lock().unwrap();
+            let entry = new_msi_routing_entry(self.base + i, &*msicfg);
+            entries.push(entry);
+        }
+        self.irq_routing.remove(&entries)?;
+
+        Ok(())
+    }
+
+    #[allow(irrefutable_let_patterns)]
+    fn update(&self, index: InterruptIndex, config: &InterruptSourceConfig) -> Result<()> {
+        if index >= self.count {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+
+        if let InterruptSourceConfig::MsiIrq(ref cfg) = config {
+            // Safe to unwrap because there's no legal way to break the mutex.
+            let entry = {
+                let mut msicfg = self.msi_configs[index as usize].config.lock().unwrap();
+                msicfg.high_addr = cfg.high_addr;
+                msicfg.low_addr = cfg.low_addr;
+                msicfg.data = cfg.data;
+                new_msi_routing_entry(self.base + index, &*msicfg)
+            };
+            self.irq_routing.modify(&entry)
+        } else {
+            Err(std::io::Error::from_raw_os_error(libc::EINVAL))
+        }
+    }
+
+    fn notifier(&self, index: InterruptIndex) -> Option<&EventFd> {
+        if index >= self.count {
+            None
+        } else {
+            let msi_config = &self.msi_configs[index as usize];
+            Some(&msi_config.irqfd)
+        }
+    }
+
+    fn trigger(&self, index: InterruptIndex) -> Result<()> {
+        // Assume that the caller will maintain the interrupt states and only call this function
+        // when suitable.
+        if index >= self.count {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+        let msi_config = &self.msi_configs[index as usize];
+        msi_config.irqfd.write(1)
+    }
+}