From e175ad64f2403c030e781f2c7d90166030f5c6c8 Mon Sep 17 00:00:00 2001 From: Sebastian Eydam Date: Tue, 10 Mar 2026 09:47:19 +0100 Subject: [PATCH] vmm: move SocketStream into the migration_transport module This is mainly to clean up the lib.rs a bit more. On-behalf-of: SAP sebastian.eydam@sap.com Signed-off-by: Sebastian Eydam --- vmm/src/lib.rs | 90 ++------------------------------ vmm/src/migration_transport.rs | 95 ++++++++++++++++++++++++++++++++-- 2 files changed, 95 insertions(+), 90 deletions(-) diff --git a/vmm/src/lib.rs b/vmm/src/lib.rs index 1a9c53dd3..c08ec9e28 100644 --- a/vmm/src/lib.rs +++ b/vmm/src/lib.rs @@ -6,9 +6,7 @@ use std::collections::HashMap; use std::fs::File; use std::io::{Read, Write, stdout}; -use std::net::TcpStream; use std::os::unix::io::{AsRawFd, FromRawFd, RawFd}; -use std::os::unix::net::UnixStream; use std::panic::AssertUnwindSafe; #[cfg(feature = "guest_debug")] use std::path::PathBuf; @@ -38,8 +36,8 @@ use serde::{Deserialize, Serialize}; use signal_hook::iterator::{Handle, Signals}; use thiserror::Error; use tracer::trace_scoped; -use vm_memory::bitmap::{AtomicBitmap, BitmapSlice}; -use vm_memory::{ReadVolatile, VolatileMemoryError, VolatileSlice, WriteVolatile}; +use vm_memory::ReadVolatile; +use vm_memory::bitmap::AtomicBitmap; use vm_migration::protocol::*; use vm_migration::{ MemoryMigrationContext, Migratable, MigratableError, Pausable, Snapshot, Snapshottable, @@ -61,6 +59,7 @@ use crate::memory_manager::MemoryManager; #[cfg(all(feature = "kvm", target_arch = "x86_64"))] use crate::migration::get_vm_snapshot; use crate::migration::{recv_vm_config, recv_vm_state}; +use crate::migration_transport::SocketStream; use crate::seccomp_filters::{Thread, get_seccomp_filter}; use crate::vm::{Error as VmError, Vm, VmState}; use crate::vm_config::{ @@ -265,89 +264,6 @@ impl From for EpollDispatch { } } -enum SocketStream { - Unix(UnixStream), - Tcp(TcpStream), -} - -impl Read for SocketStream { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - match self { - SocketStream::Unix(stream) => stream.read(buf), - SocketStream::Tcp(stream) => stream.read(buf), - } - } -} - -impl Write for SocketStream { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - match self { - SocketStream::Unix(stream) => stream.write(buf), - SocketStream::Tcp(stream) => stream.write(buf), - } - } - - fn flush(&mut self) -> std::io::Result<()> { - match self { - SocketStream::Unix(stream) => stream.flush(), - SocketStream::Tcp(stream) => stream.flush(), - } - } -} - -impl AsRawFd for SocketStream { - fn as_raw_fd(&self) -> RawFd { - match self { - SocketStream::Unix(s) => s.as_raw_fd(), - SocketStream::Tcp(s) => s.as_raw_fd(), - } - } -} - -impl ReadVolatile for SocketStream { - fn read_volatile( - &mut self, - buf: &mut VolatileSlice, - ) -> std::result::Result { - match self { - SocketStream::Unix(s) => s.read_volatile(buf), - SocketStream::Tcp(s) => s.read_volatile(buf), - } - } - - fn read_exact_volatile( - &mut self, - buf: &mut VolatileSlice, - ) -> std::result::Result<(), VolatileMemoryError> { - match self { - SocketStream::Unix(s) => s.read_exact_volatile(buf), - SocketStream::Tcp(s) => s.read_exact_volatile(buf), - } - } -} - -impl WriteVolatile for SocketStream { - fn write_volatile( - &mut self, - buf: &VolatileSlice, - ) -> std::result::Result { - match self { - SocketStream::Unix(s) => s.write_volatile(buf), - SocketStream::Tcp(s) => s.write_volatile(buf), - } - } - - fn write_all_volatile( - &mut self, - buf: &VolatileSlice, - ) -> std::result::Result<(), VolatileMemoryError> { - match self { - SocketStream::Unix(s) => s.write_all_volatile(buf), - SocketStream::Tcp(s) => s.write_all_volatile(buf), - } - } -} - pub struct EpollContext { epoll_file: File, } diff --git a/vmm/src/migration_transport.rs b/vmm/src/migration_transport.rs index 22dac6f71..168d718be 100644 --- a/vmm/src/migration_transport.rs +++ b/vmm/src/migration_transport.rs @@ -3,8 +3,9 @@ // SPDX-License-Identifier: Apache-2.0 // -use std::io::Write; +use std::io::{self, Read, Write}; use std::net::{TcpListener, TcpStream}; +use std::os::unix::io::{AsRawFd, RawFd}; use std::os::unix::net::{UnixListener, UnixStream}; use std::path::PathBuf; use std::result::Result; @@ -12,11 +13,99 @@ use std::result::Result; use anyhow::{Context, anyhow}; use log::info; use serde_json; -use vm_memory::{Bytes, GuestAddress, GuestAddressSpace, GuestMemoryAtomic}; +use vm_memory::bitmap::BitmapSlice; +use vm_memory::{ + Bytes, GuestAddress, GuestAddressSpace, GuestMemoryAtomic, ReadVolatile, VolatileMemoryError, + VolatileSlice, WriteVolatile, +}; use vm_migration::protocol::{MemoryRangeTable, Request, Response}; use vm_migration::{MigratableError, Snapshot}; -use crate::{GuestMemoryMmap, SocketStream, VmMigrationConfig}; +use crate::{GuestMemoryMmap, VmMigrationConfig}; + +/// Transport-agnostic stream used by the migration protocol. +pub(crate) enum SocketStream { + Unix(UnixStream), + Tcp(TcpStream), +} + +impl Read for SocketStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + match self { + SocketStream::Unix(stream) => stream.read(buf), + SocketStream::Tcp(stream) => stream.read(buf), + } + } +} + +impl Write for SocketStream { + fn write(&mut self, buf: &[u8]) -> io::Result { + match self { + SocketStream::Unix(stream) => stream.write(buf), + SocketStream::Tcp(stream) => stream.write(buf), + } + } + + fn flush(&mut self) -> io::Result<()> { + match self { + SocketStream::Unix(stream) => stream.flush(), + SocketStream::Tcp(stream) => stream.flush(), + } + } +} + +impl AsRawFd for SocketStream { + fn as_raw_fd(&self) -> RawFd { + match self { + SocketStream::Unix(s) => s.as_raw_fd(), + SocketStream::Tcp(s) => s.as_raw_fd(), + } + } +} + +impl ReadVolatile for SocketStream { + fn read_volatile( + &mut self, + buf: &mut VolatileSlice, + ) -> Result { + match self { + SocketStream::Unix(s) => s.read_volatile(buf), + SocketStream::Tcp(s) => s.read_volatile(buf), + } + } + + fn read_exact_volatile( + &mut self, + buf: &mut VolatileSlice, + ) -> Result<(), VolatileMemoryError> { + match self { + SocketStream::Unix(s) => s.read_exact_volatile(buf), + SocketStream::Tcp(s) => s.read_exact_volatile(buf), + } + } +} + +impl WriteVolatile for SocketStream { + fn write_volatile( + &mut self, + buf: &VolatileSlice, + ) -> Result { + match self { + SocketStream::Unix(s) => s.write_volatile(buf), + SocketStream::Tcp(s) => s.write_volatile(buf), + } + } + + fn write_all_volatile( + &mut self, + buf: &VolatileSlice, + ) -> Result<(), VolatileMemoryError> { + match self { + SocketStream::Unix(s) => s.write_all_volatile(buf), + SocketStream::Tcp(s) => s.write_all_volatile(buf), + } + } +} /// Extract a UNIX socket path from a "unix:" migration URL. fn socket_url_to_path(url: &str) -> Result {