vhost-user-frontend: Remove unnecessary definition/helpers

vireshk · vireshk · commit f55eef477c52 · 2022-10-18T13:02:53.000+05:30
Some of the helpers are not required for every user, and can be dropped.
Remove them and do minor cleanups.

Signed-off-by: Viresh Kumar &lt;viresh.kumar@linaro.org&gt;
diff --git a/crates/vhost-user-frontend/src/device.rs b/crates/vhost-user-frontend/src/device.rs
@@ -7,23 +7,17 @@
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
 use crate::{
-    ActivateError, ActivateResult, Error, GuestMemoryMmap, GuestRegionMmap,
-    VIRTIO_F_RING_INDIRECT_DESC,
+    AccessPlatform, ActivateError, ActivateResult, Error, GuestMemoryMmap, GuestRegionMmap,
+    VirtioDeviceType, VIRTIO_F_RING_INDIRECT_DESC,
 };
 use libc::EFD_NONBLOCK;
 use std::collections::HashMap;
 use std::io::Write;
 use std::num::Wrapping;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc, Barrier,
-};
+use std::sync::{atomic::AtomicBool, Arc, Barrier};
 use std::thread;
 use virtio_queue::Queue;
 use vm_memory::{GuestAddress, GuestMemoryAtomic, GuestUsize};
