pci: Replace BAR tuple with PciBarConfiguration

In order to make the code more consistent and easier to read, we remove
the former tuple that was used to describe a BAR, replacing it with the
existing structure PciBarConfiguration.

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

pci/src/bus.rs

@@ -6,13 +6,13 @@ use crate::configuration::{
     PciBarRegionType, PciBridgeSubclass, PciClassCode, PciConfiguration, PciHeaderType,
 };
 use crate::device::{DeviceRelocation, Error as PciDeviceError, PciDevice};
+use crate::PciBarConfiguration;
 use byteorder::{ByteOrder, LittleEndian};
 use std::any::Any;
 use std::collections::HashMap;
 use std::ops::DerefMut;
 use std::sync::{Arc, Barrier, Mutex};
 use vm_device::{Bus, BusDevice};
-use vm_memory::{Address, GuestAddress, GuestUsize};
 
 const VENDOR_ID_INTEL: u16 = 0x8086;
 const DEVICE_ID_INTEL_VIRT_PCIE_HOST: u16 = 0x0d57;
@@ -122,21 +122,21 @@ impl PciBus {
         dev: Arc<Mutex<dyn BusDevice>>,
         #[cfg(target_arch = "x86_64")] io_bus: &Bus,
         mmio_bus: &Bus,
-        bars: Vec<(GuestAddress, GuestUsize, PciBarRegionType)>,
+        bars: Vec<PciBarConfiguration>,
     ) -> Result<()> {
-        for (address, size, type_) in bars {
-            match type_ {
+        for bar in bars {
+            match bar.region_type() {
                 PciBarRegionType::IoRegion => {
                     #[cfg(target_arch = "x86_64")]
                     io_bus
-                        .insert(dev.clone(), address.raw_value(), size)
+                        .insert(dev.clone(), bar.addr(), bar.size())
                         .map_err(PciRootError::PioInsert)?;
                     #[cfg(target_arch = "aarch64")]
                     error!("I/O region is not supported");
                 }
                 PciBarRegionType::Memory32BitRegion | PciBarRegionType::Memory64BitRegion => {
                     mmio_bus
-                        .insert(dev.clone(), address.raw_value(), size)
+                        .insert(dev.clone(), bar.addr(), bar.size())
                         .map_err(PciRootError::MmioInsert)?;
                 }
             }

pci/src/configuration.rs

@@ -961,15 +961,27 @@ impl PciBarConfiguration {
         self
     }
 
-    pub fn get_size(&self) -> u64 {
-        self.size
-    }
-
     #[must_use]
     pub fn set_region_type(mut self, region_type: PciBarRegionType) -> Self {
         self.region_type = region_type;
         self
     }
+
+    pub fn idx(&self) -> usize {
+        self.idx
+    }
+
+    pub fn addr(&self) -> u64 {
+        self.addr
+    }
+
+    pub fn size(&self) -> u64 {
+        self.size
+    }
+
+    pub fn region_type(&self) -> PciBarRegionType {
+        self.region_type
+    }
 }
 
 #[cfg(test)]

pci/src/device.rs

@@ -3,13 +3,13 @@
 // found in the LICENSE-BSD-3-Clause file.
 
 use crate::configuration::{self, PciBarRegionType};
+use crate::PciBarConfiguration;
 use std::any::Any;
 use std::fmt::{self, Display};
 use std::sync::{Arc, Barrier, Mutex};
 use std::{self, io, result};
 use vm_allocator::{AddressAllocator, SystemAllocator};
 use vm_device::{BusDevice, Resource};
-use vm_memory::{GuestAddress, GuestUsize};
 
 #[derive(Debug)]
 pub enum Error {
@@ -60,7 +60,7 @@ pub trait PciDevice: BusDevice {
         _allocator: &Arc<Mutex<SystemAllocator>>,
         _mmio_allocator: &mut AddressAllocator,
         _resources: Option<Vec<Resource>>,
-    ) -> Result<Vec<(GuestAddress, GuestUsize, PciBarRegionType)>> {
+    ) -> Result<Vec<PciBarConfiguration>> {
         Ok(Vec::new())
     }
 

pci/src/vfio.rs

@@ -364,8 +364,8 @@ impl VfioCommon {
         mmio_allocator: &mut AddressAllocator,
         vfio_wrapper: &dyn Vfio,
         resources: Option<Vec<Resource>>,
-    ) -> Result<Vec<(GuestAddress, GuestUsize, PciBarRegionType)>, PciDeviceError> {
-        let mut ranges = Vec::new();
+    ) -> Result<Vec<PciBarConfiguration>, PciDeviceError> {
+        let mut bars = Vec::new();
         let mut bar_id = VFIO_PCI_BAR0_REGION_INDEX as u32;
 
         // Going through all regular regions to compute the BAR size.
@@ -378,7 +378,7 @@ impl VfioCommon {
 
             let restored_bar_addr = if let Some(resources) = &resources {
                 match resources
-                    .get(ranges.len())
+                    .get(bars.len())
                     .ok_or(PciDeviceError::MissingResource)?
                 {
                     Resource::MmioAddressRange { base, .. } => Some(GuestAddress(*base)),
@@ -499,7 +499,7 @@ impl VfioCommon {
             }
 
             // We can now build our BAR configuration block.
-            let config = PciBarConfiguration::default()
+            let bar = PciBarConfiguration::default()
                 .set_index(bar_id as usize)
                 .set_address(bar_addr.raw_value())
                 .set_size(region_size)
@@ -507,15 +507,15 @@ impl VfioCommon {
 
             if bar_id == VFIO_PCI_ROM_REGION_INDEX {
                 self.configuration
-                    .add_pci_rom_bar(&config, flags & 0x1)
+                    .add_pci_rom_bar(&bar, flags & 0x1)
                     .map_err(|e| PciDeviceError::IoRegistrationFailed(bar_addr.raw_value(), e))?;
             } else {
                 self.configuration
-                    .add_pci_bar(&config)
+                    .add_pci_bar(&bar)
                     .map_err(|e| PciDeviceError::IoRegistrationFailed(bar_addr.raw_value(), e))?;
             }
 
-            ranges.push((bar_addr, region_size, region_type));
+            bars.push(bar);
             self.mmio_regions.push(MmioRegion {
                 start: bar_addr,
                 length: region_size,
@@ -533,7 +533,7 @@ impl VfioCommon {
             }
         }
 
-        Ok(ranges)
+        Ok(bars)
     }
 
     pub(crate) fn free_bars(
@@ -1339,7 +1339,7 @@ impl PciDevice for VfioPciDevice {
         allocator: &Arc<Mutex<SystemAllocator>>,
         mmio_allocator: &mut AddressAllocator,
         resources: Option<Vec<Resource>>,
-    ) -> Result<Vec<(GuestAddress, GuestUsize, PciBarRegionType)>, PciDeviceError> {
+    ) -> Result<Vec<PciBarConfiguration>, PciDeviceError> {
         self.common
             .allocate_bars(allocator, mmio_allocator, &self.vfio_wrapper, resources)
     }

pci/src/vfio_user.rs

@@ -4,7 +4,7 @@
 //
 
 use crate::vfio::{Interrupt, Vfio, VfioCommon, VfioError};
-use crate::{BarReprogrammingParams, PciBarRegionType, VfioPciError};
+use crate::{BarReprogrammingParams, PciBarConfiguration, VfioPciError};
 use crate::{
     PciBdf, PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType, PciSubclass,
 };
@@ -25,7 +25,6 @@ use vm_device::{BusDevice, Resource};
 use vm_memory::bitmap::AtomicBitmap;
 use vm_memory::{
     Address, GuestAddress, GuestAddressSpace, GuestMemory, GuestMemoryRegion, GuestRegionMmap,
-    GuestUsize,
 };
 use vmm_sys_util::eventfd::EventFd;
 
@@ -396,7 +395,7 @@ impl PciDevice for VfioUserPciDevice {
         allocator: &Arc<Mutex<SystemAllocator>>,
         mmio_allocator: &mut AddressAllocator,
         resources: Option<Vec<Resource>>,
-    ) -> Result<Vec<(GuestAddress, GuestUsize, PciBarRegionType)>, PciDeviceError> {
+    ) -> Result<Vec<PciBarConfiguration>, PciDeviceError> {
         self.common
             .allocate_bars(allocator, mmio_allocator, &self.vfio_wrapper, resources)
     }