build: Release v31.2 (bug fix release)

Signed-off-by: Bo Chen <chen.bo@intel.com>

Cargo.lock

@@ -179,7 +179,7 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "cloud-hypervisor"
-version = "31.0.0"
+version = "31.2.0"
 dependencies = [
  "anyhow",
  "api_client",
@@ -545,8 +545,7 @@ dependencies = [
 [[package]]
 name = "kvm-ioctls"
 version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8f8dc9c1896e5f144ec5d07169bc29f39a047686d29585a91f30489abfaeb6b"
+source = "git+https://github.com/rust-vmm/kvm-ioctls?branch=main#23a3bb045a467e60bb00328a0b13cea13b5815d0"
 dependencies = [
  "kvm-bindings",
  "libc",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cloud-hypervisor"
-version = "31.0.0"
+version = "31.2.0"
 authors = ["The Cloud Hypervisor Authors"]
 edition = "2021"
 default-run = "cloud-hypervisor"
@@ -52,6 +52,7 @@ vm-memory = "0.10.0"
 # List of patched crates
 [patch.crates-io]
 kvm-bindings = { git = "https://github.com/cloud-hypervisor/kvm-bindings", branch = "ch-v0.6.0-tdx" }
+kvm-ioctls = { git = "https://github.com/rust-vmm/kvm-ioctls", branch = "main" }
 versionize_derive = { git = "https://github.com/cloud-hypervisor/versionize_derive", branch = "ch" }
 
 [dev-dependencies]

arch/src/aarch64/fdt.rs

@@ -260,32 +260,86 @@ fn create_memory_node(
             fdt.end_node(memory_node)?;
         }
     } else {
-        let last_addr = guest_mem.last_addr().raw_value();
-        if last_addr < super::layout::MEM_32BIT_RESERVED_START.raw_value() {
-            // Case 1: all RAM is under the hole
-            let mem_size = last_addr - super::layout::RAM_START.raw_value() + 1;
-            let mem_reg_prop = [super::layout::RAM_START.raw_value(), mem_size];
-            let memory_node = fdt.begin_node("memory")?;
-            fdt.property_string("device_type", "memory")?;
-            fdt.property_array_u64("reg", &mem_reg_prop)?;
-            fdt.end_node(memory_node)?;
-        } else {
-            // Case 2: RAM is split by the hole
-            // Region 1: RAM before the hole
-            let mem_size = super::layout::MEM_32BIT_RESERVED_START.raw_value()
-                - super::layout::RAM_START.raw_value();
-            let mem_reg_prop = [super::layout::RAM_START.raw_value(), mem_size];
-            let memory_node_name = format!("memory@{:x}", super::layout::RAM_START.raw_value());
+        // Note: memory regions from "GuestMemory" are sorted and non-zero sized.
+        let ram_regions = {
+            let mut ram_regions = Vec::new();
+            let mut current_start = guest_mem
+                .iter()
+                .next()
+                .map(GuestMemoryRegion::start_addr)
+                .expect("GuestMemory must have one memory region at least")
+                .raw_value();
+            let mut current_end = current_start;
+
+            for (start, size) in guest_mem
+                .iter()
+                .map(|m| (m.start_addr().raw_value(), m.len()))
+            {
+                if current_end == start {
+                    // This zone is continuous with the previous one.
+                    current_end += size;
+                } else {
+                    ram_regions.push((current_start, current_end));
+
+                    current_start = start;
+                    current_end = start + size;
+                }
+            }
+
+            ram_regions.push((current_start, current_end));
+
+            ram_regions
+        };
+
+        if ram_regions.len() > 2 {
+            panic!(
+                "There should be up to two non-continuous regions, devidided by the
+                    gap at the end of 32bit address space."
+            );
+        }
+
+        // Create the memory node for memory region before the gap
+        {
+            let (first_region_start, first_region_end) = ram_regions
+                .first()
+                .expect("There should be at last one memory region");
+            let ram_start = super::layout::RAM_START.raw_value();
+            let mem_32bit_reserved_start = super::layout::MEM_32BIT_RESERVED_START.raw_value();
+
+            if !((first_region_start <= &ram_start)
+                && (first_region_end > &ram_start)
+                && (first_region_end <= &mem_32bit_reserved_start))
+            {
+                panic!(
+                    "Unexpected first memory region layout: (start: 0x{:08x}, end: 0x{:08x}).
+                    ram_start: 0x{:08x}, mem_32bit_reserved_start: 0x{:08x}",
+                    first_region_start, first_region_end, ram_start, mem_32bit_reserved_start
+                );
+            }
+
+            let mem_size = first_region_end - ram_start;
+            let mem_reg_prop = [ram_start, mem_size];
+            let memory_node_name = format!("memory@{:x}", ram_start);
             let memory_node = fdt.begin_node(&memory_node_name)?;
             fdt.property_string("device_type", "memory")?;
             fdt.property_array_u64("reg", &mem_reg_prop)?;
             fdt.end_node(memory_node)?;
+        }
 
-            // Region 2: RAM after the hole
-            let mem_size = last_addr - super::layout::RAM_64BIT_START.raw_value() + 1;
-            let mem_reg_prop = [super::layout::RAM_64BIT_START.raw_value(), mem_size];
-            let memory_node_name =
-                format!("memory@{:x}", super::layout::RAM_64BIT_START.raw_value());
+        // Create the memory map entry for memory region after the gap if any
+        if let Some((second_region_start, second_region_end)) = ram_regions.get(1) {
+            let ram_64bit_start = super::layout::RAM_64BIT_START.raw_value();
+
+            if second_region_start != &ram_64bit_start {
+                panic!(
+                    "Unexpected second memory region layout: start: 0x{:08x}, ram_64bit_start: 0x{:08x}",
+                    second_region_start, ram_64bit_start
+                );
+            }
+
+            let mem_size = second_region_end - ram_64bit_start;
+            let mem_reg_prop = [ram_64bit_start, mem_size];
+            let memory_node_name = format!("memory@{:x}", ram_64bit_start);
             let memory_node = fdt.begin_node(&memory_node_name)?;
             fdt.property_string("device_type", "memory")?;
             fdt.property_array_u64("reg", &mem_reg_prop)?;

arch/src/aarch64/mod.rs

@@ -19,7 +19,7 @@ use std::collections::HashMap;
 use std::convert::TryInto;
 use std::fmt::Debug;
 use std::sync::{Arc, Mutex};
-use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic, GuestUsize};
+use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic};
 
 pub const _NSIG: i32 = 65;
 
@@ -83,8 +83,8 @@ pub fn configure_vcpu(
     Ok(mpidr)
 }
 
-pub fn arch_memory_regions(size: GuestUsize) -> Vec<(GuestAddress, usize, RegionType)> {
-    let mut regions = vec![
+pub fn arch_memory_regions() -> Vec<(GuestAddress, usize, RegionType)> {
+    vec![
         // 0 MiB ~ 256 MiB: UEFI, GIC and legacy devices
         (
             GuestAddress(0),
@@ -103,39 +103,21 @@ pub fn arch_memory_regions(size: GuestUsize) -> Vec<(GuestAddress, usize, Region
             layout::PCI_MMCONFIG_SIZE as usize,
             RegionType::Reserved,
         ),
-    ];
-
-    let ram_32bit_space_size =
-        layout::MEM_32BIT_RESERVED_START.unchecked_offset_from(layout::RAM_START);
-
-    // RAM space
-    // Case1: guest memory fits before the gap
-    if size <= ram_32bit_space_size {
-        regions.push((layout::RAM_START, size as usize, RegionType::Ram));
-    // Case2: guest memory extends beyond the gap
-    } else {
-        // Push memory before the gap
-        regions.push((
+        // 1GiB ~ 4032 MiB: RAM before the gap
+        (
             layout::RAM_START,
-            ram_32bit_space_size as usize,
+            layout::MEM_32BIT_RESERVED_START.unchecked_offset_from(layout::RAM_START) as usize,
             RegionType::Ram,
-        ));
-        // Other memory is placed after 4GiB
-        regions.push((
-            layout::RAM_64BIT_START,
-            (size - ram_32bit_space_size) as usize,
-            RegionType::Ram,
-        ));
-    }
-
-    // Add the 32-bit reserved memory hole as a reserved region
-    regions.push((
-        layout::MEM_32BIT_RESERVED_START,
-        layout::MEM_32BIT_RESERVED_SIZE as usize,
-        RegionType::Reserved,
-    ));
-
-    regions
+        ),
+        // 4GiB ~ inf: RAM after the gap
+        (layout::RAM_64BIT_START, usize::MAX, RegionType::Ram),
+        // Add the 32-bit reserved memory hole as a reserved region
+        (
+            layout::MEM_32BIT_RESERVED_START,
+            layout::MEM_32BIT_RESERVED_SIZE as usize,
+            RegionType::Reserved,
+        ),
+    ]
 }
 
 /// Configures the system and should be called once per vm before starting vcpu threads.
@@ -217,26 +199,12 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_arch_memory_regions_dram_2gb() {
-        let regions = arch_memory_regions((1usize << 31) as u64); //2GB
-        assert_eq!(5, regions.len());
-        assert_eq!(layout::RAM_START, regions[3].0);
-        assert_eq!((1usize << 31), regions[3].1);
-        assert_eq!(RegionType::Ram, regions[3].2);
-        assert_eq!(RegionType::Reserved, regions[4].2);
-    }
-
-    #[test]
-    fn test_arch_memory_regions_dram_4gb() {
-        let regions = arch_memory_regions((1usize << 32) as u64); //4GB
-        let ram_32bit_space_size =
-            layout::MEM_32BIT_RESERVED_START.unchecked_offset_from(layout::RAM_START) as usize;
+    fn test_arch_memory_regions_dram() {
+        let regions = arch_memory_regions();
         assert_eq!(6, regions.len());
         assert_eq!(layout::RAM_START, regions[3].0);
-        assert_eq!(ram_32bit_space_size, regions[3].1);
         assert_eq!(RegionType::Ram, regions[3].2);
         assert_eq!(RegionType::Reserved, regions[5].2);
         assert_eq!(RegionType::Ram, regions[4].2);
-        assert_eq!(((1usize << 32) - ram_32bit_space_size), regions[4].1);
     }
 }

arch/src/x86_64/mod.rs

@@ -776,6 +776,13 @@ pub fn configure_vcpu(
     CpuidPatch::set_cpuid_reg(&mut cpuid, 0xb, None, CpuidReg::EDX, u32::from(id));
     CpuidPatch::set_cpuid_reg(&mut cpuid, 0x1f, None, CpuidReg::EDX, u32::from(id));
 
+    // Set ApicId in cpuid for each vcpu
+    // SAFETY: get host cpuid when eax=1
+    let mut cpu_ebx = unsafe { core::arch::x86_64::__cpuid(1) }.ebx;
+    cpu_ebx &= 0xffffff;
+    cpu_ebx |= (id as u32) << 24;
+    CpuidPatch::set_cpuid_reg(&mut cpuid, 0x1, None, CpuidReg::EBX, cpu_ebx);
+
     // The TSC frequency CPUID leaf should not be included when running with HyperV emulation
     if !kvm_hyperv {
         if let Some(tsc_khz) = vcpu.tsc_khz().map_err(Error::GetTscFrequency)? {
@@ -828,47 +835,29 @@ pub fn configure_vcpu(
 /// These should be used to configure the GuestMemory structure for the platform.
 /// For x86_64 all addresses are valid from the start of the kernel except a
 /// carve out at the end of 32bit address space.
-pub fn arch_memory_regions(size: GuestUsize) -> Vec<(GuestAddress, usize, RegionType)> {
-    let reserved_memory_gap_start = layout::MEM_32BIT_RESERVED_START
-        .checked_add(layout::MEM_32BIT_DEVICES_SIZE)
-        .expect("32-bit reserved region is too large");
-
-    let requested_memory_size = GuestAddress(size);
-    let mut regions = Vec::new();
-
-    // case1: guest memory fits before the gap
-    if size <= layout::MEM_32BIT_RESERVED_START.raw_value() {
-        regions.push((GuestAddress(0), size as usize, RegionType::Ram));
-    // case2: guest memory extends beyond the gap
-    } else {
-        // push memory before the gap
-        regions.push((
+pub fn arch_memory_regions() -> Vec<(GuestAddress, usize, RegionType)> {
+    vec![
+        // 0 GiB ~ 3GiB: memory before the gap
+        (
             GuestAddress(0),
             layout::MEM_32BIT_RESERVED_START.raw_value() as usize,
             RegionType::Ram,
-        ));
-        regions.push((
-            layout::RAM_64BIT_START,
-            requested_memory_size.unchecked_offset_from(layout::MEM_32BIT_RESERVED_START) as usize,
-            RegionType::Ram,
-        ));
-    }
-
-    // Add the 32-bit device memory hole as a sub region.
-    regions.push((
-        layout::MEM_32BIT_RESERVED_START,
-        layout::MEM_32BIT_DEVICES_SIZE as usize,
-        RegionType::SubRegion,
-    ));
-
-    // Add the 32-bit reserved memory hole as a sub region.
-    regions.push((
-        reserved_memory_gap_start,
-        (layout::MEM_32BIT_RESERVED_SIZE - layout::MEM_32BIT_DEVICES_SIZE) as usize,
-        RegionType::Reserved,
-    ));
-
-    regions
+        ),
+        // 4 GiB ~ inf: memory after the gap
+        (layout::RAM_64BIT_START, usize::MAX, RegionType::Ram),
+        // 3 GiB ~ 3712 MiB: 32-bit device memory hole
+        (
+            layout::MEM_32BIT_RESERVED_START,
+            layout::MEM_32BIT_DEVICES_SIZE as usize,
+            RegionType::SubRegion,
+        ),
+        // 3712 MiB ~ 3968 MiB: 32-bit reserved memory hole
+        (
+            layout::MEM_32BIT_RESERVED_START.unchecked_add(layout::MEM_32BIT_DEVICES_SIZE),
+            (layout::MEM_32BIT_RESERVED_SIZE - layout::MEM_32BIT_DEVICES_SIZE) as usize,
+            RegionType::Reserved,
+        ),
+    ]
 }
 
 /// Configures the system and should be called once per vm before starting vcpu threads.
@@ -966,30 +955,102 @@ fn configure_pvh(
     // Create the memory map entries.
     add_memmap_entry(&mut memmap, 0, layout::EBDA_START.raw_value(), E820_RAM);
 
-    let mem_end = guest_mem.last_addr();
+    // Merge continuous memory regions into one region.
+    // Note: memory regions from "GuestMemory" are sorted and non-zero sized.
+    let ram_regions = {
+        let mut ram_regions = Vec::new();
+        let mut current_start = guest_mem
+            .iter()
+            .next()
+            .map(GuestMemoryRegion::start_addr)
+            .expect("GuestMemory must have one memory region at least")
+            .raw_value();
+        let mut current_end = current_start;
 
-    if mem_end < layout::MEM_32BIT_RESERVED_START {
-        add_memmap_entry(
-            &mut memmap,
-            layout::HIGH_RAM_START.raw_value(),
-            mem_end.unchecked_offset_from(layout::HIGH_RAM_START) + 1,
-            E820_RAM,
-        );
-    } else {
-        add_memmap_entry(
-            &mut memmap,
-            layout::HIGH_RAM_START.raw_value(),
-            layout::MEM_32BIT_RESERVED_START.unchecked_offset_from(layout::HIGH_RAM_START),
-            E820_RAM,
-        );
-        if mem_end > layout::RAM_64BIT_START {
-            add_memmap_entry(
-                &mut memmap,
-                layout::RAM_64BIT_START.raw_value(),
-                mem_end.unchecked_offset_from(layout::RAM_64BIT_START) + 1,
-                E820_RAM,
-            );
+        for (start, size) in guest_mem
+            .iter()
+            .map(|m| (m.start_addr().raw_value(), m.len()))
+        {
+            if current_end == start {
+                // This zone is continuous with the previous one.
+                current_end += size;
+            } else {
+                ram_regions.push((current_start, current_end));
+
+                current_start = start;
+                current_end = start + size;
+            }
         }
+
+        ram_regions.push((current_start, current_end));
+
+        ram_regions
+    };
+
+    if ram_regions.len() > 2 {
+        error!(
+            "There should be up to two non-continuous regions, devidided by the
+            gap at the end of 32bit address space (e.g. between 3G and 4G)."
+        );
+        return Err(super::Error::MemmapTableSetup);
+    }
+
+    // Create the memory map entry for memory region before the gap
+    {
+        let (first_region_start, first_region_end) =
+            ram_regions.first().ok_or(super::Error::MemmapTableSetup)?;
+        let high_ram_start = layout::HIGH_RAM_START.raw_value();
+        let mem_32bit_reserved_start = layout::MEM_32BIT_RESERVED_START.raw_value();
+
+        if !((first_region_start <= &high_ram_start)
+            && (first_region_end > &high_ram_start)
+            && (first_region_end <= &mem_32bit_reserved_start))
+        {
+            error!(
+                "Unexpected first memory region layout: (start: 0x{:08x}, end: 0x{:08x}).
+                high_ram_start: 0x{:08x}, mem_32bit_reserved_start: 0x{:08x}",
+                first_region_start, first_region_end, high_ram_start, mem_32bit_reserved_start
+            );
+
+            return Err(super::Error::MemmapTableSetup);
+        }
+
+        info!(
+            "create_memmap_entry, start: 0x{:08x}, end: 0x{:08x})",
+            high_ram_start, first_region_end
+        );
+
+        add_memmap_entry(
+            &mut memmap,
+            high_ram_start,
+            first_region_end - high_ram_start,
+            E820_RAM,
+        );
+    }
+
+    // Create the memory map entry for memory region after the gap if any
+    if let Some((second_region_start, second_region_end)) = ram_regions.get(1) {
+        let ram_64bit_start = layout::RAM_64BIT_START.raw_value();
+
+        if second_region_start != &ram_64bit_start {
+            error!(
+                "Unexpected second memory region layout: start: 0x{:08x}, ram_64bit_start: 0x{:08x}",
+                second_region_start, ram_64bit_start
+            );
+
+            return Err(super::Error::MemmapTableSetup);
+        }
+
+        info!(
+            "create_memmap_entry, start: 0x{:08x}, end: 0x{:08x})",
+            ram_64bit_start, second_region_end
+        );
+        add_memmap_entry(
+            &mut memmap,
+            ram_64bit_start,
+            second_region_end - ram_64bit_start,
+            E820_RAM,
+        );
     }
 
     add_memmap_entry(
@@ -1225,16 +1286,8 @@ mod tests {
     use super::*;
 
     #[test]
-    fn regions_lt_4gb() {
-        let regions = arch_memory_regions(1 << 29);
-        assert_eq!(3, regions.len());
-        assert_eq!(GuestAddress(0), regions[0].0);
-        assert_eq!(1usize << 29, regions[0].1);
-    }
-
-    #[test]
-    fn regions_gt_4gb() {
-        let regions = arch_memory_regions((1 << 32) + 0x8000);
+    fn regions_base_addr() {
+        let regions = arch_memory_regions();
         assert_eq!(4, regions.len());
         assert_eq!(GuestAddress(0), regions[0].0);
         assert_eq!(GuestAddress(1 << 32), regions[1].0);
@@ -1258,11 +1311,10 @@ mod tests {
         assert!(config_err.is_err());
 
         // Now assigning some memory that falls before the 32bit memory hole.
-        let mem_size = 128 << 20;
-        let arch_mem_regions = arch_memory_regions(mem_size);
+        let arch_mem_regions = arch_memory_regions();
         let ram_regions: Vec<(GuestAddress, usize)> = arch_mem_regions
             .iter()
-            .filter(|r| r.2 == RegionType::Ram)
+            .filter(|r| r.2 == RegionType::Ram && r.1 != usize::MAX)
             .map(|r| (r.0, r.1))
             .collect();
         let gm = GuestMemoryMmap::from_ranges(&ram_regions).unwrap();
@@ -1280,48 +1332,18 @@ mod tests {
         )
         .unwrap();
 
-        // Now assigning some memory that is equal to the start of the 32bit memory hole.
-        let mem_size = 3328 << 20;
-        let arch_mem_regions = arch_memory_regions(mem_size);
-        let ram_regions: Vec<(GuestAddress, usize)> = arch_mem_regions
-            .iter()
-            .filter(|r| r.2 == RegionType::Ram)
-            .map(|r| (r.0, r.1))
-            .collect();
-        let gm = GuestMemoryMmap::from_ranges(&ram_regions).unwrap();
-        configure_system(
-            &gm,
-            GuestAddress(0),
-            &None,
-            no_vcpus,
-            None,
-            None,
-            None,
-            None,
-            None,
-        )
-        .unwrap();
-
-        configure_system(
-            &gm,
-            GuestAddress(0),
-            &None,
-            no_vcpus,
-            None,
-            None,
-            None,
-            None,
-            None,
-        )
-        .unwrap();
-
         // Now assigning some memory that falls after the 32bit memory hole.
-        let mem_size = 3330 << 20;
-        let arch_mem_regions = arch_memory_regions(mem_size);
+        let arch_mem_regions = arch_memory_regions();
         let ram_regions: Vec<(GuestAddress, usize)> = arch_mem_regions
             .iter()
             .filter(|r| r.2 == RegionType::Ram)
-            .map(|r| (r.0, r.1))
+            .map(|r| {
+                if r.1 == usize::MAX {
+                    (r.0, 128 << 20)
+                } else {
+                    (r.0, r.1)
+                }
+            })
             .collect();
         let gm = GuestMemoryMmap::from_ranges(&ram_regions).unwrap();
         configure_system(

hypervisor/src/hypervisor.rs

@@ -133,4 +133,7 @@ pub trait Hypervisor: Send + Sync {
     fn get_guest_debug_hw_bps(&self) -> usize {
         unimplemented!()
     }
+
+    /// Get maximum number of vCPUs
+    fn get_max_vcpus(&self) -> u32;
 }

hypervisor/src/kvm/mod.rs

@@ -330,7 +330,7 @@ impl KvmVm {
         Ok(VfioDeviceFd::new_from_kvm(device_fd))
     }
     /// Checks if a particular `Cap` is available.
-    fn check_extension(&self, c: Cap) -> bool {
+    pub fn check_extension(&self, c: Cap) -> bool {
         self.fd.check_extension(c)
     }
 }
@@ -1084,6 +1084,11 @@ impl hypervisor::Hypervisor for KvmHypervisor {
             self.kvm.get_guest_debug_hw_bps() as usize
         }
     }
+
+    /// Get maximum number of vCPUs
+    fn get_max_vcpus(&self) -> u32 {
+        self.kvm.get_max_vcpus().min(u32::MAX as usize) as u32
+    }
 }
 /// Vcpu struct for KVM
 pub struct KvmVcpu {

hypervisor/src/mshv/mod.rs

@@ -279,6 +279,13 @@ impl hypervisor::Hypervisor for MshvHypervisor {
     fn get_supported_cpuid(&self) -> hypervisor::Result<Vec<CpuIdEntry>> {
         Ok(Vec::new())
     }
+
+    /// Get maximum number of vCPUs
+    fn get_max_vcpus(&self) -> u32 {
+        // TODO: Using HV_MAXIMUM_PROCESSORS would be better
+        // but the ioctl API is limited to u8
+        256
+    }
 }
 
 /// Vcpu struct for Microsoft Hypervisor
@@ -576,8 +583,14 @@ impl cpu::Vcpu for MshvVcpu {
     ///
     /// X86 specific call to setup the CPUID registers.
     ///
-    fn set_cpuid2(&self, _cpuid: &[CpuIdEntry]) -> cpu::Result<()> {
-        Ok(())
+    fn set_cpuid2(&self, cpuid: &[CpuIdEntry]) -> cpu::Result<()> {
+        let cpuid: Vec<mshv_bindings::hv_cpuid_entry> = cpuid.iter().map(|e| (*e).into()).collect();
+        let mshv_cpuid = <CpuId>::from_entries(&cpuid)
+            .map_err(|_| cpu::HypervisorCpuError::SetCpuid(anyhow!("failed to create CpuId")))?;
+
+        self.fd
+            .register_intercept_result_cpuid(&mshv_cpuid)
+            .map_err(|e| cpu::HypervisorCpuError::SetCpuid(e.into()))
     }
     #[cfg(target_arch = "x86_64")]
     ///

net_gen/src/lib.rs

@@ -28,10 +28,12 @@ pub mod inn;
 // generated with bindgen /usr/include/linux/sockios.h --no-unstable-rust
 // --constified-enum '*' --with-derive-default
 pub mod sockios;
-pub use if_tun::*;
-pub use iff::*;
-pub use inn::*;
-pub use sockios::*;
+pub use if_tun::{
+    sock_fprog, IFF_MULTI_QUEUE, IFF_NO_PI, IFF_TAP, IFF_VNET_HDR, TUN_F_CSUM, TUN_F_TSO4,
+    TUN_F_TSO6, TUN_F_TSO_ECN, TUN_F_UFO,
+};
+pub use iff::{ifreq, net_device_flags_IFF_UP, setsockopt, sockaddr, AF_INET};
+pub use inn::sockaddr_in;
 
 pub const TUNTAP: ::std::os::raw::c_uint = 84;
 

pci/src/msix.rs

@@ -511,6 +511,16 @@ impl MsixCap {
         self.pba & 0xffff_fff8
     }
 
+    pub fn table_set_offset(&mut self, addr: u32) {
+        self.table &= 0x7;
+        self.table += addr;
+    }
+
+    pub fn pba_set_offset(&mut self, addr: u32) {
+        self.pba &= 0x7;
+        self.pba += addr;
+    }
+
     pub fn table_bir(&self) -> u32 {
         self.table & 0x7
     }

pci/src/vfio.rs

@@ -14,6 +14,7 @@ use crate::{
 use anyhow::anyhow;
 use byteorder::{ByteOrder, LittleEndian};
 use hypervisor::HypervisorVmError;
+use libc::{sysconf, _SC_PAGESIZE};
 use std::any::Any;
 use std::collections::{BTreeMap, HashMap};
 use std::io;
@@ -27,6 +28,9 @@ use vfio_bindings::bindings::vfio::*;
 use vfio_ioctls::{
     VfioContainer, VfioDevice, VfioIrq, VfioRegionInfoCap, VfioRegionSparseMmapArea,
 };
+use vm_allocator::page_size::{
+    align_page_size_down, align_page_size_up, is_4k_aligned, is_4k_multiple, is_page_size_aligned,
+};
 use vm_allocator::{AddressAllocator, SystemAllocator};
 use vm_device::interrupt::{
     InterruptIndex, InterruptManager, InterruptSourceGroup, MsiIrqGroupConfig,
@@ -498,6 +502,29 @@ impl VfioCommon {
         Ok(vfio_common)
     }
 
+    /// In case msix table offset is not page size aligned, we need do some fixup to achive it.
+    /// Becuse we don't want the MMIO RW region and trap region overlap each other.
+    fn fixup_msix_region(&mut self, bar_id: u32, region_size: u64) -> u64 {
+        let msix = self.interrupt.msix.as_mut().unwrap();
+        let msix_cap = &mut msix.cap;
+
+        // Suppose table_bir equals to pba_bir here. Am I right?
+        let (table_offset, table_size) = msix_cap.table_range();
+        if is_page_size_aligned(table_offset) || msix_cap.table_bir() != bar_id {
+            return region_size;
+        }
+
+        let (pba_offset, pba_size) = msix_cap.pba_range();
+        let msix_sz = align_page_size_up(table_size + pba_size);
+        // Expand region to hold RW and trap region which both page size aligned
+        let size = std::cmp::max(region_size * 2, msix_sz * 2);
+        // let table starts from the middle of the region
+        msix_cap.table_set_offset((size / 2) as u32);
+        msix_cap.pba_set_offset((size / 2 + pba_offset - table_offset) as u32);
+
+        size
+    }
+
     pub(crate) fn allocate_bars(
         &mut self,
         allocator: &Arc<Mutex<SystemAllocator>>,
@@ -661,9 +688,16 @@ impl VfioCommon {
                         .ok_or(PciDeviceError::IoAllocationFailed(region_size))?
                 }
                 PciBarRegionType::Memory64BitRegion => {
-                    // BAR allocation must be naturally aligned
+                    // We need do some fixup to keep MMIO RW region and msix cap region page size
+                    // aligned.
+                    region_size = self.fixup_msix_region(bar_id, region_size);
                     mmio_allocator
-                        .allocate(restored_bar_addr, region_size, Some(region_size))
+                        .allocate(
+                            restored_bar_addr,
+                            region_size,
+                            // SAFETY: FFI call. Trivially safe.
+                            Some(unsafe { sysconf(_SC_PAGESIZE) as GuestUsize }),
+                        )
                         .ok_or(PciDeviceError::IoAllocationFailed(region_size))?
                 }
             };
@@ -800,6 +834,23 @@ impl VfioCommon {
         });
     }
 
+    pub(crate) fn get_msix_cap_idx(&self) -> Option<usize> {
+        let mut cap_next = self
+            .vfio_wrapper
+            .read_config_byte(PCI_CONFIG_CAPABILITY_OFFSET);
+
+        while cap_next != 0 {
+            let cap_id = self.vfio_wrapper.read_config_byte(cap_next.into());
+            if PciCapabilityId::from(cap_id) == PciCapabilityId::MsiX {
+                return Some(cap_next as usize);
+            } else {
+                cap_next = self.vfio_wrapper.read_config_byte((cap_next + 1).into());
+            }
+        }
+
+        None
+    }
+
     pub(crate) fn parse_capabilities(&mut self, bdf: PciBdf) {
         let mut cap_next = self
             .vfio_wrapper
@@ -1154,6 +1205,15 @@ impl VfioCommon {
             return self.configuration.read_reg(reg_idx);
         }
 
+        if let Some(id) = self.get_msix_cap_idx() {
+            let msix = self.interrupt.msix.as_mut().unwrap();
+            if reg_idx * 4 == id + 4 {
+                return msix.cap.table;
+            } else if reg_idx * 4 == id + 8 {
+                return msix.cap.pba;
+            }
+        }
+
         // Since we don't support passing multi-functions devices, we should
         // mask the multi-function bit, bit 7 of the Header Type byte on the
         // register 3.
@@ -1316,18 +1376,6 @@ impl VfioPciDevice {
         self.iommu_attached
     }
 
-    fn align_4k(address: u64) -> u64 {
-        (address + 0xfff) & 0xffff_ffff_ffff_f000
-    }
-
-    fn is_4k_aligned(address: u64) -> bool {
-        (address & 0xfff) == 0
-    }
-
-    fn is_4k_multiple(size: u64) -> bool {
-        (size & 0xfff) == 0
-    }
-
     fn generate_sparse_areas(
         caps: &[VfioRegionInfoCap],
         region_index: u32,
@@ -1339,14 +1387,14 @@ impl VfioPciDevice {
             match cap {
                 VfioRegionInfoCap::SparseMmap(sparse_mmap) => return Ok(sparse_mmap.areas.clone()),
                 VfioRegionInfoCap::MsixMappable => {
-                    if !Self::is_4k_aligned(region_start) {
+                    if !is_4k_aligned(region_start) {
                         error!(
                             "Region start address 0x{:x} must be at least aligned on 4KiB",
                             region_start
                         );
                         return Err(VfioPciError::RegionAlignment);
                     }
-                    if !Self::is_4k_multiple(region_size) {
+                    if !is_4k_multiple(region_size) {
                         error!(
                             "Region size 0x{:x} must be at least a multiple of 4KiB",
                             region_size
@@ -1358,7 +1406,8 @@ impl VfioPciDevice {
                     // the MSI-X PBA table, we must calculate the subregions
                     // around them, leading to a list of sparse areas.
                     // We want to make sure we will still trap MMIO accesses
-                    // to these MSI-X specific ranges.
+                    // to these MSI-X specific ranges. If these region don't align
+                    // with pagesize, we can achive it by enlarging its range.
                     //
                     // Using a BtreeMap as the list provided through the iterator is sorted
                     // by key. This ensures proper split of the whole region.
@@ -1366,10 +1415,14 @@ impl VfioPciDevice {
                     if let Some(msix) = vfio_msix {
                         if region_index == msix.cap.table_bir() {
                             let (offset, size) = msix.cap.table_range();
+                            let offset = align_page_size_down(offset);
+                            let size = align_page_size_up(size);
                             inter_ranges.insert(offset, size);
                         }
                         if region_index == msix.cap.pba_bir() {
                             let (offset, size) = msix.cap.pba_range();
+                            let offset = align_page_size_down(offset);
+                            let size = align_page_size_up(size);
                             inter_ranges.insert(offset, size);
                         }
                     }
@@ -1383,8 +1436,7 @@ impl VfioPciDevice {
                                 size: range_offset - current_offset,
                             });
                         }
-
-                        current_offset = Self::align_4k(range_offset + range_size);
+                        current_offset = align_page_size_down(range_offset + range_size);
                     }
 
                     if region_size > current_offset {
@@ -1482,6 +1534,15 @@ impl VfioPciDevice {
                         return Err(VfioPciError::MmapArea);
                     }
 
+                    if !is_page_size_aligned(area.size) || !is_page_size_aligned(area.offset) {
+                        warn!(
+                            "Could not mmap sparse area that is not page size aligned (offset = 0x{:x}, size = 0x{:x})",
+                            area.offset,
+                            area.size,
+                            );
+                        return Ok(());
+                    }
+
                     let user_memory_region = UserMemoryRegion {
                         slot: (self.memory_slot)(),
                         start: region.start.0 + area.offset,

qcow/src/qcow_raw_file.rs

@@ -66,7 +66,7 @@ impl QcowRawFile {
         non_zero_flags: u64,
     ) -> io::Result<()> {
         self.file.seek(SeekFrom::Start(offset))?;
-        let mut buffer = BufWriter::with_capacity(table.len() * size_of::<u64>(), &mut self.file);
+        let mut buffer = BufWriter::with_capacity(std::mem::size_of_val(table), &mut self.file);
         for addr in table {
             let val = if *addr == 0 {
                 0
@@ -91,7 +91,7 @@ impl QcowRawFile {
     /// Writes a refcount block to the file.
     pub fn write_refcount_block(&mut self, offset: u64, table: &[u16]) -> io::Result<()> {
         self.file.seek(SeekFrom::Start(offset))?;
-        let mut buffer = BufWriter::with_capacity(table.len() * size_of::<u16>(), &mut self.file);
+        let mut buffer = BufWriter::with_capacity(std::mem::size_of_val(table), &mut self.file);
         for count in table {
             buffer.write_u16::<BigEndian>(*count)?;
         }

release-notes.md

@@ -1,3 +1,5 @@
+- [v31.2](#v312)
+- [v31.1](#v311)
 - [v31.0](#v310)
     - [Update to Latest `acpi_tables`](#update-to-latest-acpi_tables)
     - [Update Reference Kernel to 6.2](#update-reference-kernel-to-62)
@@ -276,6 +278,33 @@
     - [Unit testing](#unit-testing)
     - [Integration tests parallelization](#integration-tests-parallelization)
 
+# v31.2
+
+This is a bug fix release. The following issues have been addressed:
+
+* The number of vCPUs is capped at the hypervisor maximum (#5357)
+* Fixes for TTY reset (#5414)
+* CPU topology fixes on MSHV (#5325)
+* Seccomp fixes for older distributions (#5397)
+* Report errors explicitly to users when VM failed to boot (#5453)
+* Fix VFIO on platforms with non-4k page size (#5450, #5469)
+* Fix TDX initialization (#5454)
+* Ensure all guest memory regions are page-size aligned (#5496)
+* Fix seccomp filter lists related to virtio-console, serial and pty
+(#5506, #5524)
+* Populate APIC ID properly (#5512)
+* Ignore and warn TAP FDs in more situations (#5522)
+
+# v31.1
+
+This is a bug fix release. The following issues have been addressed:
+
+* Ignore and warn TAP FDs sent via the HTTP request body (#5350)
+* Properly preserve and close valid FDs for TAP devices (#5373)
+* Only use `KVM_ARM_VCPU_PMU_V3` if available (#5360)
+* Only touch the tty flags if it's being used (#5343)
+* Fix seccomp filter lists for vhost-user devices (#5361)
+
 # v31.0
 
 This release has been tracked in our [roadmap

src/main.rs

@@ -8,7 +8,7 @@ extern crate event_monitor;
 
 use argh::FromArgs;
 use libc::EFD_NONBLOCK;
-use log::LevelFilter;
+use log::{warn, LevelFilter};
 use option_parser::OptionParser;
 use seccompiler::SeccompAction;
 use signal_hook::consts::SIGSYS;
@@ -21,7 +21,6 @@ use thiserror::Error;
 use vmm::config;
 use vmm_sys_util::eventfd::EventFd;
 use vmm_sys_util::signal::block_signal;
-use vmm_sys_util::terminal::Terminal;
 
 #[cfg(feature = "dhat-heap")]
 #[global_allocator]
@@ -34,6 +33,8 @@ enum Error {
     #[cfg(feature = "guest_debug")]
     #[error("Failed to create Debug EventFd: {0}")]
     CreateDebugEventFd(#[source] std::io::Error),
+    #[error("Failed to create exit EventFd: {0}")]
+    CreateExitEventFd(#[source] std::io::Error),
     #[error("Failed to open hypervisor interface (is hypervisor interface available?): {0}")]
     CreateHypervisor(#[source] hypervisor::HypervisorError),
     #[error("Failed to start the VMM thread: {0}")]
@@ -91,9 +92,9 @@ impl log::Log for Logger {
         let duration = now.duration_since(self.start);
 
         if record.file().is_some() && record.line().is_some() {
-            writeln!(
+            write!(
                 *(*(self.output.lock().unwrap())),
-                "cloud-hypervisor: {:.6?}: <{}> {}:{}:{} -- {}",
+                "cloud-hypervisor: {:.6?}: <{}> {}:{}:{} -- {}\r\n",
                 duration,
                 std::thread::current().name().unwrap_or("anonymous"),
                 record.level(),
@@ -102,9 +103,9 @@ impl log::Log for Logger {
                 record.args()
             )
         } else {
-            writeln!(
+            write!(
                 *(*(self.output.lock().unwrap())),
-                "cloud-hypervisor: {:.6?}: <{}> {}:{} -- {}",
+                "cloud-hypervisor: {:.6?}: <{}> {}:{} -- {}\r\n",
                 duration,
                 std::thread::current().name().unwrap_or("anonymous"),
                 record.level(),
@@ -510,6 +511,8 @@ fn start_vmm(toplevel: TopLevel) -> Result<Option<String>, Error> {
     #[cfg(feature = "guest_debug")]
     let vm_debug_evt = EventFd::new(EFD_NONBLOCK).map_err(Error::CreateDebugEventFd)?;
 
+    let exit_evt = EventFd::new(EFD_NONBLOCK).map_err(Error::CreateExitEventFd)?;
+
     let vmm_thread = vmm::start_vmm_thread(
         env!("CARGO_PKG_VERSION").to_string(),
         &api_socket_path,
@@ -523,33 +526,46 @@ fn start_vmm(toplevel: TopLevel) -> Result<Option<String>, Error> {
         debug_evt.try_clone().unwrap(),
         #[cfg(feature = "guest_debug")]
         vm_debug_evt.try_clone().unwrap(),
+        exit_evt.try_clone().unwrap(),
         &seccomp_action,
         hypervisor,
     )
     .map_err(Error::StartVmmThread)?;
 
-    let payload_present = toplevel.kernel.is_some() || toplevel.firmware.is_some();
+    let r: Result<(), Error> = (|| {
+        let payload_present = toplevel.kernel.is_some() || toplevel.firmware.is_some();
 
-    if payload_present {
-        let vm_params = toplevel.to_vm_params();
-        let vm_config = config::VmConfig::parse(vm_params).map_err(Error::ParsingConfig)?;
+        if payload_present {
+            let vm_params = toplevel.to_vm_params();
+            let vm_config = config::VmConfig::parse(vm_params).map_err(Error::ParsingConfig)?;
 
-        // Create and boot the VM based off the VM config we just built.
-        let sender = api_request_sender.clone();
-        vmm::api::vm_create(
-            api_evt.try_clone().unwrap(),
-            api_request_sender,
-            Arc::new(Mutex::new(vm_config)),
-        )
-        .map_err(Error::VmCreate)?;
-        vmm::api::vm_boot(api_evt.try_clone().unwrap(), sender).map_err(Error::VmBoot)?;
-    } else if let Some(restore_params) = toplevel.restore {
-        vmm::api::vm_restore(
-            api_evt.try_clone().unwrap(),
-            api_request_sender,
-            Arc::new(config::RestoreConfig::parse(&restore_params).map_err(Error::ParsingRestore)?),
-        )
-        .map_err(Error::VmRestore)?;
+            // Create and boot the VM based off the VM config we just built.
+            let sender = api_request_sender.clone();
+            vmm::api::vm_create(
+                api_evt.try_clone().unwrap(),
+                api_request_sender,
+                Arc::new(Mutex::new(vm_config)),
+            )
+            .map_err(Error::VmCreate)?;
+            vmm::api::vm_boot(api_evt.try_clone().unwrap(), sender).map_err(Error::VmBoot)?;
+        } else if let Some(restore_params) = toplevel.restore {
+            vmm::api::vm_restore(
+                api_evt.try_clone().unwrap(),
+                api_request_sender,
+                Arc::new(
+                    config::RestoreConfig::parse(&restore_params).map_err(Error::ParsingRestore)?,
+                ),
+            )
+            .map_err(Error::VmRestore)?;
+        }
+
+        Ok(())
+    })();
+
+    if r.is_err() {
+        if let Err(e) = exit_evt.write(1) {
+            warn!("writing to exit EventFd: {e}");
+        }
     }
 
     vmm_thread
@@ -557,7 +573,7 @@ fn start_vmm(toplevel: TopLevel) -> Result<Option<String>, Error> {
         .map_err(Error::ThreadJoin)?
         .map_err(Error::VmmThread)?;
 
-    Ok(api_socket_path)
+    r.map(|_| api_socket_path)
 }
 
 fn main() {
@@ -586,14 +602,6 @@ fn main() {
         }
     };
 
-    // SAFETY: trivially safe
-    let on_tty = unsafe { libc::isatty(libc::STDIN_FILENO) } != 0;
-    if on_tty {
-        // Don't forget to set the terminal in canonical mode
-        // before to exit.
-        std::io::stdin().lock().set_canon_mode().unwrap();
-    }
-
     #[cfg(feature = "dhat-heap")]
     drop(_profiler);
 
@@ -731,6 +739,7 @@ mod unit_tests {
             gdb: false,
             platform: None,
             tpm: None,
+            preserved_fds: None,
         };
 
         assert_eq!(expected_vm_config, result_vm_config);

tests/integration.rs

@@ -2046,19 +2046,16 @@ mod common_parallel {
     }
 
     #[test]
-    #[cfg(not(feature = "mshv"))]
     fn test_cpu_topology_421() {
         test_cpu_topology(4, 2, 1, false);
     }
 
     #[test]
-    #[cfg(not(feature = "mshv"))]
     fn test_cpu_topology_142() {
         test_cpu_topology(1, 4, 2, false);
     }
 
     #[test]
-    #[cfg(not(feature = "mshv"))]
     fn test_cpu_topology_262() {
         test_cpu_topology(2, 6, 2, false);
     }
@@ -6238,6 +6235,18 @@ mod common_parallel {
                     .unwrap_or_default(),
                 2
             );
+
+            guest.reboot_linux(0, None);
+
+            assert_eq!(
+                guest
+                    .ssh_command("ip -o link | wc -l")
+                    .unwrap()
+                    .trim()
+                    .parse::<u32>()
+                    .unwrap_or_default(),
+                2
+            );
         });
 
         let _ = child.kill();

tpm/src/emulator.rs

@@ -309,11 +309,7 @@ impl Emulator {
         }
 
         self.established_flag_cached = true;
-        if est.resp.bit != 0 {
-            self.established_flag = false;
-        } else {
-            self.established_flag = true;
-        }
+        self.established_flag = est.resp.bit == 0;
 
         self.established_flag
     }

vhdx/src/vhdx_metadata.rs

@@ -145,11 +145,7 @@ impl DiskSpec {
                 let bits = f
                     .read_u32::<LittleEndian>()
                     .map_err(VhdxMetadataError::ReadMetadata)?;
-                if bits & BLOCK_HAS_PARENT != 0 {
-                    disk_spec.has_parent = true;
-                } else {
-                    disk_spec.has_parent = false;
-                }
+                disk_spec.has_parent = bits & BLOCK_HAS_PARENT != 0;
 
                 metadata_presence |= METADATA_FILE_PARAMETER_PRESENT;
             } else if metadata_entry.item_id

virtio-devices/src/lib.rs

@@ -39,19 +39,24 @@ pub mod vhost_user;
 pub mod vsock;
 pub mod watchdog;
 
-pub use self::balloon::*;
-pub use self::block::*;
-pub use self::console::*;
-pub use self::device::*;
-pub use self::epoll_helper::*;
-pub use self::iommu::*;
-pub use self::mem::*;
-pub use self::net::*;
-pub use self::pmem::*;
-pub use self::rng::*;
-pub use self::vdpa::*;
-pub use self::vsock::*;
-pub use self::watchdog::*;
+pub use self::balloon::Balloon;
+pub use self::block::{Block, BlockState};
+pub use self::console::{Console, ConsoleResizer, Endpoint};
+pub use self::device::{
+    DmaRemapping, UserspaceMapping, VirtioCommon, VirtioDevice, VirtioInterrupt,
+    VirtioInterruptType, VirtioSharedMemoryList,
+};
+pub use self::epoll_helper::{
+    EpollHelper, EpollHelperError, EpollHelperHandler, EPOLL_HELPER_EVENT_LAST,
+};
+pub use self::iommu::{AccessPlatformMapping, Iommu, IommuMapping};
+pub use self::mem::{BlocksState, Mem, VirtioMemMappingSource, VIRTIO_MEM_ALIGN_SIZE};
+pub use self::net::{Net, NetCtrlEpollHandler};
+pub use self::pmem::Pmem;
+pub use self::rng::Rng;
+pub use self::vdpa::{Vdpa, VdpaDmaMapping};
+pub use self::vsock::Vsock;
+pub use self::watchdog::Watchdog;
 use vm_memory::{bitmap::AtomicBitmap, GuestAddress, GuestMemory};
 use vm_virtio::VirtioDeviceType;
 

virtio-devices/src/seccomp_filters.rs

@@ -151,6 +151,7 @@ fn virtio_rng_thread_rules() -> Vec<(i64, Vec<SeccompRule>)> {
 
 fn virtio_vhost_fs_thread_rules() -> Vec<(i64, Vec<SeccompRule>)> {
     vec![
+        (libc::SYS_clock_nanosleep, vec![]),
         (libc::SYS_connect, vec![]),
         (libc::SYS_nanosleep, vec![]),
         (libc::SYS_pread64, vec![]),
@@ -170,8 +171,11 @@ fn virtio_vhost_net_thread_rules() -> Vec<(i64, Vec<SeccompRule>)> {
     vec![
         (libc::SYS_accept4, vec![]),
         (libc::SYS_bind, vec![]),
+        (libc::SYS_clock_nanosleep, vec![]),
+        (libc::SYS_connect, vec![]),
         (libc::SYS_getcwd, vec![]),
         (libc::SYS_listen, vec![]),
+        (libc::SYS_nanosleep, vec![]),
         (libc::SYS_recvmsg, vec![]),
         (libc::SYS_sendmsg, vec![]),
         (libc::SYS_sendto, vec![]),
@@ -184,7 +188,14 @@ fn virtio_vhost_net_thread_rules() -> Vec<(i64, Vec<SeccompRule>)> {
 }
 
 fn virtio_vhost_block_thread_rules() -> Vec<(i64, Vec<SeccompRule>)> {
-    vec![]
+    vec![
+        (libc::SYS_clock_nanosleep, vec![]),
+        (libc::SYS_connect, vec![]),
+        (libc::SYS_nanosleep, vec![]),
+        (libc::SYS_recvmsg, vec![]),
+        (libc::SYS_sendmsg, vec![]),
+        (libc::SYS_socket, vec![]),
+    ]
 }
 
 fn create_vsock_ioctl_seccomp_rule() -> Vec<SeccompRule> {
@@ -248,6 +259,7 @@ fn virtio_thread_common() -> Vec<(i64, Vec<SeccompRule>)> {
         (libc::SYS_madvise, vec![]),
         (libc::SYS_mmap, vec![]),
         (libc::SYS_mprotect, vec![]),
+        (libc::SYS_mremap, vec![]),
         (libc::SYS_munmap, vec![]),
         (libc::SYS_openat, vec![]),
         (libc::SYS_read, vec![]),

virtio-devices/src/vhost_user/fs.rs

@@ -605,7 +605,7 @@ impl VirtioDevice for Fs {
         &mut self,
         shm_regions: VirtioSharedMemoryList,
     ) -> std::result::Result<(), crate::Error> {
-        if let Some(mut cache) = self.cache.as_mut() {
+        if let Some(cache) = self.cache.as_mut() {
             cache.0 = shm_regions;
             Ok(())
         } else {

vm-allocator/src/lib.rs

@@ -12,6 +12,8 @@
 
 mod address;
 mod gsi;
+/// page size related utility funtions
+pub mod page_size;
 mod system;
 
 pub use crate::address::AddressAllocator;

vm-allocator/src/page_size.rs

@@ -0,0 +1,38 @@
+// Copyright 2023 Arm Limited (or its affiliates). All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use libc::{sysconf, _SC_PAGESIZE};
+
+/// get host page size
+pub fn get_page_size() -> u64 {
+    // SAFETY: FFI call. Trivially safe.
+    unsafe { sysconf(_SC_PAGESIZE) as u64 }
+}
+
+/// round up address to let it align page size
+pub fn align_page_size_up(address: u64) -> u64 {
+    let page_size = get_page_size();
+    (address + page_size - 1) & !(page_size - 1)
+}
+
+/// round down address to let it align page size
+pub fn align_page_size_down(address: u64) -> u64 {
+    let page_size = get_page_size();
+    address & !(page_size - 1)
+}
+
+/// Test if address is 4k aligned
+pub fn is_4k_aligned(address: u64) -> bool {
+    (address & 0xfff) == 0
+}
+
+/// Test if size is 4k aligned
+pub fn is_4k_multiple(size: u64) -> bool {
+    (size & 0xfff) == 0
+}
+
+/// Test if address is page size aligned
+pub fn is_page_size_aligned(address: u64) -> bool {
+    let page_size = get_page_size();
+    address & (page_size - 1) == 0
+}

vm-allocator/src/system.rs

@@ -14,14 +14,7 @@ use crate::gsi::GsiAllocator;
 #[cfg(target_arch = "x86_64")]
 use crate::gsi::GsiApic;
 
-use libc::{sysconf, _SC_PAGESIZE};
-
-/// Safe wrapper for `sysconf(_SC_PAGESIZE)`.
-#[inline(always)]
-fn pagesize() -> usize {
-    // SAFETY: FFI call. Trivially safe.
-    unsafe { sysconf(_SC_PAGESIZE) as usize }
-}
+use crate::page_size::get_page_size;
 
 /// Manages allocating system resources such as address space and interrupt numbers.
 ///
@@ -126,7 +119,7 @@ impl SystemAllocator {
         self.platform_mmio_address_space.allocate(
             address,
             size,
-            Some(align_size.unwrap_or(pagesize() as u64)),
+            Some(align_size.unwrap_or(get_page_size())),
         )
     }
 
@@ -140,7 +133,7 @@ impl SystemAllocator {
         self.mmio_hole_address_space.allocate(
             address,
             size,
-            Some(align_size.unwrap_or(pagesize() as u64)),
+            Some(align_size.unwrap_or(get_page_size())),
         )
     }
 

vm-device/src/bus.rs

@@ -110,8 +110,7 @@ impl Bus {
         let devices = self.devices.read().unwrap();
         let (range, dev) = devices
             .range(..=BusRange { base: addr, len: 1 })
-            .rev()
-            .next()?;
+            .next_back()?;
         dev.upgrade().map(|d| (*range, d.clone()))
     }
 

vm-migration/src/lib.rs

@@ -13,7 +13,7 @@ pub mod protocol;
 
 /// Global VMM version for versioning
 const MAJOR_VERSION: u16 = 31;
-const MINOR_VERSION: u16 = 0;
+const MINOR_VERSION: u16 = 2;
 const VMM_VERSION: u16 = MAJOR_VERSION << 12 | MINOR_VERSION & 0b1111;
 
 pub trait VersionMapped {

vmm/src/api/http_endpoint.rs

@@ -36,13 +36,22 @@ impl EndpointHandler for VmCreate {
                 match &req.body {
                     Some(body) => {
                         // Deserialize into a VmConfig
-                        let vm_config: VmConfig = match serde_json::from_slice(body.raw())
+                        let mut vm_config: VmConfig = match serde_json::from_slice(body.raw())
                             .map_err(HttpError::SerdeJsonDeserialize)
                         {
                             Ok(config) => config,
                             Err(e) => return error_response(e, StatusCode::BadRequest),
                         };
 
+                        if let Some(ref mut nets) = vm_config.net {
+                            if nets.iter().any(|net| net.fds.is_some()) {
+                                warn!("Ignoring FDs sent via the HTTP request body");
+                            }
+                            for net in nets {
+                                net.fds = None;
+                            }
+                        }
+
                         // Call vm_create()
                         match vm_create(api_notifier, api_sender, Arc::new(Mutex::new(vm_config)))
                             .map_err(HttpError::ApiError)
@@ -105,6 +114,10 @@ impl EndpointHandler for VmActionHandler {
                 ),
                 AddNet(_) => {
                     let mut net_cfg: NetConfig = serde_json::from_slice(body.raw())?;
+                    if net_cfg.fds.is_some() {
+                        warn!("Ignoring FDs sent via the HTTP request body");
+                        net_cfg.fds = None;
+                    }
                     // Update network config with optional files that might have
                     // been sent through control message.
                     if !files.is_empty() {

vmm/src/config.rs

@@ -1134,38 +1134,6 @@ impl NetConfig {
     }
 }
 
-impl Clone for NetConfig {
-    fn clone(&self) -> Self {
-        NetConfig {
-            tap: self.tap.clone(),
-            vhost_socket: self.vhost_socket.clone(),
-            id: self.id.clone(),
-            fds: self
-                .fds
-                .as_ref()
-                // SAFETY: We have been handed these FDs through the API
-                .map(|fds| fds.iter().map(|fd| unsafe { libc::dup(*fd) }).collect()),
-            ..*self
-        }
-    }
-}
-
-impl Drop for NetConfig {
-    fn drop(&mut self) {
-        if let Some(mut fds) = self.fds.take() {
-            for fd in fds.drain(..) {
-                // Skip reserved FDs
-                if fd <= 2 {
-                    continue;
-                }
-
-                // SAFETY: Safe as the fd was given to the config by the API
-                unsafe { libc::close(fd) };
-            }
-        }
-    }
-}
-
 impl RngConfig {
     pub fn parse(rng: &str) -> Result<Self> {
         let mut parser = OptionParser::new();
@@ -2125,23 +2093,83 @@ impl VmConfig {
             gdb,
             platform,
             tpm,
+            preserved_fds: None,
         };
         config.validate().map_err(Error::Validation)?;
         Ok(config)
     }
 
+    /// # Safety
+    /// To use this safely, the caller must guarantee that the input
+    /// fds are all valid.
+    pub unsafe fn add_preserved_fds(&mut self, mut fds: Vec<i32>) {
+        if fds.is_empty() {
+            return;
+        }
+
+        if let Some(preserved_fds) = &self.preserved_fds {
+            fds.append(&mut preserved_fds.clone());
+        }
+
+        self.preserved_fds = Some(fds);
+    }
+
     #[cfg(feature = "tdx")]
     pub fn is_tdx_enabled(&self) -> bool {
         self.platform.as_ref().map(|p| p.tdx).unwrap_or(false)
     }
 }
 
+impl Clone for VmConfig {
+    fn clone(&self) -> Self {
+        VmConfig {
+            cpus: self.cpus.clone(),
+            memory: self.memory.clone(),
+            payload: self.payload.clone(),
+            disks: self.disks.clone(),
+            net: self.net.clone(),
+            rng: self.rng.clone(),
+            balloon: self.balloon.clone(),
+            fs: self.fs.clone(),
+            pmem: self.pmem.clone(),
+            serial: self.serial.clone(),
+            console: self.console.clone(),
+            devices: self.devices.clone(),
+            user_devices: self.user_devices.clone(),
+            vdpa: self.vdpa.clone(),
+            vsock: self.vsock.clone(),
+            #[cfg(target_arch = "x86_64")]
+            sgx_epc: self.sgx_epc.clone(),
+            numa: self.numa.clone(),
+            platform: self.platform.clone(),
+            tpm: self.tpm.clone(),
+            preserved_fds: self
+                .preserved_fds
+                .as_ref()
+                // SAFETY: FFI call with valid FDs
+                .map(|fds| fds.iter().map(|fd| unsafe { libc::dup(*fd) }).collect()),
+            ..*self
+        }
+    }
+}
+
+impl Drop for VmConfig {
+    fn drop(&mut self) {
+        if let Some(mut fds) = self.preserved_fds.take() {
+            for fd in fds.drain(..) {
+                // SAFETY: FFI call with valid FDs
+                unsafe { libc::close(fd) };
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use std::{fs::File, os::fd::AsRawFd};
-
     use super::*;
     use net_util::MacAddr;
+    use std::fs::File;
+    use std::os::unix::io::AsRawFd;
 
     #[test]
     fn test_cpu_parsing() -> Result<()> {
@@ -2361,10 +2389,6 @@ mod tests {
             NetConfig {
                 mac: MacAddr::parse_str("de:ad:be:ef:12:34").unwrap(),
                 host_mac: Some(MacAddr::parse_str("12:34:de:ad:be:ef").unwrap()),
-                fds: None,
-                id: None,
-                tap: None,
-                vhost_socket: None,
                 ..Default::default()
             }
         );
@@ -2375,9 +2399,6 @@ mod tests {
                 mac: MacAddr::parse_str("de:ad:be:ef:12:34").unwrap(),
                 host_mac: Some(MacAddr::parse_str("12:34:de:ad:be:ef").unwrap()),
                 id: Some("mynet0".to_owned()),
-                fds: None,
-                tap: None,
-                vhost_socket: None,
                 ..Default::default()
             }
         );
@@ -2392,9 +2413,6 @@ mod tests {
                 tap: Some("tap0".to_owned()),
                 ip: "192.168.100.1".parse().unwrap(),
                 mask: "255.255.255.128".parse().unwrap(),
-                fds: None,
-                id: None,
-                vhost_socket: None,
                 ..Default::default()
             }
         );
@@ -2408,9 +2426,6 @@ mod tests {
                 host_mac: Some(MacAddr::parse_str("12:34:de:ad:be:ef").unwrap()),
                 vhost_user: true,
                 vhost_socket: Some("/tmp/sock".to_owned()),
-                fds: None,
-                id: None,
-                tap: None,
                 ..Default::default()
             }
         );
@@ -2423,31 +2438,18 @@ mod tests {
                 num_queues: 4,
                 queue_size: 1024,
                 iommu: true,
-                fds: None,
-                id: None,
-                tap: None,
-                vhost_socket: None,
                 ..Default::default()
             }
         );
 
-        // SAFETY: Safe as the file was just opened
-        let fd1 = unsafe { libc::dup(File::open("/dev/null").unwrap().as_raw_fd()) };
-        // SAFETY: Safe as the file was just opened
-        let fd2 = unsafe { libc::dup(File::open("/dev/null").unwrap().as_raw_fd()) };
-
         assert_eq!(
-            &format!(
-                "{:?}",
-                NetConfig::parse(&format!(
-                    "mac=de:ad:be:ef:12:34,fd=[{fd1},{fd2}],num_queues=4"
-                ))?
-            ),
-            &format!("NetConfig {{ tap: None, ip: 192.168.249.1, mask: 255.255.255.0, \
-                mac: MacAddr {{ bytes: [222, 173, 190, 239, 18, 52] }}, host_mac: None, mtu: None, \
-                iommu: false, num_queues: 4, queue_size: 256, vhost_user: false, vhost_socket: None, \
-                vhost_mode: Client, id: None, fds: Some([{fd1}, {fd2}]), \
-                rate_limiter_config: None, pci_segment: 0, offload_tso: true, offload_ufo: true, offload_csum: true }}")
+            NetConfig::parse("mac=de:ad:be:ef:12:34,fd=[3,7],num_queues=4")?,
+            NetConfig {
+                mac: MacAddr::parse_str("de:ad:be:ef:12:34").unwrap(),
+                fds: Some(vec![3, 7]),
+                num_queues: 4,
+                ..Default::default()
+            }
         );
 
         Ok(())
@@ -2774,6 +2776,7 @@ mod tests {
             gdb: false,
             platform: None,
             tpm: None,
+            preserved_fds: None,
         };
 
         assert!(valid_config.validate().is_ok());
@@ -2868,10 +2871,6 @@ mod tests {
         let mut invalid_config = valid_config.clone();
         invalid_config.net = Some(vec![NetConfig {
             vhost_user: true,
-            fds: None,
-            id: None,
-            tap: None,
-            vhost_socket: None,
             ..Default::default()
         }]);
         assert_eq!(
@@ -2883,9 +2882,6 @@ mod tests {
         still_valid_config.net = Some(vec![NetConfig {
             vhost_user: true,
             vhost_socket: Some("/path/to/sock".to_owned()),
-            fds: None,
-            id: None,
-            tap: None,
             ..Default::default()
         }]);
         still_valid_config.memory.shared = true;
@@ -2894,9 +2890,6 @@ mod tests {
         let mut invalid_config = valid_config.clone();
         invalid_config.net = Some(vec![NetConfig {
             fds: Some(vec![0]),
-            id: None,
-            tap: None,
-            vhost_socket: None,
             ..Default::default()
         }]);
         assert_eq!(
@@ -2907,10 +2900,6 @@ mod tests {
         let mut invalid_config = valid_config.clone();
         invalid_config.net = Some(vec![NetConfig {
             offload_csum: false,
-            fds: None,
-            id: None,
-            tap: None,
-            vhost_socket: None,
             ..Default::default()
         }]);
         assert_eq!(
@@ -3014,10 +3003,6 @@ mod tests {
         still_valid_config.net = Some(vec![NetConfig {
             iommu: true,
             pci_segment: 1,
-            fds: None,
-            id: None,
-            tap: None,
-            vhost_socket: None,
             ..Default::default()
         }]);
         assert!(still_valid_config.validate().is_ok());
@@ -3086,10 +3071,6 @@ mod tests {
         invalid_config.net = Some(vec![NetConfig {
             iommu: false,
             pci_segment: 1,
-            fds: None,
-            id: None,
-            tap: None,
-            vhost_socket: None,
             ..Default::default()
         }]);
         assert_eq!(
@@ -3205,7 +3186,7 @@ mod tests {
         ]);
         assert!(still_valid_config.validate().is_ok());
 
-        let mut invalid_config = valid_config;
+        let mut invalid_config = valid_config.clone();
         invalid_config.devices = Some(vec![
             DeviceConfig {
                 path: "/device1".into(),
@@ -3217,5 +3198,16 @@ mod tests {
             },
         ]);
         assert!(invalid_config.validate().is_err());
+
+        let mut still_valid_config = valid_config;
+        // SAFETY: Safe as the file was just opened
+        let fd1 = unsafe { libc::dup(File::open("/dev/null").unwrap().as_raw_fd()) };
+        // SAFETY: Safe as the file was just opened
+        let fd2 = unsafe { libc::dup(File::open("/dev/null").unwrap().as_raw_fd()) };
+        // SAFETY: safe as both FDs are valid
+        unsafe {
+            still_valid_config.add_preserved_fds(vec![fd1, fd2]);
+        }
+        let _still_valid_config = still_valid_config.clone();
     }
 }

vmm/src/cpu.rs

@@ -52,6 +52,8 @@ use hypervisor::arch::x86::MsrEntry;
 use hypervisor::arch::x86::{SpecialRegisters, StandardRegisters};
 #[cfg(target_arch = "aarch64")]
 use hypervisor::kvm::kvm_bindings;
+#[cfg(all(target_arch = "aarch64", feature = "kvm"))]
+use hypervisor::kvm::kvm_ioctls::Cap;
 #[cfg(feature = "tdx")]
 use hypervisor::kvm::{TdxExitDetails, TdxExitStatus};
 use hypervisor::{CpuState, HypervisorCpuError, HypervisorType, VmExit, VmOps};
@@ -165,6 +167,9 @@ pub enum Error {
     #[cfg(target_arch = "x86_64")]
     #[error("Error setting up AMX: {0}")]
     AmxEnable(#[source] anyhow::Error),
+
+    #[error("Maximum number of vCPUs exceeds host limit")]
+    MaximumVcpusExceeded,
 }
 pub type Result<T> = result::Result<T, Error>;
 
@@ -370,7 +375,14 @@ impl Vcpu {
             .map_err(Error::VcpuArmPreferredTarget)?;
         // We already checked that the capability is supported.
         kvi.features[0] |= 1 << kvm_bindings::KVM_ARM_VCPU_PSCI_0_2;
-        kvi.features[0] |= 1 << kvm_bindings::KVM_ARM_VCPU_PMU_V3;
+        if vm
+            .as_any()
+            .downcast_ref::<hypervisor::kvm::KvmVm>()
+            .unwrap()
+            .check_extension(Cap::ArmPmuV3)
+        {
+            kvi.features[0] |= 1 << kvm_bindings::KVM_ARM_VCPU_PMU_V3;
+        }
         // Non-boot cpus are powered off initially.
         if self.id > 0 {
             kvi.features[0] |= 1 << kvm_bindings::KVM_ARM_VCPU_POWER_OFF;
@@ -580,6 +592,10 @@ impl CpuManager {
         #[cfg(feature = "tdx")] tdx_enabled: bool,
         numa_nodes: &NumaNodes,
     ) -> Result<Arc<Mutex<CpuManager>>> {
+        if u32::from(config.max_vcpus) > hypervisor.get_max_vcpus() {
+            return Err(Error::MaximumVcpusExceeded);
+        }
+
         let mut vcpu_states = Vec::with_capacity(usize::from(config.max_vcpus));
         vcpu_states.resize_with(usize::from(config.max_vcpus), VcpuState::default);
         let hypervisor_type = hypervisor.hypervisor_type();
@@ -680,14 +696,23 @@ impl CpuManager {
             .sgx_epc_region()
             .as_ref()
             .map(|sgx_epc_region| sgx_epc_region.epc_sections().values().cloned().collect());
+
+        let topology = self.config.topology.clone().map_or_else(
+            || {
+                #[cfg(feature = "mshv")]
+                if matches!(hypervisor.hypervisor_type(), HypervisorType::Mshv) {
+                    return Some((1, self.boot_vcpus(), 1));
+                }
+                None
+            },
+            |t| Some((t.threads_per_core, t.cores_per_die, t.dies_per_package)),
+        );
+
         self.cpuid = {
             let phys_bits = physical_bits(self.config.max_phys_bits);
             arch::generate_common_cpuid(
                 hypervisor,
-                self.config
-                    .topology
-                    .clone()
-                    .map(|t| (t.threads_per_core, t.cores_per_die, t.dies_per_package)),
+                topology,
                 sgx_epc_sections,
                 phys_bits,
                 self.config.kvm_hyperv,
@@ -1099,7 +1124,7 @@ impl CpuManager {
 
     fn remove_vcpu(&mut self, cpu_id: u8) -> Result<()> {
         info!("Removing vCPU: cpu_id = {}", cpu_id);
-        let mut state = &mut self.vcpu_states[usize::from(cpu_id)];
+        let state = &mut self.vcpu_states[usize::from(cpu_id)];
         state.kill.store(true, Ordering::SeqCst);
         state.signal_thread();
         state.join_thread()?;

vmm/src/device_manager.rs

@@ -831,6 +831,9 @@ pub struct DeviceManager {
     // pty foreground status,
     console_resize_pipe: Option<Arc<File>>,
 
+    // To restore on exit.
+    original_termios_opt: Arc<Mutex<Option<termios>>>,
+
     // Interrupt controller
     #[cfg(target_arch = "x86_64")]
     interrupt_controller: Option<Arc<Mutex<ioapic::Ioapic>>>,
@@ -1115,6 +1118,7 @@ impl DeviceManager {
             serial_manager: None,
             console_pty: None,
             console_resize_pipe: None,
+            original_termios_opt: Arc::new(Mutex::new(None)),
             virtio_mem_devices: Vec::new(),
             #[cfg(target_arch = "aarch64")]
             gpio_device: None,
@@ -1162,6 +1166,7 @@ impl DeviceManager {
         serial_pty: Option<PtyPair>,
         console_pty: Option<PtyPair>,
         console_resize_pipe: Option<File>,
+        original_termios_opt: Arc<Mutex<Option<termios>>>,
     ) -> DeviceManagerResult<()> {
         trace_scoped!("create_devices");
 
@@ -1217,6 +1222,8 @@ impl DeviceManager {
             )?;
         }
 
+        self.original_termios_opt = original_termios_opt;
+
         self.console = self.add_console_device(
             &legacy_interrupt_manager,
             &mut virtio_devices,
@@ -1836,7 +1843,7 @@ impl DeviceManager {
     }
 
     fn modify_mode<F: FnOnce(&mut termios)>(
-        &self,
+        &mut self,
         fd: RawFd,
         f: F,
     ) -> vmm_sys_util::errno::Result<()> {
@@ -1853,6 +1860,10 @@ impl DeviceManager {
         if ret < 0 {
             return vmm_sys_util::errno::errno_result();
         }
+        let mut original_termios_opt = self.original_termios_opt.lock().unwrap();
+        if original_termios_opt.is_none() {
+            *original_termios_opt = Some(termios);
+        }
         f(&mut termios);
         // SAFETY: Safe because the syscall will only read the extent of termios and we check
         // the return result.
@@ -1864,7 +1875,7 @@ impl DeviceManager {
         Ok(())
     }
 
-    fn set_raw_mode(&self, f: &mut File) -> vmm_sys_util::errno::Result<()> {
+    fn set_raw_mode(&mut self, f: &mut dyn AsRawFd) -> vmm_sys_util::errno::Result<()> {
         // SAFETY: FFI call. Variable t is guaranteed to be a valid termios from modify_mode.
         self.modify_mode(f.as_raw_fd(), |t| unsafe { cfmakeraw(t) })
     }
@@ -1926,7 +1937,10 @@ impl DeviceManager {
                     return vmm_sys_util::errno::errno_result().map_err(DeviceManagerError::DupFd);
                 }
                 // SAFETY: stdout is valid and owned solely by us.
-                let stdout = unsafe { File::from_raw_fd(stdout) };
+                let mut stdout = unsafe { File::from_raw_fd(stdout) };
+
+                // Make sure stdout is in raw mode, if it's a terminal.
+                let _ = self.set_raw_mode(&mut stdout);
 
                 // SAFETY: FFI call. Trivially safe.
                 if unsafe { libc::isatty(libc::STDOUT_FILENO) } == 1 {
@@ -2025,7 +2039,11 @@ impl DeviceManager {
                 }
                 None
             }
-            ConsoleOutputMode::Tty => Some(Box::new(stdout())),
+            ConsoleOutputMode::Tty => {
+                let mut out = stdout();
+                let _ = self.set_raw_mode(&mut out);
+                Some(Box::new(out))
+            }
             ConsoleOutputMode::Off | ConsoleOutputMode::Null => None,
         };
         if serial_config.mode != ConsoleOutputMode::Off {
@@ -2388,26 +2406,31 @@ impl DeviceManager {
                     .map_err(DeviceManagerError::CreateVirtioNet)?,
                 ))
             } else if let Some(fds) = &net_cfg.fds {
-                Arc::new(Mutex::new(
-                    virtio_devices::Net::from_tap_fds(
-                        id.clone(),
-                        fds,
-                        Some(net_cfg.mac),
-                        net_cfg.mtu,
-                        self.force_iommu | net_cfg.iommu,
-                        net_cfg.queue_size,
-                        self.seccomp_action.clone(),
-                        net_cfg.rate_limiter_config,
-                        self.exit_evt
-                            .try_clone()
-                            .map_err(DeviceManagerError::EventFd)?,
-                        state,
-                        net_cfg.offload_tso,
-                        net_cfg.offload_ufo,
-                        net_cfg.offload_csum,
-                    )
-                    .map_err(DeviceManagerError::CreateVirtioNet)?,
-                ))
+                let net = virtio_devices::Net::from_tap_fds(
+                    id.clone(),
+                    fds,
+                    Some(net_cfg.mac),
+                    net_cfg.mtu,
+                    self.force_iommu | net_cfg.iommu,
+                    net_cfg.queue_size,
+                    self.seccomp_action.clone(),
+                    net_cfg.rate_limiter_config,
+                    self.exit_evt
+                        .try_clone()
+                        .map_err(DeviceManagerError::EventFd)?,
+                    state,
+                    net_cfg.offload_tso,
+                    net_cfg.offload_ufo,
+                    net_cfg.offload_csum,
+                )
+                .map_err(DeviceManagerError::CreateVirtioNet)?;
+
+                // SAFETY: 'fds' are valid because TAP devices are created successfully
+                unsafe {
+                    self.config.lock().unwrap().add_preserved_fds(fds.clone());
+                }
+
+                Arc::new(Mutex::new(net))
             } else {
                 Arc::new(Mutex::new(
                     virtio_devices::Net::new(
@@ -4631,5 +4654,10 @@ impl Drop for DeviceManager {
         for handle in self.virtio_devices.drain(..) {
             handle.virtio_device.lock().unwrap().shutdown();
         }
+
+        if let Some(termios) = *self.original_termios_opt.lock().unwrap() {
+            // SAFETY: FFI call
+            let _ = unsafe { tcsetattr(stdout().lock().as_raw_fd(), TCSANOW, &termios) };
+        }
     }
 }

vmm/src/lib.rs

@@ -25,7 +25,7 @@ use crate::migration::{recv_vm_config, recv_vm_state};
 use crate::seccomp_filters::{get_seccomp_filter, Thread};
 use crate::vm::{Error as VmError, Vm, VmState};
 use anyhow::anyhow;
-use libc::{EFD_NONBLOCK, SIGINT, SIGTERM};
+use libc::{tcsetattr, termios, EFD_NONBLOCK, SIGINT, SIGTERM, TCSANOW};
 use memory_manager::MemoryManagerSnapshotData;
 use pci::PciBdf;
 use seccompiler::{apply_filter, SeccompAction};
@@ -35,7 +35,7 @@ use signal_hook::iterator::{Handle, Signals};
 use std::collections::HashMap;
 use std::fs::File;
 use std::io;
-use std::io::{Read, Write};
+use std::io::{stdout, Read, Write};
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 use std::os::unix::net::UnixListener;
 use std::os::unix::net::UnixStream;
@@ -53,7 +53,6 @@ use vm_migration::{MigratableError, Pausable, Snapshot, Snapshottable, Transport
 use vmm_sys_util::eventfd::EventFd;
 use vmm_sys_util::signal::unblock_signal;
 use vmm_sys_util::sock_ctrl_msg::ScmSocket;
-use vmm_sys_util::terminal::Terminal;
 
 mod acpi;
 pub mod api;
@@ -290,6 +289,7 @@ pub fn start_vmm_thread(
     #[cfg(feature = "guest_debug")] debug_path: Option<PathBuf>,
     #[cfg(feature = "guest_debug")] debug_event: EventFd,
     #[cfg(feature = "guest_debug")] vm_debug_event: EventFd,
+    exit_event: EventFd,
     seccomp_action: &SeccompAction,
     hypervisor: Arc<dyn hypervisor::Hypervisor>,
 ) -> Result<thread::JoinHandle<Result<()>>> {
@@ -310,9 +310,8 @@ pub fn start_vmm_thread(
         .map_err(Error::CreateSeccompFilter)?;
 
     let vmm_seccomp_action = seccomp_action.clone();
-    let exit_evt = EventFd::new(EFD_NONBLOCK).map_err(Error::EventFdCreate)?;
     let thread = {
-        let exit_evt = exit_evt.try_clone().map_err(Error::EventFdClone)?;
+        let exit_event = exit_event.try_clone().map_err(Error::EventFdClone)?;
         thread::Builder::new()
             .name("vmm".to_string())
             .spawn(move || {
@@ -330,7 +329,7 @@ pub fn start_vmm_thread(
                     vm_debug_event,
                     vmm_seccomp_action,
                     hypervisor,
-                    exit_evt,
+                    exit_event,
                 )?;
 
                 vmm.setup_signal_handler()?;
@@ -351,7 +350,7 @@ pub fn start_vmm_thread(
             http_api_event,
             api_sender,
             seccomp_action,
-            exit_evt,
+            exit_event,
             hypervisor_type,
         )?;
     } else if let Some(http_fd) = http_fd {
@@ -360,7 +359,7 @@ pub fn start_vmm_thread(
             http_api_event,
             api_sender,
             seccomp_action,
-            exit_evt,
+            exit_event,
             hypervisor_type,
         )?;
     }
@@ -407,12 +406,17 @@ pub struct Vmm {
     activate_evt: EventFd,
     signals: Option<Handle>,
     threads: Vec<thread::JoinHandle<()>>,
+    original_termios_opt: Arc<Mutex<Option<termios>>>,
 }
 
 impl Vmm {
     pub const HANDLED_SIGNALS: [i32; 2] = [SIGTERM, SIGINT];
 
-    fn signal_handler(mut signals: Signals, on_tty: bool, exit_evt: &EventFd) {
+    fn signal_handler(
+        mut signals: Signals,
+        original_termios_opt: Arc<Mutex<Option<termios>>>,
+        exit_evt: &EventFd,
+    ) {
         for sig in &Self::HANDLED_SIGNALS {
             unblock_signal(*sig).unwrap();
         }
@@ -422,12 +426,17 @@ impl Vmm {
                 SIGTERM | SIGINT => {
                     if exit_evt.write(1).is_err() {
                         // Resetting the terminal is usually done as the VMM exits
-                        if on_tty {
-                            io::stdin()
-                                .lock()
-                                .set_canon_mode()
-                                .expect("failed to restore terminal mode");
+                        if let Ok(lock) = original_termios_opt.lock() {
+                            if let Some(termios) = *lock {
+                                // SAFETY: FFI call
+                                let _ = unsafe {
+                                    tcsetattr(stdout().lock().as_raw_fd(), TCSANOW, &termios)
+                                };
+                            }
+                        } else {
+                            warn!("Failed to lock original termios");
                         }
+
                         std::process::exit(1);
                     }
                 }
@@ -442,8 +451,7 @@ impl Vmm {
             Ok(signals) => {
                 self.signals = Some(signals.handle());
                 let exit_evt = self.exit_evt.try_clone().map_err(Error::EventFdClone)?;
-                // SAFETY: trivially safe
-                let on_tty = unsafe { libc::isatty(libc::STDIN_FILENO) } != 0;
+                let original_termios_opt = Arc::clone(&self.original_termios_opt);
 
                 let signal_handler_seccomp_filter = get_seccomp_filter(
                     &self.seccomp_action,
@@ -465,7 +473,7 @@ impl Vmm {
                                 }
                             }
                             std::panic::catch_unwind(AssertUnwindSafe(|| {
-                                Vmm::signal_handler(signals, on_tty, &exit_evt);
+                                Vmm::signal_handler(signals, original_termios_opt, &exit_evt);
                             }))
                             .map_err(|_| {
                                 error!("vmm signal_handler thread panicked");
@@ -532,6 +540,7 @@ impl Vmm {
             activate_evt,
             signals: None,
             threads: vec![],
+            original_termios_opt: Arc::new(Mutex::new(None)),
         })
     }
 
@@ -582,6 +591,7 @@ impl Vmm {
                         None,
                         None,
                         None,
+                        Arc::clone(&self.original_termios_opt),
                         None,
                         None,
                         None,
@@ -680,6 +690,7 @@ impl Vmm {
             None,
             None,
             None,
+            Arc::clone(&self.original_termios_opt),
             Some(snapshot),
             Some(source_url),
             Some(restore_cfg.prefault),
@@ -760,6 +771,7 @@ impl Vmm {
             serial_pty,
             console_pty,
             console_resize_pipe,
+            Arc::clone(&self.original_termios_opt),
             None,
             None,
             None,
@@ -1262,6 +1274,7 @@ impl Vmm {
             None,
             None,
             None,
+            Arc::clone(&self.original_termios_opt),
             Some(snapshot),
         )
         .map_err(|e| {
@@ -2130,6 +2143,7 @@ mod unit_tests {
             gdb: false,
             platform: None,
             tpm: None,
+            preserved_fds: None,
         }))
     }
 

vmm/src/memory_manager.rs

@@ -31,7 +31,7 @@ use std::convert::TryInto;
 use std::ffi;
 use std::fs::{File, OpenOptions};
 use std::io::{self, Read};
-use std::ops::Deref;
+use std::ops::{BitAnd, Deref, Not, Sub};
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 use std::path::PathBuf;
 use std::result;
@@ -330,6 +330,12 @@ pub enum Error {
 
     /// Using a directory as a backing file for memory is not supported
     DirectoryAsBackingFileForMemory,
+
+    /// Failed to stat filesystem
+    GetFileSystemBlockSize(io::Error),
+
+    /// Memory size is misaligned with default page size or its hugepage size
+    MisalignedMemorySize,
 }
 
 const ENABLE_FLAG: usize = 0;
@@ -353,6 +359,77 @@ fn mmio_address_space_size(phys_bits: u8) -> u64 {
     (1 << phys_bits) - (1 << 16)
 }
 
+// The `statfs` function can get information of hugetlbfs, and the hugepage size is in the
+// `f_bsize` field.
+//
+// See: https://github.com/torvalds/linux/blob/v6.3/fs/hugetlbfs/inode.c#L1169
+fn statfs_get_bsize(path: &str) -> Result<u64, Error> {
+    let path = std::ffi::CString::new(path).map_err(|_| Error::InvalidMemoryParameters)?;
+    let mut buf = std::mem::MaybeUninit::<libc::statfs>::uninit();
+
+    // SAFETY: FFI call with a valid path and buffer
+    let ret = unsafe { libc::statfs(path.as_ptr(), buf.as_mut_ptr()) };
+    if ret != 0 {
+        return Err(Error::GetFileSystemBlockSize(
+            std::io::Error::last_os_error(),
+        ));
+    }
+
+    // SAFETY: `buf` is valid at this point
+    // Because this value is always positive, just convert it directly.
+    // Note that the `f_bsize` is `i64` in glibc and `u64` in musl, using `as u64` will be warned
+    // by `clippy` on musl target.  To avoid the warning, there should be `as _` instead of
+    // `as u64`.
+    let bsize = unsafe { (*buf.as_ptr()).f_bsize } as _;
+    Ok(bsize)
+}
+
+fn memory_zone_get_align_size(zone: &MemoryZoneConfig) -> Result<u64, Error> {
+    // SAFETY: FFI call. Trivially safe.
+    let page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) as u64 };
+
+    // There is no backend file and the `hugepages` is disabled, just use system page size.
+    if zone.file.is_none() && !zone.hugepages {
+        return Ok(page_size);
+    }
+
+    // The `hugepages` is enabled and the `hugepage_size` is specified, just use it directly.
+    if zone.hugepages && zone.hugepage_size.is_some() {
+        return Ok(zone.hugepage_size.unwrap());
+    }
+
+    // There are two scenarios here:
+    //  - `hugepages` is enabled but `hugepage_size` is not specified:
+    //     Call `statfs` for `/dev/hugepages` for getting the default size of hugepage
+    //  - The backing file is specified:
+    //     Call `statfs` for the file and get its `f_bsize`.  If the value is larger than the page
+    //     size of normal page, just use the `f_bsize` because the file is in a hugetlbfs.  If the
+    //     value is less than or equal to the page size, just use the page size.
+    let path = zone.file.as_ref().map_or(Ok("/dev/hugepages"), |pathbuf| {
+        pathbuf.to_str().ok_or(Error::InvalidMemoryParameters)
+    })?;
+
+    let align_size = std::cmp::max(page_size, statfs_get_bsize(path)?);
+
+    Ok(align_size)
+}
+
+#[inline]
+fn align_down<T>(val: T, align: T) -> T
+where
+    T: BitAnd<Output = T> + Not<Output = T> + Sub<Output = T> + From<u8>,
+{
+    val & !(align - 1u8.into())
+}
+
+#[inline]
+fn is_aligned<T>(val: T, align: T) -> bool
+where
+    T: BitAnd<Output = T> + Sub<Output = T> + From<u8> + PartialEq,
+{
+    (val & (align - 1u8.into())) == 0u8.into()
+}
+
 impl BusDevice for MemoryManager {
     fn read(&mut self, _base: u64, offset: u64, data: &mut [u8]) {
         if self.selected_slot < self.hotplug_slots.len() {
@@ -442,6 +519,9 @@ impl MemoryManager {
     /// - First one mapping entirely the first memory zone on 0-1G range
     /// - Second one mapping partially the second memory zone on 1G-3G range
     /// - Third one mapping partially the second memory zone on 4G-6G range
+    /// Also, all memory regions are page-size aligned (e.g. their sizes must
+    /// be multiple of page-size), which may leave an additional hole in the
+    /// address space when hugepage is used.
     fn create_memory_regions_from_zones(
         ram_regions: &[(GuestAddress, usize)],
         zones: &[MemoryZoneConfig],
@@ -451,9 +531,14 @@ impl MemoryManager {
         let mut zones = zones.to_owned();
         let mut mem_regions = Vec::new();
         let mut zone = zones.remove(0);
-        let mut zone_offset = 0;
+        let mut zone_align_size = memory_zone_get_align_size(&zone)?;
+        let mut zone_offset = 0u64;
         let mut memory_zones = HashMap::new();
 
+        if !is_aligned(zone.size, zone_align_size) {
+            return Err(Error::MisalignedMemorySize);
+        }
+
         // Add zone id to the list of memory zones.
         memory_zones.insert(zone.id.clone(), MemoryZone::default());
 
@@ -465,16 +550,20 @@ impl MemoryManager {
                 let mut ram_region_consumed = false;
                 let mut pull_next_zone = false;
 
-                let ram_region_sub_size = ram_region.1 - ram_region_offset;
-                let zone_sub_size = zone.size as usize - zone_offset;
+                let ram_region_available_size =
+                    align_down(ram_region.1 as u64 - ram_region_offset, zone_align_size);
+                if ram_region_available_size == 0 {
+                    break;
+                }
+                let zone_sub_size = zone.size - zone_offset;
 
-                let file_offset = zone_offset as u64;
+                let file_offset = zone_offset;
                 let region_start = ram_region
                     .0
-                    .checked_add(ram_region_offset as u64)
+                    .checked_add(ram_region_offset)
                     .ok_or(Error::GuestAddressOverFlow)?;
-                let region_size = if zone_sub_size <= ram_region_sub_size {
-                    if zone_sub_size == ram_region_sub_size {
+                let region_size = if zone_sub_size <= ram_region_available_size {
+                    if zone_sub_size == ram_region_available_size {
                         ram_region_consumed = true;
                     }
 
@@ -483,21 +572,24 @@ impl MemoryManager {
 
                     zone_sub_size
                 } else {
-                    zone_offset += ram_region_sub_size;
+                    zone_offset += ram_region_available_size;
                     ram_region_consumed = true;
 
-                    ram_region_sub_size
+                    ram_region_available_size
                 };
 
+                info!(
+                    "create ram region for zone {}, region_start: {:#x}, region_size: {:#x}",
+                    zone.id,
+                    region_start.raw_value(),
+                    region_size
+                );
                 let region = MemoryManager::create_ram_region(
                     &zone.file,
                     file_offset,
                     region_start,
-                    region_size,
-                    match prefault {
-                        Some(pf) => pf,
-                        None => zone.prefault,
-                    },
+                    region_size as usize,
+                    prefault.unwrap_or(zone.prefault),
                     zone.shared,
                     zone.hugepages,
                     zone.hugepage_size,
@@ -522,6 +614,10 @@ impl MemoryManager {
                         break;
                     }
                     zone = zones.remove(0);
+                    zone_align_size = memory_zone_get_align_size(&zone)?;
+                    if !is_aligned(zone.size, zone_align_size) {
+                        return Err(Error::MisalignedMemorySize);
+                    }
 
                     // Check if zone id already exist. In case it does, throw
                     // an error as we need unique identifiers. Otherwise, add
@@ -573,10 +669,7 @@ impl MemoryManager {
                         guest_ram_mapping.file_offset,
                         GuestAddress(guest_ram_mapping.gpa),
                         guest_ram_mapping.size as usize,
-                        match prefault {
-                            Some(pf) => pf,
-                            None => zone_config.prefault,
-                        },
+                        prefault.unwrap_or(zone_config.prefault),
                         zone_config.shared,
                         zone_config.hugepages,
                         zone_config.hugepage_size,
@@ -939,7 +1032,7 @@ impl MemoryManager {
             )
         } else {
             // Init guest memory
-            let arch_mem_regions = arch::arch_memory_regions(ram_size);
+            let arch_mem_regions = arch::arch_memory_regions();
 
             let ram_regions: Vec<(GuestAddress, usize)> = arch_mem_regions
                 .iter()
@@ -997,10 +1090,7 @@ impl MemoryManager {
                                 0,
                                 start_addr,
                                 hotplug_size as usize,
-                                match prefault {
-                                    Some(pf) => pf,
-                                    None => zone.prefault,
-                                },
+                                prefault.unwrap_or(zone.prefault),
                                 zone.shared,
                                 zone.hugepages,
                                 zone.hugepage_size,
@@ -1501,7 +1591,7 @@ impl MemoryManager {
             .ok_or(Error::MemoryRangeAllocation)?;
 
         // Update the slot so that it can be queried via the I/O port
-        let mut slot = &mut self.hotplug_slots[self.next_hotplug_slot];
+        let slot = &mut self.hotplug_slots[self.next_hotplug_slot];
         slot.active = true;
         slot.inserting = true;
         slot.base = region.start_addr().0;

vmm/src/seccomp_filters.rs

@@ -168,6 +168,7 @@ mod mshv {
     pub const MSHV_GET_GPA_ACCESS_STATES: u64 = 0xc01c_b812;
     pub const MSHV_VP_TRANSLATE_GVA: u64 = 0xc020_b80e;
     pub const MSHV_CREATE_PARTITION: u64 = 0x4030_b801;
+    pub const MSHV_VP_REGISTER_INTERCEPT_RESULT: u64 = 0x4030_b817;
 }
 #[cfg(feature = "mshv")]
 use mshv::*;
@@ -197,6 +198,12 @@ fn create_vmm_ioctl_seccomp_rule_common_mshv() -> Result<Vec<SeccompRule>, Backe
         and![Cond::new(1, ArgLen::Dword, Eq, MSHV_GET_GPA_ACCESS_STATES)?],
         and![Cond::new(1, ArgLen::Dword, Eq, MSHV_VP_TRANSLATE_GVA)?],
         and![Cond::new(1, ArgLen::Dword, Eq, MSHV_CREATE_PARTITION)?],
+        and![Cond::new(
+            1,
+            ArgLen::Dword,
+            Eq,
+            MSHV_VP_REGISTER_INTERCEPT_RESULT
+        )?],
     ])
 }
 
@@ -477,6 +484,7 @@ fn pty_foreground_thread_rules() -> Result<Vec<(i64, Vec<SeccompRule>)>, Backend
         #[cfg(target_arch = "aarch64")]
         (libc::SYS_ppoll, vec![]),
         (libc::SYS_read, vec![]),
+        (libc::SYS_restart_syscall, vec![]),
         (libc::SYS_rt_sigaction, vec![]),
         (libc::SYS_rt_sigreturn, vec![]),
         (libc::SYS_setsid, vec![]),
@@ -523,6 +531,7 @@ fn vmm_thread_rules(
         #[cfg(target_arch = "aarch64")]
         (libc::SYS_newfstatat, vec![]),
         (libc::SYS_futex, vec![]),
+        (libc::SYS_getdents64, vec![]),
         (libc::SYS_getpgid, vec![]),
         #[cfg(target_arch = "x86_64")]
         (libc::SYS_getpgrp, vec![]),
@@ -601,6 +610,7 @@ fn vmm_thread_rules(
         (libc::SYS_socketpair, vec![]),
         #[cfg(target_arch = "x86_64")]
         (libc::SYS_stat, vec![]),
+        (libc::SYS_statfs, vec![]),
         (libc::SYS_statx, vec![]),
         (libc::SYS_tgkill, vec![]),
         (libc::SYS_timerfd_create, vec![]),
@@ -707,6 +717,7 @@ fn vcpu_thread_rules(
         (libc::SYS_madvise, vec![]),
         (libc::SYS_mmap, vec![]),
         (libc::SYS_mprotect, vec![]),
+        (libc::SYS_mremap, vec![]),
         (libc::SYS_munmap, vec![]),
         (libc::SYS_nanosleep, vec![]),
         (libc::SYS_newfstatat, vec![]),

vmm/src/vm.rs

@@ -55,7 +55,7 @@ use gdbstub_arch::aarch64::reg::AArch64CoreRegs as CoreRegs;
 #[cfg(all(target_arch = "x86_64", feature = "guest_debug"))]
 use gdbstub_arch::x86::reg::X86_64CoreRegs as CoreRegs;
 use hypervisor::{HypervisorVmError, VmOps};
-use libc::SIGWINCH;
+use libc::{termios, SIGWINCH};
 use linux_loader::cmdline::Cmdline;
 #[cfg(all(target_arch = "x86_64", feature = "guest_debug"))]
 use linux_loader::elf;
@@ -95,7 +95,6 @@ use vm_migration::{
 };
 use vmm_sys_util::eventfd::EventFd;
 use vmm_sys_util::sock_ctrl_msg::ScmSocket;
-use vmm_sys_util::terminal::Terminal;
 
 /// Errors associated with VM management
 #[derive(Debug, Error)]
@@ -138,12 +137,6 @@ pub enum Error {
     #[error("Error from device manager: {0:?}")]
     DeviceManager(DeviceManagerError),
 
-    #[error("Cannot setup terminal in raw mode: {0}")]
-    SetTerminalRaw(#[source] vmm_sys_util::errno::Error),
-
-    #[error("Cannot setup terminal in canonical mode.: {0}")]
-    SetTerminalCanon(#[source] vmm_sys_util::errno::Error),
-
     #[error("Cannot spawn a signal handler thread: {0}")]
     SignalHandlerSpawn(#[source] io::Error),
 
@@ -321,10 +314,10 @@ impl VmState {
     fn valid_transition(self, new_state: VmState) -> Result<()> {
         match self {
             VmState::Created => match new_state {
-                VmState::Created | VmState::Shutdown => {
-                    Err(Error::InvalidStateTransition(self, new_state))
+                VmState::Created => Err(Error::InvalidStateTransition(self, new_state)),
+                VmState::Running | VmState::Paused | VmState::BreakPoint | VmState::Shutdown => {
+                    Ok(())
                 }
-                VmState::Running | VmState::Paused | VmState::BreakPoint => Ok(()),
             },
 
             VmState::Running => match new_state {
@@ -437,7 +430,6 @@ pub struct Vm {
     threads: Vec<thread::JoinHandle<()>>,
     device_manager: Arc<Mutex<DeviceManager>>,
     config: Arc<Mutex<VmConfig>>,
-    on_tty: bool,
     state: RwLock<VmState>,
     cpu_manager: Arc<Mutex<cpu::CpuManager>>,
     memory_manager: Arc<Mutex<MemoryManager>>,
@@ -471,6 +463,7 @@ impl Vm {
         serial_pty: Option<PtyPair>,
         console_pty: Option<PtyPair>,
         console_resize_pipe: Option<File>,
+        original_termios: Arc<Mutex<Option<termios>>>,
         snapshot: Option<Snapshot>,
     ) -> Result<Self> {
         trace_scoped!("Vm::new_from_memory_manager");
@@ -592,12 +585,14 @@ impl Vm {
         device_manager
             .lock()
             .unwrap()
-            .create_devices(serial_pty, console_pty, console_resize_pipe)
+            .create_devices(
+                serial_pty,
+                console_pty,
+                console_resize_pipe,
+                original_termios,
+            )
             .map_err(Error::DeviceManager)?;
 
-        // SAFETY: trivially safe
-        let on_tty = unsafe { libc::isatty(libc::STDIN_FILENO) } != 0;
-
         #[cfg(feature = "tdx")]
         let kernel = config
             .lock()
@@ -639,7 +634,6 @@ impl Vm {
             initramfs,
             device_manager,
             config,
-            on_tty,
             threads: Vec::with_capacity(1),
             state: RwLock::new(vm_state),
             cpu_manager,
@@ -746,6 +740,7 @@ impl Vm {
         serial_pty: Option<PtyPair>,
         console_pty: Option<PtyPair>,
         console_resize_pipe: Option<File>,
+        original_termios: Arc<Mutex<Option<termios>>>,
         snapshot: Option<Snapshot>,
         source_url: Option<&str>,
         prefault: Option<bool>,
@@ -815,6 +810,7 @@ impl Vm {
             serial_pty,
             console_pty,
             console_resize_pipe,
+            original_termios,
             snapshot,
         )
     }
@@ -1205,15 +1201,6 @@ impl Vm {
 
         state.valid_transition(new_state)?;
 
-        if self.on_tty {
-            // Don't forget to set the terminal in canonical mode
-            // before to exit.
-            io::stdin()
-                .lock()
-                .set_canon_mode()
-                .map_err(Error::SetTerminalCanon)?;
-        }
-
         // Wake up the DeviceManager threads so they will get terminated cleanly
         self.device_manager
             .lock()
@@ -1271,7 +1258,7 @@ impl Vm {
                 .resize(desired_memory)
                 .map_err(Error::MemoryManager)?;
 
-            let mut memory_config = &mut self.config.lock().unwrap().memory;
+            let memory_config = &mut self.config.lock().unwrap().memory;
 
             if let Some(new_region) = &new_region {
                 self.device_manager
@@ -1915,17 +1902,6 @@ impl Vm {
         Ok(())
     }
 
-    fn setup_tty(&self) -> Result<()> {
-        if self.on_tty {
-            io::stdin()
-                .lock()
-                .set_raw_mode()
-                .map_err(Error::SetTerminalRaw)?;
-        }
-
-        Ok(())
-    }
-
     // Creates ACPI tables
     // In case of TDX being used, this is a no-op since the tables will be
     // created and passed when populating the HOB.
@@ -1979,8 +1955,6 @@ impl Vm {
         #[cfg(target_arch = "x86_64")]
         let rsdp_addr = self.create_acpi_tables();
 
-        self.setup_tty()?;
-
         // Load kernel synchronously or if asynchronous then wait for load to
         // finish.
         let entry_point = self.entry_point()?;
@@ -2030,6 +2004,18 @@ impl Vm {
             })
             .transpose()?;
 
+        #[cfg(target_arch = "x86_64")]
+        // Note: For x86, always call this function before invoking start boot vcpus.
+        // Otherwise guest would fail to boot because we haven't created the
+        // userspace mappings to update the hypervisor about the memory mappings.
+        // These mappings must be created before we start the vCPU threads for
+        // the very first time.
+        self.memory_manager
+            .lock()
+            .unwrap()
+            .allocate_address_space()
+            .map_err(Error::MemoryManager)?;
+
         #[cfg(feature = "tdx")]
         if let Some(hob_address) = hob_address {
             // With the HOB address extracted the vCPUs can have
@@ -2047,18 +2033,6 @@ impl Vm {
             self.vm.tdx_finalize().map_err(Error::FinalizeTdx)?;
         }
 
-        #[cfg(target_arch = "x86_64")]
-        // Note: For x86, always call this function before invoking start boot vcpus.
-        // Otherwise guest would fail to boot because we haven't created the
-        // userspace mappings to update the hypervisor about the memory mappings.
-        // These mappings must be created before we start the vCPU threads for
-        // the very first time.
-        self.memory_manager
-            .lock()
-            .unwrap()
-            .allocate_address_space()
-            .map_err(Error::MemoryManager)?;
-
         self.cpu_manager
             .lock()
             .unwrap()
@@ -2093,8 +2067,6 @@ impl Vm {
             .start_restored_vcpus()
             .map_err(Error::CpuManager)?;
 
-        self.setup_tty()?;
-
         event!("vm", "restored");
         Ok(())
     }
@@ -2722,7 +2694,7 @@ mod tests {
                 // Check the transitions from Created
                 assert!(state.valid_transition(VmState::Created).is_err());
                 assert!(state.valid_transition(VmState::Running).is_ok());
-                assert!(state.valid_transition(VmState::Shutdown).is_err());
+                assert!(state.valid_transition(VmState::Shutdown).is_ok());
                 assert!(state.valid_transition(VmState::Paused).is_ok());
                 assert!(state.valid_transition(VmState::BreakPoint).is_ok());
             }

vmm/src/vm_config.rs

@@ -183,7 +183,7 @@ impl Default for MemoryConfig {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, Default)]
 pub enum VhostMode {
     #[default]
     Client,
@@ -248,7 +248,7 @@ impl Default for DiskConfig {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct NetConfig {
     #[serde(default = "default_netconfig_tap")]
     pub tap: Option<String>,
@@ -563,7 +563,7 @@ pub struct TpmConfig {
     pub socket: PathBuf,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+#[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct VmConfig {
     #[serde(default)]
     pub cpus: CpusConfig,
@@ -596,4 +596,10 @@ pub struct VmConfig {
     pub gdb: bool,
     pub platform: Option<PlatformConfig>,
     pub tpm: Option<TpmConfig>,
+    // Preseved FDs are the ones that share the same life-time as its holding
+    // VmConfig instance, such as FDs for creating TAP devices.
+    // Perserved FDs will stay open as long as the holding VmConfig instance is
+    // valid, and will be closed when the holding VmConfig instance is destroyed.
+    #[serde(skip)]
+    pub preserved_fds: Option<Vec<i32>>,
 }