refactor(balloon): remove unused restored_from_file

This flag was used for determining how to discard memory, but we
previously changed that logic to look at the region mmap and perform the
right action depending on that.
This commit removes all references to this flag.

Signed-off-by: Riccardo Mancini <mancio@amazon.com>

Author: Manciukic

src/vmm/src/builder.rs

@@ -462,7 +462,6 @@ pub fn build_microvm_from_snapshot(
         event_manager,
         vm_resources,
         instance_id: &instance_info.id,
-        restored_from_file: uffd.is_none(),
         vcpus_exit_evt: &vcpus_exit_evt,
     };
     #[allow(unused_mut)]

src/vmm/src/device_manager/mod.rs

@@ -439,7 +439,6 @@ pub struct DeviceRestoreArgs<'a> {
     pub vcpus_exit_evt: &'a EventFd,
     pub vm_resources: &'a mut VmResources,
     pub instance_id: &'a str,
-    pub restored_from_file: bool,
 }
 
 impl std::fmt::Debug for DeviceRestoreArgs<'_> {
@@ -449,7 +448,6 @@ impl std::fmt::Debug for DeviceRestoreArgs<'_> {
             .field("vm", &self.vm)
             .field("vm_resources", &self.vm_resources)
             .field("instance_id", &self.instance_id)
-            .field("restored_from_file", &self.restored_from_file)
             .finish()
     }
 }
@@ -487,7 +485,6 @@ impl<'a> Persist<'a> for DeviceManager {
             event_manager: constructor_args.event_manager,
             vm_resources: constructor_args.vm_resources,
             instance_id: constructor_args.instance_id,
-            restored_from_file: constructor_args.restored_from_file,
         };
         let mmio_devices = MMIODeviceManager::restore(mmio_ctor_args, &state.mmio_state)?;
 
@@ -505,7 +502,6 @@ impl<'a> Persist<'a> for DeviceManager {
             mem: constructor_args.mem,
             vm_resources: constructor_args.vm_resources,
             instance_id: constructor_args.instance_id,
-            restored_from_file: constructor_args.restored_from_file,
             event_manager: constructor_args.event_manager,
         };
         let pci_devices = PciDevices::restore(pci_ctor_args, &state.pci_state)?;

src/vmm/src/device_manager/pci_mngr.rs

@@ -247,7 +247,6 @@ pub struct PciDevicesConstructorArgs<'a> {
     pub mem: &'a GuestMemoryMmap,
     pub vm_resources: &'a mut VmResources,
     pub instance_id: &'a str,
-    pub restored_from_file: bool,
     pub event_manager: &'a mut EventManager,
 }
 
@@ -258,7 +257,6 @@ impl<'a> Debug for PciDevicesConstructorArgs<'a> {
             .field("mem", &self.mem)
             .field("vm_resources", &self.vm_resources)
             .field("instance_id", &self.instance_id)
-            .field("restored_from_file", &self.restored_from_file)
             .finish()
     }
 }
