Add generic heplers to manage MSI interrupts

Introduce generic mechanism to support message signalled interrupts
based on KVM hypervisor.

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

Author: jiangliu

Cargo.toml

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

src/interrupt/kvm/mod.rs

@@ -20,6 +20,11 @@ use super::*;
 mod legacy_irq;
 #[cfg(feature = "kvm-legacy-irq")]
 use self::legacy_irq::LegacyIrq;
+#[cfg(feature = "kvm-msi-generic")]
+mod msi_generic;
+
+/// Maximum number of global interrupt sources.
+pub const MAX_IRQS: InterruptIndex = 1024;
 
 /// Structure to manage interrupt sources for a virtual machine based on the Linux KVM framework.
 ///
@@ -178,6 +183,46 @@ impl KvmIrqRouting {
     }
 }
 
+#[cfg(feature = "kvm-msi-generic")]
+impl KvmIrqRouting {
+    pub(super) fn add(&self, entries: &[kvm_irq_routing_entry]) -> Result<()> {
+        // Safe to unwrap because there's no legal way to break the mutex.
+        let mut routes = self.routes.lock().unwrap();
+        for entry in entries {
+            if entry.gsi >= MAX_IRQS {
+                return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+            } else if routes.contains_key(&hash_key(entry)) {
+                return Err(std::io::Error::from_raw_os_error(libc::EEXIST));
+            }
+        }
+
+        for entry in entries {
+            let _ = routes.insert(hash_key(entry), *entry);
+        }
+        self.set_routing(&routes)
+    }
+
+    pub(super) fn remove(&self, entries: &[kvm_irq_routing_entry]) -> Result<()> {
+        // Safe to unwrap because there's no legal way to break the mutex.
+        let mut routes = self.routes.lock().unwrap();
+        for entry in entries {
+            let _ = routes.remove(&hash_key(entry));
+        }
+        self.set_routing(&routes)
+    }
+
+    pub(super) fn modify(&self, entry: &kvm_irq_routing_entry) -> Result<()> {
+        // Safe to unwrap because there's no legal way to break the mutex.
+        let mut routes = self.routes.lock().unwrap();
+        if !routes.contains_key(&hash_key(entry)) {
+            return Err(std::io::Error::from_raw_os_error(libc::ENOENT));
+        }
+
+        let _ = routes.insert(hash_key(entry), *entry);
+        self.set_routing(&routes)
+    }
+}
+
 /// Helper function convert from vmm_sys_util::errno::Error to std::io::Error.
 pub fn from_sys_util_errno(e: vmm_sys_util::errno::Error) -> std::io::Error {
     std::io::Error::from_raw_os_error(e.errno())

src/interrupt/kvm/msi_generic.rs

@@ -0,0 +1,58 @@
+// Copyright (C) 2019 Alibaba Cloud. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Helper utilities for handling MSI interrupts.
+
+use kvm_bindings::{kvm_irq_routing_entry, KVM_IRQ_ROUTING_MSI};
+
+use super::*;
+
+pub(super) struct MsiConfig {
+    pub(super) irqfd: EventFd,
+    pub(super) config: Mutex<MsiIrqSourceConfig>,
+}
+
+impl MsiConfig {
+    pub(super) fn new() -> Self {
+        MsiConfig {
+            irqfd: EventFd::new(0).unwrap(),
+            config: Mutex::new(Default::default()),
+        }
+    }
+}
+
+pub(super) fn new_msi_routing_entry(
+    gsi: InterruptIndex,
+    msicfg: &MsiIrqSourceConfig,
+) -> kvm_irq_routing_entry {
+    let mut entry = kvm_irq_routing_entry {
+        gsi,
+        type_: KVM_IRQ_ROUTING_MSI,
+        flags: 0,
+        ..Default::default()
+    };
+    entry.u.msi.address_hi = msicfg.high_addr;
+    entry.u.msi.address_lo = msicfg.low_addr;
+    entry.u.msi.data = msicfg.data;
+    entry
+}
+
+#[allow(irrefutable_let_patterns)]
+pub(super) fn create_msi_routing_entries(
+    base: InterruptIndex,
+    configs: &[InterruptSourceConfig],
+) -> Result<Vec<kvm_irq_routing_entry>> {
+    let _ = base
+        .checked_add(configs.len() as u32)
+        .ok_or_else(|| std::io::Error::from_raw_os_error(libc::EINVAL))?;
+    let mut entries = Vec::with_capacity(configs.len());
+    for (i, ref val) in configs.iter().enumerate() {
+        if let InterruptSourceConfig::MsiIrq(msicfg) = val {
+            let entry = new_msi_routing_entry(base + i as u32, msicfg);
+            entries.push(entry);
+        } else {
+            return Err(std::io::Error::from_raw_os_error(libc::EINVAL));
+        }
+    }
+    Ok(entries)
+}