Add read and write operations handling

IO manager is responsible for handling IO operation when VMExit.
It works out the specific device according to the address range and
hand over to DeviceIo trait.

Signed-off-by: Jing Liu <[email protected]>

Author: Jing Liu

src/device_manager.rs

@@ -12,29 +12,76 @@
 //! devices IO windows, and finally set resources to virtual device.
 
 use crate::resources::Resource;
-use crate::DeviceIo;
+use crate::{DeviceIo, IoAddress, IoSize};
 
+use std::cmp::{Ord, Ordering, PartialEq, PartialOrd};
 use std::collections::btree_map::BTreeMap;
 use std::result;
 use std::sync::Arc;
 
+use vm_memory::GuestAddress;
+
 /// Error type for `IoManager` usage.
 #[derive(Debug)]
 pub enum Error {
     /// The inserting device overlaps with a current device.
     DeviceOverlap,
+    /// The device doesn't exist.
+    DeviceNotExist,
 }
 
 /// Simplify the `Result` type.
 pub type Result<T> = result::Result<T, Error>;
 
+// Structure describing an IO range.
+#[derive(Debug, Copy, Clone)]
+struct IoRange {
+    base: IoAddress,
+    size: IoSize,
+}
+
+impl IoRange {
+    fn new_pio_range(base: u16, size: u16) -> Self {
+        IoRange {
+            base: IoAddress::Pio(base),
+            size: IoSize::Pio(size),
+        }
+    }
+    fn new_mmio_range(base: u64, size: u64) -> Self {
+        IoRange {
+            base: IoAddress::Mmio(GuestAddress(base)),
+            size: IoSize::Mmio(size),
+        }
+    }
+}
+
+impl Eq for IoRange {}
+
+impl PartialEq for IoRange {
+    fn eq(&self, other: &IoRange) -> bool {
+        self.base == other.base
+    }
+}
+
+impl Ord for IoRange {
+    fn cmp(&self, other: &IoRange) -> Ordering {
+        self.base.cmp(&other.base)
+    }
+}
+
+impl PartialOrd for IoRange {
+    fn partial_cmp(&self, other: &IoRange) -> Option<Ordering> {
+        self.base.partial_cmp(&other.base)
+    }
+}
+
 /// System IO manager serving for all devices management and VM exit handling.
 #[derive(Default)]
 pub struct IoManager {
     /// Range mapping for VM exit pio operations.
-    pio_bus: BTreeMap<(u16, u16), Arc<dyn DeviceIo>>,
+    pio_bus: BTreeMap<IoRange, Arc<dyn DeviceIo>>,
     /// Range mapping for VM exit mmio operations.
-    mmio_bus: BTreeMap<(u64, u64), Arc<dyn DeviceIo>>,
+    mmio_bus: BTreeMap<IoRange, Arc<dyn DeviceIo>>,
 }
 
 impl IoManager {
@@ -56,15 +103,23 @@ impl IoManager {
         for (idx, res) in resources.iter().enumerate() {
             match *res {
                 Resource::PioAddressRange { base, size } => {
-                    if self.pio_bus.insert((base, size), device.clone()).is_some() {
+                    if self
+                        .pio_bus
+                        .insert(IoRange::new_pio_range(base, size), device.clone())
+                        .is_some()
+                    {
                         // Unregister registered resources.
                         self.unregister_device_io(&resources[0..idx])?;
 
                         return Err(Error::DeviceOverlap);
                     }
                 }
                 Resource::MmioAddressRange { base, size } => {
-                    if self.mmio_bus.insert((base, size), device.clone()).is_some() {
+                    if self
+                        .mmio_bus
+                        .insert(IoRange::new_mmio_range(base, size), device.clone())
+                        .is_some()
+                    {
                         // Unregister registered resources.
                         self.unregister_device_io(&resources[0..idx])?;
 
@@ -89,14 +144,97 @@ impl IoManager {
         for res in resources.iter() {
             match *res {
                 Resource::PioAddressRange { base, size } => {
-                    self.pio_bus.remove(&(base, size));
+                    self.pio_bus.remove(&IoRange::new_pio_range(base, size));
                 }
                 Resource::MmioAddressRange { base, size } => {
-                    self.mmio_bus.remove(&(base, size));
+                    self.mmio_bus.remove(&IoRange::new_mmio_range(base, size));
                 }
                 _ => continue,
             }
         }
         Ok(())
     }
+
+    fn first_before(
+        &self,
+        addr: IoAddress,
+        map: BTreeMap<IoRange, Arc<dyn DeviceIo>>,
+    ) -> Option<(IoRange, Arc<dyn DeviceIo>)> {
+        for (range, dev) in map.iter().rev() {
+            if range.base <= addr {
+                return Some((*range, dev.clone()));
+            }
+        }
+        None
+    }
+
+    // Return the Device mapped the address.
+    fn get_device(
+        &self,
+        addr: IoAddress,
+        map: BTreeMap<IoRange, Arc<dyn DeviceIo>>,
+    ) -> Option<Arc<dyn DeviceIo>> {
+        if let Some((range, dev)) = self.first_before(addr, map) {
+            if (addr.raw_value() - range.base.raw_value()) < range.size.raw_value() {
+                return Some(dev);
+            }
+        }
+        None
+    }
+
+    /// A helper function handling PIO read command during VM exit.
+    /// The virtual device itself provides mutable ability and thead-safe protection.
+    ///
+    /// Return error if failed to get the device.
+    pub fn pio_read(&self, addr: u16, data: &mut [u8]) -> Result<()> {
+        if let Some(device) = self.get_device(IoAddress::Pio(addr), self.pio_bus.clone()) {
+            device.read(IoAddress::Pio(addr), data);
+            Ok(())
+        } else {
+            Err(Error::DeviceNotExist)
+        }
+    }
+
+    /// A helper function handling PIO write command during VM exit.
+    /// The virtual device itself provides mutable ability and thead-safe protection.
+    ///
+    /// Return error if failed to get the device.
+    pub fn pio_write(&self, addr: u16, data: &[u8]) -> Result<()> {
+        if let Some(device) = self.get_device(IoAddress::Pio(addr), self.pio_bus.clone()) {
+            device.write(IoAddress::Pio(addr), data);
+            Ok(())
+        } else {
+            Err(Error::DeviceNotExist)
+        }
+    }
+
+    /// A helper function handling MMIO read command during VM exit.
+    /// The virtual device itself provides mutable ability and thead-safe protection.
+    ///
+    /// Return error if failed to get the device.
+    pub fn mmio_read(&self, addr: u64, data: &mut [u8]) -> Result<()> {
+        if let Some(device) =
+            self.get_device(IoAddress::Mmio(GuestAddress(addr)), self.mmio_bus.clone())
+        {
+            device.read(IoAddress::Mmio(GuestAddress(addr)), data);
+            Ok(())
+        } else {
+            Err(Error::DeviceNotExist)
+        }
+    }
+
+    /// A helper function handling MMIO write command during VM exit.
+    /// The virtual device itself provides mutable ability and thead-safe protection.
+    ///
+    /// Return error if failed to get the device.
+    pub fn mmio_write(&self, addr: u64, data: &[u8]) -> Result<()> {
+        if let Some(device) =
+            self.get_device(IoAddress::Mmio(GuestAddress(addr)), self.mmio_bus.clone())
+        {
+            device.write(IoAddress::Mmio(GuestAddress(addr)), data);
+            Ok(())
+        } else {
+            Err(Error::DeviceNotExist)
+        }
+    }
 }

src/lib.rs

@@ -5,11 +5,32 @@
 
 extern crate vm_memory;
 
-use vm_memory::GuestAddress;
+use std::cmp::{Ord, Ordering, PartialOrd};
+use vm_memory::{Address, GuestAddress, GuestUsize};
 
 pub mod device_manager;
 pub mod resources;
 
+/// IO Size.
+#[derive(Debug, Copy, Clone)]
+pub enum IoSize {
+    /// Port I/O size.
+    Pio(u16),
+
+    /// Memory mapped I/O size.
+    Mmio(GuestUsize),
+}
+
+impl IoSize {
+    /// Get the raw value as u64 to make operation simple.
+    pub fn raw_value(&self) -> u64 {
+        match *self {
+            IoSize::Pio(p) => u64::from(p),
+            IoSize::Mmio(m) => m,
+        }
+    }
+}
+
 /// IO Addresses.
 #[derive(Debug, Copy, Clone)]
 pub enum IoAddress {
@@ -20,15 +41,47 @@ pub enum IoAddress {
     Mmio(GuestAddress),
 }
 
+impl IoAddress {
+    /// Get the raw value of IO Address to make operation simple.
+    pub fn raw_value(&self) -> u64 {
+        match *self {
+            IoAddress::Pio(p) => u64::from(p),
+            IoAddress::Mmio(m) => m.raw_value(),
+        }
+    }
+}
+
+impl Eq for IoAddress {}
+
+impl PartialEq for IoAddress {
+    fn eq(&self, other: &IoAddress) -> bool {
+        self.raw_value() == other.raw_value()
+    }
+}
+
+impl Ord for IoAddress {
+    fn cmp(&self, other: &IoAddress) -> Ordering {
+        self.raw_value().cmp(&other.raw_value())
+    }
+}
+
+impl PartialOrd for IoAddress {
+    fn partial_cmp(&self, other: &IoAddress) -> Option<Ordering> {
+        self.raw_value().partial_cmp(&other.raw_value())
+    }
+}
+
 /// Device IO trait.
 /// A device supporting memory based I/O should implement this trait, then
 /// register itself against the different IO type ranges it handles.
 /// The VMM will then dispatch IO (PIO or MMIO) VM exits by calling into the
 /// registered devices read or write method from this trait.
+/// The mutable ability is provided by virtual device inside. e.g. Mutex, RwLock.
+/// So we can get a real multiple thread handling.
 pub trait DeviceIo: Send {
     /// Read from the guest physical address `addr` to `data`.
-    fn read(&mut self, addr: IoAddress, data: &mut [u8]);
+    fn read(&self, addr: IoAddress, data: &mut [u8]);
 
     /// Write `data` to the guest physical address `addr`.
-    fn write(&mut self, addr: IoAddress, data: &[u8]);
+    fn write(&self, addr: IoAddress, data: &[u8]);
 }