@@ -410,10 +408,7 @@ impl<'a> Persist<'a> for PciDevices {
         if let Some(balloon_state) = &state.balloon_device {
             let device = Arc::new(Mutex::new(
                 Balloon::restore(
-                    BalloonConstructorArgs {
-                        mem: mem.clone(),
-                        restored_from_file: constructor_args.restored_from_file,
-                    },
+                    BalloonConstructorArgs { mem: mem.clone() },
                     &balloon_state.device_state,
                 )
                 .unwrap(),
@@ -668,7 +663,6 @@ mod tests {
             mem: vmm.vm.guest_memory(),
             vm_resources,
             instance_id: "microvm-id",
-            restored_from_file: true,
             event_manager: &mut event_manager,
         };
         let _restored_dev_manager =

src/vmm/src/device_manager/persist.rs

@@ -144,7 +144,6 @@ pub struct MMIODevManagerConstructorArgs<'a> {
     pub event_manager: &'a mut EventManager,
     pub vm_resources: &'a mut VmResources,
     pub instance_id: &'a str,
-    pub restored_from_file: bool,
 }
 impl fmt::Debug for MMIODevManagerConstructorArgs<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -412,10 +411,7 @@ impl<'a> Persist<'a> for MMIODeviceManager {
 
         if let Some(balloon_state) = &state.balloon_device {
             let device = Arc::new(Mutex::new(Balloon::restore(
-                BalloonConstructorArgs {
-                    mem: mem.clone(),
-                    restored_from_file: constructor_args.restored_from_file,
-                },
+                BalloonConstructorArgs { mem: mem.clone() },
                 &balloon_state.device_state,
             )?));
 
@@ -686,7 +682,6 @@ mod tests {
             event_manager: &mut event_manager,
             vm_resources,
             instance_id: "microvm-id",
-            restored_from_file: true,
         };
         let _restored_dev_manager =
             MMIODeviceManager::restore(restore_args, &device_manager_state.mmio_state).unwrap();

src/vmm/src/devices/virtio/balloon/device.rs

@@ -173,7 +173,6 @@ pub struct Balloon {
     pub(crate) device_state: DeviceState,
 
     // Implementation specific fields.
-    pub(crate) restored_from_file: bool,
     pub(crate) stats_polling_interval_s: u16,
     pub(crate) stats_timer: TimerFd,
     // The index of the previous stats descriptor is saved because
@@ -190,7 +189,6 @@ impl Balloon {
         amount_mib: u32,
         deflate_on_oom: bool,
         stats_polling_interval_s: u16,
-        restored_from_file: bool,
     ) -> Result<Balloon, BalloonError> {
         let mut avail_features = 1u64 << VIRTIO_F_VERSION_1;
 
@@ -230,7 +228,6 @@ impl Balloon {
             queues,
             device_state: DeviceState::Inactive,
             activate_evt: EventFd::new(libc::EFD_NONBLOCK).map_err(BalloonError::EventFd)?,
-            restored_from_file,
             stats_polling_interval_s,
             stats_timer,
             stats_desc_index: None,
@@ -740,7 +737,7 @@ pub(crate) mod tests {
         // Test all feature combinations.
         for deflate_on_oom in [true, false].iter() {
             for stats_interval in [0, 1].iter() {
-                let mut balloon = Balloon::new(0, *deflate_on_oom, *stats_interval, false).unwrap();
+                let mut balloon = Balloon::new(0, *deflate_on_oom, *stats_interval).unwrap();
                 assert_eq!(balloon.device_type(), VIRTIO_ID_BALLOON);
 
                 let features: u64 = (1u64 << VIRTIO_F_VERSION_1)
@@ -767,7 +764,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_virtio_read_config() {
-        let balloon = Balloon::new(0x10, true, 0, false).unwrap();
+        let balloon = Balloon::new(0x10, true, 0).unwrap();
 
         let cfg = BalloonConfig {
             amount_mib: 16,
@@ -801,7 +798,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_virtio_write_config() {
-        let mut balloon = Balloon::new(0, true, 0, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 0).unwrap();
 
         let expected_config_space: [u8; BALLOON_CONFIG_SPACE_SIZE] =
             [0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
@@ -827,7 +824,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_invalid_request() {
-        let mut balloon = Balloon::new(0, true, 0, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 0).unwrap();
         let mem = default_mem();
         let interrupt = default_interrupt();
         // Only initialize the inflate queue to demonstrate invalid request handling.
@@ -888,7 +885,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_inflate() {
-        let mut balloon = Balloon::new(0, true, 0, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 0).unwrap();
         let mem = default_mem();
         let interrupt = default_interrupt();
         let infq = VirtQueue::new(GuestAddress(0), &mem, 16);
@@ -960,7 +957,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_deflate() {
-        let mut balloon = Balloon::new(0, true, 0, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 0).unwrap();
         let mem = default_mem();
         let interrupt = default_interrupt();
         let defq = VirtQueue::new(GuestAddress(0), &mem, 16);
@@ -1010,7 +1007,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_stats() {
-        let mut balloon = Balloon::new(0, true, 1, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 1).unwrap();
         let mem = default_mem();
         let interrupt = default_interrupt();
         let statsq = VirtQueue::new(GuestAddress(0), &mem, 16);
@@ -1102,7 +1099,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_process_balloon_queues() {
-        let mut balloon = Balloon::new(0x10, true, 0, false).unwrap();
+        let mut balloon = Balloon::new(0x10, true, 0).unwrap();
         let mem = default_mem();
         let interrupt = default_interrupt();
         let infq = VirtQueue::new(GuestAddress(0), &mem, 16);
@@ -1117,7 +1114,7 @@ pub(crate) mod tests {
 
     #[test]
     fn test_update_stats_interval() {
-        let mut balloon = Balloon::new(0, true, 0, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 0).unwrap();
         let mem = default_mem();
         let q = VirtQueue::new(GuestAddress(0), &mem, 16);
         balloon.set_queue(INFLATE_INDEX, q.create_queue());
@@ -1130,7 +1127,7 @@ pub(crate) mod tests {
         );
         balloon.update_stats_polling_interval(0).unwrap();
 
-        let mut balloon = Balloon::new(0, true, 1, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 1).unwrap();
         let mem = default_mem();
         let q = VirtQueue::new(GuestAddress(0), &mem, 16);
         balloon.set_queue(INFLATE_INDEX, q.create_queue());
@@ -1148,14 +1145,14 @@ pub(crate) mod tests {
 
     #[test]
     fn test_cannot_update_inactive_device() {
-        let mut balloon = Balloon::new(0, true, 0, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 0).unwrap();
         // Assert that we can't update an inactive device.
         balloon.update_size(1).unwrap_err();
     }
 
     #[test]
     fn test_num_pages() {
-        let mut balloon = Balloon::new(0, true, 0, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 0).unwrap();
         // Switch the state to active.
         balloon.device_state = DeviceState::Activated(ActiveState {
             mem: single_region_mem(32 << 20),

src/vmm/src/devices/virtio/balloon/event_handler.rs

@@ -142,7 +142,7 @@ pub mod tests {
     #[test]
     fn test_event_handler() {
         let mut event_manager = EventManager::new().unwrap();
-        let mut balloon = Balloon::new(0, true, 10, false).unwrap();
+        let mut balloon = Balloon::new(0, true, 10).unwrap();
         let mem = default_mem();
         let interrupt = default_interrupt();
         let infq = VirtQueue::new(GuestAddress(0), &mem, 16);

src/vmm/src/devices/virtio/balloon/persist.rs

@@ -95,7 +95,6 @@ pub struct BalloonState {
 pub struct BalloonConstructorArgs {
     /// Pointer to guest memory.
     pub mem: GuestMemoryMmap,
-    pub restored_from_file: bool,
 }
 
 impl Persist<'_> for Balloon {
@@ -122,12 +121,7 @@ impl Persist<'_> for Balloon {
     ) -> Result<Self, Self::Error> {
         // We can safely create the balloon with arbitrary flags and
         // num_pages because we will overwrite them after.
-        let mut balloon = Balloon::new(
-            0,
-            false,
-            state.stats_polling_interval_s,
-            constructor_args.restored_from_file,
-        )?;
+        let mut balloon = Balloon::new(0, false, state.stats_polling_interval_s)?;
 
         let mut num_queues = BALLOON_NUM_QUEUES;
         // As per the virtio 1.1 specification, the statistics queue
@@ -184,26 +178,22 @@ mod tests {
         let mut mem = vec![0; 4096];
 
         // Create and save the balloon device.
-        let balloon = Balloon::new(0x42, false, 2, false).unwrap();
+        let balloon = Balloon::new(0x42, false, 2).unwrap();
 
         Snapshot::new(balloon.save())
             .save(&mut mem.as_mut_slice())
             .unwrap();
 
         // Deserialize and restore the balloon device.
         let restored_balloon = Balloon::restore(
-            BalloonConstructorArgs {
-                mem: guest_mem,
-                restored_from_file: true,
-            },
+            BalloonConstructorArgs { mem: guest_mem },
             &Snapshot::load_without_crc_check(mem.as_slice())
                 .unwrap()
                 .data,
         )
         .unwrap();
 
         assert_eq!(restored_balloon.device_type(), VIRTIO_ID_BALLOON);
-        assert!(restored_balloon.restored_from_file);
 
         assert_eq!(restored_balloon.acked_features, balloon.acked_features);
         assert_eq!(restored_balloon.avail_features, balloon.avail_features);

src/vmm/src/resources.rs

@@ -1520,7 +1520,7 @@ mod tests {
             .unwrap();
         let err = vm_resources
             .update_from_restored_device(SharedDeviceType::Balloon(Arc::new(Mutex::new(
-                Balloon::new(128, false, 0, true).unwrap(),
+                Balloon::new(128, false, 0).unwrap(),
             ))))
             .unwrap_err();
         assert!(

src/vmm/src/vmm_config/balloon.rs

@@ -88,9 +88,6 @@ impl BalloonBuilder {
             cfg.amount_mib,
             cfg.deflate_on_oom,
             cfg.stats_polling_interval_s,
-            // `restored` flag is false because this code path
-            // is never called by snapshot restore functionality.
-            false,
         )?)));
 
         Ok(())
@@ -178,7 +175,7 @@ pub(crate) mod tests {
     #[test]
     fn test_set_device() {
         let mut builder = BalloonBuilder::new();
-        let balloon = Balloon::new(0, true, 0, true).unwrap();
+        let balloon = Balloon::new(0, true, 0).unwrap();
         builder.set_device(Arc::new(Mutex::new(balloon)));
         assert!(builder.inner.is_some());
     }