-use vm_migration::{MigratableError, Pausable};
-use vm_virtio::AccessPlatform;
-use vm_virtio::VirtioDeviceType;
 use vmm_sys_util::eventfd::EventFd;
 
 pub enum VirtioInterruptType {
@@ -281,11 +275,6 @@ impl VirtioCommon {
     }
 
     pub fn reset(&mut self) -> Option<Arc<dyn VirtioInterrupt>> {
-        // We first must resume the virtio thread if it was paused.
-        if self.pause_evt.take().is_some() {
-            self.resume().ok()?;
-        }
-
         if let Some(kill_evt) = self.kill_evt.take() {
             // Ignore the result because there is nothing we can do about it.
             let _ = kill_evt.write(1);
@@ -317,42 +306,3 @@ impl VirtioCommon {
         self.avail_features &= !(1 << VIRTIO_F_RING_INDIRECT_DESC);
     }
 }
-
-impl Pausable for VirtioCommon {
-    fn pause(&mut self) -> std::result::Result<(), MigratableError> {
-        info!(
-            "Pausing virtio-{}",
-            VirtioDeviceType::from(self.device_type)
-        );
-        self.paused.store(true, Ordering::SeqCst);
-        if let Some(pause_evt) = &self.pause_evt {
-            pause_evt
-                .write(1)
-                .map_err(|e| MigratableError::Pause(e.into()))?;
-
-            // Wait for all threads to acknowledge the pause before going
-            // any further. This is exclusively performed when pause_evt
-            // eventfd is Some(), as this means the virtio device has been
-            // activated. One specific case where the device can be paused
-            // while it hasn't been yet activated is snapshot/restore.
-            self.paused_sync.as_ref().unwrap().wait();
-        }
-
-        Ok(())
-    }
-
-    fn resume(&mut self) -> std::result::Result<(), MigratableError> {
-        info!(
-            "Resuming virtio-{}",
-            VirtioDeviceType::from(self.device_type)
-        );
-        self.paused.store(false, Ordering::SeqCst);
-        if let Some(epoll_threads) = &self.epoll_threads {
-            for t in epoll_threads.iter() {
-                t.thread().unpark();
-            }
-        }
-
-        Ok(())
-    }
-}
diff --git a/crates/vhost-user-frontend/src/lib.rs b/crates/vhost-user-frontend/src/lib.rs
@@ -24,17 +24,16 @@ pub use crate::vhost_user::*;
 use std::fmt::{self, Debug};
 
 use virtio_queue::{Queue, QueueT};
-use vm_memory::{
-    bitmap::AtomicBitmap, GuestAddress, GuestMemory,
-};
+use vm_memory::{bitmap::AtomicBitmap, GuestAddress, GuestMemory};
 
-type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
-type GuestRegionMmap = vm_memory::GuestRegionMmap<AtomicBitmap>;
-type MmapRegion = vm_memory::MmapRegion<AtomicBitmap>;
+pub type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
+pub type GuestRegionMmap = vm_memory::GuestRegionMmap<AtomicBitmap>;
+pub type MmapRegion = vm_memory::MmapRegion<AtomicBitmap>;
 
 const VIRTIO_F_RING_INDIRECT_DESC: u32 = 28;
 const VIRTIO_F_RING_EVENT_IDX: u32 = 29;
 const VIRTIO_F_VERSION_1: u32 = 32;
+#[allow(dead_code)]
 const VIRTIO_F_IOMMU_PLATFORM: u32 = 33;
 const VIRTIO_F_IN_ORDER: u32 = 35;
 const VIRTIO_F_ORDER_PLATFORM: u32 = 36;
diff --git a/crates/vhost-user-frontend/src/thread_helper.rs b/crates/vhost-user-frontend/src/thread_helper.rs
@@ -3,10 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-use crate::{
-    seccomp_filters::{get_seccomp_filter, Thread},
-    ActivateError,
-};
+use crate::{get_seccomp_filter, ActivateError, Thread};
 use seccompiler::{apply_filter, SeccompAction};
 use std::{
     panic::AssertUnwindSafe,
diff --git a/crates/vhost-user-frontend/src/vhost_user/mod.rs b/crates/vhost-user-frontend/src/vhost_user/mod.rs
@@ -2,40 +2,28 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    ActivateError, EpollHelper, EpollHelperError, EpollHelperHandler, GuestMemoryMmap,
+    clone_queue, ActivateError, EpollHelper, EpollHelperError, EpollHelperHandler, GuestMemoryMmap,
     GuestRegionMmap, VirtioInterrupt, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_IN_ORDER,
     VIRTIO_F_NOTIFICATION_DATA, VIRTIO_F_ORDER_PLATFORM, VIRTIO_F_RING_EVENT_IDX,
     VIRTIO_F_RING_INDIRECT_DESC, VIRTIO_F_VERSION_1,
 };
-use anyhow::anyhow;
+use std::fmt::Debug;
 use std::io;
 use std::ops::Deref;
 use std::os::unix::io::AsRawFd;
 use std::sync::{atomic::AtomicBool, Arc, Barrier, Mutex};
-use versionize::Versionize;
 use vhost::vhost_user::message::{
     VhostUserInflight, VhostUserProtocolFeatures, VhostUserVirtioFeatures,
 };
 use vhost::vhost_user::{MasterReqHandler, VhostUserMasterReqHandler};
 use vhost::Error as VhostError;
 use virtio_queue::Error as QueueError;
 use virtio_queue::Queue;
-use vm_memory::{
-    mmap::MmapRegionError, Address, Error as MmapError, GuestAddressSpace, GuestMemory,
-    GuestMemoryAtomic,
-};
-use vm_migration::{protocol::MemoryRangeTable, MigratableError, Snapshot, VersionMapped};
+use vm_memory::{mmap::MmapRegionError, Error as MmapError, GuestAddressSpace, GuestMemoryAtomic};
 use vmm_sys_util::eventfd::EventFd;
-use vu_common_ctrl::VhostUserHandle;
+pub(crate) use vu_common_ctrl::VhostUserHandle;
 
-pub mod blk;
-pub mod fs;
-pub mod net;
 pub mod vu_common_ctrl;
-
-pub use self::blk::Blk;
-pub use self::fs::*;
-pub use self::net::Net;
 pub use self::vu_common_ctrl::VhostUserConfig;
 
 #[derive(Debug)]
@@ -143,7 +131,7 @@ pub enum Error {
     /// Could not find the shm log region
     MissingShmLogRegion,
 }
-type Result<T> = std::result::Result<T, Error>;
+pub type Result<T> = std::result::Result<T, Error>;
 
 pub const DEFAULT_VIRTIO_FEATURES: u64 = 1 << VIRTIO_F_RING_INDIRECT_DESC
     | 1 << VIRTIO_F_RING_EVENT_IDX
@@ -225,7 +213,7 @@ impl<S: VhostUserMasterReqHandler> VhostUserEpollHandler<S> {
                 self.mem.memory().deref(),
                 self.queues
                     .iter()
-                    .map(|(i, q, e)| (*i, vm_virtio::clone_queue(q), e.try_clone().unwrap()))
+                    .map(|(i, q, e)| (*i, clone_queue(q), e.try_clone().unwrap()))
                     .collect(),
                 &self.virtio_interrupt,
                 self.acked_features,
@@ -323,7 +311,7 @@ impl VhostUserCommon {
                 &mem.memory(),
                 queues
                     .iter()
-                    .map(|(i, q, e)| (*i, vm_virtio::clone_queue(q), e.try_clone().unwrap()))
+                    .map(|(i, q, e)| (*i, clone_queue(q), e.try_clone().unwrap()))
                     .collect(),
                 &interrupt_cb,
                 acked_features,
@@ -378,150 +366,19 @@ impl VhostUserCommon {
         &mut self,
         guest_memory: &Option<GuestMemoryAtomic<GuestMemoryMmap>>,
         region: &Arc<GuestRegionMmap>,
-    ) -> std::result::Result<(), crate::Error> {
+    ) -> std::result::Result<(), Error> {
         if let Some(vu) = &self.vu {
             if self.acked_protocol_features & VhostUserProtocolFeatures::CONFIGURE_MEM_SLOTS.bits()
                 != 0
             {
-                return vu
-                    .lock()
-                    .unwrap()
-                    .add_memory_region(region)
-                    .map_err(crate::Error::VhostUserAddMemoryRegion);
+                return vu.lock().unwrap().add_memory_region(region);
             } else if let Some(guest_memory) = guest_memory {
                 return vu
                     .lock()
                     .unwrap()
-                    .update_mem_table(guest_memory.memory().deref())
-                    .map_err(crate::Error::VhostUserUpdateMemory);
-            }
-        }
-        Ok(())
-    }
-
-    pub fn pause(&mut self) -> std::result::Result<(), MigratableError> {
-        if let Some(vu) = &self.vu {
-            vu.lock().unwrap().pause_vhost_user().map_err(|e| {
-                MigratableError::Pause(anyhow!("Error pausing vhost-user-blk backend: {:?}", e))
-            })
-        } else {
-            Ok(())
-        }
-    }
-
-    pub fn resume(&mut self) -> std::result::Result<(), MigratableError> {
-        if let Some(vu) = &self.vu {
-            vu.lock().unwrap().resume_vhost_user().map_err(|e| {
-                MigratableError::Resume(anyhow!("Error resuming vhost-user-blk backend: {:?}", e))
-            })
-        } else {
-            Ok(())
-        }
-    }
-
-    pub fn snapshot<T>(
-        &mut self,
-        id: &str,
-        state: &T,
-    ) -> std::result::Result<Snapshot, MigratableError>
-    where
-        T: Versionize + VersionMapped,
-    {
-        let snapshot = Snapshot::new_from_versioned_state(id, state)?;
-
-        if self.migration_started {
-            self.shutdown();
-        }
-
-        Ok(snapshot)
-    }
-
-    pub fn start_dirty_log(
-        &mut self,
-        guest_memory: &Option<GuestMemoryAtomic<GuestMemoryMmap>>,
-    ) -> std::result::Result<(), MigratableError> {
-        if let Some(vu) = &self.vu {
-            if let Some(guest_memory) = guest_memory {
-                let last_ram_addr = guest_memory.memory().last_addr().raw_value();
-                vu.lock()
-                    .unwrap()
-                    .start_dirty_log(last_ram_addr)
-                    .map_err(|e| {
-                        MigratableError::StartDirtyLog(anyhow!(
-                            "Error starting migration for vhost-user backend: {:?}",
-                            e
-                        ))
-                    })
-            } else {
-                Err(MigratableError::StartDirtyLog(anyhow!(
-                    "Missing guest memory"
-                )))
+                    .update_mem_table(guest_memory.memory().deref());
             }
-        } else {
-            Ok(())
-        }
-    }
-
-    pub fn stop_dirty_log(&mut self) -> std::result::Result<(), MigratableError> {
-        if let Some(vu) = &self.vu {
-            vu.lock().unwrap().stop_dirty_log().map_err(|e| {
-                MigratableError::StopDirtyLog(anyhow!(
-                    "Error stopping migration for vhost-user backend: {:?}",
-                    e
-                ))
-            })
-        } else {
-            Ok(())
         }
-    }
-
-    pub fn dirty_log(
-        &mut self,
-        guest_memory: &Option<GuestMemoryAtomic<GuestMemoryMmap>>,
-    ) -> std::result::Result<MemoryRangeTable, MigratableError> {
-        if let Some(vu) = &self.vu {
-            if let Some(guest_memory) = guest_memory {
-                let last_ram_addr = guest_memory.memory().last_addr().raw_value();
-                vu.lock().unwrap().dirty_log(last_ram_addr).map_err(|e| {
-                    MigratableError::DirtyLog(anyhow!(
-                        "Error retrieving dirty ranges from vhost-user backend: {:?}",
-                        e
-                    ))
-                })
-            } else {
-                Err(MigratableError::DirtyLog(anyhow!("Missing guest memory")))
-            }
-        } else {
-            Ok(MemoryRangeTable::default())
-        }
-    }
-
-    pub fn start_migration(&mut self) -> std::result::Result<(), MigratableError> {
-        self.migration_started = true;
-        Ok(())
-    }
-
-    pub fn complete_migration(
-        &mut self,
-        kill_evt: Option<EventFd>,
-    ) -> std::result::Result<(), MigratableError> {
-        self.migration_started = false;
-
-        // Make sure the device thread is killed in order to prevent from
-        // reconnections to the socket.
-        if let Some(kill_evt) = kill_evt {
-            kill_evt.write(1).map_err(|e| {
-                MigratableError::CompleteMigration(anyhow!(
-                    "Error killing vhost-user thread: {:?}",
-                    e
-                ))
-            })?;
-        }
-
-        // Drop the vhost-user handler to avoid further calls to fail because
-        // the connection with the backend has been closed.
-        self.vu = None;
-
         Ok(())
     }
 }
diff --git a/crates/vhost-user-frontend/src/vhost_user/vu_common_ctrl.rs b/crates/vhost-user-frontend/src/vhost_user/vu_common_ctrl.rs
@@ -27,7 +27,6 @@ use virtio_queue::{Descriptor, Queue, QueueT};
 use vm_memory::{
     Address, Error as MmapError, FileOffset, GuestAddress, GuestMemory, GuestMemoryRegion,
 };
-use vm_migration::protocol::MemoryRangeTable;
 use vmm_sys_util::eventfd::EventFd;
 
 // Size of a dirty page for vhost-user.
@@ -559,26 +558,6 @@ impl VhostUserHandle {
 
         Ok(())
     }
-
-    pub fn dirty_log(&mut self, last_ram_addr: u64) -> Result<MemoryRangeTable> {
-        // The log region is updated by creating a new region that is sent to
-        // the backend. This ensures the backend stops logging to the previous
-        // region. The previous region is returned and processed to create the
-        // bitmap representing the dirty pages.
-        if let Some(region) = self.update_log_base(last_ram_addr)? {
-            // Be careful with the size, as it was based on u8, meaning we must
-            // divide it by 8.
-            let len = region.size() / 8;
-            let bitmap = unsafe {
-                // Cast the pointer to u64
-                let ptr = region.as_ptr() as *const u64;
-                std::slice::from_raw_parts(ptr, len).to_vec()
-            };
-            Ok(MemoryRangeTable::from_bitmap(bitmap, 0, 4096))
-        } else {
-            Err(Error::MissingShmLogRegion)
-        }
-    }
 }
 
 fn memfd_create(name: &ffi::CStr, flags: u32) -> std::result::Result<RawFd, std::io::Error> {
