refactor: remove unused bar relocation related items

Since we don't support BAR relocation we don't need all
of this machinery right now. It was lifted with original
PCIe code from Cloud-Hypervisor but never got used.
Now with recent commits it became even more useless.

Signed-off-by: Egor Lazarchuk <yegorlz@amazon.co.uk>

Author: ShadowCurse

src/vmm/src/devices/pci/pci_segment.rs

@@ -71,7 +71,7 @@ impl std::fmt::Debug for PciSegment {
 impl PciSegment {
     fn build(id: u16, vm: &Arc<Vm>, pci_irq_slots: &[u8; 32]) -> Result<PciSegment, BusError> {
         let pci_root = PciRoot::new(None);
-        let pci_bus = Arc::new(Mutex::new(PciBus::new(pci_root, vm.clone())));
+        let pci_bus = Arc::new(Mutex::new(PciBus::new(pci_root)));
 
         let pci_config_mmio = Arc::new(Mutex::new(PciConfigMmio::new(Arc::clone(&pci_bus))));
         let mmio_config_address = PCI_MMCONFIG_START + PCI_MMIO_CONFIG_SIZE_PER_SEGMENT * id as u64;

src/vmm/src/devices/virtio/transport/pci/device.rs

@@ -39,8 +39,8 @@ use crate::pci::configuration::{
 };
 use crate::pci::msix::{MsixCap, MsixConfig, MsixConfigState};
 use crate::pci::{
-    BarReprogrammingParams, DeviceRelocationError, PciCapabilityId, PciClassCode, PciDevice,
-    PciMassStorageSubclass, PciNetworkControllerSubclass, PciSBDF,
+    BarReprogrammingParams, PciCapabilityId, PciClassCode, PciDevice, PciMassStorageSubclass,
+    PciNetworkControllerSubclass, PciSBDF,
 };
 use crate::snapshot::Persist;
 use crate::vstate::bus::BusDevice;
@@ -249,8 +249,6 @@ pub struct VirtioPciDeviceState {
 
 #[derive(Debug, thiserror::Error, displaydoc::Display)]
 pub enum VirtioPciDeviceError {
-    /// Failed creating VirtioPciDevice: {0}
-    CreateVirtioPciDevice(#[from] DeviceRelocationError),
     /// Error creating MSI configuration: {0}
     Msi(#[from] InterruptError),
     /// Invalid PCI configuration state: {0}
@@ -804,18 +802,6 @@ impl PciDevice for VirtioPciDevice {
         }
     }
 
-    fn detect_bar_reprogramming(
-        &mut self,
-        reg_idx: u16,
-        data: &[u8],
-    ) -> Option<BarReprogrammingParams> {
-        None
-    }
-
-    fn move_bar(&mut self, old_base: u64, new_base: u64) -> Result<(), DeviceRelocationError> {
-        Ok(())
-    }
-
     fn read_bar(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
         match offset {
             o if o < u64::from(COMMON_CONFIG_BAR_OFFSET + COMMON_CONFIG_SIZE) => {

src/vmm/src/pci/bus.rs

@@ -7,14 +7,12 @@
 
 use std::collections::HashMap;
 use std::fmt::Debug;
-use std::ops::DerefMut;
 use std::sync::{Arc, Barrier, Mutex};
 
 use byteorder::{ByteOrder, LittleEndian};
 
-use crate::logger::error;
 use crate::pci::configuration::PciConfiguration;
-use crate::pci::{DeviceRelocation, PciBridgeSubclass, PciClassCode, PciDevice};
+use crate::pci::{PciBridgeSubclass, PciClassCode, PciDevice};
 use crate::utils::u64_to_usize;
 use crate::vstate::bus::BusDevice;
 
@@ -80,7 +78,6 @@ pub struct PciBus {
     /// Devices attached to this bus.
     /// Device 0 is host bridge.
     pub devices: HashMap<u8, Arc<Mutex<dyn PciDevice>>>,
-    vm: Arc<dyn DeviceRelocation>,
     device_ids: Vec<bool>,
 }
 
@@ -94,7 +91,7 @@ impl Debug for PciBus {
 
 impl PciBus {
     /// Create a new PCI bus
-    pub fn new(pci_root: PciRoot, vm: Arc<dyn DeviceRelocation>) -> Self {
+    pub fn new(pci_root: PciRoot) -> Self {
         let mut devices: HashMap<u8, Arc<Mutex<dyn PciDevice>>> = HashMap::new();
         let mut device_ids: Vec<bool> = vec![false; NUM_DEVICE_IDS];
 
@@ -103,7 +100,6 @@ impl PciBus {
 
         PciBus {
             devices,
-            vm,
             device_ids,
         }
     }
@@ -220,22 +216,6 @@ impl PciConfigIo {
         if let Some(d) = pci_bus.devices.get(&device) {
             let mut device = d.lock().unwrap();
 
-            // Find out if one of the device's BAR is being reprogrammed, and
-            // reprogram it if needed.
-            if let Some(params) = device.detect_bar_reprogramming(register, data)
-                && let Err(e) = pci_bus.vm.move_bar(
-                    params.old_base,
-                    params.new_base,
-                    params.len,
-                    device.deref_mut(),
-                )
-            {
-                error!(
-                    "Failed moving device BAR: {}: 0x{:x}->0x{:x}(0x{:x})",
-                    e, params.old_base, params.new_base, params.len
-                );
-            }
-
             // offset is validated to be < 4 at the top of this function.
             #[allow(clippy::cast_possible_truncation)]
             let offset = offset as u8;
@@ -360,22 +340,6 @@ impl PciConfigMmio {
         if let Some(d) = pci_bus.devices.get(&device) {
             let mut device = d.lock().unwrap();
 
-            // Find out if one of the device's BAR is being reprogrammed, and
-            // reprogram it if needed.
-            if let Some(params) = device.detect_bar_reprogramming(register, data)
-                && let Err(e) = pci_bus.vm.move_bar(
-                    params.old_base,
-                    params.new_base,
-                    params.len,
-                    device.deref_mut(),
-                )
-            {
-                error!(
-                    "Failed moving device BAR: {}: 0x{:x}->0x{:x}(0x{:x})",
-                    e, params.old_base, params.new_base, params.len
-                );
-            }
-
             // offset is validated to be < 4 at the top of this function.
             #[allow(clippy::cast_possible_truncation)]
             let offset = offset as u8;
@@ -474,37 +438,14 @@ fn parse_io_config_address(config_address: u32) -> (u8, u8, u8, u16) {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::atomic::AtomicUsize;
     use std::sync::{Arc, Mutex};
 
     use super::{PciBus, PciConfigIo, PciConfigMmio, PciRoot};
     use crate::pci::bus::{DEVICE_ID_INTEL_VIRT_PCIE_HOST, VENDOR_ID_INTEL};
     use crate::pci::configuration::PciConfiguration;
-    use crate::pci::{
-        BarReprogrammingParams, DeviceRelocation, DeviceRelocationError, PciClassCode, PciDevice,
-        PciMassStorageSubclass,
-    };
+    use crate::pci::{PciClassCode, PciDevice, PciMassStorageSubclass};
     use crate::vstate::bus::BusDevice;
 
-    #[derive(Debug, Default)]
-    struct RelocationMock {
-        reloc_cnt: AtomicUsize,
-    }
-
-    impl DeviceRelocation for RelocationMock {
-        fn move_bar(
-            &self,
-            _old_base: u64,
-            _new_base: u64,
-            _len: u64,
-            _pci_dev: &mut dyn PciDevice,
-        ) -> Result<(), DeviceRelocationError> {
-            self.reloc_cnt
-                .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-            Ok(())
-        }
-    }
-
     struct PciDevMock(PciConfiguration);
 
     impl PciDevMock {
@@ -536,21 +477,12 @@ mod tests {
         fn read_config_register(&mut self, reg_idx: u16) -> u32 {
             self.0.read_reg(reg_idx)
         }
-
-        fn detect_bar_reprogramming(
-            &mut self,
-            _reg_idx: u16,
-            _data: &[u8],
-        ) -> Option<BarReprogrammingParams> {
-            None
-        }
     }
 
     #[test]
     fn test_writing_io_config_address() {
-        let mock = Arc::new(RelocationMock::default());
         let root = PciRoot::new(None);
-        let mut bus = PciConfigIo::new(Arc::new(Mutex::new(PciBus::new(root, mock))));
+        let mut bus = PciConfigIo::new(Arc::new(Mutex::new(PciBus::new(root))));
 
         assert_eq!(bus.config_address, 0);
         // Writing more than 32 bits will should fail
@@ -590,9 +522,8 @@ mod tests {
 
     #[test]
     fn test_reading_io_config_address() {
-        let mock = Arc::new(RelocationMock::default());
         let root = PciRoot::new(None);
-        let mut bus = PciConfigIo::new(Arc::new(Mutex::new(PciBus::new(root, mock))));
+        let mut bus = PciConfigIo::new(Arc::new(Mutex::new(PciBus::new(root))));
 
         let mut buffer = [0u8; 4];
 
@@ -637,19 +568,18 @@ mod tests {
         assert_eq!(buffer, [0x45, 0x44, 0x43, 0x42]);
     }
 
-    fn initialize_bus() -> (PciConfigMmio, PciConfigIo, Arc<RelocationMock>) {
-        let mock = Arc::new(RelocationMock::default());
+    fn initialize_bus() -> (PciConfigMmio, PciConfigIo) {
         let root = PciRoot::new(None);
-        let mut bus = PciBus::new(root, mock.clone());
+        let mut bus = PciBus::new(root);
         bus.add_device(1, Arc::new(Mutex::new(PciDevMock::new())));
 
         let bus = Arc::new(Mutex::new(bus));
-        (PciConfigMmio::new(bus.clone()), PciConfigIo::new(bus), mock)
+        (PciConfigMmio::new(bus.clone()), PciConfigIo::new(bus))
     }
 
     #[test]
     fn test_invalid_register_boundary_reads() {
-        let (mut mmio_config, mut io_config, _) = initialize_bus();
+        let (mut mmio_config, mut io_config) = initialize_bus();
 
         // Read crossing register boundaries
         let mut buffer = [0u8; 4];
@@ -784,7 +714,7 @@ mod tests {
 
     #[test]
     fn test_mmio_invalid_bus_number() {
-        let (mut mmio_config, _, _) = initialize_bus();
+        let (mut mmio_config, _) = initialize_bus();
         let mut buffer = [0u8; 4];
 
         // Asking for Bus 1 should return all 1s
@@ -809,7 +739,7 @@ mod tests {
 
     #[test]
     fn test_io_invalid_bus_number() {
-        let (_, mut pio_config, _) = initialize_bus();
+        let (_, mut pio_config) = initialize_bus();
         let mut buffer = [0u8; 4];
 
         // Asking for Bus 1 should return all 1s
@@ -827,7 +757,7 @@ mod tests {
 
     #[test]
     fn test_mmio_invalid_function() {
-        let (mut mmio_config, _, _) = initialize_bus();
+        let (mut mmio_config, _) = initialize_bus();
         let mut buffer = [0u8; 4];
 
         // Asking for Bus 1 should return all 1s
@@ -852,7 +782,7 @@ mod tests {
 
     #[test]
     fn test_io_invalid_function() {
-        let (_, mut pio_config, _) = initialize_bus();
+        let (_, mut pio_config) = initialize_bus();
         let mut buffer = [0u8; 4];
 
         // Asking for Bus 1 should return all 1s
@@ -870,7 +800,7 @@ mod tests {
 
     #[test]
     fn test_io_disabled_reads() {
-        let (_, mut pio_config, _) = initialize_bus();
+        let (_, mut pio_config) = initialize_bus();
         let mut buffer = [0u8; 4];
 
         // Trying to read without enabling should return all 1s
@@ -888,7 +818,7 @@ mod tests {
 
     #[test]
     fn test_io_disabled_writes() {
-        let (_, mut pio_config, _) = initialize_bus();
+        let (_, mut pio_config) = initialize_bus();
 
         // Try to write the IRQ line used for the root port.
         let mut buffer = [0u8; 4];
@@ -916,7 +846,7 @@ mod tests {
 
     #[test]
     fn test_mmio_writes() {
-        let (mut mmio_config, _, _) = initialize_bus();
+        let (mut mmio_config, _) = initialize_bus();
         let mut buffer = [0u8; 4];
 
         read_mmio_config(&mut mmio_config, 0, 0, 0, 15, 0, &mut buffer);

src/vmm/src/pci/mod.rs

@@ -42,14 +42,6 @@ pub trait PciDevice: Send {
     /// Gets a register from the configuration space.
     /// * `reg_idx` - The index of the config register to read.
     fn read_config_register(&mut self, reg_idx: u16) -> u32;
-    /// Detects if a BAR is being reprogrammed.
-    fn detect_bar_reprogramming(
-        &mut self,
-        _reg_idx: u16,
-        _data: &[u8],
-    ) -> Option<BarReprogrammingParams> {
-        None
-    }
     /// Reads from a BAR region mapped into the device.
     /// * `addr` - The guest address inside the BAR.
     /// * `data` - Filled with the data from `addr`.
@@ -60,31 +52,6 @@ pub trait PciDevice: Send {
     fn write_bar(&mut self, _base: u64, _offset: u64, _data: &[u8]) -> Option<Arc<Barrier>> {
         None
     }
-    /// Relocates the BAR to a different address in guest address space.
-    fn move_bar(&mut self, _old_base: u64, _new_base: u64) -> Result<(), DeviceRelocationError> {
-        Ok(())
-    }
-}
-
-/// Errors for device manager.
-#[derive(Debug, thiserror::Error, displaydoc::Display)]
-pub enum DeviceRelocationError {
-    /// Device relocation not supported.
-    NotSupported,
-}
-
-/// This trait defines a set of functions which can be triggered whenever a
-/// PCI device is modified in any way.
-pub trait DeviceRelocation: Send + Sync {
-    /// The BAR needs to be moved to a different location in the guest address
-    /// space. This follows a decision from the software running in the guest.
-    fn move_bar(
-        &self,
-        old_base: u64,
-        new_base: u64,
-        len: u64,
-        pci_dev: &mut dyn PciDevice,
-    ) -> Result<(), DeviceRelocationError>;
 }
 
 /// Segment with associated Device BDF

src/vmm/src/vstate/vm.rs

@@ -26,7 +26,6 @@ use vmm_sys_util::eventfd::EventFd;
 pub use crate::arch::{ArchVm as Vm, ArchVmError, VmState};
 use crate::arch::{GSI_MSI_END, host_page_size};
 use crate::logger::{debug, info};
-use crate::pci::{DeviceRelocation, DeviceRelocationError, PciDevice};
 use crate::persist::CreateSnapshotError;
 use crate::vmm_config::snapshot::SnapshotType;
 use crate::vstate::bus::Bus;
@@ -522,18 +521,6 @@ fn mincore_bitmap(addr: *mut u8, len: usize) -> Result<Vec<u64>, VmError> {
     Ok(bitmap)
 }
 
-impl DeviceRelocation for Vm {
-    fn move_bar(
-        &self,
-        _old_base: u64,
-        _new_base: u64,
-        _len: u64,
-        _pci_dev: &mut dyn PciDevice,
-    ) -> Result<(), DeviceRelocationError> {
-        Err(DeviceRelocationError::NotSupported)
-    }
-}
-
 #[cfg(test)]
 pub(crate) mod tests {
     use std::sync::atomic::Ordering;