Add read and write operations handling

DeviceManager 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 <jing2.liu@linux.intel.com>

Author: Jing Liu

src/device_manager.rs

@@ -12,13 +12,16 @@
 //! devices, 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::collections::HashMap;
 use std::result;
 use std::sync::Arc;
 
+use vm_memory::GuestAddress;
+
 /// Error type for `DeviceManager` usage.
 #[derive(Debug)]
 pub enum Error {
@@ -43,14 +46,56 @@ pub struct DeviceDescriptor {
     pub parent_bus: Option<Arc<dyn DeviceIo>>,
 }
 
+// Structure describing a bus range.
+#[derive(Debug, Copy, Clone)]
+struct BusRange {
+    base: IoAddress,
+    size: IoSize,
+}
+
+impl BusRange {
+    fn new_pio_range(base: u16, size: u16) -> Self {
+        BusRange {
+            base: IoAddress::Pio(base),
+            size: IoSize::Pio(size),
+        }
+    }
+    fn new_mmio_range(base: u64, size: u64) -> Self {
+        BusRange {
+            base: IoAddress::Mmio(GuestAddress(base)),
+            size: IoSize::Mmio(size),
+        }
+    }
+}
+
+impl Eq for BusRange {}
+
+impl PartialEq for BusRange {
+    fn eq(&self, other: &BusRange) -> bool {
+        self.base == other.base
+    }
+}
+
+impl Ord for BusRange {
+    fn cmp(&self, other: &BusRange) -> Ordering {
+        self.base.cmp(&other.base)
+    }
+}
+
+impl PartialOrd for BusRange {
+    fn partial_cmp(&self, other: &BusRange) -> Option<Ordering> {
+        self.base.partial_cmp(&other.base)
+    }
+}
+
 /// System device manager serving for all devices management and VM exit handling.
 pub struct DeviceManager {
     /// Devices information mapped by instance id.
     devices: HashMap<u16, DeviceDescriptor>,
     /// Range mapping for VM exit pio operations.
-    pio_bus: BTreeMap<(u16, u16), Arc<dyn DeviceIo>>,
+    pio_bus: BTreeMap<BusRange, Arc<dyn DeviceIo>>,
     /// Range mapping for VM exit mmio operations.
-    mmio_bus: BTreeMap<(u64, u64), Arc<dyn DeviceIo>>,
+    mmio_bus: BTreeMap<BusRange, Arc<dyn DeviceIo>>,
 }
 
 impl DeviceManager {
@@ -87,7 +132,11 @@ impl DeviceManager {
         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(BusRange::new_pio_range(base, size), device.clone())
+                        .is_some()
+                    {
                         // Unregister and let VMM free resources.
                         if idx > 0 {
                             self.unregister_resources(&resources[0..idx]);
@@ -96,7 +145,11 @@ impl DeviceManager {
                     }
                 }
                 Resource::MmioAddressRange { base, size } => {
-                    if self.mmio_bus.insert((base, size), device.clone()).is_some() {
+                    if self
+                        .mmio_bus
+                        .insert(BusRange::new_mmio_range(base, size), device.clone())
+                        .is_some()
+                    {
                         // Unregister and let VMM free resources.
                         if idx > 0 {
                             self.unregister_resources(&resources[0..idx]);
@@ -145,10 +198,10 @@ impl DeviceManager {
         for res in resources.iter() {
             match *res {
                 Resource::PioAddressRange { base, size } => {
-                    self.pio_bus.remove(&(base, size));
+                    self.pio_bus.remove(&BusRange::new_pio_range(base, size));
                 }
                 Resource::MmioAddressRange { base, size } => {
-                    self.mmio_bus.remove(&(base, size));
+                    self.mmio_bus.remove(&BusRange::new_mmio_range(base, size));
                 }
                 _ => continue,
             }
@@ -173,4 +226,87 @@ impl DeviceManager {
             Err(Error::DeviceNotExist)
         }
     }
+
+    fn first_before(
+        &self,
+        addr: IoAddress,
+        map: BTreeMap<BusRange, Arc<dyn DeviceIo>>,
+    ) -> Option<(BusRange, 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<BusRange, 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

@@ -7,12 +7,33 @@
 
 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 interrupt;
 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) => p as u64,
+            IoSize::Mmio(m) => m,
+        }
+    }
+}
+
 /// IO Addresses.
 #[derive(Debug, Copy, Clone)]
 pub enum IoAddress {
@@ -23,15 +44,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) => p as u64,
+            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]);
 }