vmm: Use new Resource type PciBar

Instead of defining some very generic resources as PioAddressRange or
MmioAddressRange for each PCI BAR, let's move to the new Resource type
PciBar in order to make things clearer. This allows the code for being
more readable, but also removes the need for hard assumptions about the
MMIO and PIO ranges. PioAddressRange and MmioAddressRange types can be
used to describe everything except PCI BARs. BARs are very special as
they can be relocated and have special information we want to carry
along with them.

Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>

pci/src/configuration.rs

@@ -9,6 +9,7 @@ use std::fmt::{self, Display};
 use std::sync::{Arc, Mutex};
 use versionize::{VersionMap, Versionize, VersionizeError, VersionizeResult};
 use versionize_derive::Versionize;
+use vm_device::PciBarType;
 use vm_migration::{MigratableError, Pausable, Snapshot, Snapshottable, VersionMapped};
 
 // The number of 32bit registers in the config space, 4096 bytes.
@@ -327,12 +328,43 @@ pub enum PciBarRegionType {
     Memory64BitRegion = 0x04,
 }
 
+impl From<PciBarType> for PciBarRegionType {
+    fn from(type_: PciBarType) -> Self {
+        match type_ {
+            PciBarType::Io => PciBarRegionType::IoRegion,
+            PciBarType::Mmio32 => PciBarRegionType::Memory32BitRegion,
+            PciBarType::Mmio64 => PciBarRegionType::Memory64BitRegion,
+        }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl Into<PciBarType> for PciBarRegionType {
+    fn into(self) -> PciBarType {
+        match self {
+            PciBarRegionType::IoRegion => PciBarType::Io,
+            PciBarRegionType::Memory32BitRegion => PciBarType::Mmio32,
+            PciBarRegionType::Memory64BitRegion => PciBarType::Mmio64,
+        }
+    }
+}
+
 #[derive(Copy, Clone)]
 pub enum PciBarPrefetchable {
     NotPrefetchable = 0,
     Prefetchable = 0x08,
 }
 
+#[allow(clippy::from_over_into)]
+impl Into<bool> for PciBarPrefetchable {
+    fn into(self) -> bool {
+        match self {
+            PciBarPrefetchable::NotPrefetchable => false,
+            PciBarPrefetchable::Prefetchable => true,
+        }
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct PciBarConfiguration {
     addr: u64,
@@ -982,6 +1014,10 @@ impl PciBarConfiguration {
     pub fn region_type(&self) -> PciBarRegionType {
         self.region_type
     }
+
+    pub fn prefetchable(&self) -> PciBarPrefetchable {
+        self.prefetchable
+    }
 }
 
 #[cfg(test)]

pci/src/device.rs

@@ -19,10 +19,8 @@ pub enum Error {
     IoAllocationFailed(u64),
     /// Registering an IO BAR failed.
     IoRegistrationFailed(u64, configuration::Error),
-    /// Not enough resources
+    /// Expected resource not found.
     MissingResource,
-    /// Invalid type of resource
-    InvalidResourceType,
 }
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -38,8 +36,7 @@ impl Display for Error {
             IoRegistrationFailed(addr, e) => {
                 write!(f, "failed to register an IO BAR, addr={} err={}", addr, e)
             }
-            MissingResource => write!(f, "Missing resource"),
-            InvalidResourceType => write!(f, "Invalid type of resource"),
+            MissingResource => write!(f, "failed to find expected resource"),
         }
     }
 }

pci/src/vfio.rs

@@ -376,18 +376,17 @@ impl VfioCommon {
             let region_size: u64;
             let bar_addr: GuestAddress;
 
-            let restored_bar_addr = if let Some(resources) = &resources {
-                match resources
-                    .get(bars.len())
-                    .ok_or(PciDeviceError::MissingResource)?
-                {
-                    Resource::MmioAddressRange { base, .. } => Some(GuestAddress(*base)),
-                    Resource::PioAddressRange { base, .. } => Some(GuestAddress(*base as u64)),
-                    _ => return Err(PciDeviceError::InvalidResourceType),
+            let mut restored_bar_addr = None;
+            if let Some(resources) = &resources {
+                for resource in resources {
+                    if let Resource::PciBar { index, base, .. } = resource {
+                        if *index == bar_id as usize {
+                            restored_bar_addr = Some(GuestAddress(*base));
+                            break;
+                        }
+                    }
                 }
-            } else {
-                None
-            };
+            }
 
             let bar_offset = if bar_id == VFIO_PCI_ROM_REGION_INDEX {
                 (PCI_ROM_EXP_BAR_INDEX * 4) as u32