Add device manager support

Based on interrupt management and resources definition, this
adds device manager to manage all devices registering and
unregistering.

Signed-off-by: Jing Liu <jing2.liu@linux.intel.com>

Author: Jing Liu

src/device_manager.rs

@@ -0,0 +1,176 @@
+// Copyright © 2019 Intel Corporation. All Rights Reserved.
+// SPDX-License-Identifier: (Apache-2.0 AND BSD-3-Clause)
+
+//! System level device management.
+//!
+//! [DeviceManager](struct.DeviceManager.html) responds to manage all devices
+//! of virtual machine, parent bus, register IO resources callback,
+//! unregister devices and help VM IO exit handling.
+//！
+//！VMM would take responsible for getting device resource request, ask
+//! vm_allocator to allocate the resources, ask vm_device to register the
+//! devices, and finally set resources to virtual device.
+
+use crate::resources::Resource;
+use crate::DeviceIo;
+
+use std::collections::btree_map::BTreeMap;
+use std::collections::HashMap;
+use std::result;
+use std::sync::Arc;
+
+/// Error type for `DeviceManager` usage.
+#[derive(Debug)]
+pub enum Error {
+    /// The insertion failed because the new device overlapped with an old device.
+    DeviceOverlap,
+    /// The insertion failed because device already exists.
+    DeviceExist,
+    /// The removing fails because the device doesn't exist.
+    DeviceNotExist,
+}
+
+/// Simplify the `Result` type.
+pub type Result<T> = result::Result<T, Error>;
+
+/// Storing Device information and for topology managing.
+pub struct DeviceDescriptor {
+    /// The device to describe.
+    pub device: Arc<dyn DeviceIo>,
+    /// Instance id of device.
+    pub id: u16,
+    /// The parent bus of this device.
+    pub parent_bus: Option<Arc<dyn DeviceIo>>,
+}
+
+/// 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>>,
+    /// Range mapping for VM exit mmio operations.
+    mmio_bus: BTreeMap<(u64, u64), Arc<dyn DeviceIo>>,
+}
+
+impl DeviceManager {
+    /// Create a new `DeviceManager`.
+    pub fn new() -> Self {
+        DeviceManager {
+            devices: HashMap::new(),
+            mmio_bus: BTreeMap::new(),
+            pio_bus: BTreeMap::new(),
+        }
+    }
+
+    fn insert(&mut self, des: DeviceDescriptor, id: u16) -> Result<()> {
+        // Insert if the key is non-present, else report error.
+        if self.devices.contains_key(&id) {
+            return Err(Error::DeviceExist);
+        }
+        self.devices.insert(id, des);
+        Ok(())
+    }
+
+    fn remove(&mut self, id: u16) -> Option<DeviceDescriptor> {
+        self.devices.remove(&id)
+    }
+
+    fn register_resources(
+        &mut self,
+        device: Arc<dyn DeviceIo>,
+        resources: &[Resource],
+        instance_id: &mut u16,
+    ) -> Result<()> {
+        // Register and mark device resources
+        // The resources addresses being registered are sucessfully allocated before.
+        for (idx, res) in resources.iter().enumerate() {
+            match *res {
+                Resource::PioAddressRange { base, size } => {
+                    if self.pio_bus.insert((base, size), device.clone()).is_some() {
+                        // Unregister and let VMM free resources.
+                        if idx > 0 {
+                            self.unregister_resources(&resources[0..idx]);
+                        }
+                        return Err(Error::DeviceOverlap);
+                    }
+                }
+                Resource::MmioAddressRange { base, size } => {
+                    if self.mmio_bus.insert((base, size), device.clone()).is_some() {
+                        // Unregister and let VMM free resources.
+                        if idx > 0 {
+                            self.unregister_resources(&resources[0..idx]);
+                        }
+                        return Err(Error::DeviceOverlap);
+                    }
+                }
+                Resource::InstanceId(id) => *instance_id = id,
+                _ => continue,
+            }
+        }
+        Ok(())
+    }
+
+    /// Register a new device with its parent bus and allocated resources.
+    /// VMM is responsible for providing the allocated resources to virtual device.
+    ///
+    /// # Arguements
+    ///
+    /// * `device`: device instance object to be registered
+    /// * `parent_bus`: parent bus of the device
+    /// * `resources`: resources that this device owns, might include
+    ///                port I/O and memory-mapped I/O ranges, irq number, etc.
+    pub fn register_device(
+        &mut self,
+        device: Arc<dyn DeviceIo>,
+        parent_bus: Option<Arc<dyn DeviceIo>>,
+        resources: &[Resource],
+    ) -> Result<()> {
+        let mut id = 0;
+
+        // Register the IO resource
+        self.register_resources(device.clone(), resources, &mut id)?;
+
+        // Insert bus/device with parent bus
+        let descriptor = DeviceDescriptor {
+            device,
+            id,
+            parent_bus,
+        };
+        self.insert(descriptor, id)
+    }
+
+    // Unregister resources with all entries addresses valid.
+    fn unregister_resources(&mut self, resources: &[Resource]) {
+        for res in resources.iter() {
+            match *res {
+                Resource::PioAddressRange { base, size } => {
+                    self.pio_bus.remove(&(base, size));
+                }
+                Resource::MmioAddressRange { base, size } => {
+                    self.mmio_bus.remove(&(base, size));
+                }
+                _ => continue,
+            }
+        }
+    }
+
+    /// Unregister a device from `DeviceManager`, e.g. users specified removing.
+    /// VMM pre-fetches the resources e.g. dev.get_assigned_resources()
+    /// VMM is responsible for freeing the resources.
+    ///
+    /// # Arguements
+    ///
+    /// * `id`: device instance id to be unregistered
+    /// * `resources`: resources that this device owns, might include
+    ///                port I/O and memory-mapped I/O ranges, irq number, etc.
+    pub fn unregister_device(&mut self, id: u16, resources: &[Resource]) -> Result<()> {
+        if let Some(_) = self.remove(id) {
+            // Unregister resources
+            self.unregister_resources(resources);
+            Ok(())
+        } else {
+            Err(Error::DeviceNotExist)
+        }
+    }
+}

src/lib.rs

@@ -9,6 +9,7 @@ extern crate vm_memory;
 
 use vm_memory::GuestAddress;
 
+pub mod device_manager;
 pub mod interrupt;
 pub mod resources;
 

src/resources.rs

@@ -133,6 +133,8 @@ pub enum Resource {
     MacAddresss(String),
     /// KVM memslot index.
     KvmMemSlot(u32),
+    /// Instance ID.
+    InstanceId(u16),
 }
 
 /// Newtype to store a set of device resources.