add logging

Author: CompuIves

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

@@ -8,7 +8,7 @@ use std::sync::atomic::AtomicUsize;
 use std::sync::Arc;
 use std::time::Duration;
 
-use logger::{error, IncMetric, METRICS};
+use logger::{debug, error, IncMetric, METRICS};
 use serde::Serialize;
 use timerfd::{ClockId, SetTimeFlags, TimerFd, TimerState};
 use utils::eventfd::EventFd;
@@ -158,6 +158,7 @@ impl Balloon {
         stats_polling_interval_s: u16,
         restored: bool,
     ) -> Result<Balloon, BalloonError> {
+        debug!("creating new balloon");
         let mut avail_features = 1u64 << VIRTIO_F_VERSION_1;
 
         if deflate_on_oom {
@@ -207,32 +208,45 @@ impl Balloon {
     }
 
     pub(crate) fn process_inflate_queue_event(&mut self) -> Result<(), BalloonError> {
+        debug!("balloon: inflate queue event");
         self.queue_evts[INFLATE_INDEX]
             .read()
             .map_err(BalloonError::EventFd)?;
-        self.process_inflate()
+        self.process_inflate()?;
+        debug!("balloon: inflate queue event done");
+        Ok(())
     }
 
     pub(crate) fn process_deflate_queue_event(&mut self) -> Result<(), BalloonError> {
+        debug!("balloon: deflate queue event");
         self.queue_evts[DEFLATE_INDEX]
             .read()
             .map_err(BalloonError::EventFd)?;
-        self.process_deflate_queue()
+        self.process_deflate_queue()?;
+        debug!("balloon: deflate queue event done");
+        Ok(())
     }
 
     pub(crate) fn process_stats_queue_event(&mut self) -> Result<(), BalloonError> {
+        debug!("balloon: process stats queue event");
         self.queue_evts[STATS_INDEX]
             .read()
             .map_err(BalloonError::EventFd)?;
-        self.process_stats_queue()
+        self.process_stats_queue()?;
+        debug!("balloon: process stats queue event finished");
+        Ok(())
     }
 
     pub(crate) fn process_stats_timer_event(&mut self) -> Result<(), BalloonError> {
+        debug!("balloon: process stats timer event");
         self.stats_timer.read();
-        self.trigger_stats_update()
+        self.trigger_stats_update()?;
+        debug!("balloon: process stats timer event done");
+        Ok(())
     }
 
     pub(crate) fn process_inflate(&mut self) -> Result<(), BalloonError> {
+        debug!("balloon: process inflate queue");
         // This is safe since we checked in the event handler that the device is activated.
         let mem = self.device_state.mem().unwrap();
         METRICS.balloon.inflate_count.inc();
@@ -316,14 +330,19 @@ impl Balloon {
             }
         }
 
+        debug!("balloon: process inflate queue finished, interrupting...");
+
         if needs_interrupt {
             self.signal_used_queue()?;
         }
 
+        debug!("balloon: process inflate queue finally finished");
+
         Ok(())
     }
 
     pub(crate) fn process_deflate_queue(&mut self) -> Result<(), BalloonError> {
+        debug!("balloon: process deflate queue");
         // This is safe since we checked in the event handler that the device is activated.
         let mem = self.device_state.mem().unwrap();
         METRICS.balloon.deflate_count.inc();
@@ -339,13 +358,17 @@ impl Balloon {
         }
 
         if needs_interrupt {
-            self.signal_used_queue()
+            debug!("balloon: process deflate queue finished, interrupting...");
+            self.signal_used_queue()?;
+            debug!("balloon: process deflate queue finished");
+            Ok(())
         } else {
             Ok(())
         }
     }
 
     pub(crate) fn process_stats_queue(&mut self) -> std::result::Result<(), BalloonError> {
+        debug!("balloon: process stats queue");
         // This is safe since we checked in the event handler that the device is activated.
         let mem = self.device_state.mem().unwrap();
         METRICS.balloon.stats_updates_count.inc();
@@ -380,6 +403,8 @@ impl Balloon {
             self.stats_desc_index = Some(head.index);
         }
 
+        debug!("balloon: process stats queue finished");
+
         Ok(())
     }
 

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

@@ -36,7 +36,7 @@ impl Balloon {
     }
 
     fn process_activate_event(&self, ops: &mut EventOps) {
-        debug!("balloon: activate event");
+        debug!("balloon: activate eventeeeee");
         if let Err(err) = self.activate_evt.read() {
             error!("Failed to consume balloon activate event: {:?}", err);
         }

src/vmm/src/persist.rs

@@ -36,7 +36,7 @@ use crate::device_manager::persist::{DeviceStates, Error as DevicePersistError};
 use crate::devices::virtio::TYPE_NET;
 use crate::memory_snapshot::{mem_dump_dirty, GuestMemoryState, SnapshotMemory};
 use crate::resources::VmResources;
-use crate::rpc_interface::LoadSnapshotError;
+
 #[cfg(target_arch = "x86_64")]
 use crate::version_map::FC_V0_23_SNAP_VERSION;
 use crate::version_map::{FC_V1_0_SNAP_VERSION, FC_V1_1_SNAP_VERSION, FC_VERSION_TO_SNAP_VERSION};